postchain-client 1.19.1 → 1.20.1

package/built/cjs/index.js

@@ -5,8 +5,8 @@ var bn_js = require('bn.js');
 var crypto = require('crypto');
 var secp256k1 = require('secp256k1');
 var cloneDeep = require('lodash/cloneDeep');
-var events = require('events');
 var zod = require('zod');
+var events = require('events');
 
 function _interopNamespaceDefault(e) {
 	var n = Object.create(null);
@@ -56,6 +56,8 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-nocheck
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const asn = require("@chromia/asn1/lib/asn1");
 const ASNDictPair = asn.define("DictPair", function () {
@@ -189,7 +191,7 @@ function checkGtvType(value) {
             return true;
         }
         if (value.constructor === Array) {
-            value.map((item) => checkGtvType(item));
+            value.map(item => checkGtvType(item));
             return true;
         }
         if (typeof value === "object") {
@@ -236,14 +238,14 @@ function checkGtxType(value) {
 }
 function removeDuplicateSigners(signers) {
     const signersAsString = [];
-    signers.forEach((item) => {
+    signers.forEach(item => {
         const itemAsString = item.toString("hex");
         if (!signersAsString.includes(itemAsString)) {
             signersAsString.push(itemAsString);
         }
     });
     const result = [];
-    signersAsString.forEach((item) => {
+    signersAsString.forEach(item => {
         result.push(require$$0$1.Buffer.from(item, "hex"));
     });
     return result;
@@ -279,9 +281,13 @@ function encodeValueGtx(rawGtx) {
     return encodeValue(rawGtx);
 }
 function decodeValue(bytes) {
-    //TODO add a try catch to catch asn1 errors to be more readable error
-    const obj = rawGTV.decode(bytes);
-    return parseValue(obj);
+    try {
+        const obj = rawGTV.decode(bytes);
+        return parseValue(obj);
+    }
+    catch (error) {
+        throw new Error(`Invalid GTV data. ${error}`);
+    }
 }
 function decodeValueGtx(bytes) {
     const decodedValue = decodeValue(bytes);
@@ -349,7 +355,7 @@ function createTypedArg(value) {
         if (value.constructor === Array) {
             return {
                 type: "array",
-                value: value.map((item) => createTypedArg(item)),
+                value: value.map(item => createTypedArg(item)),
             };
         }
         if (typeof value === "object") {
@@ -1889,7 +1895,7 @@ function rawGtvToGtx(gtv) {
     if (!Array.isArray(gtvArray[1])) {
         throw new Error("Second element must be an array");
     }
-    gtvArray[1].forEach((element) => {
+    gtvArray[1].forEach(element => {
         if (!Buffer.isBuffer(element)) {
             throw new Error("Element must be a buffer");
         }
@@ -1911,14 +1917,14 @@ function rawGtvToGtxBody(gtv) {
     if (!Array.isArray(array[2])) {
         throw new Error("Third element must be an array");
     }
-    array[2].forEach((element) => {
+    array[2].forEach(element => {
         if (!Buffer.isBuffer(element)) {
             throw new Error("Element must be a buffer");
         }
     });
     return {
         blockchainRid: array[0],
-        operations: array[1].map((element) => rawGtvToRellOp(element)),
+        operations: array[1].map(element => rawGtvToRellOp(element)),
         signers: array[2],
     };
 }
@@ -2096,10 +2102,10 @@ function createClient$1(restApiClient, blockchainRid, functionNames) {
                         ? `privkey: ${privOrSigProv.toString("hex")}`
                         : `signature provider [pubKey: ${privOrSigProv.pubKey}]`}`);
                     if (privOrSigProv instanceof require$$0$1.Buffer) {
-                        yield sign(this.gtx, privOrSigProv, pubKey);
+                        yield sign(gtx$1, privOrSigProv, pubKey);
                     }
                     else {
-                        yield sign(this.gtx, privOrSigProv);
+                        yield sign(gtx$1, privOrSigProv);
                     }
                 });
             },
@@ -2110,28 +2116,31 @@ function createClient$1(restApiClient, blockchainRid, functionNames) {
                 return getDigestToSign(this.gtx);
             },
             addSignature: function (pubKey, signature) {
-                addSignature(pubKey, signature, this.gtx);
+                addSignature(pubKey, signature, gtx$1);
             },
             // raw call
             addOperation: function (name, ...args) {
-                addTransactionToGtx(name, args, this.gtx);
+                addTransactionToGtx(name, args, gtx$1);
             },
             postAndWaitConfirmation() {
-                return restApiClient.postAndWaitConfirmation(serialize(this.gtx), this.getTxRID());
+                return restApiClient.postAndWaitConfirmation(serialize(gtx$1), this.getTxRID());
             },
             send: function (callback) {
-                const gtxBytes = serialize(this.gtx);
+                const gtxBytes = serialize(gtx$1);
                 restApiClient.postTransaction(gtxBytes, callback);
-                this.gtx = null;
+                // Todo it seems like an error to set a non nullable parent function's input to null
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                gtx$1 = null;
                 this.gtxBytes = gtxBytes;
             },
             encode: function () {
-                return serialize(this.gtx);
+                return serialize(gtx$1);
             },
         };
     }
     function addFunctions(req) {
-        functionNames.forEach((functionName) => {
+        functionNames.forEach(functionName => {
             req[functionName] = function (...args) {
                 addTransactionToGtx(functionName, args, this.gtx);
             };
@@ -2141,7 +2150,7 @@ function createClient$1(restApiClient, blockchainRid, functionNames) {
         newTransaction: function (signers) {
             signers = removeDuplicateSigners(signers);
             const newGtx = emptyGtx(require$$0$1.Buffer.from(blockchainRid, "hex"));
-            signers.forEach((signer) => addSignerToGtx(signer, newGtx));
+            signers.forEach(signer => addSignerToGtx(signer, newGtx));
             const req = transaction(newGtx);
             addFunctions(req);
             return req;
@@ -2170,14 +2179,6 @@ var gtxclient = /*#__PURE__*/Object.freeze({
 	createClient: createClient$1
 });
 
-var ResponseStatus;
-(function (ResponseStatus) {
-    ResponseStatus["Confirmed"] = "confirmed";
-    ResponseStatus["Rejected"] = "rejected";
-    ResponseStatus["Unknown"] = "unknown";
-    ResponseStatus["Waiting"] = "waiting";
-})(ResponseStatus || (ResponseStatus = {}));
-
 class TxRejectedError extends Error {
     constructor(rejectReason) {
         super(`Transaction was rejected, ${rejectReason}`);
@@ -2318,7 +2319,7 @@ function post(path, endpoint, requestBody) {
                 return {
                     error: null,
                     statusCode: response.status,
-                    rspBody: decodeValue(require$$0$1.Buffer.from(yield response.arrayBuffer())),
+                    rspBody: yield constructBufferPostResponseBody(response),
                 };
             }
             catch (error) {
@@ -2330,11 +2331,15 @@ function post(path, endpoint, requestBody) {
                 const response = yield fetch(new URL(path, endpoint).href, {
                     method: "post",
                     body: JSON.stringify(requestBody),
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                    },
                 });
                 return {
                     error: null,
                     statusCode: response.status,
-                    rspBody: yield response.json(),
+                    rspBody: yield constructBufferPostResponseBody(response),
                 };
             }
             catch (error) {
@@ -2343,6 +2348,21 @@ function post(path, endpoint, requestBody) {
         }
     });
 }
+function constructBufferPostResponseBody(response) {
+    return __awaiter$a(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$1.Buffer.from(responseBuffer);
+            return decodeValue(buffer);
+        }
+        if (contentType === "application/json") {
+            return yield response.json();
+        }
+        const responseText = yield response.text();
+        return responseText ? responseText : response.statusText;
+    });
+}
 
 var __awaiter$9 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -2363,7 +2383,7 @@ function abortOnError({ method, path, config, postObject, }) {
             path,
             config,
             postObject,
-            validateStatusCode: (statuscode) => !hasServerError(statuscode),
+            validateStatusCode: statuscode => !hasServerError(statuscode),
         });
     });
 }
@@ -2374,7 +2394,7 @@ function tryNextOnError({ method, path, config, postObject, }) {
             path,
             config,
             postObject,
-            validateStatusCode: (statusCode) => !hasClientError(statusCode) && !hasServerError(statusCode),
+            validateStatusCode: statusCode => !hasClientError(statusCode) && !hasServerError(statusCode),
         });
     });
 }
@@ -2394,9 +2414,9 @@ function queryMajority({ method, path, config, postObject, }) {
             nodeManager.makeAllNodesAvailable();
         }
         const outcomes = [];
-        const promises = nodeManager.getAvailableNodes().map((node) => {
+        const promises = nodeManager.getAvailableNodes().map(node => {
             return handleRequest(method, path, node.url, postObject)
-                .then((response) => {
+                .then(response => {
                 const { statusCode } = response;
                 if (statusCode && isSuccessfullRequest(statusCode)) {
                     outcomes.push({ type: "SUCCESS", result: response });
@@ -2420,17 +2440,16 @@ function queryMajority({ method, path, config, postObject, }) {
             remainingPromises = yield racePromisesWithTimeout(remainingPromises, timeout);
         }
         // Evaluate the outcomes
-        const successfullOutcomes = outcomes.filter((outcome) => outcome.type === "SUCCESS");
-        const failureOutcomes = outcomes.filter((outcome) => outcome.type === "FAILURE");
-        const errorOutcomes = outcomes.filter((outcome) => outcome.type === "ERROR");
+        const successfullOutcomes = 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);
         // validate the responses
         // eslint-disable-next-line no-constant-condition
         while (true) {
             // Successfull majority response was found
-            if (groupedSuccessfullResponses.maxNumberOfEqualResponses() >=
-                bftMajorityThreshold) {
+            if (groupedSuccessfullResponses.maxNumberOfEqualResponses() >= bftMajorityThreshold) {
                 if (groupedSuccessfullResponses.numberOfDistinctResponses() > 1) {
                     warning(`Got disagreeing responses, but could still reach BFT majority`);
                 }
@@ -2460,11 +2479,12 @@ function singleEndpoint({ method, path, config, postObject, }) {
         let statusCode, rspBody, error;
         const { nodeManager } = config;
         const endpoint = nodeManager.getNode();
+        if (!endpoint) {
+            throw new Error("Cannot get endpoint. Node not found!");
+        }
         for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
             ({ error, statusCode, rspBody } = yield handleRequest(method, path, endpoint.url, postObject));
-            const isError = statusCode
-                ? hasServerError(statusCode) || hasClientError(statusCode)
-                : false;
+            const isError = statusCode ? hasServerError(statusCode) || hasClientError(statusCode) : false;
             if (!isError && !error) {
                 return { error, statusCode, rspBody };
             }
@@ -2486,9 +2506,7 @@ function retryRequest({ method, path, config, postObject, validateStatusCode, })
         for (const endpoint of nodeManager.getAvailableNodes()) {
             for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
                 ({ error, statusCode, rspBody } = yield handleRequest(method, path, endpoint.url, postObject));
-                const isStatusCodeValid = statusCode
-                    ? validateStatusCode(statusCode)
-                    : false;
+                const isStatusCodeValid = statusCode ? validateStatusCode(statusCode) : false;
                 const isServerError = statusCode ? hasServerError(statusCode) : false;
                 if (isStatusCodeValid && !error) {
                     // Find a way to have this handled more elegantly in the node manager.
@@ -2548,77 +2566,75 @@ class GetTransactionRidException extends CustomError {
     }
 }
 
-/*
-This file is part of web3.js.
-
-web3.js is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-web3.js is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
+const BufferSchema = zod.z.union([zod.z.instanceof(Uint8Array), zod.z.instanceof(Buffer)]);
 
-You should have received a copy of the GNU Lesser General Public License
-along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
-*/
-class Web3EventEmitter {
-    constructor() {
-        this._emitter = new events.EventEmitter();
-    }
-    on(eventName, fn) {
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        this._emitter.on(eventName, fn);
-    }
-    once(eventName, fn) {
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        this._emitter.once(eventName, fn);
+const TxRidSchema = BufferSchema.refine(x => x.length === 32, "Rid must be 32 bytes long");
+const isTxRidValid = (rid, options) => {
+    const TxRidValidationContext = TxRidSchema.safeParse(rid);
+    const { throwOnError = false } = options || {};
+    const hasError = "error" in TxRidValidationContext;
+    if (!hasError) {
+        return { success: true };
     }
-    off(eventName, fn) {
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        this._emitter.off(eventName, fn);
+    const validationError = new InvalidTxRidException(rid);
+    if (throwOnError) {
+        throw validationError;
     }
-    emit(eventName, params) {
-        this._emitter.emit(eventName, params);
+    return {
+        success: false,
+        error: TxRidValidationContext.error,
+        message: validationError.message,
+    };
+};
+
+const AnchoringTransactionSchema = zod.z.object({
+    txRid: zod.z.instanceof(Buffer).superRefine((rid, refCtx) => {
+        const txRidValidation = TxRidSchema.safeParse(rid);
+        if (!txRidValidation.success)
+            txRidValidation.error.issues.forEach(issue => refCtx.addIssue(issue));
+    }),
+    txData: zod.z.instanceof(Buffer).refine(data => data.length > 0, {
+        message: "txData must be a non-empty Buffer",
+    }),
+    txOpIndex: zod.z.number().int().nonnegative({ message: "txOpIndex must be a non-negative integer" }),
+});
+
+class MissingTransactionProof extends Error {
+    constructor(proofHash, fetchedTxHash) {
+        super(`Unable to verify source transaction proof,transaction hash in proof ${toString(proofHash)} does not match hash from fetched transaction ${toString(fetchedTxHash)}`);
     }
-    listenerCount(eventName) {
-        return this._emitter.listenerCount(eventName);
+}
+class DifferentNumberOfSignersException extends Error {
+    constructor(length, comparableLength) {
+        super(`Transaction signatures amount ${length} do not match expected amount of signers ${comparableLength}`);
     }
-    listeners(eventName) {
-        return this._emitter.listeners(eventName);
+}
+class SignatureException extends Error {
+    constructor(signer) {
+        super(`Expected signer ${toString(signer)} has not signed source transaction`);
     }
-    eventNames() {
-        return this._emitter.eventNames();
+}
+class ProofRidException extends Error {
+    constructor() {
+        super("Unable to verify source transaction proof, got a different transaction from query than we asked for");
     }
-    removeAllListeners() {
-        this._emitter.removeAllListeners();
+}
+class SystemChainException extends Error {
+    constructor(errorMessage) {
+        super(`Query to system chain failed with error: ${errorMessage}`);
     }
-    setMaxListenerWarningThreshold(maxListenersWarningThreshold) {
-        this._emitter.setMaxListeners(maxListenersWarningThreshold);
+}
+class ConfirmationProofException extends Error {
+    constructor(transactionRid) {
+        super(`Unable to fetch confirmation proof for transaction RID: ${toString(transactionRid)}.`);
     }
-    getMaxListeners() {
-        return this._emitter.getMaxListeners();
+}
+class BlockAnchoringException extends Error {
+    constructor() {
+        super(`Block is not present in cluster anchoring chain`);
     }
 }
 
-/*
-This file is part of web3.js.
-
-web3.js is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-web3.js is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
-*/
 var __awaiter$8 = (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) {
@@ -2628,245 +2644,140 @@ var __awaiter$8 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var _a;
-class Web3PromiEvent extends Web3EventEmitter {
-    constructor(executor) {
-        super();
-        // public tag to treat object as promise by different libs
-        // eslint-disable-next-line @typescript-eslint/prefer-as-const
-        this[_a] = "Promise";
-        this._promise = new Promise(executor);
-    }
-    then(onfulfilled, onrejected) {
-        return __awaiter$8(this, void 0, void 0, function* () {
-            return this._promise.then(onfulfilled, onrejected);
-        });
-    }
-    catch(onrejected) {
-        return __awaiter$8(this, void 0, void 0, function* () {
-            return this._promise.catch(onrejected);
-        });
-    }
-    finally(onfinally) {
-        return __awaiter$8(this, void 0, void 0, function* () {
-            return this._promise.finally(onfinally);
-        });
-    }
-    on(eventName, fn) {
-        super.on(eventName, fn);
-        return this;
-    }
-    once(eventName, fn) {
-        super.once(eventName, fn);
-        return this;
-    }
+function getClusterOfBlockchain(client, blockchainRid) {
+    return __awaiter$8(this, void 0, void 0, function* () {
+        try {
+            const clusterName = yield client.query({
+                name: "cm_get_blockchain_cluster",
+                args: { brid: blockchainRid },
+            });
+            return clusterName;
+        }
+        catch (error) {
+            throw new SystemChainException(error.message);
+        }
+    });
 }
-_a = Symbol.toStringTag;
-
-exports.FailoverStrategy = void 0;
-(function (FailoverStrategy) {
-    FailoverStrategy["AbortOnError"] = "abortOnError";
-    FailoverStrategy["TryNextOnError"] = "tryNextOnError";
-    FailoverStrategy["SingleEndpoint"] = "singleEndpoint";
-    FailoverStrategy["QueryMajority"] = "queryMajority";
-})(exports.FailoverStrategy || (exports.FailoverStrategy = {}));
-exports.ResponseStatus = void 0;
-(function (ResponseStatus) {
-    ResponseStatus["Confirmed"] = "confirmed";
-    ResponseStatus["Rejected"] = "rejected";
-    ResponseStatus["Unknown"] = "unknown";
-    ResponseStatus["Waiting"] = "waiting";
-})(exports.ResponseStatus || (exports.ResponseStatus = {}));
-
-const WRONG_STRING_LENGTH = "wrong string length";
-const BlockIdentifierSchema = zod.z.union([
-    zod.z
-        .string()
-        .refine((val) => /^[0-9a-fA-F]{64}$/.test(val), WRONG_STRING_LENGTH),
-    zod.z.number(),
-]);
-const isBlockIdentifierValid = (blockIdentifier, options) => {
-    const ctx = BlockIdentifierSchema.safeParse(blockIdentifier);
-    const { success } = ctx;
-    const hasError = "error" in ctx;
-    const { throwOnError = false } = options || {};
-    if (!hasError) {
-        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 message = (() => {
-        if (isInvalidInputType) {
-            return `Invalid "blockIdentifier" type. Expected string or number, but received ${typeof blockIdentifier}.`;
+function getClusterInfo(client, name) {
+    return __awaiter$8(this, void 0, void 0, function* () {
+        try {
+            const clusterInfo = yield client.query({
+                name: "cm_get_cluster_info",
+                args: { name },
+            });
+            return clusterInfo;
         }
-        if (isInvalidStringLength) {
-            return "Parameter 'blockIdentifier' does not have the correct format (64-character hexadecimal string).";
+        catch (error) {
+            throw new SystemChainException(error.message);
         }
-        return error.issues.map((issue) => issue.message).join(", ");
-    })();
-    if (throwOnError) {
-        throw new Error(message);
-    }
+    });
+}
+function awaitGetAnchoringTransactionForBlockRid(client, blockchainRid, blockRid, statusPollInterval, statusPollCount) {
+    return __awaiter$8(this, void 0, void 0, function* () {
+        let anchoringTransactionResponse = null;
+        for (let i = 0; i < statusPollCount; i++) {
+            anchoringTransactionResponse = yield getAnchoringTransactionForBlockRid(client, blockchainRid, blockRid);
+            if (anchoringTransactionResponse) {
+                const anchoringTransactionValidaiton = AnchoringTransactionSchema.safeParse(anchoringTransactionResponse);
+                if (anchoringTransactionValidaiton.success) {
+                    return anchoringTransactionValidaiton.data;
+                }
+                else if (!anchoringTransactionValidaiton.success) {
+                    throw new TxRejectedError("Invalid anchoring transaction format");
+                }
+            }
+            yield sleep(statusPollInterval);
+        }
+        return anchoringTransactionResponse;
+    });
+}
+function getAnchoringTransactionForBlockRid(client, blockchainRid, blockRid) {
+    return __awaiter$8(this, void 0, void 0, function* () {
+        try {
+            const anchoringTxForBlockRid = yield client.query({
+                name: "get_anchoring_transaction_for_block_rid",
+                args: { blockchain_rid: blockchainRid, block_rid: blockRid },
+            });
+            if (!anchoringTxForBlockRid)
+                return null;
+            return convertToAnchoringTransaction(anchoringTxForBlockRid);
+        }
+        catch (error) {
+            throw new SystemChainException(error.message);
+        }
+    });
+}
+function convertToAnchoringTransaction(responseTx) {
+    const { tx_rid, tx_data, tx_op_index } = responseTx;
     return {
-        success,
-        error,
-        message: error.issues.map((issue) => issue.message).join(", "),
+        txRid: tx_rid,
+        txData: tx_data,
+        txOpIndex: tx_op_index,
     };
-};
-
-const IdentifierSchema = zod.z.union([
-    zod.z.object({
-        blockchainRid: zod.z.undefined(),
-        blockchainIid: zod.z.number(),
-    }),
-    zod.z.object({
-        blockchainRid: zod.z.string(),
-        blockchainIid: zod.z.undefined(),
-    }),
-]);
-const NodeUrlSchema = zod.z.union([
-    zod.z.object({
-        nodeUrlPool: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
-        directoryNodeUrlPool: zod.z.undefined(),
-    }),
-    zod.z.object({
-        nodeUrlPool: zod.z.undefined(),
-        directoryNodeUrlPool: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
-    }),
-]);
-const RestNetworkSettingsSchema = zod.z.object({
-    statusPollingInterval: zod.z.number().optional(),
-    statusPollingCount: zod.z.number().optional(),
-    failOverConfig: zod.z
-        .object({
-        strategy: zod.z.nativeEnum(exports.FailoverStrategy).optional(),
-        attemptsPerEndpoint: zod.z.number().optional(),
-        attemptInterval: zod.z.number().optional(),
-        unreachableDuration: zod.z.number().optional(),
-    })
-        .optional(),
-});
-const validateBlockChainIdentifier = (networkSettings, options) => {
-    const { throwOnError = false } = options || {};
-    const identifierValidationContext = IdentifierSchema.safeParse(networkSettings);
-    if ("error" in identifierValidationContext) {
-        const missingBlockchainIdentifierError = new MissingBlockchainIdentifierError();
-        if (throwOnError) {
-            throw missingBlockchainIdentifierError;
-        }
-        return {
-            success: identifierValidationContext.success,
-            error: identifierValidationContext.error,
-            message: missingBlockchainIdentifierError.message,
-        };
+}
+function calculateBlockRID(decodedTxProof) {
+    const sourceBlockHeader = decodedTxProof.blockHeader;
+    if (!sourceBlockHeader) {
+        throw new Error("Failed to get blockHeader from confirmation proof");
     }
-    return { success: true };
-};
-const validateNodeUrl = (networkSettings, options) => {
-    const { throwOnError = false } = options || {};
-    const nodeUrlValidationContext = NodeUrlSchema.safeParse(networkSettings);
-    if ("error" in nodeUrlValidationContext) {
-        const missingNodeUrlError = new MissingNodeUrlError();
-        if (throwOnError) {
-            throw missingNodeUrlError;
+    const decodeSourceBlockRid = decodeValue(sourceBlockHeader);
+    return gtvHash(decodeSourceBlockRid);
+}
+// 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$8(this, void 0, void 0, function* () {
+        const rawTx = yield sourceClient.getTransaction(txToProveRID);
+        const txGtv = decodeValue(rawTx);
+        const fetchedTxHash = gtvHash(txGtv);
+        if (Buffer.compare(fetchedTxHash, proofHash)) {
+            // We received another hash for tx RID than what was included in proof
+            // Possibly rouge or faulty node(s). Anyway, we need to give up.
+            throw new MissingTransactionProof(proofHash, fetchedTxHash);
         }
-        return {
-            success: nodeUrlValidationContext.success,
-            error: nodeUrlValidationContext.error,
-            message: missingNodeUrlError.message,
-        };
-    }
-    return { success: true };
-};
-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(", ");
-        if (throwOnError) {
-            throw new Error(errorMessage);
+        const fetchedTx = rawGtvToGtx(txGtv);
+        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);
         }
-        return {
-            success: restNetworkSettingsValidationContext.success,
-            error: restNetworkSettingsValidationContext.error,
-            message: errorMessage,
-        };
-    }
-    return { success: true };
-};
-const isNetworkSettingValid = (networkSettings, options) => {
-    const identifierValidationContext = validateBlockChainIdentifier(networkSettings, options);
-    if ("error" in identifierValidationContext) {
-        return identifierValidationContext;
-    }
-    const nodeUrlValidationContext = validateNodeUrl(networkSettings, options);
-    if ("error" in nodeUrlValidationContext) {
-        return nodeUrlValidationContext;
-    }
-    const restNetworkSettingsValidationContext = validateRestNetworkSettings(networkSettings, options);
-    if ("error" in restNetworkSettingsValidationContext) {
-        return restNetworkSettingsValidationContext;
-    }
-    return { success: true };
-};
-
-const BufferSchema = zod.z.union([
-    zod.z.instanceof(Uint8Array),
-    zod.z.instanceof(Buffer),
-]);
-
-const KeyPairSchema = zod.z.object({
-    privKey: BufferSchema,
-    pubKey: BufferSchema,
-});
-const SignatureProviderSchema = zod.z.object({
-    pubKey: BufferSchema,
-    sign: zod.z.function().args(BufferSchema).returns(zod.z.promise(BufferSchema)),
-});
-const SignMethodSchema = zod.z.union([
-    KeyPairSchema,
-    SignatureProviderSchema,
-]);
-const isSignMethodValid = (signMethod, options) => {
-    const signMethodValidationCtx = SignMethodSchema.safeParse(signMethod);
-    const { throwOnError = false } = options || {};
-    const hasError = "error" in signMethodValidationCtx;
-    if (!hasError) {
-        return { success: true };
-    }
-    const message = "Invalid sign method";
-    if (throwOnError) {
-        throw new Error(message);
-    }
-    return {
-        success: false,
-        error: signMethodValidationCtx.error,
-        message,
+        const txRID = getDigestToSign(fetchedTx);
+        if (Buffer.compare(txRID, txToProveRID)) {
+            throw new ProofRidException();
+        }
+        for (const signer of txToProveSigners) {
+            let hasSignature = false;
+            for (const signature of fetchedTx.signatures) {
+                // verify that txRID (hash of gtxBody) signed by signers equals the signatures from network
+                if (checkDigestSignature(txRID, signer, signature)) {
+                    hasSignature = true;
+                    break;
+                }
+            }
+            if (!hasSignature)
+                throw new SignatureException(signer);
+        }
+        return { verifiedTx: fetchedTx, verifiedTxHash: fetchedTxHash };
+    });
+}
+function composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, anchoringTx, anchoringProof, isNetwork = true) {
+    let operationArgs;
+    operationArgs = {
+        sourceBlockchainRid: toBuffer(sourceBlockchainRid),
+        transactionHash: verifiedTxHash,
+        transactionProof: encodeValue(txProof),
     };
-};
-
-const TxRidSchema = BufferSchema.refine((x) => x.length === 32, "Rid must be 32 bytes long");
-const isTxRidValid = (rid, options) => {
-    const TxRidValidationContext = TxRidSchema.safeParse(rid);
-    const { throwOnError = false } = options || {};
-    const hasError = "error" in TxRidValidationContext;
-    if (!hasError) {
-        return { success: true };
-    }
-    const validationError = new InvalidTxRidException(rid);
-    if (throwOnError) {
-        throw validationError;
+    if (isNetwork) {
+        operationArgs = Object.assign(Object.assign({}, operationArgs), { transactionData: anchoringTx === null || anchoringTx === void 0 ? void 0 : anchoringTx.txData, transactionIndex: anchoringTx === null || anchoringTx === void 0 ? void 0 : anchoringTx.txOpIndex, anchoringProof: anchoringProof && encodeValue(anchoringProof) });
     }
     return {
-        success: false,
-        error: TxRidValidationContext.error,
-        message: validationError.message,
+        operations: [
+            {
+                name: "iccf_proof",
+                args: Object.values(operationArgs),
+            },
+        ],
+        signers: iccfTxSigners,
     };
-};
+}
 
 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); }); }
@@ -2877,142 +2788,545 @@ var __awaiter$7 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function createClient(settings) {
+/**
+ * Creates an ICCF (Inter-Chain Communication Framework) proof transaction.
+ * This function generates a proof that a specific transaction has occurred on the source blockchain
+ * and constructs an ICCF proof transaction that can be posted to the target blockchain.
+ *
+ * @param {IClient} client - The client configured to communicate with the management chain.
+ * @param {Buffer} txToProveRid - The RID of the transaction to be proven.
+ * @param {Buffer} txToProveHash - The hash of the transaction to be proven.
+ * @param {PubKey[]} txToProveSigners - An array of public keys representing signers of the transaction to be proven.
+ * @param {string} sourceBlockchainRid - The RID of the source blockchain.
+ * @param {string} targetBlockchainRid - The RID of the target blockchain.
+ * @param {PubKey[]} iccfTxSigners - An array of public keys representing signers of the ICCF proof transaction (optional, default: []).
+ * @param {boolean} forceIntraNetworkIccfOperation - Whether to force the ICCF operation to be performed within the same network (optional, default: false).
+ * @returns {Promise<IccfProof>} A promise that resolves to an ICCF proof object containing the ICCF proof transaction.
+ */
+function createIccfProofTx(client, txToProveRid, txToProveHash, txToProveSigners, sourceBlockchainRid, targetBlockchainRid, iccfTxSigners = [], forceIntraNetworkIccfOperation = false) {
     return __awaiter$7(this, void 0, void 0, function* () {
-        isNetworkSettingValid(settings, { throwOnError: true });
-        return {
-            config: yield getClientConfigFromSettings(settings),
-            query(nameOrQueryObject, args, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
-                    let _name, _args;
-                    if (typeof nameOrQueryObject === "string") {
-                        _name = nameOrQueryObject;
-                        _args = args;
-                    }
-                    else {
-                        _name = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.name;
-                        _args = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.args;
-                    }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `query_gtv/${this.config.blockchainRid}`, this.config, encodeValue(toQueryObjectGTV(_name, _args)));
-                    return new Promise((resolve, reject) => {
-                        handlePostResponse(error, statusCode, rspBody, callbackPromiseBuilder(reject, resolve, callback));
-                    });
-                });
-            },
-            signTransaction(transaction, signMethod, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
-                    debug(`Signing transaction with ${!isKeyPair(signMethod) ? "signature provider containing " : ""}pubKey: ${toString(signMethod.pubKey)}`);
-                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRid);
-                    try {
-                        const signedTx = yield (isKeyPair(signMethod)
-                            ? sign(gtx$1, signMethod.privKey, signMethod.pubKey)
-                            : sign(gtx$1, signMethod));
-                        const gtxBytes = getSerializedGTX(signedTx);
-                        if (typeof callback === "function") {
-                            callback(null, gtxBytes);
-                        }
-                        return gtxBytes;
-                    }
-                    catch (error) {
-                        if (typeof callback === "function") {
-                            callback(error, null);
-                        }
-                        throw new Error(error);
-                    }
-                });
-            },
-            sendTransaction(transaction, doStatusPolling = true, callback = undefined) {
-                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter$7(this, void 0, void 0, function* () {
-                    var _a;
-                    try {
-                        const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRid);
-                        if (gtx$1.signers.length !== ((_a = gtx$1.signatures) === null || _a === void 0 ? void 0 : _a.length)) {
-                            reject(new NumberOfSignersAndSignaturesException());
-                        }
-                        const gtxBytes = getSerializedGTX(gtx$1);
-                        const transactionObject = {
-                            tx: gtxBytes.toString("hex"),
-                        };
-                        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `tx/${this.config.blockchainRid}`, this.config, transactionObject);
-                        const transactionRid = getDigestToSign(gtx$1);
-                        try {
-                            yield handlePostResponsePromisified(error, statusCode, rspBody);
-                            if (typeof callback === "function") {
-                                callback(null, {
-                                    status: exports.ResponseStatus.Waiting,
-                                    statusCode,
-                                    transactionRid: transactionRid,
-                                });
-                            }
-                        }
+        const clientConfiguredToSource = yield createClient({
+            directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool),
+            blockchainRid: sourceBlockchainRid,
+        });
+        const txProof = yield clientConfiguredToSource.getConfirmationProof(txToProveRid);
+        if (!txProof || !txProof.hash) {
+            throw new ConfirmationProofException(txToProveRid);
+        }
+        const proofHash = txProof.hash;
+        const { verifiedTx, verifiedTxHash } = !txToProveHash.equals(proofHash)
+            ? yield fetchAndVerifyTransaction(clientConfiguredToSource, txToProveRid, proofHash, txToProveSigners)
+            : { verifiedTx: null, verifiedTxHash: txToProveHash };
+        const sourceCluster = yield getClusterOfBlockchain(client, toBuffer(sourceBlockchainRid));
+        const targetCluster = yield getClusterOfBlockchain(client, toBuffer(targetBlockchainRid));
+        if (!forceIntraNetworkIccfOperation && sourceCluster === targetCluster) {
+            // intra-cluster
+            const intraClusterProofTx = composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, undefined, undefined, false);
+            return { iccfTx: intraClusterProofTx };
+        }
+        else {
+            // intra-network
+            const anchoringClient = yield getAnchoringClient(client, sourceBlockchainRid, sourceCluster);
+            const clusterAnchoredTx = yield getBlockAnchoringTransaction(clientConfiguredToSource, anchoringClient, undefined, txProof);
+            if (!clusterAnchoredTx) {
+                throw new BlockAnchoringException();
+            }
+            const anchoringProof = yield anchoringClient.getConfirmationProof(clusterAnchoredTx.txRid);
+            const intraNetworkProofTx = composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, clusterAnchoredTx, anchoringProof);
+            return { iccfTx: intraNetworkProofTx, verifiedTx };
+        }
+    });
+}
+/**
+ * Checks whether a given transaction is included in the cluster anchoring chain and returns the
+ * block anchoring transaction. If `txProof` is not provided, it fetches the confirmation proof
+ * using the `sourceClient`.
+ *
+ * @param sourceClient - A client configured to the blockchain where the transaction was made.
+ * @param anchoringClient - The client responsible for querying the anchoring blockchain.
+ * @param txRid - The transaction RID to check for anchoring.
+ * @param txProof - (Optional) The transaction proof for the specified `txRid`.
+ * @returns A Promise that resolves to the anchored transaction response object.
+ */
+function getBlockAnchoringTransaction(sourceClient, anchoringClient, txRid, txProof) {
+    return __awaiter$7(this, void 0, void 0, function* () {
+        if (!txRid && !txProof) {
+            throw Error("Missing a txRid or TxProof");
+        }
+        const confirmationProof = txProof !== null && txProof !== void 0 ? txProof : (txRid && (yield sourceClient.getConfirmationProof(txRid)));
+        if (!confirmationProof) {
+            throw Error("Confirmation proof not found");
+        }
+        const blockRid = calculateBlockRID(confirmationProof);
+        const blockchainRid = sourceClient.config.blockchainRid;
+        const anchoringTxResponse = yield awaitGetAnchoringTransactionForBlockRid(anchoringClient, toBuffer(blockchainRid), blockRid, sourceClient.config.statusPollInterval, sourceClient.config.statusPollCount);
+        return anchoringTxResponse;
+    });
+}
+/**
+ * Checks whether a given transaction is included in the anchoring blockchain.
+ *
+ * @param sourceClient - A client configured to the blockchain where the transaction was made.
+ * @param anchoringClient - The client responsible for querying the anchoring blockchain.
+ * @param txRid - The transaction RID to check for anchoring.
+ * @param txProof - (Optional) The transaction proof for the specified `txRid`.
+ * @returns A Promise that resolves to `true` if the transaction is anchored, `false` otherwise.
+ */
+function isBlockAnchored(sourceClient, anchoringClient, txRid, txProof) {
+    return __awaiter$7(this, void 0, void 0, function* () {
+        return !!(yield getBlockAnchoringTransaction(sourceClient, anchoringClient, txRid, txProof));
+    });
+}
+/**
+ * Gets a client configured for the cluster anchoring blockchain of a cluster. Takes a specific
+ * cluster name or blockchain RID to determine the cluster.
+ * @param client - The client configured to communicate with the management chain.
+ * @param dappBlockchainRid - (Optional) The RID of a blockchain which anchoring wants to be checked.
+ * @param cluster - (Optional) The cluster of interest.
+ * @returns A Promise that resolves to the client configured to a cluster anchoring chain.
+ */
+function getAnchoringClient(client, dappBlockchainRid, cluster) {
+    return __awaiter$7(this, void 0, void 0, function* () {
+        if (!dappBlockchainRid && !cluster) {
+            throw Error("Missing a dapp blockchainRid or cluster name");
+        }
+        const sourceCluster = cluster !== null && cluster !== void 0 ? cluster : (dappBlockchainRid && (yield getClusterOfBlockchain(client, toBuffer(dappBlockchainRid))));
+        if (!sourceCluster) {
+            throw Error("No cluster could be found");
+        }
+        const sourceClusterInfo = yield getClusterInfo(client, sourceCluster);
+        if (!sourceClusterInfo || !sourceClusterInfo.anchoring_chain) {
+            throw Error("Cluster info could not be found");
+        }
+        const networkSettings = Object.assign(Object.assign({}, client.config), { directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool), blockchainRid: toString(sourceClusterInfo.anchoring_chain) });
+        const clientConfiguredToAnchoringchain = yield createClient(networkSettings);
+        return clientConfiguredToAnchoringchain;
+    });
+}
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+class Web3EventEmitter {
+    constructor() {
+        this._emitter = new events.EventEmitter();
+    }
+    on(eventName, fn) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._emitter.on(eventName, fn);
+    }
+    once(eventName, fn) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._emitter.once(eventName, fn);
+    }
+    off(eventName, fn) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._emitter.off(eventName, fn);
+    }
+    emit(eventName, params) {
+        this._emitter.emit(eventName, params);
+    }
+    listenerCount(eventName) {
+        return this._emitter.listenerCount(eventName);
+    }
+    listeners(eventName) {
+        return this._emitter.listeners(eventName);
+    }
+    eventNames() {
+        return this._emitter.eventNames();
+    }
+    removeAllListeners() {
+        this._emitter.removeAllListeners();
+    }
+    setMaxListenerWarningThreshold(maxListenersWarningThreshold) {
+        this._emitter.setMaxListeners(maxListenersWarningThreshold);
+    }
+    getMaxListeners() {
+        return this._emitter.getMaxListeners();
+    }
+}
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+var __awaiter$6 = (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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+class Web3PromiEvent extends Web3EventEmitter {
+    constructor(executor) {
+        super();
+        // public tag to treat object as promise by different libs
+        // eslint-disable-next-line @typescript-eslint/prefer-as-const
+        this[_a] = "Promise";
+        this._promise = new Promise(executor);
+    }
+    then(onfulfilled, onrejected) {
+        return __awaiter$6(this, void 0, void 0, function* () {
+            return this._promise.then(onfulfilled, onrejected);
+        });
+    }
+    catch(onrejected) {
+        return __awaiter$6(this, void 0, void 0, function* () {
+            return this._promise.catch(onrejected);
+        });
+    }
+    finally(onfinally) {
+        return __awaiter$6(this, void 0, void 0, function* () {
+            return this._promise.finally(onfinally);
+        });
+    }
+    on(eventName, fn) {
+        super.on(eventName, fn);
+        return this;
+    }
+    once(eventName, fn) {
+        super.once(eventName, fn);
+        return this;
+    }
+}
+_a = Symbol.toStringTag;
+
+exports.FailoverStrategy = void 0;
+(function (FailoverStrategy) {
+    FailoverStrategy["AbortOnError"] = "abortOnError";
+    FailoverStrategy["TryNextOnError"] = "tryNextOnError";
+    FailoverStrategy["SingleEndpoint"] = "singleEndpoint";
+    FailoverStrategy["QueryMajority"] = "queryMajority";
+})(exports.FailoverStrategy || (exports.FailoverStrategy = {}));
+exports.ResponseStatus = void 0;
+(function (ResponseStatus) {
+    ResponseStatus["Confirmed"] = "confirmed";
+    ResponseStatus["Rejected"] = "rejected";
+    ResponseStatus["Unknown"] = "unknown";
+    ResponseStatus["Waiting"] = "waiting";
+})(exports.ResponseStatus || (exports.ResponseStatus = {}));
+exports.AnchoringStatus = void 0;
+(function (AnchoringStatus) {
+    AnchoringStatus["NotAnchored"] = "notAnchored";
+    AnchoringStatus["ClusterAnchored"] = "clusterAnchored";
+    AnchoringStatus["SystemAnchored"] = "systemAnchored";
+    AnchoringStatus["FailedAnchoring"] = "failedAnchoring";
+})(exports.AnchoringStatus || (exports.AnchoringStatus = {}));
+exports.ChainConfirmationLevel = void 0;
+(function (ChainConfirmationLevel) {
+    ChainConfirmationLevel["None"] = "none";
+    ChainConfirmationLevel["Dapp"] = "dapp";
+    ChainConfirmationLevel["ClusterAnchoring"] = "clusterAnchoring";
+    ChainConfirmationLevel["SystemAnchoring"] = "systemAnchoring";
+    ChainConfirmationLevel["EvmNetwork"] = "evmNetwork";
+})(exports.ChainConfirmationLevel || (exports.ChainConfirmationLevel = {}));
+
+const WRONG_STRING_LENGTH = "wrong string length";
+const BlockIdentifierSchema = zod.z.union([
+    zod.z.string().refine(val => /^[0-9a-fA-F]{64}$/.test(val), WRONG_STRING_LENGTH),
+    zod.z.number(),
+]);
+const isBlockIdentifierValid = (blockIdentifier, options) => {
+    const ctx = BlockIdentifierSchema.safeParse(blockIdentifier);
+    const { success } = ctx;
+    const hasError = "error" in ctx;
+    const { throwOnError = false } = options || {};
+    if (!hasError) {
+        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 message = (() => {
+        if (isInvalidInputType) {
+            return `Invalid "blockIdentifier" type. Expected string or number, but received ${typeof blockIdentifier}.`;
+        }
+        if (isInvalidStringLength) {
+            return "Parameter 'blockIdentifier' does not have the correct format (64-character hexadecimal string).";
+        }
+        return error.issues.map(issue => issue.message).join(", ");
+    })();
+    if (throwOnError) {
+        throw new Error(message);
+    }
+    return {
+        success,
+        error,
+        message: error.issues.map(issue => issue.message).join(", "),
+    };
+};
+
+const IdentifierSchema = zod.z.union([
+    zod.z.object({
+        blockchainRid: zod.z.undefined(),
+        blockchainIid: zod.z.number(),
+    }),
+    zod.z.object({
+        blockchainRid: zod.z.string(),
+        blockchainIid: zod.z.undefined(),
+    }),
+]);
+const NodeUrlSchema = zod.z.union([
+    zod.z.object({
+        nodeUrlPool: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
+        directoryNodeUrlPool: zod.z.undefined(),
+    }),
+    zod.z.object({
+        nodeUrlPool: zod.z.undefined(),
+        directoryNodeUrlPool: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
+    }),
+]);
+const RestNetworkSettingsSchema = zod.z.object({
+    statusPollingInterval: zod.z.number().optional(),
+    statusPollingCount: zod.z.number().optional(),
+    failOverConfig: zod.z
+        .object({
+        strategy: zod.z.nativeEnum(exports.FailoverStrategy).optional(),
+        attemptsPerEndpoint: zod.z.number().optional(),
+        attemptInterval: zod.z.number().optional(),
+        unreachableDuration: zod.z.number().optional(),
+    })
+        .optional(),
+});
+const validateBlockChainIdentifier = (networkSettings, options) => {
+    const { throwOnError = false } = options || {};
+    const identifierValidationContext = IdentifierSchema.safeParse(networkSettings);
+    if ("error" in identifierValidationContext) {
+        const missingBlockchainIdentifierError = new MissingBlockchainIdentifierError();
+        if (throwOnError) {
+            throw missingBlockchainIdentifierError;
+        }
+        return {
+            success: identifierValidationContext.success,
+            error: identifierValidationContext.error,
+            message: missingBlockchainIdentifierError.message,
+        };
+    }
+    return { success: true };
+};
+const validateNodeUrl = (networkSettings, options) => {
+    const { throwOnError = false } = options || {};
+    const nodeUrlValidationContext = NodeUrlSchema.safeParse(networkSettings);
+    if ("error" in nodeUrlValidationContext) {
+        const missingNodeUrlError = new MissingNodeUrlError();
+        if (throwOnError) {
+            throw missingNodeUrlError;
+        }
+        return {
+            success: nodeUrlValidationContext.success,
+            error: nodeUrlValidationContext.error,
+            message: missingNodeUrlError.message,
+        };
+    }
+    return { success: true };
+};
+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(", ");
+        if (throwOnError) {
+            throw new Error(errorMessage);
+        }
+        return {
+            success: restNetworkSettingsValidationContext.success,
+            error: restNetworkSettingsValidationContext.error,
+            message: errorMessage,
+        };
+    }
+    return { success: true };
+};
+const isNetworkSettingValid = (networkSettings, options) => {
+    const identifierValidationContext = validateBlockChainIdentifier(networkSettings, options);
+    if ("error" in identifierValidationContext) {
+        return identifierValidationContext;
+    }
+    const nodeUrlValidationContext = validateNodeUrl(networkSettings, options);
+    if ("error" in nodeUrlValidationContext) {
+        return nodeUrlValidationContext;
+    }
+    const restNetworkSettingsValidationContext = validateRestNetworkSettings(networkSettings, options);
+    if ("error" in restNetworkSettingsValidationContext) {
+        return restNetworkSettingsValidationContext;
+    }
+    return { success: true };
+};
+
+const KeyPairSchema = zod.z.object({
+    privKey: BufferSchema,
+    pubKey: BufferSchema,
+});
+const SignatureProviderSchema = zod.z.object({
+    pubKey: BufferSchema,
+    sign: zod.z.function().args(BufferSchema).returns(zod.z.promise(BufferSchema)),
+});
+const SignMethodSchema = zod.z.union([KeyPairSchema, SignatureProviderSchema]);
+const isSignMethodValid = (signMethod, options) => {
+    const signMethodValidationCtx = SignMethodSchema.safeParse(signMethod);
+    const { throwOnError = false } = options || {};
+    const hasError = "error" in signMethodValidationCtx;
+    if (!hasError) {
+        return { success: true };
+    }
+    const message = "Invalid sign method";
+    if (throwOnError) {
+        throw new Error(message);
+    }
+    return {
+        success: false,
+        error: signMethodValidationCtx.error,
+        message,
+    };
+};
+
+var __awaiter$5 = (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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function createClient(settings) {
+    return __awaiter$5(this, void 0, void 0, function* () {
+        isNetworkSettingValid(settings, { throwOnError: true });
+        const config = yield getClientConfigFromSettings(settings);
+        return {
+            config,
+            query(nameOrQueryObject, args, callback) {
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    let _name, _args;
+                    if (typeof nameOrQueryObject === "string") {
+                        _name = nameOrQueryObject;
+                        _args = args;
+                    }
+                    else {
+                        _name = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.name;
+                        _args = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.args;
+                    }
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `query_gtv/${config.blockchainRid}`, config, encodeValue(toQueryObjectGTV(_name, _args)));
+                    return new Promise((resolve, reject) => {
+                        handlePostResponse(error, statusCode, rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                    });
+                });
+            },
+            signTransaction(transaction, signMethod, callback) {
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    debug(`Signing transaction with ${!isKeyPair(signMethod) ? "signature provider containing " : ""}pubKey: ${toString(signMethod.pubKey)}`);
+                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, config.blockchainRid);
+                    try {
+                        const signedTx = yield (isKeyPair(signMethod)
+                            ? sign(gtx$1, signMethod.privKey, signMethod.pubKey)
+                            : sign(gtx$1, signMethod));
+                        const gtxBytes = getSerializedGTX(signedTx);
+                        if (typeof callback === "function") {
+                            callback(null, gtxBytes);
+                        }
+                        return gtxBytes;
+                    }
+                    catch (error) {
+                        if (typeof callback === "function") {
+                            callback(error, null);
+                        }
+                        throw new Error(error);
+                    }
+                });
+            },
+            sendTransaction(transaction, doStatusPolling = true, callback, confirmationLevel = exports.ChainConfirmationLevel.Dapp) {
+                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter$5(this, void 0, void 0, function* () {
+                    var _a;
+                    try {
+                        const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, config.blockchainRid);
+                        if (gtx$1.signers.length !== ((_a = gtx$1.signatures) === null || _a === void 0 ? void 0 : _a.length)) {
+                            reject(new NumberOfSignersAndSignaturesException());
+                        }
+                        const gtxBytes = getSerializedGTX(gtx$1);
+                        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `tx/${config.blockchainRid}`, config, gtxBytes);
+                        const transactionRid = getDigestToSign(gtx$1);
+                        try {
+                            yield handlePostResponsePromisified(error, statusCode, rspBody);
+                            if (typeof callback === "function") {
+                                callback(null, {
+                                    status: exports.ResponseStatus.Waiting,
+                                    statusCode,
+                                    transactionRid: transactionRid,
+                                });
+                            }
+                        }
                         catch (_error) {
                             if (typeof callback === "function") {
                                 callback(_error, null);
                             }
                             return reject(_error);
                         }
-                        const transactionReceipt = {
-                            status: exports.ResponseStatus.Waiting,
-                            statusCode: statusCode,
-                            transactionRid: transactionRid,
-                        };
-                        promiEvent.emit("sent", transactionReceipt);
-                        if (doStatusPolling === false) {
-                            return resolve(transactionReceipt);
-                        }
-                        const awaitConfirmation = (txRID) => __awaiter$7(this, void 0, void 0, function* () {
-                            var _b;
-                            let lastKnownResult;
-                            for (let i = 0; i < this.config.statusPollCount; i++) {
-                                lastKnownResult = yield this.getTransactionStatus(txRID);
-                                if (lastKnownResult.status === exports.ResponseStatus.Confirmed) {
-                                    return exports.ResponseStatus.Confirmed;
-                                }
-                                else if (lastKnownResult.status === exports.ResponseStatus.Rejected) {
-                                    throw new TxRejectedError((_b = lastKnownResult.rejectReason) !== null && _b !== void 0 ? _b : "");
-                                }
-                                yield sleep(this.config.statusPollInterval);
-                            }
-                            // TS issue. This could be fixed by implementing new retry strategy
-                            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                            //@ts-expect-error
-                            return lastKnownResult.status;
-                        });
-                        const confirmationStatus = yield awaitConfirmation(getDigestToSign(gtx$1));
-                        resolve({
-                            status: confirmationStatus,
-                            statusCode: statusCode,
-                            transactionRid: transactionRid,
-                        });
+                        const client = this;
+                        resolve(yield handleTransactionConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusCode, config.statusPollInterval, config.statusPollCount, () => client.getTransactionStatus(transactionRid, callback), () => client.getClusterAnchoringTransactionConfirmation(transactionRid, callback), anchoredTxRid => client.getSystemAnchoringTransactionConfirmation(anchoredTxRid, callback)));
                     }
                     catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
                         reject(error);
                     }
                 }));
                 return promiEvent;
             },
-            signAndSendUniqueTransaction(transactionOrOperation, signMethod, doStatusPolling = true, callback = undefined) {
+            signAndSendUniqueTransaction(transactionOrOperation, signMethod, doStatusPolling = true, callback, confirmationLevel = exports.ChainConfirmationLevel.Dapp) {
                 isSignMethodValid(signMethod, { throwOnError: true });
                 const promiEvent = new Web3PromiEvent((resolve, reject) => {
+                    const client = this;
                     const transaction = "name" in transactionOrOperation
                         ? {
                             operations: [transactionOrOperation],
                             signers: [signMethod.pubKey],
                         }
                         : transactionOrOperation;
-                    const hasNop = transaction.operations.some((operation) => {
+                    const hasNop = transaction.operations.some(operation => {
                         return operation.name === "nop";
                     });
-                    const transactionWithNop = hasNop
-                        ? transaction
-                        : this.addNop(transaction);
-                    this.signTransaction(transactionWithNop, signMethod)
+                    const transactionWithNop = hasNop ? transaction : client.addNop(transaction);
+                    client
+                        .signTransaction(transactionWithNop, signMethod)
                         .then((signedTx) => {
-                        const sendTransactionPromiEvent = this.sendTransaction(signedTx, doStatusPolling, callback);
+                        const sendTransactionPromiEvent = client.sendTransaction(signedTx, doStatusPolling, callback, confirmationLevel);
                         sendTransactionPromiEvent.on("sent", (receipt) => {
                             promiEvent.emit("sent", receipt);
                         });
-                        resolve(sendTransactionPromiEvent);
+                        sendTransactionPromiEvent
+                            .then((receipt) => {
+                            resolve(receipt);
+                        })
+                            .catch((error) => {
+                            reject(error);
+                        });
                     })
                         .catch((error) => {
                         reject(error);
@@ -3021,7 +3335,7 @@ function createClient(settings) {
                 return promiEvent;
             },
             getTransaction(transactionRid, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     try {
                         isTxRidValid(transactionRid, { throwOnError: true });
                     }
@@ -3029,14 +3343,14 @@ function createClient(settings) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${this.config.blockchainRid}/${transactionRid.toString("hex")}`, this.config);
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${config.blockchainRid}/${transactionRid.toString("hex")}`, config);
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, statusCode === 200 ? toBuffer(rspBody.tx) : rspBody, callbackPromiseBuilder(reject, resolve, callback));
                     });
                 });
             },
             getTransactionStatus(transactionRid, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     try {
                         isTxRidValid(transactionRid, { throwOnError: true });
                     }
@@ -3044,7 +3358,7 @@ function createClient(settings) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${this.config.blockchainRid}/${transactionRid.toString("hex")}/status`, this.config);
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${config.blockchainRid}/${transactionRid.toString("hex")}/status`, config);
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, rspBody, callbackPromiseBuilder(reject, resolve, callback));
                     });
@@ -3061,7 +3375,7 @@ function createClient(settings) {
             },
             getTransactionRid(transaction) {
                 try {
-                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRid);
+                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, config.blockchainRid);
                     return getDigestToSign(gtx$1);
                 }
                 catch (e) {
@@ -3069,21 +3383,17 @@ function createClient(settings) {
                 }
             },
             getTransactionsInfo(limit = 25, beforeTime, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
-                    const beforeTimeQueryParam = beforeTime
-                        ? `&before-time=${beforeTime.getTime()}`
-                        : "";
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${this.config.blockchainRid}?limit=${limit}${beforeTimeQueryParam}`, this.config);
-                    const body = statusCode === 200
-                        ? rspBody === null || rspBody === void 0 ? void 0 : rspBody.map(formatTransactionInfoResponse)
-                        : rspBody;
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    const beforeTimeQueryParam = beforeTime ? `&before-time=${beforeTime.getTime()}` : "";
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${config.blockchainRid}?limit=${limit}${beforeTimeQueryParam}`, config);
+                    const body = statusCode === 200 ? rspBody === null || rspBody === void 0 ? void 0 : rspBody.map(formatTransactionInfoResponse) : rspBody;
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, body, callbackPromiseBuilder(reject, resolve, callback));
                     });
                 });
             },
             getTransactionInfo(transactionRid, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     try {
                         isTxRidValid(transactionRid, { throwOnError: true });
                     }
@@ -3091,30 +3401,75 @@ function createClient(settings) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${this.config.blockchainRid}/${toString(transactionRid)}`, this.config);
-                    const body = statusCode === 200 && rspBody
-                        ? formatTransactionInfoResponse(rspBody)
-                        : rspBody;
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${config.blockchainRid}/${toString(transactionRid)}`, config);
+                    const body = statusCode === 200 && rspBody ? formatTransactionInfoResponse(rspBody) : rspBody;
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, body, callbackPromiseBuilder(reject, resolve, callback));
                     });
                 });
             },
+            getTransactionConfirmationLevel(transactionRid, callback) {
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    try {
+                        const client = this;
+                        const dappConfirmation = yield client.getTransactionStatus(transactionRid);
+                        const response = {
+                            status: dappConfirmation.status,
+                            statusCode: 200,
+                            transactionRid,
+                        };
+                        if (dappConfirmation.status === exports.ResponseStatus.Waiting) {
+                            return response;
+                        }
+                        let clusterAnchoringResult = null;
+                        if (dappConfirmation.status === exports.ResponseStatus.Confirmed) {
+                            clusterAnchoringResult = yield client.getClusterAnchoringTransactionConfirmation(transactionRid);
+                            if (clusterAnchoringResult === exports.AnchoringStatus.NotAnchored || !clusterAnchoringResult) {
+                                return response;
+                            }
+                            if (clusterAnchoringResult === exports.AnchoringStatus.FailedAnchoring) {
+                                response.status = exports.AnchoringStatus.FailedAnchoring;
+                                response.statusCode = 400;
+                                return response;
+                            }
+                            const anchoringTransactionValidation = AnchoringTransactionSchema.safeParse(clusterAnchoringResult);
+                            if (!anchoringTransactionValidation.success) {
+                                return response;
+                            }
+                            if (anchoringTransactionValidation.success) {
+                                response.status = exports.AnchoringStatus.ClusterAnchored;
+                                response.statusCode = 200;
+                                response["clusterAnchoredTx"] = anchoringTransactionValidation.data;
+                                const systemAnchoringResult = yield client.getSystemAnchoringTransactionConfirmation(anchoringTransactionValidation.data.txRid);
+                                if (!systemAnchoringResult) {
+                                    return response;
+                                }
+                                response.status = exports.AnchoringStatus.SystemAnchored;
+                                response["systemAnchoredTx"] = systemAnchoringResult;
+                                return response;
+                            }
+                        }
+                        return response;
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        throw error;
+                    }
+                });
+            },
             getTransactionCount(callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${this.config.blockchainRid}/count`, this.config, undefined, true);
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${config.blockchainRid}/count`, config, undefined, true);
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, statusCode === 200 ? rspBody.transactionsCount : rspBody, callbackPromiseBuilder(reject, resolve, callback));
                     });
                 });
             },
             getBlockInfo(blockIdentifier, txs = false, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     isBlockIdentifierValid(blockIdentifier, { throwOnError: true });
-                    const queryString = typeof blockIdentifier === "string"
-                        ? blockIdentifier
-                        : `height/${blockIdentifier}`;
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${this.config.blockchainRid}/${queryString}?txs=${txs}`, this.config);
+                    const queryString = typeof blockIdentifier === "string" ? blockIdentifier : `height/${blockIdentifier}`;
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}/${queryString}?txs=${txs}`, config);
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, statusCode === 200 && rspBody !== null && rspBody
                             ? formatBlockInfoResponse(rspBody)
@@ -3123,9 +3478,9 @@ function createClient(settings) {
                 });
             },
             getLatestBlock(txs = false, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     const shouldIncludeFullTransaction = txs ? `&txs=${txs}` : "";
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${this.config.blockchainRid}?limit=1${shouldIncludeFullTransaction}`, this.config, undefined, true);
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}?limit=1${shouldIncludeFullTransaction}`, config, undefined, true);
                     const indexOfLatestBlock = 0;
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, statusCode === 200 && rspBody !== null && rspBody
@@ -3134,8 +3489,8 @@ function createClient(settings) {
                     });
                 });
             },
-            getBlocks({ limit, beforeTime, afterTime, beforeHeight, afterHeight, txs, callback, }) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+            getBlocks({ limit, beforeTime, afterTime, beforeHeight, afterHeight, txs, callback }) {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     const searchValues = {
                         limit,
                         txs,
@@ -3150,16 +3505,14 @@ function createClient(settings) {
                             searchParams.append(key, value.toString());
                         }
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${this.config.blockchainRid}?${searchParams}`, this.config);
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}?${searchParams}`, config);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 && rspBody
-                            ? rspBody.map(formatBlockInfoResponse)
-                            : rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                        handleGetResponse(error, statusCode, statusCode === 200 && rspBody ? rspBody.map(formatBlockInfoResponse) : rspBody, callbackPromiseBuilder(reject, resolve, callback));
                     });
                 });
             },
             getBlocksInfo(limit = 25, beforeTime, beforeHeight, txs, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     let filteringQueryParam = "";
                     if (beforeTime) {
                         filteringQueryParam = `&before-time=${beforeTime.getTime()}`;
@@ -3168,16 +3521,14 @@ function createClient(settings) {
                         filteringQueryParam = `&before-height=${beforeHeight}`;
                     }
                     const shouldIncludeFullTransaction = txs ? `&txs=${txs}` : "";
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${this.config.blockchainRid}?limit=${limit}${filteringQueryParam}${shouldIncludeFullTransaction}`, this.config);
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}?limit=${limit}${filteringQueryParam}${shouldIncludeFullTransaction}`, config);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 && rspBody
-                            ? rspBody.map(formatBlockInfoResponse)
-                            : rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                        handleGetResponse(error, statusCode, statusCode === 200 && rspBody ? rspBody.map(formatBlockInfoResponse) : rspBody, callbackPromiseBuilder(reject, resolve, callback));
                     });
                 });
             },
             encodeTransaction(transaction) {
-                const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRid);
+                const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, config.blockchainRid);
                 return serialize(gtx$1);
             },
             decodeTransactionToGtx(encodedTransaction) {
@@ -3186,7 +3537,7 @@ function createClient(settings) {
                 return gtx$1;
             },
             getClientNodeUrlPool() {
-                return this.config.endpointPool.map((endpoint) => endpoint.url);
+                return config.endpointPool.map((endpoint) => endpoint.url);
             },
             /**
              * Retrieves a confirmation proof for a transaction with the specified sha256
@@ -3213,8 +3564,8 @@ function createClient(settings) {
              * The signatures must be validated agains some know trusted source for valid signers
              * at this specific block height.
              */
-            getConfirmationProof: function (txRid, callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
+            getConfirmationProof(txRid, callback) {
+                return __awaiter$5(this, void 0, void 0, function* () {
                     try {
                         isTxRidValid(txRid, { throwOnError: true });
                     }
@@ -3222,7 +3573,7 @@ function createClient(settings) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${this.config.blockchainRid}/${txRid.toString("hex")}/confirmationProof`, this.config);
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${config.blockchainRid}/${txRid.toString("hex")}/confirmationProof`, config);
                     const confirmationProof = {
                         merkleProofTree: "",
                         txIndex: 0,
@@ -3248,13 +3599,70 @@ function createClient(settings) {
                     });
                 });
             },
+            getClusterAnchoringTransactionConfirmation(transactionRid, callback) {
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    try {
+                        isTxRidValid(transactionRid, { throwOnError: true });
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        throw error;
+                    }
+                    const client = this;
+                    try {
+                        let confirmationProof;
+                        try {
+                            confirmationProof = yield client.getConfirmationProof(transactionRid);
+                        }
+                        catch (error) {
+                            callback === null || callback === void 0 ? void 0 : callback(error, null);
+                            return exports.AnchoringStatus.NotAnchored;
+                        }
+                        const D1Client = yield getSystemClient(getUrlsFromEndpoints(config.endpointPool), config.directoryChainRid);
+                        const anchoringClient = yield getAnchoringClient(D1Client, config.blockchainRid);
+                        const anchoringTransaction = yield getBlockAnchoringTransaction(client, anchoringClient, transactionRid, confirmationProof);
+                        if (!anchoringTransaction)
+                            return exports.AnchoringStatus.NotAnchored;
+                        return anchoringTransaction;
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        return exports.AnchoringStatus.FailedAnchoring;
+                    }
+                });
+            },
+            getSystemAnchoringTransactionConfirmation(anchoredTxRid, callback) {
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    try {
+                        isTxRidValid(anchoredTxRid, { throwOnError: true });
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        throw error;
+                    }
+                    const D1Client = yield getSystemClient(getUrlsFromEndpoints(config.endpointPool), config.directoryChainRid);
+                    const systemAnchoringChainRid = yield getSystemAnchoringChain(D1Client);
+                    if (!systemAnchoringChainRid)
+                        return null;
+                    const systemAnchoringChainClient = yield getSystemClient(getUrlsFromEndpoints(config.endpointPool), systemAnchoringChainRid.toString("hex"));
+                    const anchoringClient = yield getAnchoringClient(D1Client, config.blockchainRid);
+                    const anchoringProof = yield anchoringClient.getConfirmationProof(anchoredTxRid);
+                    const blockRid = calculateBlockRID(anchoringProof);
+                    const systemAnchoringTransactionConfirmation = yield awaitGetAnchoringTransactionForBlockRid(systemAnchoringChainClient, toBuffer(anchoringClient.config.blockchainRid), blockRid, systemAnchoringChainClient.config.statusPollInterval, systemAnchoringChainClient.config.statusPollCount);
+                    const systemAnchoringTransactionValidaiton = AnchoringTransactionSchema.safeParse(systemAnchoringTransactionConfirmation);
+                    if (systemAnchoringTransactionValidaiton.success) {
+                        return systemAnchoringTransactionValidaiton.data;
+                    }
+                    return systemAnchoringTransactionConfirmation;
+                });
+            },
             /**
              * Get app structure. Returns list of app modules in JSON format
              * @param callback - leverages error-first pattern and called when promise resolves
              */
             getAppStructure(callback) {
-                return __awaiter$7(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/query/${this.config.blockchainRid}?type=rell.get_app_structure`, this.config);
+                return __awaiter$5(this, void 0, void 0, function* () {
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/query/${config.blockchainRid}?type=rell.get_app_structure`, config);
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, rspBody, callbackPromiseBuilder(reject, resolve, callback));
                     });
@@ -3273,19 +3681,19 @@ const shuffleArray = (array) => {
     return shuffledArray;
 };
 const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuration = 5000, }) => {
-    const nodes = nodeUrls.map((url) => ({
+    const nodes = nodeUrls.map(url => ({
         url,
         whenAvailable: 0,
         isAvailable: true,
     }));
     return {
-        nodes: nodes,
+        nodes,
         stickedNode: null,
         getAvailableNodes() {
             const shuffledAvailableNodes = shuffleArray(this.nodes.filter((node) => node.isAvailable));
             // set sticky node as the first node, and then shuffle the rest
             if (useStickyNode && this.stickedNode && this.stickedNode.isAvailable) {
-                const nodesWithoutSticky = shuffledAvailableNodes.filter((node) => node !== this.stickedNode);
+                const nodesWithoutSticky = shuffledAvailableNodes.filter(node => node !== this.stickedNode);
                 return [this.stickedNode, ...nodesWithoutSticky];
             }
             return shuffledAvailableNodes;
@@ -3329,7 +3737,7 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
     };
 };
 
-var __awaiter$6 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$4 = (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) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -3340,7 +3748,7 @@ var __awaiter$6 = (undefined && undefined.__awaiter) || function (thisArg, _argu
 };
 function getClientConfigFromSettings(settings) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    return __awaiter$6(this, void 0, void 0, function* () {
+    return __awaiter$4(this, void 0, void 0, function* () {
         const nodeUrlPoolToUse = yield getNodeUrlsFromSettings(settings);
         if (nodeUrlPoolToUse.length === 0) {
             const id = (_b = (_a = settings.blockchainRid) !== null && _a !== void 0 ? _a : settings.blockchainIid) !== null && _b !== void 0 ? _b : "Unknown";
@@ -3352,7 +3760,7 @@ function getClientConfigFromSettings(settings) {
             useStickyNode: (_c = settings.useStickyNode) !== null && _c !== void 0 ? _c : false,
             unavailableDuration: (_d = settings.failOverConfig) === null || _d === void 0 ? void 0 : _d.unreachableDuration,
         });
-        const blockchainRidToUse = yield (() => __awaiter$6(this, void 0, void 0, function* () {
+        const blockchainRidToUse = yield (() => __awaiter$4(this, void 0, void 0, function* () {
             if (settings.blockchainRid) {
                 return settings.blockchainRid;
             }
@@ -3365,6 +3773,17 @@ function getClientConfigFromSettings(settings) {
             }
             throw new MissingBlockchainIdentifierError();
         }))();
+        const directoryChainRid = yield (() => __awaiter$4(this, void 0, void 0, function* () {
+            if (settings.directoryChainRid) {
+                return settings.directoryChainRid;
+            }
+            const directoryChainIid = 0;
+            return yield getBlockchainRidFromIid({
+                nodeManager,
+                endpointPool,
+                chainId: directoryChainIid,
+            });
+        }))();
         return {
             endpointPool,
             nodeManager: nodeManager,
@@ -3372,17 +3791,15 @@ function getClientConfigFromSettings(settings) {
             statusPollInterval: settings.statusPollInterval || 500,
             statusPollCount: settings.statusPollCount || 20,
             failoverStrategy: ((_e = settings.failOverConfig) === null || _e === void 0 ? void 0 : _e.strategy) || defaultFailoverConfig.strategy,
-            attemptsPerEndpoint: ((_f = settings.failOverConfig) === null || _f === void 0 ? void 0 : _f.attemptsPerEndpoint) ||
-                defaultFailoverConfig.attemptsPerEndpoint,
-            attemptInterval: ((_g = settings.failOverConfig) === null || _g === void 0 ? void 0 : _g.attemptInterval) ||
-                defaultFailoverConfig.attemptInterval,
-            unreachableDuration: ((_h = settings.failOverConfig) === null || _h === void 0 ? void 0 : _h.unreachableDuration) ||
-                defaultFailoverConfig.unreachableDuration,
+            attemptsPerEndpoint: ((_f = settings.failOverConfig) === null || _f === void 0 ? void 0 : _f.attemptsPerEndpoint) || defaultFailoverConfig.attemptsPerEndpoint,
+            attemptInterval: ((_g = settings.failOverConfig) === null || _g === void 0 ? void 0 : _g.attemptInterval) || defaultFailoverConfig.attemptInterval,
+            unreachableDuration: ((_h = settings.failOverConfig) === null || _h === void 0 ? void 0 : _h.unreachableDuration) || defaultFailoverConfig.unreachableDuration,
+            directoryChainRid: settings.directoryChainRid || directoryChainRid,
         };
     });
 }
 function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid, }) {
-    return __awaiter$6(this, void 0, void 0, function* () {
+    return __awaiter$4(this, void 0, void 0, function* () {
         if (directoryEndpointPool.length === 0) {
             throw new DirectoryNodeUrlPoolException();
         }
@@ -3396,7 +3813,7 @@ function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blo
             chainId: directoryIid,
             failOverConfig,
         });
-        const blockchainRidToUse = yield (() => __awaiter$6(this, void 0, void 0, function* () {
+        const blockchainRidToUse = yield (() => __awaiter$4(this, void 0, void 0, function* () {
             if (blockchainRid) {
                 return blockchainRid;
             }
@@ -3423,7 +3840,7 @@ function nodeDiscovery({ nodeManager, directoryEndpointPool, failOverConfig, blo
     });
 }
 function convertToRellOperation(operations) {
-    return operations.map((operation) => {
+    return operations.map(operation => {
         var _a;
         return {
             opName: operation.name,
@@ -3480,7 +3897,7 @@ const callbackPromiseBuilder = (reject, resolve, callback) => {
 };
 const handlePostResponsePromisified = (error, statusCode, rspBody) => {
     return new Promise((resolve, reject) => {
-        handlePostResponse(error, statusCode, rspBody, (_error) => {
+        handlePostResponse(error, statusCode, rspBody, _error => {
             if (_error) {
                 reject(_error);
             }
@@ -3516,7 +3933,7 @@ const formatBlockInfoResponse = (blockInfoResponse) => {
         transactions: blockInfoResponse.transactions.map(formatTransaction),
         height: blockInfoResponse.height,
         witness: toBuffer(blockInfoResponse.witness),
-        witnesses: blockInfoResponse.witnesses.map((witness) => {
+        witnesses: blockInfoResponse.witnesses.map(witness => {
             return toBuffer(witness);
         }),
         timestamp: blockInfoResponse.timestamp,
@@ -3542,7 +3959,7 @@ const isKeyPair = (keypair) => {
 };
 function getNodeUrlsFromSettings(settings) {
     var _a;
-    return __awaiter$6(this, void 0, void 0, function* () {
+    return __awaiter$4(this, void 0, void 0, function* () {
         if (settings.directoryNodeUrlPool) {
             // If directoryNodeUrlPool is provided, use nodeDiscovery
             const nodeManager = createNodeManager({
@@ -3554,496 +3971,285 @@ function getNodeUrlsFromSettings(settings) {
                 directoryEndpointPool: createEndpointObjects(ensureArray(settings.directoryNodeUrlPool)),
                 failOverConfig: settings.failOverConfig,
                 blockchainRid: settings.blockchainRid,
-                blockchainIid: settings.blockchainIid,
-            });
-        }
-        else if (typeof settings.nodeUrlPool === "string") {
-            // If nodeUrlPool is a string, convert it to an array
-            return [settings.nodeUrlPool];
-        }
-        else if (Array.isArray(settings.nodeUrlPool)) {
-            // If nodeUrlPool is already an array, use it as-is
-            return settings.nodeUrlPool;
-        }
-        else {
-            // Default to an empty array if no valid configuration is provided
-            return [];
-        }
-    });
-}
-const defaultFailoverConfig = {
-    strategy: exports.FailoverStrategy.AbortOnError,
-    attemptsPerEndpoint: 3,
-    attemptInterval: 500,
-    unreachableDuration: 30000,
-};
-const createEndpointObjects = (endpointPoolUrls) => {
-    const endpoints = endpointPoolUrls.map((endpointUrl) => {
-        return { url: endpointUrl, whenAvailable: 0 };
-    });
-    return endpoints;
-};
-const getUrlsFromEndpoints = (endpointPool) => {
-    return endpointPool.map((endpoint) => endpoint.url);
-};
-
-var __awaiter$5 = (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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-function getBlockchainRidFromIid({ endpointPool, chainId, failOverConfig = {}, nodeManager, }) {
-    return __awaiter$5(this, void 0, void 0, function* () {
-        const mergedFailOverConfig = Object.assign(Object.assign({}, defaultFailoverConfig), failOverConfig);
-        const config = {
-            endpointPool,
-            statusPollInterval: 500,
-            nodeManager,
-            statusPollCount: 20,
-            failoverStrategy: mergedFailOverConfig.strategy,
-            attemptsPerEndpoint: mergedFailOverConfig.attemptsPerEndpoint,
-            attemptInterval: mergedFailOverConfig.attemptInterval,
-            unreachableDuration: mergedFailOverConfig.unreachableDuration,
-        };
-        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/brid/iid_${chainId}`, config);
-        if (error) {
-            throw new GetBridFromChainException(chainId, error.message);
+                blockchainIid: settings.blockchainIid,
+            });
         }
-        else if (statusCode !== 200) {
-            throw new GetBridFromChainException(chainId, rspBody);
+        else if (typeof settings.nodeUrlPool === "string") {
+            // If nodeUrlPool is a string, convert it to an array
+            return [settings.nodeUrlPool];
+        }
+        else if (Array.isArray(settings.nodeUrlPool)) {
+            // If nodeUrlPool is already an array, use it as-is
+            return settings.nodeUrlPool;
+        }
+        else {
+            // Default to an empty array if no valid configuration is provided
+            return [];
         }
-        return rspBody;
     });
 }
-function createTimeoutPromise(timeoutMs) {
-    return __awaiter$5(this, void 0, void 0, function* () {
-        return new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error("Timeout exceeded"));
-            }, timeoutMs);
+function getSystemClient(directoryNodeUrlPool, directoryChainRid) {
+    return __awaiter$4(this, void 0, void 0, function* () {
+        return yield createClient({
+            directoryNodeUrlPool,
+            blockchainRid: directoryChainRid,
         });
     });
 }
-const checkStateOfPromises = (promises) => __awaiter$5(void 0, void 0, void 0, function* () {
-    const promiseList = [];
-    const pendingState = { status: "pending" };
-    for (const p of promises) {
-        promiseList.push(yield Promise.race([p, pendingState]).then((value) => value === pendingState
-            ? Object.assign(Object.assign({}, pendingState), { value: p }) : { status: "fulfilled", value }, (reason) => ({ status: "rejected", value: reason })));
-    }
-    return promiseList;
-});
-function racePromisesWithTimeout(promises, timeout) {
-    return __awaiter$5(this, void 0, void 0, function* () {
-        let remainingPromises = [];
+function getSystemAnchoringChain(directoryClient) {
+    return __awaiter$4(this, void 0, void 0, function* () {
         try {
-            const resolvedPromise = yield Promise.race([
-                createTimeoutPromise(timeout),
-                ...promises,
-            ]);
-            const promisesWithState = yield checkStateOfPromises(promises);
-            const indexOfpromiseToRemove = promisesWithState.findIndex((p) => JSON.stringify(p.value) === JSON.stringify(resolvedPromise));
-            // Remove the promise that resolved from the list of promises
-            promisesWithState.splice(indexOfpromiseToRemove, 1);
-            // Remove the state before returning the promises.
-            remainingPromises = promisesWithState.map((p) => p.value);
-            return remainingPromises;
+            const queryObject = {
+                name: "cm_get_system_anchoring_chain",
+            };
+            const systemAnchoringChain = yield directoryClient.query(queryObject);
+            return systemAnchoringChain;
         }
         catch (error) {
-            if (error instanceof Error && error.message === "Timeout exceeded") {
-                throw error;
-            }
-            return remainingPromises;
+            throw new SystemChainException(error.message);
         }
     });
 }
-const stableStringify = (obj) => JSON.stringify(obj, Object.keys(obj).sort());
-const groupResponses = (responses) => {
-    const responseMap = responses.reduce((acc, response) => {
-        const key = stableStringify(response.result);
-        acc[key] = acc[key]
-            ? { response: acc[key].response, count: acc[key].count + 1 }
-            : { response, count: 1 };
-        return acc;
-    }, {});
-    const distinctResponses = Object.values(responseMap).sort((a, b) => b.count - a.count);
-    // Returns the count of the most common response
-    const maxNumberOfEqualResponses = () => {
-        return distinctResponses.length > 0 ? distinctResponses[0].count : 0;
-    };
-    // Returns the number of distinct responses
-    const numberOfDistinctResponses = () => {
-        return distinctResponses.length;
-    };
-    // Returns the most common response
-    const majorityResponse = () => {
-        return distinctResponses[0].response.result;
-    };
-    return {
-        maxNumberOfEqualResponses,
-        numberOfDistinctResponses,
-        majorityResponse,
-    };
+const defaultFailoverConfig = {
+    strategy: exports.FailoverStrategy.AbortOnError,
+    attemptsPerEndpoint: 3,
+    attemptInterval: 500,
+    unreachableDuration: 30000,
 };
-function requestWithFailoverStrategy(method, path, config, postObject, forceSingleEndpoint = false) {
-    return __awaiter$5(this, void 0, void 0, function* () {
-        switch (config.failoverStrategy) {
-            case exports.FailoverStrategy.AbortOnError:
-                return yield abortOnError({ method, path, config, postObject });
-            case exports.FailoverStrategy.TryNextOnError:
-                return yield tryNextOnError({ method, path, config, postObject });
-            case exports.FailoverStrategy.SingleEndpoint:
-                return yield singleEndpoint({ method, path, config, postObject });
-            case exports.FailoverStrategy.QueryMajority:
-                if (forceSingleEndpoint) {
-                    return yield singleEndpoint({ method, path, config, postObject });
-                }
-                return yield queryMajority({ method, path, config, postObject });
-        }
-    });
-}
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function convertToPrintable(responseObject) {
-    if (typeof responseObject === "bigint") {
-        return `${responseObject}n`;
-    }
-    else if (typeof responseObject === "object") {
-        return JSON.stringify(responseObject, (key, value) => typeof value === "bigint" ? `${value}n` : value);
-    }
-    else {
-        return responseObject;
-    }
-}
-const bftMajority = (n) => n - (n - 1) / 3;
-
-var restclientutil = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	bftMajority: bftMajority,
-	checkStateOfPromises: checkStateOfPromises,
-	convertToPrintable: convertToPrintable,
-	createTimeoutPromise: createTimeoutPromise,
-	getBlockchainRidFromIid: getBlockchainRidFromIid,
-	groupResponses: groupResponses,
-	racePromisesWithTimeout: racePromisesWithTimeout,
-	requestWithFailoverStrategy: requestWithFailoverStrategy,
-	sleep: sleep
-});
-
-var __awaiter$4 = (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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+const createEndpointObjects = (endpointPoolUrls) => {
+    const endpoints = endpointPoolUrls.map(endpointUrl => {
+        return { url: endpointUrl, whenAvailable: 0 };
     });
+    return endpoints;
 };
-function createRestClient(endpointPool, blockchainRid, maxSockets = 10, pollingInterval = 500, failOverConfig, unreachableDuration = 5000, useStickyNode = false) {
-    validateInput(endpointPool, failOverConfig !== null && failOverConfig !== void 0 ? failOverConfig : {});
-    return {
-        config: {
-            nodeManager: createNodeManager({
-                nodeUrls: endpointPool,
-                useStickyNode,
-            }),
-            endpointPool: createEndpointObjects(endpointPool),
-            pool: { maxSockets },
-            pollingInterval,
-            failoverStrategy: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.strategy) || exports.FailoverStrategy.AbortOnError,
-            attemptsPerEndpoint: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptsPerEndpoint) || 3,
-            attemptInterval: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptInterval) || 500,
-            unreachableDuration: unreachableDuration,
-        },
-        getTransaction: function (txRID, callback) {
-            return __awaiter$4(this, void 0, void 0, function* () {
-                if (!isTxRidValid(txRID)) {
-                    callback(new InvalidTxRidException(txRID), null);
-                }
-                else {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${blockchainRid}/${txRID.toString("hex")}`, this.config);
-                    handleGetResponse(error, statusCode, statusCode === 200 ? toBuffer(rspBody.tx) : rspBody, callback);
-                }
-            });
-        },
-        postTransaction: function (serializedTransaction, callback) {
-            return __awaiter$4(this, void 0, void 0, function* () {
-                if (!require$$0$1.Buffer.isBuffer(serializedTransaction)) {
-                    throw new SerializedTransactionFormatException();
-                }
-                const transactionObject = {
-                    tx: serializedTransaction.toString("hex"),
-                };
-                const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `tx/${blockchainRid}`, this.config, transactionObject);
-                handlePostResponse(error, statusCode, rspBody, callback);
-            });
-        },
-        status: function (txRID, callback) {
-            return __awaiter$4(this, void 0, void 0, function* () {
-                if (!isTxRidValid(txRID)) {
-                    callback(new InvalidTxRidException(txRID), null);
-                }
-                else {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${blockchainRid}/${txRID.toString("hex")}/status`, this.config);
-                    handleGetResponse(error, statusCode, rspBody, callback);
-                }
-            });
-        },
-        query: function (nameOrQueryObject, queryArguments) {
-            return __awaiter$4(this, void 0, void 0, function* () {
-                // eslint-disable-next-line no-async-promise-executor
-                return new Promise((resolve, reject) => __awaiter$4(this, void 0, void 0, function* () {
-                    const callback = (error, result) => {
-                        if (error) {
-                            reject(error);
-                        }
-                        else {
-                            resolve(result);
-                        }
-                    };
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `query_gtv/${blockchainRid}`, this.config, encodeValue(toQueryObjectGTV(nameOrQueryObject, queryArguments)));
-                    handlePostResponse(error, statusCode, rspBody, callback);
-                }));
-            });
-        },
-        waitConfirmation(txRID) {
-            return new Promise((resolve, reject) => {
-                this.status(txRID, (error$1, result) => {
-                    if (error$1) {
-                        reject(error$1);
-                    }
-                    else {
-                        const status = result.status;
-                        switch (status) {
-                            case ResponseStatus.Confirmed:
-                                resolve(null);
-                                break;
-                            case ResponseStatus.Rejected:
-                                reject(new TxRejectedError(result.rejectReason));
-                                break;
-                            case ResponseStatus.Unknown:
-                                reject(new LostMessageError());
-                                break;
-                            case ResponseStatus.Waiting:
-                                setTimeout(() => this.waitConfirmation(txRID).then(resolve, reject), this.config.pollingInterval);
-                                break;
-                            default:
-                                error(status);
-                                reject(new UnexpectedResponseError());
-                        }
-                    }
-                });
-            });
-        },
-        postAndWaitConfirmation(serializedTransaction, txRID, validate) {
-            if (validate === true) {
-                return Promise.reject("Automatic validation is not yet implemented");
+const getUrlsFromEndpoints = (endpointPool) => {
+    return endpointPool.map(endpoint => endpoint.url);
+};
+function awaitDappConfirmation(txRID, statusPollInterval, statusPollCount, getTransactionStatus) {
+    var _a;
+    return __awaiter$4(this, void 0, void 0, function* () {
+        let lastKnownResult;
+        for (let i = 0; i < statusPollCount; i++) {
+            lastKnownResult = yield getTransactionStatus(txRID);
+            if (lastKnownResult.status === exports.ResponseStatus.Confirmed) {
+                return exports.ResponseStatus.Confirmed;
             }
-            return new Promise((resolve, reject) => {
-                this.postTransaction(serializedTransaction, (error) => {
-                    if (error)
-                        reject(error);
-                    else {
-                        setTimeout(() => this.waitConfirmation(txRID).then(resolve, reject), 1011);
-                    }
-                });
-            });
-        },
-        getEndpointPool() {
-            return getUrlsFromEndpoints(this.config.endpointPool);
-        },
-    };
-}
-function validateInput(endpointPool, failOverConfig) {
-    if (!endpointPool.length) {
-        throw new EmptyListOfUrlsException();
-    }
-    if ((failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptsPerEndpoint) &&
-        failOverConfig.attemptsPerEndpoint < 1) {
-        debug("Attempts can not be 0 or below, setting it to 1");
-        failOverConfig.attemptsPerEndpoint = 1;
-    }
-}
-/**
- * @param error response error
- * @param statusCode response status code
- * @param responseObject the responsebody from the server
- * @param callback the callback function to propagate the error and response back to the caller
- */
-function handleGetResponse(error$1, statusCode, responseObject, callback) {
-    try {
-        const responseObjectPrintable = convertToPrintable(responseObject);
-        debug(`error: ${error$1}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
-        if (error$1) {
-            return callback(error$1, null);
+            else if (lastKnownResult.status === exports.ResponseStatus.Rejected) {
+                throw new TxRejectedError((_a = lastKnownResult.rejectReason) !== null && _a !== void 0 ? _a : "");
+            }
+            yield sleep(statusPollInterval);
         }
-        if (statusCode !== 200) {
-            return callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), null);
+        // TS issue. This could be fixed by implementing new retry strategy
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        //@ts-expect-error
+        return lastKnownResult.status;
+    });
+}
+function awaitClusterAnchoringChainConfirmation(txRID, statusPollInterval, statusPollCount, getClusterAnchoringTransactionConfirmation) {
+    var _a;
+    return __awaiter$4(this, void 0, void 0, function* () {
+        let clusterAnchoringConfirmation;
+        for (let i = 0; i < statusPollCount; i++) {
+            clusterAnchoringConfirmation = yield getClusterAnchoringTransactionConfirmation(txRID);
+            const anchoringTransactionValidaiton = AnchoringTransactionSchema.safeParse(clusterAnchoringConfirmation);
+            if (anchoringTransactionValidaiton.success) {
+                return {
+                    status: exports.AnchoringStatus.ClusterAnchored,
+                    clusterAnchoredTx: anchoringTransactionValidaiton.data,
+                };
+            }
+            else if (!anchoringTransactionValidaiton.success) {
+                throw new TxRejectedError((_a = exports.AnchoringStatus.FailedAnchoring) !== null && _a !== void 0 ? _a : "");
+            }
+            yield sleep(statusPollInterval);
         }
-        return callback(null, responseObject);
-    }
-    catch (error$1) {
-        callback(error$1, null);
-        error(`restclient.handleGetResponse(): Failed to call the callback function. ${error$1}`);
-    }
+        // TS issue. This could be fixed by implementing new retry strategy
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        //@ts-expect-error
+        return clusterAnchoringConfirmation;
+    });
 }
-/**
- * @param error response error
- * @param statusCode response status code
- * @param responseObject the responsebody from the server
- * @param callback the callback function to propagate the error and response back to the caller
- */
-function handlePostResponse(error$1, statusCode, responseObject, callback) {
-    const responseObjectPrintable = convertToPrintable(responseObject);
-    debug(`error: ${error$1}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
-    try {
-        if (error$1) {
-            error(`In restclient post(). ${error$1}`);
-            callback(error$1, null);
+function handleTransactionConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusCode, statusPollInterval, statusPollCount, getTransactionStatus, getClusterAnchoringTransactionConfirmation, getSystemAnchoringTransactionConfirmation) {
+    return __awaiter$4(this, void 0, void 0, function* () {
+        const transactionReceipt = {
+            status: exports.ResponseStatus.Waiting,
+            statusCode: statusCode,
+            transactionRid: transactionRid,
+        };
+        promiEvent.emit("sent", transactionReceipt);
+        if (doStatusPolling === false || confirmationLevel === exports.ChainConfirmationLevel.None) {
+            return transactionReceipt;
         }
-        else if (statusCode != 200) {
-            let errorMessage = `Unexpected status code from server. Code: ${statusCode}.`;
-            if (responseObjectPrintable) {
-                errorMessage += ` Message: ${responseObjectPrintable}.`;
-            }
-            error(errorMessage);
-            callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), responseObject);
+        const dappConfirmationStatus = yield awaitDappConfirmation(transactionRid, statusPollInterval, statusPollCount, getTransactionStatus);
+        transactionReceipt.status = dappConfirmationStatus;
+        promiEvent.emit("sent", transactionReceipt);
+        if (confirmationLevel === exports.ChainConfirmationLevel.Dapp) {
+            return transactionReceipt;
         }
-        else {
-            info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
-            callback(null, responseObject);
+        const clusterAnchoringChainConfirmation = yield awaitClusterAnchoringChainConfirmation(transactionRid, statusPollInterval, statusPollCount, getClusterAnchoringTransactionConfirmation);
+        transactionReceipt.status = clusterAnchoringChainConfirmation.status;
+        transactionReceipt["clusterAnchoredTx"] = clusterAnchoringChainConfirmation.clusterAnchoredTx;
+        promiEvent.emit("sent", transactionReceipt);
+        if (confirmationLevel === exports.ChainConfirmationLevel.ClusterAnchoring) {
+            return transactionReceipt;
         }
-    }
-    catch (error$1) {
-        error(`restclient.handlePostResponse(): Failed to call callback function ${error$1}`);
-    }
+        const systemAnchoringConfirmation = yield getSystemAnchoringTransactionConfirmation(clusterAnchoringChainConfirmation.clusterAnchoredTx.txRid);
+        if (!systemAnchoringConfirmation) {
+            return transactionReceipt;
+        }
+        transactionReceipt.status = exports.AnchoringStatus.SystemAnchored;
+        transactionReceipt["systemAnchoredTx"] = systemAnchoringConfirmation;
+        promiEvent.emit("sent", transactionReceipt);
+        if (confirmationLevel === exports.ChainConfirmationLevel.SystemAnchoring) {
+            return transactionReceipt;
+        }
+        return transactionReceipt;
+    });
 }
 
-var restclient = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	createRestClient: createRestClient,
-	handleGetResponse: handleGetResponse,
-	handlePostResponse: handlePostResponse
-});
-
-var internalNodePrefix = require$$0$1.Buffer.alloc(1, 0);
-var leafPrefix = require$$0$1.Buffer.alloc(1, 1);
-var nonExistingNodeHash = require$$0$1.Buffer.alloc(32);
-function calculateRoot(hashes, depth, leafDepth) {
-    var numTransactions = hashes.length;
-    if (numTransactions === 0) {
-        return require$$0$1.Buffer.alloc(32);
-    }
-    if (depth === undefined) {
-        depth = 0;
-    }
-    if (!leafDepth) {
-        leafDepth = Math.ceil(Math.log2(numTransactions));
-    }
-    if (depth === leafDepth) {
-        return hashes[0];
-    }
-    var maxLeavesPerChild = Math.pow(2, leafDepth - depth - 1);
-    var prefix = depth === leafDepth - 1 ? leafPrefix : internalNodePrefix;
-    if (numTransactions <= maxLeavesPerChild) {
-        var left = calculateRoot(hashes, depth + 1, leafDepth);
-        return hashConcat([prefix, left, nonExistingNodeHash]);
-    }
-    var left = calculateRoot(hashes.slice(0, maxLeavesPerChild), depth + 1, leafDepth);
-    var right = calculateRoot(hashes.slice(maxLeavesPerChild), depth + 1, leafDepth);
-    return hashConcat([prefix, left, prefix, right]);
+var __awaiter$3 = (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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function getBlockchainRidFromIid({ endpointPool, chainId, failOverConfig = {}, nodeManager, }) {
+    return __awaiter$3(this, void 0, void 0, function* () {
+        const mergedFailOverConfig = Object.assign(Object.assign({}, defaultFailoverConfig), failOverConfig);
+        const config = {
+            endpointPool,
+            statusPollInterval: 500,
+            nodeManager,
+            statusPollCount: 20,
+            failoverStrategy: mergedFailOverConfig.strategy,
+            attemptsPerEndpoint: mergedFailOverConfig.attemptsPerEndpoint,
+            attemptInterval: mergedFailOverConfig.attemptInterval,
+            unreachableDuration: mergedFailOverConfig.unreachableDuration,
+        };
+        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/brid/iid_${chainId}`, config);
+        if (error) {
+            throw new GetBridFromChainException(chainId, error.message);
+        }
+        else if (statusCode !== 200) {
+            throw new GetBridFromChainException(chainId, rspBody);
+        }
+        return rspBody;
+    });
 }
-function internalMerklePath(hashes, targetIndex, depth, leafDepth) {
-    var numTransactions = hashes.length;
-    if (depth === leafDepth) {
-        return [];
-    }
-    var maxLeavesPerChild = Math.pow(2, leafDepth - depth - 1);
-    if (numTransactions <= maxLeavesPerChild) {
-        var path = internalMerklePath(hashes, targetIndex, depth + 1, leafDepth);
-        path.push({ side: 1, hash: nonExistingNodeHash });
-        return path;
-    }
-    if (targetIndex < maxLeavesPerChild) {
-        var path = internalMerklePath(hashes.slice(0, maxLeavesPerChild), targetIndex, depth + 1, leafDepth);
-        var right = calculateRoot(hashes.slice(maxLeavesPerChild), depth + 1, leafDepth);
-        path.push({ side: 1, hash: right });
-    }
-    else {
-        var left = calculateRoot(hashes.slice(0, maxLeavesPerChild), depth + 1, leafDepth);
-        var path = internalMerklePath(hashes.slice(maxLeavesPerChild), targetIndex - maxLeavesPerChild, depth + 1, leafDepth);
-        path.push({ side: 0, hash: left });
-    }
-    return path;
+function createTimeoutPromise(timeoutMs) {
+    return __awaiter$3(this, void 0, void 0, function* () {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error("Timeout exceeded"));
+            }, timeoutMs);
+        });
+    });
 }
-/*
- * a path looks like this:
- * {merklePath: [{side: <0|1>, hash: <hash buffer depth n-1>},
- *               {side: <0|1>, hash: <hash buffer depth n-2>},
- *               ...
- *               {side: <0|1>, hash: <hash buffer depth 1>}]}
- */
-function merklePath(hashes, target) {
-    if (!hashes || hashes.length == 0) {
-        throw new Error("Cannot make merkle path from empty transaction set");
-    }
-    var index = -1;
-    for (var i = 0; i < hashes.length; i++) {
-        if (hashes[i].equals(target)) {
-            index = i;
-            break;
-        }
-    }
-    if (index === -1) {
-        throw new Error("Target is not in list of hashes");
+const checkStateOfPromises = (promises) => __awaiter$3(void 0, void 0, void 0, function* () {
+    const promiseList = [];
+    const pendingState = { status: "pending" };
+    for (const p of promises) {
+        promiseList.push(yield Promise.race([p, pendingState]).then(value => value === pendingState ? Object.assign(Object.assign({}, pendingState), { value: p }) : { status: "fulfilled", value }, reason => ({ status: "rejected", value: reason })));
     }
-    var leafDepth = Math.ceil(Math.log2(hashes.length));
-    var path = internalMerklePath(hashes, index, 0, leafDepth);
-    return path;
-}
-/**
- *
- * @param path The merkle path to validate.
- * Format [{side: <0|1>, hash: <hash buffer depth n-1>},
- *         {side: <0|1>, hash: <hash buffer depth n-2>},
- *         ...,
- *         {side: <0|1>, hash: <hash buffer depth 1>}]
-
- * @param target the leaf hash that the path proves belongs in the merkleRoot
- * @param merkleRoot The merkle root that supposedly contains the target via the supplied path.
- * The merkle root is typically taken from a block header.
- */
-function validateMerklePath(path, target, merkleRoot) {
-    let currentHash = target;
-    for (let i = 0; i < path.length; i++) {
-        const item = path[i];
-        const prefix = (i === 0) ? require$$0$1.Buffer.from([1]) : require$$0$1.Buffer.from([0]);
-        if (item.side === 0) {
-            currentHash = hashConcat([prefix, item.hash, prefix, currentHash]);
+    return promiseList;
+});
+function racePromisesWithTimeout(promises, timeout) {
+    return __awaiter$3(this, void 0, void 0, function* () {
+        let remainingPromises = [];
+        try {
+            const resolvedPromise = yield Promise.race([createTimeoutPromise(timeout), ...promises]);
+            const promisesWithState = yield checkStateOfPromises(promises);
+            const indexOfpromiseToRemove = promisesWithState.findIndex(p => JSON.stringify(p.value) === JSON.stringify(resolvedPromise));
+            // Remove the promise that resolved from the list of promises
+            promisesWithState.splice(indexOfpromiseToRemove, 1);
+            // Remove the state before returning the promises.
+            remainingPromises = promisesWithState.map(p => p.value);
+            return remainingPromises;
         }
-        else {
-            if (item.hash.equals(nonExistingNodeHash)) {
-                currentHash = hashConcat([prefix, currentHash, nonExistingNodeHash]);
-            }
-            else {
-                currentHash = hashConcat([prefix, currentHash, prefix, item.hash]);
+        catch (error) {
+            if (error instanceof Error && error.message === "Timeout exceeded") {
+                throw error;
             }
+            return remainingPromises;
+        }
+    });
+}
+const stableStringify = (obj) => JSON.stringify(obj, Object.keys(obj).sort());
+const groupResponses = (responses) => {
+    const responseMap = responses.reduce((acc, response) => {
+        const key = stableStringify(response.result);
+        acc[key] = acc[key]
+            ? { response: acc[key].response, count: acc[key].count + 1 }
+            : { response, count: 1 };
+        return acc;
+    }, {});
+    const distinctResponses = Object.values(responseMap).sort((a, b) => b.count - a.count);
+    // Returns the count of the most common response
+    const maxNumberOfEqualResponses = () => {
+        return distinctResponses.length > 0 ? distinctResponses[0].count : 0;
+    };
+    // Returns the number of distinct responses
+    const numberOfDistinctResponses = () => {
+        return distinctResponses.length;
+    };
+    // Returns the most common response
+    const majorityResponse = () => {
+        return distinctResponses[0].response.result;
+    };
+    return {
+        maxNumberOfEqualResponses,
+        numberOfDistinctResponses,
+        majorityResponse,
+    };
+};
+function requestWithFailoverStrategy(method, path, config, postObject, forceSingleEndpoint = false) {
+    return __awaiter$3(this, void 0, void 0, function* () {
+        switch (config.failoverStrategy) {
+            case exports.FailoverStrategy.AbortOnError:
+                return yield abortOnError({ method, path, config, postObject });
+            case exports.FailoverStrategy.TryNextOnError:
+                return yield tryNextOnError({ method, path, config, postObject });
+            case exports.FailoverStrategy.SingleEndpoint:
+                return yield singleEndpoint({ method, path, config, postObject });
+            case exports.FailoverStrategy.QueryMajority:
+                if (forceSingleEndpoint) {
+                    return yield singleEndpoint({ method, path, config, postObject });
+                }
+                return yield queryMajority({ method, path, config, postObject });
         }
+    });
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+function convertToPrintable(responseObject) {
+    if (typeof responseObject === "bigint") {
+        return `${responseObject}n`;
+    }
+    else if (typeof responseObject === "object") {
+        return JSON.stringify(responseObject, (key, value) => typeof value === "bigint" ? `${value}n` : value);
+    }
+    else {
+        return responseObject;
     }
-    return merkleRoot.equals(currentHash);
 }
+const bftMajority = (n) => n - (n - 1) / 3;
 
-var merkleHelper = /*#__PURE__*/Object.freeze({
+var restclientutil = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	calculateRoot: calculateRoot,
-	merklePath: merklePath,
-	validateMerklePath: validateMerklePath
+	bftMajority: bftMajority,
+	checkStateOfPromises: checkStateOfPromises,
+	convertToPrintable: convertToPrintable,
+	createTimeoutPromise: createTimeoutPromise,
+	getBlockchainRidFromIid: getBlockchainRidFromIid,
+	groupResponses: groupResponses,
+	racePromisesWithTimeout: racePromisesWithTimeout,
+	requestWithFailoverStrategy: requestWithFailoverStrategy,
+	sleep: sleep
 });
 
-var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$2 = (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) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -4052,309 +4258,306 @@ var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-/**
- * @deprecated Use the function createClient instead.
- * Provides postchain clients that can be used to communicate with dapps within the chromia network
- * @param chain0BRID brid of chain0
- * @param rest rest client configured to node running chain0
- */
-function chromiaClientProvider(chain0BRID, rest) {
-    const chain0Client = createClient$1(rest, chain0BRID, []);
+function createRestClient(endpointPool, blockchainRid, maxSockets = 10, pollingInterval = 500, failOverConfig, unreachableDuration = 5000, useStickyNode = false) {
+    validateInput(endpointPool, failOverConfig !== null && failOverConfig !== void 0 ? failOverConfig : {});
     return {
-        blockchainConnection: function (dappBRID) {
-            return __awaiter$3(this, void 0, void 0, function* () {
-                const queryObject = {
-                    type: "cm_get_blockchain_api_urls",
-                    blockchain_rid: dappBRID,
-                };
-                const baseUrls = yield chain0Client.query(queryObject);
-                if (!baseUrls.length) {
-                    throw new BlockchainUrlUndefinedException(dappBRID);
+        config: {
+            nodeManager: createNodeManager({
+                nodeUrls: endpointPool,
+                useStickyNode,
+            }),
+            endpointPool: createEndpointObjects(endpointPool),
+            pool: { maxSockets },
+            pollingInterval,
+            failoverStrategy: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.strategy) || exports.FailoverStrategy.AbortOnError,
+            attemptsPerEndpoint: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptsPerEndpoint) || 3,
+            attemptInterval: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptInterval) || 500,
+            unreachableDuration: unreachableDuration,
+        },
+        getTransaction: function (txRID, callback) {
+            return __awaiter$2(this, void 0, void 0, function* () {
+                if (!isTxRidValid(txRID)) {
+                    callback(new InvalidTxRidException(txRID), null);
+                }
+                else {
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${blockchainRid}/${txRID.toString("hex")}`, this.config);
+                    handleGetResponse(error, statusCode, statusCode === 200 ? toBuffer(rspBody.tx) : rspBody, callback);
                 }
-                return createRestClient(baseUrls, dappBRID);
             });
         },
-    };
-}
-
-var chromiaClientProvider$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	chromiaClientProvider: chromiaClientProvider
-});
-
-var __awaiter$2 = (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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-function createStubClient() {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        return {
-            config: {
-                nodeManager: createNodeManager({
-                    nodeUrls: [],
-                }),
-                endpointPool: [],
-                blockchainRid: "0000000000000000000000000000000000000000000000000000000000000000",
-                statusPollInterval: 5000,
-                statusPollCount: 5,
-                failoverStrategy: exports.FailoverStrategy.AbortOnError,
-                attemptsPerEndpoint: 3,
-                attemptInterval: 5000,
-                unreachableDuration: 30000,
-            },
-            query() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("query rejected");
-                });
-            },
-            signTransaction() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("signTransaction rejected");
-                });
-            },
-            sendTransaction() {
-                return new Web3PromiEvent((_resolve, reject) => reject("sendTransaction rejected"));
-            },
-            signAndSendUniqueTransaction() {
-                return new Web3PromiEvent((_resolve, reject) => reject("signAndSendUniqueTransaction rejected"));
-            },
-            getTransaction() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getTransaction rejected");
-                });
-            },
-            getTransactionStatus() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getTransactionStatus rejected");
-                });
-            },
-            addNop() {
-                throw new Error("addNop error");
-            },
-            getTransactionRid() {
-                throw new Error("getTransactionRid error");
-            },
-            getTransactionsInfo() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getTransactionsInfo rejected");
-                });
-            },
-            getTransactionInfo() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getTransactionInfo rejected");
-                });
-            },
-            getTransactionCount() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getTransactionCount rejected");
-                });
-            },
-            getBlocks() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getBlockInfo rejected");
-                });
-            },
-            getBlockInfo() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getBlockInfo rejected");
-                });
-            },
-            getLatestBlock() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getLatestBlock rejected");
-                });
-            },
-            getBlocksInfo() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getBlocksInfo rejected");
+        postTransaction: function (serializedTransaction, callback) {
+            return __awaiter$2(this, void 0, void 0, function* () {
+                if (!require$$0$1.Buffer.isBuffer(serializedTransaction)) {
+                    throw new SerializedTransactionFormatException();
+                }
+                const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `tx/${blockchainRid}`, this.config, serializedTransaction);
+                handlePostResponse(error, statusCode, rspBody, callback);
+            });
+        },
+        status: function (txRID, callback) {
+            return __awaiter$2(this, void 0, void 0, function* () {
+                if (!isTxRidValid(txRID)) {
+                    callback(new InvalidTxRidException(txRID), null);
+                }
+                else {
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${blockchainRid}/${txRID.toString("hex")}/status`, this.config);
+                    handleGetResponse(error, statusCode, rspBody, callback);
+                }
+            });
+        },
+        query: function (nameOrQueryObject, queryArguments) {
+            return __awaiter$2(this, void 0, void 0, function* () {
+                // eslint-disable-next-line no-async-promise-executor
+                return new Promise((resolve, reject) => __awaiter$2(this, void 0, void 0, function* () {
+                    const callback = (error, result) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    };
+                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `query_gtv/${blockchainRid}`, this.config, encodeValue(toQueryObjectGTV(nameOrQueryObject, queryArguments)));
+                    handlePostResponse(error, statusCode, rspBody, callback);
+                }));
+            });
+        },
+        waitConfirmation(txRID) {
+            return new Promise((resolve, reject) => {
+                this.status(txRID, (error$1, result) => {
+                    if (error$1) {
+                        reject(error$1);
+                    }
+                    else {
+                        const status = result.status;
+                        switch (status) {
+                            case exports.ResponseStatus.Confirmed:
+                                resolve(null);
+                                break;
+                            case exports.ResponseStatus.Rejected:
+                                reject(new TxRejectedError(result.rejectReason));
+                                break;
+                            case exports.ResponseStatus.Unknown:
+                                reject(new LostMessageError());
+                                break;
+                            case exports.ResponseStatus.Waiting:
+                                setTimeout(() => this.waitConfirmation(txRID).then(resolve, reject), this.config.pollingInterval);
+                                break;
+                            default:
+                                error(status);
+                                reject(new UnexpectedResponseError());
+                        }
+                    }
                 });
-            },
-            encodeTransaction() {
-                throw new Error("encodeTransaction error");
-            },
-            decodeTransactionToGtx() {
-                throw new Error("decodeTransactionToGtx error");
-            },
-            getClientNodeUrlPool() {
-                return [];
-            },
-            getConfirmationProof() {
-                return __awaiter$2(this, void 0, void 0, function* () {
-                    return Promise.reject("getConfirmationProof rejected");
+            });
+        },
+        postAndWaitConfirmation(serializedTransaction, txRID, validate) {
+            if (validate === true) {
+                return Promise.reject("Automatic validation is not yet implemented");
+            }
+            return new Promise((resolve, reject) => {
+                this.postTransaction(serializedTransaction, error => {
+                    if (error)
+                        reject(error);
+                    else {
+                        setTimeout(() => this.waitConfirmation(txRID)
+                            .then(() => resolve(null))
+                            .catch(reject), 1011);
+                    }
                 });
-            },
-            getAppStructure() {
-                return Promise.reject("getAppStructure rejected");
-            },
-        };
-    });
-}
-
-class MissingTransactionProof extends Error {
-    constructor(proofHash, fetchedTxHash) {
-        super(`Unable to verify source transaction proof,transaction hash in proof ${toString(proofHash)} does not match hash from fetched transaction ${toString(fetchedTxHash)}`);
-    }
-}
-class DifferentNumberOfSignersException extends Error {
-    constructor(length, comparableLength) {
-        super(`Transaction signatures amount ${length} do not match expected amount of signers ${comparableLength}`);
-    }
-}
-class SignatureException extends Error {
-    constructor(signer) {
-        super(`Expected signer ${toString(signer)} has not signed source transaction`);
-    }
-}
-class ProofRidException extends Error {
-    constructor() {
-        super("Unable to verify source transaction proof, got a different transaction from query than we asked for");
-    }
-}
-class SystemChainException extends Error {
-    constructor(errorMessage) {
-        super(`Query to system chain failed with error: ${errorMessage}`);
-    }
+            });
+        },
+        getEndpointPool() {
+            return getUrlsFromEndpoints(this.config.endpointPool);
+        },
+    };
 }
-class ConfirmationProofException extends Error {
-    constructor(transactionRid) {
-        super(`Unable to fetch confirmation proof for transaction RID: ${toString(transactionRid)}.`);
+function validateInput(endpointPool, failOverConfig) {
+    if (!endpointPool.length) {
+        throw new EmptyListOfUrlsException();
     }
-}
-class BlockAnchoringException extends Error {
-    constructor() {
-        super(`Block is not present in cluster anchoring chain`);
+    if ((failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptsPerEndpoint) && failOverConfig.attemptsPerEndpoint < 1) {
+        debug("Attempts can not be 0 or below, setting it to 1");
+        failOverConfig.attemptsPerEndpoint = 1;
     }
 }
-
-var __awaiter$1 = (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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-function getClusterOfBlockchain(client, blockchainRid) {
-    return __awaiter$1(this, void 0, void 0, function* () {
-        try {
-            const clusterName = yield client.query({
-                name: "cm_get_blockchain_cluster",
-                args: { brid: blockchainRid },
-            });
-            return clusterName;
+/**
+ * @param error response error
+ * @param statusCode response status code
+ * @param responseObject the responsebody from the server
+ * @param callback the callback function to propagate the error and response back to the caller
+ */
+function handleGetResponse(error$1, statusCode, responseObject, callback) {
+    try {
+        const responseObjectPrintable = convertToPrintable(responseObject);
+        debug(`error: ${error$1}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
+        if (error$1) {
+            return callback(error$1, null);
         }
-        catch (error) {
-            throw new SystemChainException(error.message);
+        if (statusCode !== 200) {
+            return callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), null);
         }
-    });
+        return callback(null, responseObject);
+    }
+    catch (error$1) {
+        callback(error$1, null);
+        error(`restclient.handleGetResponse(): Failed to call the callback function. ${error$1}`);
+    }
 }
