postchain-client 2.1.0 → 2.1.2

package/built/cjs/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
-var merklehashts = require('merklehashts');
 var buffer = require('buffer');
+var merklehashts = require('merklehashts');
 var bn_js = require('bn.js');
 var zod = require('zod');
 var crypto = require('crypto');
@@ -1362,13 +1362,22 @@ var __awaiter$8 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function handleRequest(method, path, endpoint, postObject) {
+function createTimeoutController(timeout) {
+    if (!timeout)
+        return { controller: undefined, timeoutId: undefined };
+    const controller = new AbortController();
+    const timeoutError = new Error(`Request timeout after ${timeout}ms`);
+    timeoutError.name = 'TimeoutError';
+    const timeoutId = setTimeout(() => controller.abort(timeoutError), timeout);
+    return { controller, timeoutId };
+}
+function handleRequest(method, path, endpoint, timeout, postObject) {
     return __awaiter$8(this, void 0, void 0, function* () {
         if (method == Method.GET) {
-            return yield get(path, endpoint);
+            return yield get(path, endpoint, timeout);
         }
         else {
-            return yield post(path, endpoint, postObject);
+            return yield post(path, endpoint, timeout, postObject);
         }
     });
 }
@@ -1376,12 +1385,18 @@ function handleRequest(method, path, endpoint, postObject) {
  * Sends request to get data from a given API endpoint.
  * @param path API endpoint of Rell backend
  * @param endpoint
+ * @param timeout
  */
-function get(path, endpoint) {
+function get(path, endpoint, timeout) {
     return __awaiter$8(this, void 0, void 0, function* () {
         debug(`GET URL ${new URL(path, endpoint).href}`);
         try {
-            const response = yield fetch(new URL(path, endpoint).href);
+            const { controller, timeoutId } = createTimeoutController(timeout);
+            const response = yield fetch(new URL(path, endpoint).href, {
+                signal: controller === null || controller === void 0 ? void 0 : controller.signal,
+            });
+            if (timeoutId)
+                clearTimeout(timeoutId);
             const contentType = response.headers.get("Content-Type");
             const transactionTimestamp = response.headers.get("X-Transaction-Timestamp");
             let rspBody = null;
@@ -1403,18 +1418,35 @@ function get(path, endpoint) {
         }
     });
 }
+function constructBufferResponseBody(response) {
+    return __awaiter$8(this, void 0, void 0, function* () {
+        const contentType = response.headers.get("content-type");
+        if (contentType === "application/octet-stream") {
+            const responseBuffer = yield response.arrayBuffer();
+            const buffer$1 = buffer.Buffer.from(responseBuffer);
+            return decodeValue(buffer$1);
+        }
+        if (contentType === "application/json") {
+            return yield response.json();
+        }
+        const responseText = yield response.text();
+        return responseText ? responseText : response.statusText;
+    });
+}
 /**
  * Sends request to post data to a given API endpoint.
  * @param path API endpoint of Rell backend
  * @param endpoint
+ * @param timeout
  * @param requestBody request body
  */
-function post(path, endpoint, requestBody) {
+function post(path, endpoint, timeout, requestBody) {
     return __awaiter$8(this, void 0, void 0, function* () {
         debug(`POST URL ${new URL(path, endpoint).href}`);
         debug(`POST body ${JSON.stringify(requestBody)}`);
         if (buffer.Buffer.isBuffer(requestBody)) {
             try {
+                const { controller, timeoutId } = createTimeoutController(timeout);
                 const requestOptions = {
                     method: "post",
                     body: new Uint8Array(requestBody),
@@ -1422,8 +1454,11 @@ function post(path, endpoint, requestBody) {
                         Accept: "application/octet-stream",
                         "Content-Type": "application/octet-stream",
                     },
+                    signal: controller === null || controller === void 0 ? void 0 : controller.signal,
                 };
                 const response = yield fetch(new URL(path, endpoint).href, requestOptions);
+                if (timeoutId)
+                    clearTimeout(timeoutId);
                 const transactionTimestamp = response.headers.get("X-Transaction-Timestamp");
                 return createResponseObject(null, response.status, yield constructBufferResponseBody(response), transactionTimestamp);
             }
@@ -1433,6 +1468,7 @@ function post(path, endpoint, requestBody) {
         }
         else {
             try {
+                const { controller, timeoutId } = createTimeoutController(timeout);
                 const response = yield fetch(new URL(path, endpoint).href, {
                     method: "post",
                     body: JSON.stringify(requestBody),
@@ -1440,7 +1476,10 @@ function post(path, endpoint, requestBody) {
                         Accept: "application/json",
                         "Content-Type": "application/json",
                     },
+                    signal: controller === null || controller === void 0 ? void 0 : controller.signal,
                 });
+                if (timeoutId)
+                    clearTimeout(timeoutId);
                 const transactionTimestamp = response.headers.get("X-Transaction-Timestamp");
                 return createResponseObject(null, response.status, yield constructBufferResponseBody(response), transactionTimestamp);
             }
@@ -1450,21 +1489,6 @@ function post(path, endpoint, requestBody) {
         }
     });
 }
-function constructBufferResponseBody(response) {
-    return __awaiter$8(this, void 0, void 0, function* () {
-        const contentType = response.headers.get("content-type");
-        if (contentType === "application/octet-stream") {
-            const responseBuffer = yield response.arrayBuffer();
-            const buffer$1 = buffer.Buffer.from(responseBuffer);
-            return decodeValue(buffer$1);
-        }
-        if (contentType === "application/json") {
-            return yield response.json();
-        }
-        const responseText = yield response.text();
-        return responseText ? responseText : response.statusText;
-    });
-}
 function createResponseObject(error, statusCode, rspBody, transactionTimestamp) {
     let finalStatusCode = statusCode;
     // Handle browser network errors as a specific status code for smart timeout logic
@@ -1550,24 +1574,26 @@ function getUnreachableDuration(statusCode, error) {
     }
 }
 function abortOnError(_a) {
-    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, timeoutOverride, }) {
         return yield retryRequest({
             method,
             path,
             config,
             postObject,
+            timeoutOverride,
             useNextNodeOnError: false,
             recoveryThreshold: config.recoveryThreshold, // Use user config or let nodeManager use default
         });
     });
 }
 function tryNextOnError(_a) {
-    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, timeoutOverride, }) {
         return yield retryRequest({
             method,
             path,
             config,
             postObject,
+            timeoutOverride,
             useNextNodeOnError: true,
             recoveryThreshold: config.recoveryThreshold,
         });
@@ -1580,7 +1606,7 @@ function calculateBftMajorityThreshold(endpointPoolLength) {
     return endpointPoolLength - (endpointPoolLength - 1) / 3;
 }
 function queryMajority(_a) {
-    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, timeoutOverride, }) {
         var _b;
         // Set up constants
         const bftMajorityThreshold = calculateBftMajorityThreshold(config.endpointPool.length);
@@ -1591,7 +1617,8 @@ function queryMajority(_a) {
         const outcomes = [];
         const promises = availableNodes.map((node) => __awaiter$7(this, void 0, void 0, function* () {
             try {
-                const response = yield handleRequest(method, path, node.url, postObject);
+                const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config.responseTimeout;
+                const response = yield handleRequest(method, path, node.url, requestTimeout, postObject);
                 const { statusCode } = response;
                 if (statusCode && isSuccessfulStatusCode(statusCode)) {
                     outcomes.push({ type: "SUCCESS", result: response });
@@ -1651,7 +1678,7 @@ function queryMajority(_a) {
     });
 }
 function singleEndpoint(_a) {
-    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, }) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, timeoutOverride, }) {
         let statusCode = null;
         let rspBody = null;
         let error = null;
@@ -1661,7 +1688,8 @@ function singleEndpoint(_a) {
             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);
+            const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config.responseTimeout;
+            const response = yield handleRequest(method, path, endpoint.url, requestTimeout, postObject);
             if (response) {
                 ({ error, statusCode, rspBody, transactionTimestamp } = response);
             }
@@ -1678,7 +1706,7 @@ function singleEndpoint(_a) {
     });
 }
 function retryRequest(_a) {
-    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, useNextNodeOnError, recoveryThreshold, }) {
+    return __awaiter$7(this, arguments, void 0, function* ({ method, path, config, postObject, useNextNodeOnError, recoveryThreshold, timeoutOverride, }) {
         var _b, _c, _d;
         let statusCode = null;
         let rspBody = null;
@@ -1688,7 +1716,8 @@ function retryRequest(_a) {
         const availableNodes = nodeManager.getAvailableNodes(recoveryThreshold);
         for (const node of availableNodes) {
             for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
-                const response = yield handleRequest(method, path, node.url, postObject);
+                const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config.responseTimeout;
+                const response = yield handleRequest(method, path, node.url, requestTimeout, 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;
@@ -1812,19 +1841,19 @@ var __awaiter$6 = (undefined && undefined.__awaiter) || function (thisArg, _argu
     });
 };
 function requestWithFailoverStrategy(method_1, path_1, config_1, postObject_1) {
-    return __awaiter$6(this, arguments, void 0, function* (method, path, config, postObject, forceSingleEndpoint = false) {
+    return __awaiter$6(this, arguments, void 0, function* (method, path, config, postObject, forceSingleEndpoint = false, timeoutOverride) {
         switch (config.failoverStrategy) {
             case exports.FailoverStrategy.AbortOnError:
-                return yield abortOnError({ method, path, config, postObject });
+                return yield abortOnError({ method, path, config, postObject, timeoutOverride });
             case exports.FailoverStrategy.TryNextOnError:
-                return yield tryNextOnError({ method, path, config, postObject });
+                return yield tryNextOnError({ method, path, config, postObject, timeoutOverride });
             case exports.FailoverStrategy.SingleEndpoint:
-                return yield singleEndpoint({ method, path, config, postObject });
+                return yield singleEndpoint({ method, path, config, postObject, timeoutOverride });
             case exports.FailoverStrategy.QueryMajority:
                 if (forceSingleEndpoint) {
-                    return yield singleEndpoint({ method, path, config, postObject });
+                    return yield singleEndpoint({ method, path, config, postObject, timeoutOverride });
                 }
-                return yield queryMajority({ method, path, config, postObject });
+                return yield queryMajority({ method, path, config, postObject, timeoutOverride });
             default:
                 throw new Error(`Unsupported failover strategy: ${config.failoverStrategy}`);
         }
@@ -1865,6 +1894,8 @@ function getClientConfigFromSettings(settings) {
                     endpointPool,
                     chainId: settings.blockchainIid,
                     merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
+                    connectTimeout: settings.connectTimeout,
+                    responseTimeout: settings.responseTimeout,
                 });
             }
             throw new MissingBlockchainIdentifierError();
@@ -1880,6 +1911,8 @@ function getClientConfigFromSettings(settings) {
                 endpointPool,
                 chainId: directoryChainIid,
                 merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
+                connectTimeout: settings.connectTimeout,
+                responseTimeout: settings.responseTimeout,
             });
         }))();
         return {
@@ -1896,13 +1929,16 @@ function getClientConfigFromSettings(settings) {
             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,
             directoryChainRid: settings.directoryChainRid || directoryChainRid,
+            connectTimeout: settings.connectTimeout,
+            responseTimeout: settings.responseTimeout,
         };
     });
 }
 function getMerkleHashVersionFromDapp(config) {
     return __awaiter$5(this, void 0, void 0, function* () {
+        var _a;
         try {
-            const response = yield requestWithFailoverStrategy(Method.GET, `/config/${config.blockchainRid}/features`, config);
+            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);
             return validatedResponse.merkle_hash_version;
         }
@@ -1913,7 +1949,7 @@ function getMerkleHashVersionFromDapp(config) {
     });
 }
 function nodeDiscovery(_a) {
-    return __awaiter$5(this, arguments, void 0, function* ({ nodeManager, directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid, }) {
+    return __awaiter$5(this, arguments, void 0, function* ({ nodeManager, directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid, connectTimeout, responseTimeout, }) {
         if (directoryEndpointPool.length === 0) {
             throw new DirectoryNodeUrlPoolException();
         }
@@ -1926,6 +1962,8 @@ function nodeDiscovery(_a) {
             endpointPool: directoryEndpointPool,
             chainId: directoryIid,
             failOverConfig,
+            connectTimeout,
+            responseTimeout,
         });
         const blockchainRidToUse = yield (() => __awaiter$5(this, void 0, void 0, function* () {
             if (blockchainRid) {
@@ -1937,6 +1975,8 @@ function nodeDiscovery(_a) {
                     endpointPool: directoryEndpointPool,
                     chainId: blockchainIid,
                     failOverConfig,
+                    connectTimeout,
+                    responseTimeout,
                 });
             }
             throw new MissingBlockchainIdentifierError();
@@ -2094,6 +2134,8 @@ function getNodeUrlsFromSettings(settings) {
                 failOverConfig: settings.failOverConfig,
                 blockchainRid: settings.blockchainRid,
                 blockchainIid: settings.blockchainIid,
+                connectTimeout: settings.connectTimeout,
+                responseTimeout: settings.responseTimeout,
             });
             return discoveredNodes;
         }
@@ -2353,7 +2395,8 @@ function handlePostResponse(error$1, statusCode, responseObject, callback) {
     }
 }
 function getBlockchainRidFromIid(_a) {
-    return __awaiter$5(this, arguments, void 0, function* ({ endpointPool, chainId, failOverConfig = {}, nodeManager, }) {
+    return __awaiter$5(this, arguments, void 0, function* ({ endpointPool, chainId, failOverConfig = {}, nodeManager, connectTimeout, responseTimeout, }) {
+        var _b;
         const mergedFailOverConfig = Object.assign(Object.assign({}, defaultFailoverConfig), failOverConfig);
         const config = {
             endpointPool,
@@ -2367,8 +2410,10 @@ function getBlockchainRidFromIid(_a) {
             attemptInterval: mergedFailOverConfig.attemptInterval,
             unreachableDuration: mergedFailOverConfig.unreachableDuration,
             merkleHashVersion: MERKLE_HASH_VERSIONS.UNSET,
+            connectTimeout,
+            responseTimeout,
         };
-        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/brid/iid_${chainId}`, config);
+        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);
         if (!blockchainRid) {
             throw error;
@@ -3585,6 +3630,8 @@ function createStubClient() {
                 attemptInterval: 5000,
                 unreachableDuration: 30000,
                 directoryChainRid: "1111111111111111111111111111111111111111111111111111111111111111",
+                connectTimeout: 1000,
+                responseTimeout: 1000,
             },
             query() {
                 return __awaiter(this, void 0, void 0, function* () {
@@ -3750,6 +3797,10 @@ function decodeTransactionToGtx(encodedTransaction) {
     return gtx$1;
 }
 
+Object.defineProperty(exports, 'Buffer', {
+    enumerable: true,
+    get: function () { return buffer.Buffer; }
+});
 exports.AlreadySignedTransactionException = AlreadySignedTransactionException;
 exports.BlockAnchoringException = BlockAnchoringException;
 exports.BlockchainUrlUndefinedException = BlockchainUrlUndefinedException;