postchain-client 2.0.4 → 2.1.0

package/built/cjs/index.js

@@ -106,6 +106,14 @@ function isRawGtx(value) {
     return result.success;
 }
 
+/**
+ * Type guard to check if a value is a Buffer instance.
+ * Works correctly with Buffer imported from the 'buffer' package.
+ */
+function isBuffer(value) {
+    return buffer.Buffer.isBuffer(value);
+}
+
 function pgBytes(buffer$1) {
     if (!buffer.Buffer.isBuffer(buffer$1)) {
         throw new PgBytesInputException(buffer$1);
@@ -143,12 +151,10 @@ class PgBytesInputException extends Error {
     }
 }
 function ensureBuffer(value) {
-    if (value instanceof buffer.Buffer) {
+    if (isBuffer(value)) {
         return value;
     }
-    else {
-        return toBuffer(value);
-    }
+    return toBuffer(value);
 }
 function ensureString(value) {
     if (typeof value === "string") {
@@ -615,7 +621,7 @@ function gtxToRawGtx(gtx) {
 }
 function sign(gtx, privOrSigProv, merkleHashVersion, pubKey) {
     return __awaiter$9(this, void 0, void 0, function* () {
-        if (privOrSigProv instanceof buffer.Buffer) {
+        if (isBuffer(privOrSigProv)) {
             const digestToSign = getDigestToSign(gtx, merkleHashVersion);
             const signature = signDigest(digestToSign, privOrSigProv);
             return addSignature(pubKey || makeKeyPair(privOrSigProv).pubKey, signature, gtx);
@@ -1024,6 +1030,21 @@ var Method;
     Method["POST"] = "post";
 })(Method || (Method = {}));
 
+class NetworkNode {
+    constructor(url) {
+        this.availabilityDate = 0;
+        this.url = url;
+    }
+    isAvailable() {
+        return Date.now() >= this.availabilityDate;
+    }
+    makeUnavailable(duration) {
+        this.availabilityDate = Date.now() + duration;
+    }
+    makeAvailable() {
+        this.availabilityDate = 0;
+    }
+}
 const shuffleArray = (array) => {
     const shuffledArray = [...array];
     for (let i = shuffledArray.length - 1; i > 0; i--) {
@@ -1033,20 +1054,34 @@ const shuffleArray = (array) => {
     return shuffledArray;
 };
 const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuration = 5000, }) => {
-    const nodes = nodeUrls.map(url => ({
-        url,
-        whenAvailable: 0,
-        isAvailable: true,
-    }));
+    const nodes = nodeUrls.map(url => new NetworkNode(url));
     return {
         nodes,
         stickedNode: null,
         useStickyNode: useStickyNode,
         lastUsedNode: null,
-        getAvailableNodes() {
-            const shuffledAvailableNodes = shuffleArray(this.nodes.filter((node) => node.isAvailable));
+        getAvailableNodes(customRecoveryThreshold) {
+            const availableNodes = this.nodes.filter((node) => node.isAvailable());
+            if (this.nodes.length >= 3) {
+                // Default to conservative threshold (2x formula) if no custom threshold provided
+                const recoveryThreshold = customRecoveryThreshold !== null && customRecoveryThreshold !== void 0 ? customRecoveryThreshold : this.nodes.length - Math.floor((2 * (this.nodes.length - 1)) / 3);
+                if (availableNodes.length < recoveryThreshold) {
+                    debug(`Auto-recovery: ${availableNodes.length} < ${recoveryThreshold} nodes (${this.nodes.length} total)`);
+                    const previousStickyUrl = this.stickedNode;
+                    this.makeAllNodesAvailable();
+                    if (this.useStickyNode && previousStickyUrl) {
+                        if (previousStickyUrl) {
+                            this.setStickyNode(previousStickyUrl);
+                            info(`Sticky node preserved during recovery: ${previousStickyUrl}`);
+                        }
+                    }
+                    const updatedAvailableNodes = this.nodes.filter((node) => node.isAvailable());
+                    return shuffleArray(updatedAvailableNodes);
+                }
+            }
+            const shuffledAvailableNodes = shuffleArray(availableNodes);
             // set sticky node as the first node, and then shuffle the rest
-            if (useStickyNode && this.stickedNode && this.stickedNode.isAvailable) {
+            if (useStickyNode && this.stickedNode && this.stickedNode.isAvailable()) {
                 const nodesWithoutSticky = shuffledAvailableNodes.filter(node => node !== this.stickedNode);
                 return [this.stickedNode, ...nodesWithoutSticky];
             }
@@ -1066,7 +1101,7 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
             const index = Math.floor(Math.random() * nodes.length);
             const node = nodes[index];
             this.lastUsedNode = node;
-            if (!useStickyNode) {
+            if (!this.useStickyNode) {
                 return node;
             }
             if (!this.stickedNode) {
@@ -1077,21 +1112,18 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
             return this.stickedNode;
         },
         makeAllNodesAvailable() {
-            this.nodes = this.nodes.map((node) => {
-                return Object.assign(Object.assign({}, node), { isAvailable: true, whenAvailable: 0 });
-            });
+            for (const node of this.nodes) {
+                node.makeAvailable();
+            }
         },
-        makeNodeUnavailable(nodeUrl) {
+        makeNodeUnavailable(nodeUrl, duration = unavailableDuration) {
             if (this.stickedNode && this.stickedNode.url === nodeUrl) {
                 this.stickedNode = null;
             }
-            const updatedNodes = this.nodes.map((node) => {
-                if (node.url === nodeUrl) {
-                    return Object.assign(Object.assign({}, node), { isAvailable: false, whenAvailable: Date.now() + unavailableDuration });
-                }
-                return node;
-            });
-            this.nodes = updatedNodes;
+            const invalidNode = this.nodes.find((node) => node.url === nodeUrl);
+            if (!invalidNode)
+                return;
+            invalidNode.makeUnavailable(duration);
         },
     };
 };
@@ -1385,7 +1417,7 @@ function post(path, endpoint, requestBody) {
             try {
                 const requestOptions = {
                     method: "post",
-                    body: requestBody,
+                    body: new Uint8Array(requestBody),
                     headers: {
                         Accept: "application/octet-stream",
                         "Content-Type": "application/octet-stream",
@@ -1434,9 +1466,14 @@ function constructBufferResponseBody(response) {
     });
 }
 function createResponseObject(error, statusCode, rspBody, transactionTimestamp) {
+    let finalStatusCode = statusCode;
+    // Handle browser network errors as a specific status code for smart timeout logic
+    if (error && !statusCode && !rspBody) {
+        finalStatusCode = 502; // Treat as Bad Gateway for timeout purposes
+    }
     const responseObject = {
         error,
-        statusCode,
+        statusCode: finalStatusCode,
         rspBody,
     };
     if (transactionTimestamp) {
@@ -1445,6 +1482,42 @@ function createResponseObject(error, statusCode, rspBody, transactionTimestamp)
     return responseObject;
 }
 
+function isQueryNotFoundError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "QUERY_NOT_FOUND");
+}
+function isHttpStatusError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "status" in error &&
+        typeof error.status === "number");
+}
+function isNetworkError(error) {
+    return (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string");
+}
+function isRetriableClientError(response) {
+    if (typeof response === "object" && response !== null) {
+        // Check error field first
+        if ("error" in response && isQueryNotFoundError(response.error)) {
+            return false;
+        }
+        // Check rspBody if no error
+        if ("rspBody" in response && isQueryNotFoundError(response.rspBody)) {
+            return false;
+        }
+    }
+    return true;
+}
+const isClientErrorStatusCode = (status) => {
+    return status >= 400 && status < 500;
+};
+const isServerErrorStatusCode = (status) => {
+    return status >= 500 && status < 600;
+};
+const isSuccessfulStatusCode = (statusCode) => statusCode >= 200 && statusCode < 300;
+
 var __awaiter$7 = (undefined && undefined.__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) {
@@ -1454,28 +1527,49 @@ var __awaiter$7 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const isSuccessfullRequest = (statusCode) => statusCode >= 200 && statusCode < 300;
-const hasClientError = (statusCode) => statusCode >= 400 && statusCode < 500;
-const hasServerError = (statusCode) => statusCode >= 500 && statusCode < 600;
-function abortOnError({ method, path, config, postObject, }) {
-    return __awaiter$7(this, void 0, void 0, function* () {
+function getUnreachableDuration(statusCode, error) {
+    if (isNetworkError(error)) {
+        const { code } = error;
+        if (code === "ENOTFOUND")
+            return 5 * 60 * 1000;
+        if (code === "ECONNREFUSED")
+            return 5 * 60 * 1000;
+    }
+    const status = isHttpStatusError(error) ? error.status : statusCode;
+    switch (status) {
+        case 500:
+            return 10 * 1000; // Server restart: 10s
+        case 502:
+            return 30 * 1000; // Gateway: 30s
+        case 503:
+            return 2 * 1000; // Load: 2s
+        case 504:
+            return 60 * 1000; // Timeout: 60s
+        default:
+            return 5 * 1000;
+    }
+}
+function abortOnError(_a) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
         return yield retryRequest({
             method,
             path,
             config,
             postObject,
-            validateStatusCode: statuscode => !hasServerError(statuscode),
+            useNextNodeOnError: false,
+            recoveryThreshold: config.recoveryThreshold, // Use user config or let nodeManager use default
         });
     });
 }
-function tryNextOnError({ method, path, config, postObject, }) {
-    return __awaiter$7(this, void 0, void 0, function* () {
+function tryNextOnError(_a) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
         return yield retryRequest({
             method,
             path,
             config,
             postObject,
-            validateStatusCode: statusCode => !hasClientError(statusCode) && !hasServerError(statusCode),
+            useNextNodeOnError: true,
+            recoveryThreshold: config.recoveryThreshold,
         });
     });
 }
@@ -1485,59 +1579,57 @@ const errorMessages = {
 function calculateBftMajorityThreshold(endpointPoolLength) {
     return endpointPoolLength - (endpointPoolLength - 1) / 3;
 }
-function queryMajority({ method, path, config, postObject, }) {
-    return __awaiter$7(this, void 0, void 0, function* () {
+function queryMajority(_a) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
+        var _b;
         // Set up constants
         const bftMajorityThreshold = calculateBftMajorityThreshold(config.endpointPool.length);
         const failureThreshold = config.endpointPool.length - bftMajorityThreshold + 1;
         const { nodeManager } = config;
         const timeout = 15000;
-        const availableNodes = nodeManager.getAvailableNodes();
-        // If the available nodes are less than bfthMajorityThreshold, set all nodes as reachable again.
-        if (availableNodes.length < bftMajorityThreshold) {
-            nodeManager.makeAllNodesAvailable();
-        }
+        const availableNodes = nodeManager.getAvailableNodes((_b = config.recoveryThreshold) !== null && _b !== void 0 ? _b : bftMajorityThreshold);
         const outcomes = [];
-        const promises = nodeManager.getAvailableNodes().map(node => {
-            return handleRequest(method, path, node.url, postObject)
-                .then(response => {
+        const promises = availableNodes.map((node) => __awaiter$7(this, void 0, void 0, function* () {
+            try {
+                const response = yield handleRequest(method, path, node.url, postObject);
                 const { statusCode } = response;
-                if (statusCode && isSuccessfullRequest(statusCode)) {
+                if (statusCode && isSuccessfulStatusCode(statusCode)) {
                     outcomes.push({ type: "SUCCESS", result: response });
                 }
                 else {
-                    if (statusCode && hasServerError(statusCode)) {
-                        nodeManager.makeNodeUnavailable(node.url);
+                    if (statusCode && isServerErrorStatusCode(statusCode)) {
+                        const duration = getUnreachableDuration(statusCode, response.error);
+                        nodeManager.makeNodeUnavailable(node.url, duration);
                     }
                     outcomes.push({ type: "FAILURE", result: response });
                 }
                 return response;
-            })
-                .catch((error) => {
+            }
+            catch (error) {
                 outcomes.push({ type: "ERROR", result: error });
                 return error;
-            });
-        });
+            }
+        }));
         let remainingPromises = promises;
         // Wait for the necessary majority of outcomes to come back or for the timeout to be reached, whichever comes first.
         for (let i = 0; i < bftMajorityThreshold; i++) {
             remainingPromises = yield racePromisesWithTimeout(remainingPromises, timeout);
         }
         // Evaluate the outcomes
-        const successfullOutcomes = outcomes.filter(outcome => outcome.type === "SUCCESS");
+        const successfulOutcomes = outcomes.filter(outcome => outcome.type === "SUCCESS");
         const failureOutcomes = outcomes.filter(outcome => outcome.type === "FAILURE");
         const errorOutcomes = outcomes.filter(outcome => outcome.type === "ERROR");
         // group all of the same responses together into groups and count each groups size
-        const groupedSuccessfullResponses = groupResponses(successfullOutcomes);
+        const groupedSuccessfulResponses = groupResponses(successfulOutcomes);
         // validate the responses
         // eslint-disable-next-line no-constant-condition
         while (true) {
-            // Successfull majority response was found
-            if (groupedSuccessfullResponses.maxNumberOfEqualResponses() >= bftMajorityThreshold) {
-                if (groupedSuccessfullResponses.numberOfDistinctResponses() > 1) {
+            // Successful majority response was found
+            if (groupedSuccessfulResponses.maxNumberOfEqualResponses() >= bftMajorityThreshold) {
+                if (groupedSuccessfulResponses.numberOfDistinctResponses() > 1) {
                     warning(`Got disagreeing responses, but could still reach BFT majority`);
                 }
-                return groupedSuccessfullResponses.majorityResponse();
+                return groupedSuccessfulResponses.majorityResponse();
             }
             // Too many failures or errors to be able to reach a consensus
             // If the number of failures and errors is greater than the failure threshold, return first failure, if any, otherwise throw the first error.
@@ -1558,22 +1650,24 @@ function queryMajority({ method, path, config, postObject, }) {
         }
     });
 }
-function singleEndpoint({ method, path, config, postObject, }) {
-    return __awaiter$7(this, void 0, void 0, function* () {
+function singleEndpoint(_a) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
         let statusCode = null;
         let rspBody = null;
         let error = null;
         let transactionTimestamp = undefined;
         const endpoint = config.nodeManager.getNode();
         if (!endpoint) {
-            throw new Error("Cannot get endpoint. Node not found!");
+            throw new Error("No nodes available after recovery attempt. Check node configuration.");
         }
         for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
             const response = yield handleRequest(method, path, endpoint.url, postObject);
             if (response) {
                 ({ error, statusCode, rspBody, transactionTimestamp } = response);
             }
-            const isError = statusCode ? hasServerError(statusCode) || hasClientError(statusCode) : false;
+            const isError = statusCode
+                ? isClientErrorStatusCode(statusCode) || isServerErrorStatusCode(statusCode)
+                : false;
             if (!isError && !error) {
                 return { error, statusCode, rspBody, transactionTimestamp };
             }
@@ -1583,38 +1677,54 @@ function singleEndpoint({ method, path, config, postObject, }) {
         return { error, statusCode, rspBody, transactionTimestamp };
     });
 }
-function retryRequest({ method, path, config, postObject, validateStatusCode, }) {
-    var _a, _b, _c;
-    return __awaiter$7(this, void 0, void 0, function* () {
+function retryRequest(_a) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, useNextNodeOnError, recoveryThreshold, }) {
+        var _b, _c, _d;
         let statusCode = null;
         let rspBody = null;
         let error = null;
         let transactionTimestamp = undefined;
         const { nodeManager } = config;
-        const availableNodes = nodeManager.getAvailableNodes();
-        for (const endpoint of availableNodes) {
+        const availableNodes = nodeManager.getAvailableNodes(recoveryThreshold);
+        for (const node of availableNodes) {
             for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
-                const response = yield handleRequest(method, path, endpoint.url, postObject);
-                error = (_a = response === null || response === void 0 ? void 0 : response.error) !== null && _a !== void 0 ? _a : null;
-                statusCode = (_b = response === null || response === void 0 ? void 0 : response.statusCode) !== null && _b !== void 0 ? _b : null;
-                rspBody = (_c = response === null || response === void 0 ? void 0 : response.rspBody) !== null && _c !== void 0 ? _c : null;
+                const response = yield handleRequest(method, path, node.url, postObject);
+                error = (_b = response === null || response === void 0 ? void 0 : response.error) !== null && _b !== void 0 ? _b : null;
+                statusCode = (_c = response === null || response === void 0 ? void 0 : response.statusCode) !== null && _c !== void 0 ? _c : null;
+                rspBody = (_d = response === null || response === void 0 ? void 0 : response.rspBody) !== null && _d !== void 0 ? _d : null;
                 transactionTimestamp = response === null || response === void 0 ? void 0 : response.transactionTimestamp;
-                const isStatusCodeValid = statusCode ? validateStatusCode(statusCode) : false;
-                const isServerError = statusCode ? hasServerError(statusCode) : false;
-                if (isStatusCodeValid && !error) {
+                const isServerError = !!statusCode && isServerErrorStatusCode(statusCode);
+                const isClientError = !!statusCode && isClientErrorStatusCode(statusCode);
+                if (!isServerError && !isClientError && statusCode) {
                     // Find a way to have this handled more elegantly in the node manager.
-                    nodeManager.lastUsedNode = endpoint;
-                    if (nodeManager.stickedNode !== endpoint) {
-                        nodeManager.setStickyNode(endpoint);
+                    nodeManager.lastUsedNode = node;
+                    if (nodeManager.stickedNode !== node) {
+                        node.makeAvailable();
+                        nodeManager.setStickyNode(node);
                     }
                     return { error, statusCode, rspBody, transactionTimestamp };
                 }
                 if (isServerError) {
-                    // nodeManager.makeNodeUnavailable(endpoint.url);
-                    info(`server error on ${endpoint.url}`);
+                    const duration = getUnreachableDuration(statusCode !== null && statusCode !== void 0 ? statusCode : undefined, response.error);
+                    nodeManager.makeNodeUnavailable(node.url, duration);
+                    info(`request failed with server error on ${node.url} trying next node`);
+                    break;
+                }
+                if (isClientError) {
+                    if (!useNextNodeOnError || !isRetriableClientError(response)) {
+                        return { error, statusCode, rspBody, transactionTimestamp };
+                    }
+                    if (!nodeManager.useStickyNode) {
+                        info(`request failed client error on ${node.url} trying next node`);
+                        break;
+                    }
+                    // Otherwise continue with next attempt for this node
+                }
+                info(`${method} request failed on ${node.url}. Attempt: ${attempt + 1} / ${config.attemptsPerEndpoint}`);
+                // if statement is workaround for test utils
+                if (config.attemptInterval > 0) {
+                    yield sleep(config.attemptInterval);
                 }
-                info(`${method} request failed on ${endpoint.url}. Attempt: ${attempt + 1} / ${config.attemptsPerEndpoint}`);
-                yield sleep(config.attemptInterval);
             }
         }
         return { error, statusCode, rspBody, transactionTimestamp };
@@ -1701,8 +1811,8 @@ var __awaiter$6 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function requestWithFailoverStrategy(method, path, config, postObject, forceSingleEndpoint = false) {
-    return __awaiter$6(this, void 0, void 0, function* () {
+function requestWithFailoverStrategy(method_1, path_1, config_1, postObject_1) {
+    return __awaiter$6(this, arguments, void 0, function* (method, path, config, postObject, forceSingleEndpoint = false) {
         switch (config.failoverStrategy) {
             case exports.FailoverStrategy.AbortOnError:
                 return yield abortOnError({ method, path, config, postObject });
@@ -1731,8 +1841,8 @@ var __awaiter$5 = (undefined && undefined.__awaiter) || function (thisArg, _argu
     });
 };
 function getClientConfigFromSettings(settings) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return __awaiter$5(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";
@@ -1745,7 +1855,7 @@ function getClientConfigFromSettings(settings) {
             unavailableDuration: (_d = settings.failOverConfig) === null || _d === void 0 ? void 0 : _d.unreachableDuration,
         });
         const blockchainRidToUse = yield (() => __awaiter$5(this, void 0, void 0, function* () {
-            var _k;
+            var _a;
             if (settings.blockchainRid) {
                 return settings.blockchainRid;
             }
@@ -1754,13 +1864,13 @@ function getClientConfigFromSettings(settings) {
                     nodeManager,
                     endpointPool,
                     chainId: settings.blockchainIid,
-                    merkleHashVersion: (_k = settings.merkleHashVersion) !== null && _k !== void 0 ? _k : MERKLE_HASH_VERSIONS.UNSET,
+                    merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
                 });
             }
             throw new MissingBlockchainIdentifierError();
         }))();
         const directoryChainRid = yield (() => __awaiter$5(this, void 0, void 0, function* () {
-            var _l;
+            var _a;
             if (settings.directoryChainRid) {
                 return settings.directoryChainRid;
             }
@@ -1769,7 +1879,7 @@ function getClientConfigFromSettings(settings) {
                 nodeManager,
                 endpointPool,
                 chainId: directoryChainIid,
-                merkleHashVersion: (_l = settings.merkleHashVersion) !== null && _l !== void 0 ? _l : MERKLE_HASH_VERSIONS.UNSET,
+                merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
             });
         }))();
         return {
@@ -1802,8 +1912,8 @@ function getMerkleHashVersionFromDapp(config) {
         }
     });
 }
-function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid, }) {
-    return __awaiter$5(this, void 0, void 0, function* () {
+function nodeDiscovery(_a) {
+    return __awaiter$5(this, arguments, void 0, function* ({ nodeManager, directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid, }) {
         if (directoryEndpointPool.length === 0) {
             throw new DirectoryNodeUrlPoolException();
         }
@@ -1970,8 +2080,8 @@ const isKeyPair = (keypair) => {
         keypair.pubKey instanceof buffer.Buffer);
 };
 function getNodeUrlsFromSettings(settings) {
-    var _a;
     return __awaiter$5(this, void 0, void 0, function* () {
+        var _a;
         if (settings.directoryNodeUrlPool) {
             // If directoryNodeUrlPool is provided, use nodeDiscovery
             const nodeManager = createNodeManager({
@@ -2042,8 +2152,8 @@ const getUrlsFromEndpoints = (endpointPool) => {
     return endpointPool.map(endpoint => endpoint.url);
 };
 function awaitDappConfirmation(txRID, dappStatusPolling, getTransactionStatus) {
-    var _a;
     return __awaiter$5(this, void 0, void 0, function* () {
+        var _a;
         let lastKnownResult = null;
         for (let i = 0; i < dappStatusPolling.count; i++) {
             lastKnownResult = yield getTransactionStatus(txRID);
@@ -2059,8 +2169,8 @@ function awaitDappConfirmation(txRID, dappStatusPolling, getTransactionStatus) {
     });
 }
 function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringStatusPolling, getClusterAnchoringTransactionConfirmation) {
-    var _a;
     return __awaiter$5(this, void 0, void 0, function* () {
+        var _a;
         let clusterAnchoringConfirmation;
         for (let i = 0; i < clusterAnchoringStatusPolling.count; i++) {
             clusterAnchoringConfirmation = yield getClusterAnchoringTransactionConfirmation(txRID);
@@ -2083,8 +2193,8 @@ function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringStatusPol
     });
 }
 function handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, dappStatusPolling, getTransactionStatus, client) {
-    var _a, _b;
     return __awaiter$5(this, void 0, void 0, function* () {
+        var _a, _b;
         const transactionReceipt = {
             status: exports.ResponseStatus.Pending,
             statusCode: null,
@@ -2214,6 +2324,7 @@ function handleGetResponse(error$1, statusCode, responseObject, callback) {
  * @param callback the callback function to propagate the error and response back to the caller
  */
 function handlePostResponse(error$1, statusCode, responseObject, callback) {
+    var _a;
     const responseObjectPrintable = convertToPrintable(responseObject);
     debug(`error: ${error$1}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
     try {
@@ -2221,13 +2332,16 @@ function handlePostResponse(error$1, statusCode, responseObject, callback) {
             error(`In client post(). ${error$1}`);
             callback(error$1, null);
         }
-        else if (statusCode != 200) {
+        else if (!statusCode || !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()
+                : "";
             if (responseObjectPrintable) {
                 errorMessage += ` Message: ${responseObjectPrintable}.`;
             }
             error(errorMessage);
-            callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), responseObject);
+            callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, errorMessageInResponseBody || responseObjectPrintable), responseObject);
         }
         else {
             info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
@@ -2238,8 +2352,8 @@ function handlePostResponse(error$1, statusCode, responseObject, callback) {
         error(`client.handlePostResponse(): Failed to call callback function ${error$1}`);
     }
 }
-function getBlockchainRidFromIid({ endpointPool, chainId, failOverConfig = {}, nodeManager, }) {
-    return __awaiter$5(this, void 0, void 0, function* () {
+function getBlockchainRidFromIid(_a) {
+    return __awaiter$5(this, arguments, void 0, function* ({ endpointPool, chainId, failOverConfig = {}, nodeManager, }) {
         const mergedFailOverConfig = Object.assign(Object.assign({}, defaultFailoverConfig), failOverConfig);
         const config = {
             endpointPool,
@@ -2371,10 +2485,11 @@ function calculateBlockRID(decodedTxProof, merkleHashVersion) {
 }
 // fetch tx from txRID and verifies with secp256k1.ecdsaVerify that txRID and signer creates signatures that are on the blockchain transaction
 function fetchAndVerifyTransaction(sourceClient, txToProveRID, proofHash, txToProveSigners) {
-    var _a, _b, _c;
     return __awaiter$4(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         const rawTx = yield sourceClient.getTransaction(txToProveRID);
         const txGtv = decodeValue(rawTx);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const fetchedTxHash = gtvHash2(txGtv, sourceClient.config.merkleHashVersion);
         if (buffer.Buffer.compare(fetchedTxHash, proofHash)) {
             // We received another hash for tx RID than what was included in proof
@@ -2385,6 +2500,7 @@ function fetchAndVerifyTransaction(sourceClient, txToProveRID, proofHash, txToPr
         if (txToProveSigners.length != ((_a = fetchedTx.signatures) === null || _a === void 0 ? void 0 : _a.length)) {
             throw new DifferentNumberOfSignersException((_c = (_b = fetchedTx.signatures) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0, txToProveSigners.length);
         }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const txRID = getDigestToSign(fetchedTx, sourceClient.config.merkleHashVersion);
         if (buffer.Buffer.compare(txRID, ensureBuffer(txToProveRID))) {
             throw new ProofRidException();
@@ -2451,8 +2567,8 @@ var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _argu
  * @param {string} nodeIdentifierURL - The URL of the node to use.
  * @returns {Promise<IccfProof>} A promise that resolves to an ICCF proof object containing the ICCF proof transaction.
  */
-function createIccfProofTx(directoryClient, txToProveRid, txToProveHash, txToProveSigners, sourceBlockchainRid, targetBlockchainRid, iccfTxSigners = [], forceIntraNetworkIccfOperation = false, merkleHashVersion, nodeIdentifierURL) {
-    return __awaiter$3(this, void 0, void 0, function* () {
+function createIccfProofTx(directoryClient_1, txToProveRid_1, txToProveHash_1, txToProveSigners_1, sourceBlockchainRid_1, targetBlockchainRid_1) {
+    return __awaiter$3(this, arguments, void 0, function* (directoryClient, txToProveRid, txToProveHash, txToProveSigners, sourceBlockchainRid, targetBlockchainRid, iccfTxSigners = [], forceIntraNetworkIccfOperation = false, merkleHashVersion, nodeIdentifierURL) {
         let clientConfiguredToSource;
         if (!nodeIdentifierURL) {
             clientConfiguredToSource = yield createClient({
@@ -2519,6 +2635,7 @@ function getBlockAnchoringTransaction(sourceClient, anchoringClient, txRid, txPr
         if (!confirmationProof) {
             throw Error("Confirmation proof not found");
         }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const blockRid = calculateBlockRID(confirmationProof, sourceClient.config.merkleHashVersion);
         const blockchainRid = sourceClient.config.blockchainRid;
         const anchoringTxResponse = yield awaitGetAnchoringTransactionForBlockRid(anchoringClient, toBuffer(blockchainRid), blockRid, sourceClient.config.clusterAnchoringStatusPolling);
@@ -2695,8 +2812,8 @@ const isBlockIdentifierValid = (blockIdentifier, options) => {
         return { success };
     }
     const { error } = ctx;
-    const isInvalidInputType = error.issues.some(({ code }) => code === "invalid_union");
-    const isInvalidStringLength = error.issues.some(({ message }) => message === WRONG_STRING_LENGTH);
+    const isInvalidInputType = error === null || error === void 0 ? void 0 : error.issues.some(({ code }) => code === "invalid_union");
+    const isInvalidStringLength = error === null || error === void 0 ? void 0 : error.issues.some(({ message }) => message === WRONG_STRING_LENGTH);
     const message = (() => {
         if (isInvalidInputType) {
             return `Invalid "blockIdentifier" type. Expected string or number, but received ${typeof blockIdentifier}.`;
@@ -2704,7 +2821,7 @@ const isBlockIdentifierValid = (blockIdentifier, options) => {
         if (isInvalidStringLength) {
             return "Parameter 'blockIdentifier' does not have the correct format (64-character hexadecimal string).";
         }
-        return error.issues.map(issue => issue.message).join(", ");
+        return error === null || error === void 0 ? void 0 : error.issues.map(issue => issue.message).join(", ");
     })();
     if (throwOnError) {
         throw new Error(message);
@@ -2712,7 +2829,7 @@ const isBlockIdentifierValid = (blockIdentifier, options) => {
     return {
         success,
         error,
-        message: error.issues.map(issue => issue.message).join(", "),
+        message: error === null || error === void 0 ? void 0 : error.issues.map(issue => issue.message).join(", "),
     };
 };
 
@@ -2784,8 +2901,8 @@ const validateRestNetworkSettings = (networkSettings, options) => {
     const { throwOnError = false } = options || {};
     const restNetworkSettingsValidationContext = RestNetworkSettingsSchema.safeParse(networkSettings);
     if ("error" in restNetworkSettingsValidationContext) {
-        const { error: { issues }, } = restNetworkSettingsValidationContext;
-        const errorMessage = issues.map(({ message, path }) => `${path[0]}: ${message}`).join(", ");
+        const { error: { issues } = {} } = restNetworkSettingsValidationContext;
+        const errorMessage = issues === null || issues === void 0 ? void 0 : issues.map(({ message, path }) => `${path[0]}: ${message}`).join(", ");
         if (throwOnError) {
             throw new Error(errorMessage);
         }
@@ -3082,8 +3199,8 @@ function createClient(settings) {
                 _transaction.operations = [..._transaction.operations, noOperation];
                 return _transaction;
             },
-            getTransactionsInfo(limit = 25, beforeTime, callback, afterTime, signerPubKey) {
-                return __awaiter$1(this, void 0, void 0, function* () {
+            getTransactionsInfo() {
+                return __awaiter$1(this, arguments, void 0, function* (limit = 25, beforeTime, callback, afterTime, signerPubKey) {
                     const beforeTimeQueryParam = beforeTime ? `&before-time=${beforeTime.getTime()}` : "";
                     const afterTimeQueryParam = afterTime ? `&after-time=${afterTime.getTime()}` : "";
                     const signerQueryParam = signerPubKey ? `&signer=${signerPubKey}` : "";
@@ -3140,8 +3257,8 @@ function createClient(settings) {
                 });
             },
             getTransactionConfirmationLevel(transactionRid, callback) {
-                var _a;
                 return __awaiter$1(this, void 0, void 0, function* () {
+                    var _a;
                     try {
                         const client = this;
                         const dappConfirmation = yield client.getTransactionStatus(transactionRid);
@@ -3202,8 +3319,8 @@ function createClient(settings) {
                     });
                 });
             },
-            getBlockInfo(blockIdentifier, txs = false, callback) {
-                return __awaiter$1(this, void 0, void 0, function* () {
+            getBlockInfo(blockIdentifier_1) {
+                return __awaiter$1(this, arguments, void 0, function* (blockIdentifier, txs = false, callback) {
                     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);
@@ -3215,8 +3332,8 @@ function createClient(settings) {
                     });
                 });
             },
-            getLatestBlock(txs = false, callback) {
-                return __awaiter$1(this, void 0, void 0, function* () {
+            getLatestBlock() {
+                return __awaiter$1(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 indexOfLatestBlock = 0;
@@ -3228,8 +3345,8 @@ function createClient(settings) {
                     });
                 });
             },
-            getBlocks({ limit, beforeTime, afterTime, beforeHeight, afterHeight, excludeEmpty, txs, callback, } = {}) {
-                return __awaiter$1(this, void 0, void 0, function* () {
+            getBlocks() {
+                return __awaiter$1(this, arguments, void 0, function* ({ limit, beforeTime, afterTime, beforeHeight, afterHeight, excludeEmpty, txs, callback, } = {}) {
                     const searchValues = {
                         limit,
                         txs,
@@ -3423,8 +3540,8 @@ function createClient(settings) {
             });
         }
         function createStickyNodeClient(client) {
-            var _a;
             return __awaiter$1(this, void 0, void 0, function* () {
+                var _a;
                 if (!client.config.nodeManager.lastUsedNode) {
                     throw new Error("No last used node found; cannot create sticky node client");
                 }