-function getClusterInfo(client, name) {
-    return __awaiter$1(this, void 0, void 0, function* () {
-        try {
-            const clusterInfo = yield client.query({
-                name: "cm_get_cluster_info",
-                args: { name },
-            });
-            return clusterInfo;
-        }
-        catch (error) {
-            throw new SystemChainException(error.message);
+/**
+ * @param error response error
+ * @param statusCode response status code
+ * @param responseObject the responsebody from the server
+ * @param callback the callback function to propagate the error and response back to the caller
+ */
+function handlePostResponse(error$1, statusCode, responseObject, callback) {
+    const responseObjectPrintable = convertToPrintable(responseObject);
+    debug(`error: ${error$1}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
+    try {
+        if (error$1) {
+            error(`In restclient post(). ${error$1}`);
+            callback(error$1, null);
         }
-    });
-}
-function getAnchoringTransactionForBlockRid(client, blockchainRid, blockRid) {
-    return __awaiter$1(this, void 0, void 0, function* () {
-        try {
-            const anchoringTxForBlockRid = yield client.query({
-                name: "get_anchoring_transaction_for_block_rid",
-                args: { blockchain_rid: blockchainRid, block_rid: blockRid },
-            });
-            return convertToAnchoringTransaction(anchoringTxForBlockRid);
+        else if (statusCode != 200) {
+            let errorMessage = `Unexpected status code from server. Code: ${statusCode}.`;
+            if (responseObjectPrintable) {
+                errorMessage += ` Message: ${responseObjectPrintable}.`;
+            }
+            error(errorMessage);
+            callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), responseObject);
         }
-        catch (error) {
-            throw new SystemChainException(error.message);
+        else {
+            info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
+            callback(null, responseObject);
         }
-    });
+    }
+    catch (error$1) {
+        error(`restclient.handlePostResponse(): Failed to call callback function ${error$1}`);
+    }
 }
-function convertToAnchoringTransaction(responseTx) {
-    const { tx_rid, tx_data, tx_op_index } = responseTx;
-    return {
-        txRid: tx_rid,
-        txData: tx_data,
-        txOpIndex: tx_op_index,
-    };
+
+var restclient = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	createRestClient: createRestClient,
+	handleGetResponse: handleGetResponse,
+	handlePostResponse: handlePostResponse
+});
+
+var internalNodePrefix = require$$0$1.Buffer.alloc(1, 0);
+var leafPrefix = require$$0$1.Buffer.alloc(1, 1);
+var nonExistingNodeHash = require$$0$1.Buffer.alloc(32);
+function calculateRoot(hashes, depth, leafDepth) {
+    var numTransactions = hashes.length;
+    if (numTransactions === 0) {
+        return require$$0$1.Buffer.alloc(32);
+    }
+    if (depth === undefined) {
+        depth = 0;
+    }
+    if (!leafDepth) {
+        leafDepth = Math.ceil(Math.log2(numTransactions));
+    }
+    if (depth === leafDepth) {
+        return hashes[0];
+    }
+    var maxLeavesPerChild = Math.pow(2, leafDepth - depth - 1);
+    var prefix = depth === leafDepth - 1 ? leafPrefix : internalNodePrefix;
+    if (numTransactions <= maxLeavesPerChild) {
+        var left = calculateRoot(hashes, depth + 1, leafDepth);
+        return hashConcat([prefix, left, nonExistingNodeHash]);
+    }
+    var left = calculateRoot(hashes.slice(0, maxLeavesPerChild), depth + 1, leafDepth);
+    var right = calculateRoot(hashes.slice(maxLeavesPerChild), depth + 1, leafDepth);
+    return hashConcat([prefix, left, prefix, right]);
 }
-function calculateBlockRID(decodedTxProof) {
-    const sourceBlockHeader = decodedTxProof.blockHeader;
-    if (!sourceBlockHeader) {
-        throw new Error("Failed to get blockHeader from confirmation proof");
+function internalMerklePath(hashes, targetIndex, depth, leafDepth) {
+    var numTransactions = hashes.length;
+    if (depth === leafDepth) {
+        return [];
     }
-    const decodeSourceBlockRid = decodeValue(sourceBlockHeader);
-    return gtvHash(decodeSourceBlockRid);
+    var maxLeavesPerChild = Math.pow(2, leafDepth - depth - 1);
+    if (numTransactions <= maxLeavesPerChild) {
+        var path = internalMerklePath(hashes, targetIndex, depth + 1, leafDepth);
+        path.push({ side: 1, hash: nonExistingNodeHash });
+        return path;
+    }
+    if (targetIndex < maxLeavesPerChild) {
+        var path = internalMerklePath(hashes.slice(0, maxLeavesPerChild), targetIndex, depth + 1, leafDepth);
+        var right = calculateRoot(hashes.slice(maxLeavesPerChild), depth + 1, leafDepth);
+        path.push({ side: 1, hash: right });
+    }
+    else {
+        var left = calculateRoot(hashes.slice(0, maxLeavesPerChild), depth + 1, leafDepth);
+        var path = internalMerklePath(hashes.slice(maxLeavesPerChild), targetIndex - maxLeavesPerChild, depth + 1, leafDepth);
+        path.push({ side: 0, hash: left });
+    }
+    return path;
 }
-// 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$1(this, void 0, void 0, function* () {
-        const rawTx = yield sourceClient.getTransaction(txToProveRID);
-        const txGtv = decodeValue(rawTx);
-        const fetchedTxHash = gtvHash(txGtv);
-        if (Buffer.compare(fetchedTxHash, proofHash)) {
-            // We received another hash for tx RID than what was included in proof
-            // Possibly rouge or faulty node(s). Anyway, we need to give up.
-            throw new MissingTransactionProof(proofHash, fetchedTxHash);
-        }
-        const fetchedTx = rawGtvToGtx(txGtv);
-        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);
-        }
-        const txRID = getDigestToSign(fetchedTx);
-        if (Buffer.compare(txRID, txToProveRID)) {
-            throw new ProofRidException();
-        }
-        for (const signer of txToProveSigners) {
-            let hasSignature = false;
-            for (const signature of fetchedTx.signatures) {
-                // verify that txRID (hash of gtxBody) signed by signers equals the signatures from network
-                if (checkDigestSignature(txRID, signer, signature)) {
-                    hasSignature = true;
-                    break;
-                }
-            }
-            if (!hasSignature)
-                throw new SignatureException(signer);
+/*
+ * a path looks like this:
+ * {merklePath: [{side: <0|1>, hash: <hash buffer depth n-1>},
+ *               {side: <0|1>, hash: <hash buffer depth n-2>},
+ *               ...
+ *               {side: <0|1>, hash: <hash buffer depth 1>}]}
+ */
+function merklePath(hashes, target) {
+    if (!hashes || hashes.length == 0) {
+        throw new Error("Cannot make merkle path from empty transaction set");
+    }
+    var index = -1;
+    for (var i = 0; i < hashes.length; i++) {
+        if (hashes[i].equals(target)) {
+            index = i;
+            break;
         }
-        return { verifiedTx: fetchedTx, verifiedTxHash: fetchedTxHash };
-    });
+    }
+    if (index === -1) {
+        throw new Error("Target is not in list of hashes");
+    }
+    var leafDepth = Math.ceil(Math.log2(hashes.length));
+    var path = internalMerklePath(hashes, index, 0, leafDepth);
+    return path;
 }
-function composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, anchoringTx, anchoringProof, isNetwork = true) {
-    let operationArgs;
-    operationArgs = {
-        sourceBlockchainRid: toBuffer(sourceBlockchainRid),
-        transactionHash: verifiedTxHash,
-        transactionProof: encodeValue(txProof),
-    };
-    if (isNetwork) {
-        operationArgs = Object.assign(Object.assign({}, operationArgs), { transactionData: anchoringTx === null || anchoringTx === void 0 ? void 0 : anchoringTx.txData, transactionIndex: anchoringTx === null || anchoringTx === void 0 ? void 0 : anchoringTx.txOpIndex, anchoringProof: anchoringProof && encodeValue(anchoringProof) });
+/**
+ *
+ * @param path The merkle path to validate.
+ * Format [{side: <0|1>, hash: <hash buffer depth n-1>},
+ *         {side: <0|1>, hash: <hash buffer depth n-2>},
+ *         ...,
+ *         {side: <0|1>, hash: <hash buffer depth 1>}]
+
+ * @param target the leaf hash that the path proves belongs in the merkleRoot
+ * @param merkleRoot The merkle root that supposedly contains the target via the supplied path.
+ * The merkle root is typically taken from a block header.
+ */
+function validateMerklePath(path, target, merkleRoot) {
+    let currentHash = target;
+    for (let i = 0; i < path.length; i++) {
+        const item = path[i];
+        const prefix = (i === 0) ? require$$0$1.Buffer.from([1]) : require$$0$1.Buffer.from([0]);
+        if (item.side === 0) {
+            currentHash = hashConcat([prefix, item.hash, prefix, currentHash]);
+        }
+        else {
+            if (item.hash.equals(nonExistingNodeHash)) {
+                currentHash = hashConcat([prefix, currentHash, nonExistingNodeHash]);
+            }
+            else {
+                currentHash = hashConcat([prefix, currentHash, prefix, item.hash]);
+            }
+        }
     }
-    return {
-        operations: [
-            {
-                name: "iccf_proof",
-                args: Object.values(operationArgs),
-            },
-        ],
-        signers: iccfTxSigners,
-    };
+    return merkleRoot.equals(currentHash);
 }
 
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var merkleHelper = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	calculateRoot: calculateRoot,
+	merklePath: merklePath,
+	validateMerklePath: validateMerklePath
+});
+
+var __awaiter$1 = (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) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -4364,121 +4567,161 @@ var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _argume
     });
 };
 /**
- * Creates an ICCF (Inter-Chain Communication Framework) proof transaction.
- * This function generates a proof that a specific transaction has occurred on the source blockchain
- * and constructs an ICCF proof transaction that can be posted to the target blockchain.
- *
- * @param {IClient} client - The client configured to communicate with the management chain.
- * @param {Buffer} txToProveRid - The RID of the transaction to be proven.
- * @param {Buffer} txToProveHash - The hash of the transaction to be proven.
- * @param {PubKey[]} txToProveSigners - An array of public keys representing signers of the transaction to be proven.
- * @param {string} sourceBlockchainRid - The RID of the source blockchain.
- * @param {string} targetBlockchainRid - The RID of the target blockchain.
- * @param {PubKey[]} iccfTxSigners - An array of public keys representing signers of the ICCF proof transaction (optional, default: []).
- * @param {boolean} forceIntraNetworkIccfOperation - Whether to force the ICCF operation to be performed within the same network (optional, default: false).
- * @returns {Promise<IccfProof>} A promise that resolves to an ICCF proof object containing the ICCF proof transaction.
- */
-function createIccfProofTx(client, txToProveRid, txToProveHash, txToProveSigners, sourceBlockchainRid, targetBlockchainRid, iccfTxSigners = [], forceIntraNetworkIccfOperation = false) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const clientConfiguredToSource = yield createClient({
-            directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool),
-            blockchainRid: sourceBlockchainRid,
-        });
-        const txProof = yield clientConfiguredToSource.getConfirmationProof(txToProveRid);
-        if (!txProof || !txProof.hash) {
-            throw new ConfirmationProofException(txToProveRid);
-        }
-        const proofHash = txProof.hash;
-        const { verifiedTx, verifiedTxHash } = !txToProveHash.equals(proofHash)
-            ? yield fetchAndVerifyTransaction(clientConfiguredToSource, txToProveRid, proofHash, txToProveSigners)
-            : { verifiedTx: null, verifiedTxHash: txToProveHash };
-        const sourceCluster = yield getClusterOfBlockchain(client, toBuffer(sourceBlockchainRid));
-        const targetCluster = yield getClusterOfBlockchain(client, toBuffer(targetBlockchainRid));
-        if (!forceIntraNetworkIccfOperation && sourceCluster === targetCluster) {
-            // intra-cluster
-            const intraClusterProofTx = composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, undefined, undefined, false);
-            return { iccfTx: intraClusterProofTx };
-        }
-        else {
-            // intra-network
-            const anchoringClient = yield getAnchoringClient(client, sourceBlockchainRid, sourceCluster);
-            const anchoringTx = yield getBlockAnchoringTransaction(clientConfiguredToSource, anchoringClient, undefined, txProof);
-            const anchoringProof = yield anchoringClient.getConfirmationProof(anchoringTx.txRid);
-            const intraNetworkProofTx = composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, anchoringTx, anchoringProof);
-            return { iccfTx: intraNetworkProofTx, verifiedTx };
-        }
-    });
-}
-/**
- * Checks whether a given transaction is included in the cluster anchoring chain and returns the
- * block anchoring transaction. If `txProof` is not provided, it fetches the confirmation proof
- * using the `sourceClient`.
- *
- * @param sourceClient - A client configured to the blockchain where the transaction was made.
- * @param anchoringClient - The client responsible for querying the anchoring blockchain.
- * @param txRid - The transaction RID to check for anchoring.
- * @param txProof - (Optional) The transaction proof for the specified `txRid`.
- * @returns A Promise that resolves to the anchored transaction response object.
+ * @deprecated Use the function createClient instead.
+ * Provides postchain clients that can be used to communicate with dapps within the chromia network
+ * @param chain0BRID brid of chain0
+ * @param rest rest client configured to node running chain0
  */
-function getBlockAnchoringTransaction(sourceClient, anchoringClient, txRid, txProof) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!txRid && !txProof) {
-            throw Error("Missing a txRid or TxProof");
-        }
-        const confirmationProof = txProof !== null && txProof !== void 0 ? txProof : (txRid && (yield sourceClient.getConfirmationProof(txRid)));
-        if (!confirmationProof) {
-            throw Error("Confirmation proof not found");
-        }
-        const blockRid = calculateBlockRID(confirmationProof);
-        const blockchainRid = sourceClient.config.blockchainRid;
-        const anchoringTxResponse = yield getAnchoringTransactionForBlockRid(anchoringClient, toBuffer(blockchainRid), blockRid);
-        if (!anchoringTxResponse) {
-            throw new BlockAnchoringException();
-        }
-        return anchoringTxResponse;
-    });
+function chromiaClientProvider(chain0BRID, rest) {
+    const chain0Client = createClient$1(rest, chain0BRID, []);
+    return {
+        blockchainConnection: function (dappBRID) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                const queryObject = {
+                    type: "cm_get_blockchain_api_urls",
+                    blockchain_rid: dappBRID,
+                };
+                const baseUrls = yield chain0Client.query(queryObject);
+                if (!baseUrls.length) {
+                    throw new BlockchainUrlUndefinedException(dappBRID);
+                }
+                return createRestClient(baseUrls, dappBRID);
+            });
+        },
+    };
 }
-/**
- * Checks whether a given transaction is included in the anchoring blockchain.
- *
- * @param sourceClient - A client configured to the blockchain where the transaction was made.
- * @param anchoringClient - The client responsible for querying the anchoring blockchain.
- * @param txRid - The transaction RID to check for anchoring.
- * @param txProof - (Optional) The transaction proof for the specified `txRid`.
- * @returns A Promise that resolves to `true` if the transaction is anchored, `false` otherwise.
- */
-function isBlockAnchored(sourceClient, anchoringClient, txRid, txProof) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return !!(yield getBlockAnchoringTransaction(sourceClient, anchoringClient, txRid, txProof));
+
+var chromiaClientProvider$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	chromiaClientProvider: chromiaClientProvider
+});
+
+var __awaiter = (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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-}
-/**
- * Gets a client configured for the cluster anchoring blockchain of a cluster. Takes a specific
- * cluster name or blockchain RID to determine the cluster.
- * @param client - The client configured to communicate with the management chain.
- * @param dappBlockchainRid - (Optional) The RID of a blockchain which anchoring wants to be checked.
- * @param cluster - (Optional) The cluster of interest.
- * @returns A Promise that resolves to the client configured to a cluster anchoring chain.
- */
-function getAnchoringClient(client, dappBlockchainRid, cluster) {
+};
+function createStubClient() {
     return __awaiter(this, void 0, void 0, function* () {
-        if (!dappBlockchainRid && !cluster) {
-            throw Error("Missing a dapp blockchainRid or cluster name");
-        }
-        const sourceCluster = cluster !== null && cluster !== void 0 ? cluster : (dappBlockchainRid &&
-            (yield getClusterOfBlockchain(client, toBuffer(dappBlockchainRid))));
-        if (!sourceCluster) {
-            throw Error("No cluster could be found");
-        }
-        const sourceClusterInfo = yield getClusterInfo(client, sourceCluster);
-        if (!sourceClusterInfo || !sourceClusterInfo.anchoring_chain) {
-            throw Error("Cluster info could not be found");
-        }
-        const clientConfiguredToAnchoringchain = yield createClient({
-            directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool),
-            blockchainRid: toString(sourceClusterInfo.anchoring_chain),
-        });
-        return clientConfiguredToAnchoringchain;
+        return {
+            config: {
+                nodeManager: createNodeManager({
+                    nodeUrls: [],
+                }),
+                endpointPool: [],
+                blockchainRid: "0000000000000000000000000000000000000000000000000000000000000000",
+                statusPollInterval: 5000,
+                statusPollCount: 5,
+                failoverStrategy: exports.FailoverStrategy.AbortOnError,
+                attemptsPerEndpoint: 3,
+                attemptInterval: 5000,
+                unreachableDuration: 30000,
+                directoryChainRid: "1111111111111111111111111111111111111111111111111111111111111111",
+            },
+            query() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("query rejected");
+                });
+            },
+            signTransaction() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("signTransaction rejected");
+                });
+            },
+            sendTransaction() {
+                return new Web3PromiEvent((_resolve, reject) => reject("sendTransaction rejected"));
+            },
+            signAndSendUniqueTransaction() {
+                return new Web3PromiEvent((_resolve, reject) => reject("signAndSendUniqueTransaction rejected"));
+            },
+            getTransaction() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getTransaction rejected");
+                });
+            },
+            getTransactionStatus() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getTransactionStatus rejected");
+                });
+            },
+            addNop() {
+                throw new Error("addNop error");
+            },
+            getTransactionRid() {
+                throw new Error("getTransactionRid error");
+            },
+            getTransactionsInfo() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getTransactionsInfo rejected");
+                });
+            },
+            getTransactionInfo() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getTransactionInfo rejected");
+                });
+            },
+            getTransactionConfirmationLevel() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getTransactionConfirmationLevel rejected");
+                });
+            },
+            getTransactionCount() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getTransactionCount rejected");
+                });
+            },
+            getBlocks() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getBlockInfo rejected");
+                });
+            },
+            getBlockInfo() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getBlockInfo rejected");
+                });
+            },
+            getLatestBlock() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getLatestBlock rejected");
+                });
+            },
+            getBlocksInfo() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getBlocksInfo rejected");
+                });
+            },
+            encodeTransaction() {
+                throw new Error("encodeTransaction error");
+            },
+            decodeTransactionToGtx() {
+                throw new Error("decodeTransactionToGtx error");
+            },
+            getClientNodeUrlPool() {
+                return [];
+            },
+            getConfirmationProof() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getConfirmationProof rejected");
+                });
+            },
+            getClusterAnchoringTransactionConfirmation() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getClusterAnchoringTransactionConfirmation rejected");
+                });
+            },
+            getSystemAnchoringTransactionConfirmation() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return Promise.reject("getSystemAnchoringTransactionConfirmation rejected");
+                });
+            },
+            getAppStructure() {
+                return Promise.reject("getAppStructure rejected");
+            },
+        };
     });
 }
 
@@ -4519,13 +4762,11 @@ function dumpGtx(gtxTx) {
     var _a;
     return `blockchainRid:\n${toString(gtxTx.blockchainRid)}\n
 operations:
-${gtxTx.operations
-        .map((op) => ` - ${op.opName}(${op.args.map(dumpGtv).join(", ")})\n`)
-        .join("")}
+${gtxTx.operations.map(op => ` - ${op.opName}(${op.args.map(dumpGtv).join(", ")})\n`).join("")}
 signers:
-${gtxTx.signers.map((s) => ` - ${toString(s)}\n`).join("")}
+${gtxTx.signers.map(s => ` - ${toString(s)}\n`).join("")}
 signatures:
-${(_a = gtxTx.signatures) === null || _a === void 0 ? void 0 : _a.map((s) => ` - ${toString(s)}\n`).join("")}`;
+${(_a = gtxTx.signatures) === null || _a === void 0 ? void 0 : _a.map(s => ` - ${toString(s)}\n`).join("")}`;
 }
 function dumpGtv(rawGtv) {
     return JSON.stringify(rawGtv, (_key, value) => {
@@ -4592,6 +4833,7 @@ exports.formatter = formatter;
 exports.getAnchoringClient = getAnchoringClient;
 exports.getBlockAnchoringTransaction = getBlockAnchoringTransaction;
 exports.getDigestToSignFromRawGtxBody = getDigestToSignFromRawGtxBody;
+exports.getSystemClient = getSystemClient;
 exports.gtv = index;
 exports.gtx = gtx;
 exports.gtxClient = gtxclient;