postchain-client 2.1.0 → 2.1.1

package/built/umd/index.js

@@ -39051,13 +39051,22 @@
 	        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);
 	        }
 	    });
 	}
@@ -39065,12 +39074,18 @@
 	 * 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;
@@ -39092,18 +39107,35 @@
 	        }
 	    });
 	}
+	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 = require$$0$2.Buffer.from(responseBuffer);
+	            return decodeValue(buffer);
+	        }
+	        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 (require$$0$2.Buffer.isBuffer(requestBody)) {
 	            try {
+	                const { controller, timeoutId } = createTimeoutController(timeout);
 	                const requestOptions = {
 	                    method: "post",
 	                    body: new Uint8Array(requestBody),
@@ -39111,8 +39143,11 @@
 	                        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);
 	            }
@@ -39122,6 +39157,7 @@
 	        }
 	        else {
 	            try {
+	                const { controller, timeoutId } = createTimeoutController(timeout);
 	                const response = yield fetch(new URL(path, endpoint).href, {
 	                    method: "post",
 	                    body: JSON.stringify(requestBody),
@@ -39129,7 +39165,10 @@
 	                        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);
 	            }
@@ -39139,21 +39178,6 @@
 	        }
 	    });
 	}
-	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 = require$$0$2.Buffer.from(responseBuffer);
-	            return decodeValue(buffer);
-	        }
-	        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
@@ -39239,24 +39263,26 @@
 	    }
 	}
 	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,
 	        });
@@ -39269,7 +39295,7 @@
 	    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);
@@ -39280,7 +39306,8 @@
 	        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 });
@@ -39340,7 +39367,7 @@
 	    });
 	}
 	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;
@@ -39350,7 +39377,8 @@
 	            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);
 	            }
@@ -39367,7 +39395,7 @@
 	    });
 	}
 	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;
@@ -39377,7 +39405,8 @@
 	        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;
@@ -39501,19 +39530,19 @@
 	    });
 	};
 	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}`);
 	        }
@@ -39554,6 +39583,8 @@
 	                    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();
@@ -39569,6 +39600,8 @@
 	                endpointPool,
 	                chainId: directoryChainIid,
 	                merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
+	                connectTimeout: settings.connectTimeout,
+	                responseTimeout: settings.responseTimeout,
 	            });
 	        }))();
 	        return {
@@ -39585,13 +39618,16 @@
 	            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;
 	        }
@@ -39602,7 +39638,7 @@
 	    });
 	}
 	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();
 	        }
@@ -39615,6 +39651,8 @@
 	            endpointPool: directoryEndpointPool,
 	            chainId: directoryIid,
 	            failOverConfig,
+	            connectTimeout,
+	            responseTimeout,
 	        });
 	        const blockchainRidToUse = yield (() => __awaiter$5(this, void 0, void 0, function* () {
 	            if (blockchainRid) {
@@ -39626,6 +39664,8 @@
 	                    endpointPool: directoryEndpointPool,
 	                    chainId: blockchainIid,
 	                    failOverConfig,
+	                    connectTimeout,
+	                    responseTimeout,
 	                });
 	            }
 	            throw new MissingBlockchainIdentifierError();
@@ -39783,6 +39823,8 @@
 	                failOverConfig: settings.failOverConfig,
 	                blockchainRid: settings.blockchainRid,
 	                blockchainIid: settings.blockchainIid,
+	                connectTimeout: settings.connectTimeout,
+	                responseTimeout: settings.responseTimeout,
 	            });
 	            return discoveredNodes;
 	        }
@@ -40042,7 +40084,8 @@
 	    }
 	}
 	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,
@@ -40056,8 +40099,10 @@
 	            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;
@@ -41272,6 +41317,8 @@
 	                attemptInterval: 5000,
 	                unreachableDuration: 30000,
 	                directoryChainRid: "1111111111111111111111111111111111111111111111111111111111111111",
+	                connectTimeout: 1000,
+	                responseTimeout: 1000,
 	            },
 	            query() {
 	                return __awaiter(this, void 0, void 0, function* () {