postchain-client 2.0.0 → 2.0.2

package/built/cjs/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var require$$0$1 = require('buffer');
+var merklehashts = require('merklehashts');
 var bn_js = require('bn.js');
 var zod = require('zod');
 var crypto = require('crypto');
@@ -9,53 +9,25 @@ var cloneDeep = require('lodash/cloneDeep');
 var events = require('events');
 
 function _interopNamespaceDefault(e) {
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	}
-	n.default = e;
-	return Object.freeze(n);
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
 }
 
 var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
 var secp256k1__namespace = /*#__PURE__*/_interopNamespaceDefault(secp256k1);
 
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-				var args = [null];
-				args.push.apply(args, arguments);
-				var Ctor = Function.bind.apply(f, args);
-				return new Ctor();
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -269,20 +241,20 @@ function matchRellErrorString(rellError) {
 }
 
 var formatter = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	PgBytesInputException: PgBytesInputException,
-	checkGtvType: checkGtvType,
-	checkGtxType: checkGtxType,
-	ensureBuffer: ensureBuffer,
-	ensureString: ensureString,
-	matchRellErrorString: matchRellErrorString,
-	pgBytes: pgBytes,
-	rawGtxToGtx: rawGtxToGtx,
-	rawGtxToRawGtxBody: rawGtxToRawGtxBody,
-	removeDuplicateSigners: removeDuplicateSigners,
-	toBuffer: toBuffer,
-	toQueryObjectGTV: toQueryObjectGTV,
-	toString: toString
+    __proto__: null,
+    PgBytesInputException: PgBytesInputException,
+    checkGtvType: checkGtvType,
+    checkGtxType: checkGtxType,
+    ensureBuffer: ensureBuffer,
+    ensureString: ensureString,
+    matchRellErrorString: matchRellErrorString,
+    pgBytes: pgBytes,
+    rawGtxToGtx: rawGtxToGtx,
+    rawGtxToRawGtxBody: rawGtxToRawGtxBody,
+    removeDuplicateSigners: removeDuplicateSigners,
+    toBuffer: toBuffer,
+    toQueryObjectGTV: toQueryObjectGTV,
+    toString: toString
 });
 
 function encodeValue(rawGtv) {
@@ -413,469 +385,18 @@ function sortDictPairByKey(dict) {
     return sortedDict;
 }
 
-var serialization$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	createTypedArg: createTypedArg,
-	decodeValue: decodeValue,
-	decodeValueGtx: decodeValueGtx,
-	encodeValue: encodeValue,
-	encodeValueGtx: encodeValueGtx,
-	parseValue: parseValue
-});
-
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(serialization$1);
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(formatter);
-
-var util$1 = require$$0;
-function PathElement(previous) {
-    this.previous = previous;
-}
-PathElement.prototype.getSearchKey = function () { };
-function PathLeafElement$3(previous) {
-    PathElement.call(this, previous);
-}
-PathLeafElement$3.prototype = Object.create(PathElement.prototype);
-PathLeafElement$3.prototype.constructor = PathLeafElement$3;
-PathLeafElement$3.prototype.equals = function (other) {
-    if (this === other)
-        return true;
-    if (typeof this !== typeof other)
-        return false;
-    return true;
-};
-function SearchablePathElement(previous) {
-    PathElement.call(this, previous);
-}
-SearchablePathElement.prototype = Object.create(PathElement.prototype);
-SearchablePathElement.prototype.constructor = SearchablePathElement;
-SearchablePathElement.prototype.getSearchKey = function () { };
-/**
- *
- * @param {SearchablePathElement} previous
- * @param {number} index
- */
-function ArrayPathElement(previous, index) {
-    SearchablePathElement.call(this, previous);
-    this.index = index;
-}
-ArrayPathElement.prototype = Object.create(SearchablePathElement.prototype);
-ArrayPathElement.prototype.constructor = ArrayPathElement;
-ArrayPathElement.prototype.getSearchKey = function () {
-    return this.index;
-};
-/**
- * @param {ArrayPathElement} other
- */
-ArrayPathElement.prototype.equals = function (other) {
-    if (this === other)
-        return true;
-    if (typeof this !== typeof other)
-        return false;
-    if (this.index != other.index)
-        return false;
-    return true;
-};
-/**
- *
- * @param {SearchablePathElement} previous
- * @param {string} key
- */
-function DictPathElement(previous, key) {
-    SearchablePathElement.call(this, previous);
-    this.key = key;
-}
-DictPathElement.prototype = Object.create(SearchablePathElement.prototype);
-DictPathElement.prototype.constructor = DictPathElement;
-DictPathElement.prototype.getSearchKey = function () {
-    return this.key;
-};
-/**
- * @param {DictPathElement} other
- */
-DictPathElement.prototype.equals = function (other) {
-    if (this === other)
-        return true;
-    if (typeof this !== typeof other)
-        return false;
-    if (this.key != other.key)
-        return false;
-    return true;
-};
-/**
- *
- * @param {Array} pathElements
- */
-function Path(pathElements) {
-    this.pathElements = pathElements;
-}
-/**
- *
- */
-Path.prototype.getCurrentPathElement = function () {
-    return this.pathElements[0];
-};
-/**
- *
- */
-Path.prototype.size = function () {
-    return this.pathElements.length;
-};
-/**
- *
- */
-Path.prototype.tail = function () {
-    if (this.pathElements.length == 0) {
-        throw new Error("Impossible to tail this array");
-    }
-    else {
-        var tail = this.pathElements.slice(1);
-        return new Path(tail);
-    }
-};
-Path.prototype.debugString = function () {
-    var sb = "";
-    this.pathElements.forEach(elem => {
-        if (elem instanceof SearchablePathElement) {
-            sb = sb + "-> " + elem.getSearchKey();
-        }
-        else if (elem instanceof PathLeafElement$3) {
-            sb = sb + "-> Leaf";
-        }
-    });
-    return sb;
-};
-/**
- * @param {Path} other
- */
-Path.prototype.equals = function (other) {
-    if (this === other)
-        return true;
-    if (typeof this != typeof other)
-        return false;
-    return this.pathElements == other.pathElements;
-};
-/**
- * @param {number} index
- * @param {Path} path
- */
-var getTailIfFirstElementIsArrayOfThisIndex = function (index, path) {
-    return getTail(index, path);
-};
-/**
- *
- * @param {string} key
- * @param {Path} path
- */
-var getTailIfFirstElementIsDictOfThisKey = function (key, path) {
-    return getTail(key, path);
-};
-/**
- *
- * @param {string|number} searchKey
- * @param {Path} path
- */
-var getTail = function (searchKey, path) {
-    if (searchKey === null) {
-        throw new Error("Have to provide a search key");
-    }
-    try {
-        var firstElement = path.pathElements[0];
-        if (firstElement instanceof SearchablePathElement) {
-            if (firstElement.getSearchKey() == searchKey) {
-                return path.tail();
-            }
-        }
-    }
-    catch (err) {
-        util$1.logError("Why are we dropping first element of an empty path? " + err);
-        return null;
-    }
-    return null;
-};
-/**
- *
- * @param {Array} paths
- */
-function PathSet$1(paths) {
-    this.paths = paths;
-}
-/**
- *
- */
-PathSet$1.prototype.isEmpty = function () {
-    return this.paths.length == 0;
-};
-/**
- *
- */
-PathSet$1.prototype.getPathLeafOrElseAnyCurrentPathElement = function () {
-    var leafElem = null;
-    var currElem = null;
-    var prev = {
-        "path": null,
-        "elem": null,
-    };
-    this.paths.forEach(path => {
-        currElem = path.getCurrentPathElement();
-        if (currElem instanceof PathLeafElement$3) {
-            leafElem = currElem;
-        }
-        prev = this.errorCheckUnequalParent(path, currElem, prev.path, prev.elem);
-    });
-    if (leafElem != null) {
-        return leafElem;
-    }
-    else {
-        return currElem; // It doesn't matter which one we return (Next step we will get the "previous" from this one)
-    }
-};
-/**
- * Yeah, this might be a completely un-needed check (but it MIGHT save us later on if we forget this rule).
- * What we are looking for here is an impossible state where two paths in the same set don't have the same parent.
- * (Since we usually only have one path in a path set, this check should be cheap)
- *
- * @param {Path} currPath
- * @param {PathElement} currElem
- * @param {Path} prevPath
- * @param {PathElement} prevElem
- */
-PathSet$1.prototype.errorCheckUnequalParent = function (currPath, currElem, prevPath, prevElem) {
-    if (prevElem != null) {
-        // weird: javascript cannot compare null == null then we have to compare each with null separately :(
-        if (currElem.previous == null && prevElem.previous == null) {
-            return {
-                "path": currPath,
-                "elem": currElem
-            };
-        }
-        else if ((currElem.previous == null && prevElem.previous != null) || (currElem.previous != null && prevElem.previous == null)) {
-            throw new Error("Something is wrong, these paths do not have the same parent. (" + currPath + ") (" + prevPath + ")");
-        }
-        else if (!currElem.previous.equals(prevElem.previous)) {
-            throw new Error("Something is wrong, these paths do not have the same parent. (" + currPath + ") (" + prevPath + ")");
-        }
-    }
-    return {
-        "path": currPath,
-        "elem": currElem
-    };
-};
-/**
- *
- */
-PathSet$1.prototype.keepOnlyArrayPaths = function () {
-    var filteredPaths = this.paths.filter(path => {
-        return path.pathElements[0] instanceof ArrayPathElement;
-    });
-    return new PathSet$1(filteredPaths);
-};
-/**
- *
- */
-PathSet$1.prototype.keepOnlyDictPaths = function () {
-    var filteredPaths = this.paths.filter(path => {
-        return path.pathElements[0] instanceof DictPathElement;
-    });
-    return new PathSet$1(filteredPaths);
-};
-/**
- *
- */
-PathSet$1.prototype.getTailIfFirstElementIsArrayOfThisIndexFromList = function (index) {
-    return this.getTailFromList(index, getTailIfFirstElementIsArrayOfThisIndex);
-};
-/**
- *
- */
-PathSet$1.prototype.getTailIfFirstElementIsDictOfThisKeyFromList = function (key) {
-    return this.getTailFromList(key, getTailIfFirstElementIsDictOfThisKey);
-};
-/**
- *
- */
-PathSet$1.prototype.getTailFromList = function (searchKey, filterFunc) {
-    var retPaths = new Array();
-    this.paths.forEach(path => {
-        var newPath = filterFunc(searchKey, path);
-        if (newPath != null) {
-            retPaths.push(newPath);
-        }
-    });
-    return new PathSet$1(retPaths);
-};
-/**
- *
- * @param {Array} arr
- */
-var buildPathFromArray = function (arr) {
-    var pathElements = new Array();
-    var lastPathElem = null;
-    arr.forEach(item => {
-        var newElem = null;
-        if (typeof item === 'number') {
-            newElem = new ArrayPathElement(lastPathElem, item);
-        }
-        else if (typeof item === 'string') {
-            newElem = new DictPathElement(lastPathElem, item);
-        }
-        else {
-            throw new Error("A path structure must only consist of Ints and Strings, not " + item);
-        }
-        pathElements.push(newElem);
-        lastPathElem = newElem;
-    });
-    var lastOne = lastPathElem;
-    pathElements.push(new PathLeafElement$3(lastOne));
-    return new Path(pathElements);
+const gtvHash2 = (obj, merkleHashVersion) => {
+    return merklehashts.gtvHash(obj, merkleHashVersion);
 };
-var path = { Path, PathElement, PathLeafElement: PathLeafElement$3, ArrayPathElement, SearchablePathElement, DictPathElement, PathSet: PathSet$1,
-    getTailIfFirstElementIsArrayOfThisIndex, buildPathFromArray };
+const encode$1 = encodeValue;
+const decode$1 = decodeValue;
 
-var PathLeafElement$2 = path.PathLeafElement;
-const HASH_PREFIX_NODE$1 = 0;
-const HASH_PREFIX_LEAF$1 = 1;
-const HASH_PREFIX_NODE_ARRAY$1 = 7;
-const HASH_PREFIX_NODE_DICT$1 = 8;
-/**
- *
- */
-function BinaryTreeElement() {
-    this.pathElem = null;
-}
-BinaryTreeElement.prototype.isPath = function () {
-    return this.pathElem != null;
-};
-BinaryTreeElement.prototype.isPathLeaf = function () {
-    if (this.pathElem == null) {
-        return false;
-    }
-    if (this.pathElem instanceof PathLeafElement$2) {
-        return true;
-    }
-    else {
-        return false;
-    }
-};
-BinaryTreeElement.prototype.setPathElement = function (pathElem) {
-    this.pathElem = pathElem;
-};
-BinaryTreeElement.prototype.getPrefixByte = function () {
-    return HASH_PREFIX_NODE$1;
-};
-/**
- *
- * @param {BinaryTreeElement} left
- * @param {BinaryTreeElement} right
- */
-function Node$2(left, right) {
-    this.left = left;
-    this.right = right;
-}
-Node$2.prototype = Object.create(BinaryTreeElement.prototype);
-Node$2.prototype.constructor = Node$2;
-Node$2.prototype.getPrefixByte = function () {
-    return HASH_PREFIX_NODE$1;
-};
-/**
- *
- * @param {BinaryTreeElement} left
- * @param {BinaryTreeElement} right
- * @param {*} content
- * @param {PathSet} pathElem
- */
-function SubTreeRootNode$1(left, right, content, pathElem) {
-    Node$2.call(this, left, right);
-    this.content = content;
-    BinaryTreeElement.prototype.setPathElement.call(this, pathElem);
-}
-SubTreeRootNode$1.prototype = Object.create(Node$2.prototype);
-SubTreeRootNode$1.prototype.constructor = SubTreeRootNode$1;
-/**
- *
- * @param {*} content
- * @param {PathElement} pathElem
- */
-function Leaf$2(content, pathElem = null) {
-    this.content = content;
-    if (pathElem != null) {
-        if (pathElem instanceof PathLeafElement$2) {
-            BinaryTreeElement.prototype.setPathElement.call(this, pathElem);
-        }
-        else {
-            throw new Error("The path and object structure does not match! We are at a leaf, but the path expects a sub structure.");
-        }
-    }
-}
-Leaf$2.prototype = Object.create(BinaryTreeElement.prototype);
-Leaf$2.prototype.constructor = Leaf$2;
-Leaf$2.prototype.getPrefixByte = function () {
-    return HASH_PREFIX_LEAF$1;
-};
-function EmptyLeaf$2() { }
-EmptyLeaf$2.prototype = Object.create(BinaryTreeElement.prototype);
-EmptyLeaf$2.prototype.constructor = EmptyLeaf$2;
-/**
- * Wrapper class for the root object.
- * @param {BinaryTreeElement} root
- */
-function BinaryTree$1(root) {
-    this.root = root;
-}
-BinaryTree$1.prototype.maxLevel = function () {
-    return this.maxLevelInternal(this.root);
-};
-BinaryTree$1.prototype.maxLevelInternal = function (node) {
-    if (node instanceof EmptyLeaf$2) {
-        return 0;
-    }
-    else if (node instanceof Leaf$2) {
-        return 1;
-    }
-    else if (node instanceof Node$2) {
-        return Math.max(this.maxLevelInternal(node.left), this.maxLevelInternal(node.right)) + 1;
-    }
-    else {
-        throw new Error("What is this type? " + typeof node);
-    }
-};
-/**
- * Represents the top of a sub tree generated by a [Array]
- *
- * @param {*} left
- * @param {*} right
- * @param {*} content
- * @param {*} size
- * @param {PathElement} pathElem
- */
-function ArrayHeadNode$2(left, right, content, size, pathElem = null) {
-    SubTreeRootNode$1.call(this, left, right, content, pathElem);
-    this.size = size;
-}
-ArrayHeadNode$2.prototype = Object.create(SubTreeRootNode$1.prototype);
-ArrayHeadNode$2.prototype.constructor = ArrayHeadNode$2;
-ArrayHeadNode$2.prototype.getPrefixByte = function () {
-    return HASH_PREFIX_NODE_ARRAY$1;
-};
-/**
- * Represents the top a sub tree generated by a [Dictionary]
- * @param {*} left
- * @param {*} right
- * @param {*} content
- * @param {*} size
- * @param {PathElement} pathElem
- */
-function DictHeadNode$2(left, right, content, size, pathElem = null) {
-    SubTreeRootNode$1.call(this, left, right, content, pathElem);
-    this.size = size;
-}
-DictHeadNode$2.prototype = Object.create(SubTreeRootNode$1.prototype);
-DictHeadNode$2.prototype.constructor = DictHeadNode$2;
-DictHeadNode$2.prototype.getPrefixByte = function () {
-    return HASH_PREFIX_NODE_DICT$1;
-};
-var binarytree = { HASH_PREFIX_NODE: HASH_PREFIX_NODE$1, HASH_PREFIX_LEAF: HASH_PREFIX_LEAF$1, HASH_PREFIX_NODE_ARRAY: HASH_PREFIX_NODE_ARRAY$1, HASH_PREFIX_NODE_DICT: HASH_PREFIX_NODE_DICT$1,
-    Node: Node$2, Leaf: Leaf$2, EmptyLeaf: EmptyLeaf$2, SubTreeRootNode: SubTreeRootNode$1, BinaryTreeElement, BinaryTree: BinaryTree$1, ArrayHeadNode: ArrayHeadNode$2, DictHeadNode: DictHeadNode$2 };
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    decode: decode$1,
+    encode: encode$1,
+    gtvHash: gtvHash2
+});
 
 class PrivKeyFormatException extends Error {
     constructor(privKey) {
@@ -988,747 +509,20 @@ function validatePrivKeyFormat(privKey) {
     }
 }
 
-var encryption$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	checkDigestSignature: checkDigestSignature,
-	checkSignature: checkSignature,
-	createPublicKey: createPublicKey,
-	hash256: hash256,
-	hashConcat: hashConcat,
-	makeKeyPair: makeKeyPair,
-	makeTuid: makeTuid,
-	randomBytes: randomBytes,
-	sha256: sha256,
-	sign: sign$1,
-	signDigest: signDigest,
-	verifyKeyPair: verifyKeyPair
-});
-
-var require$$3 = /*@__PURE__*/getAugmentedNamespace(encryption$1);
-
-const { Buffer: Buffer$3 } = require$$0$1;
-var serialization = require$$1;
-var HASH_PREFIX_LEAF = binarytree.HASH_PREFIX_LEAF;
-var encryption = require$$3;
-function CryptoSystem() { }
-CryptoSystem.prototype.digest = function (buffer) {
-    return encryption.hash256(buffer);
-};
-/**
- *
- * @param {Buffer} buffer
- * @param {CryptoSystem} cryptoSystem
- */
-function hashingFun(buffer, cryptoSystem) {
-    if (cryptoSystem === null) {
-        throw new Error("In this case we need the CryptoSystem to calculate the hash");
-    }
-    else {
-        return cryptoSystem.digest(buffer);
-    }
-}
-/**
- *
- * @param {CryptoSystem} cryptoSystem
- */
-function MerkleHashCalculator(cryptoSystem) {
-    this.cryptoSystem = cryptoSystem;
-}
-/**
- * @param {number} prefix
- * @param {Buffer} hashLeft
- * @param {Buffer} hashRight
- */
-MerkleHashCalculator.prototype.calculateNodeHash = function (prefix, hashLeft, hashRight) {
-    return this.calculateNodeHashInternal(prefix, hashLeft, hashRight, hashingFun);
-};
-/**
- * @param {*} value
- */
-MerkleHashCalculator.prototype.calculateLeafHash = function (value, merkleHashVersion) {
-    return this.calculateHashOfValueInternal(value, serialization.encodeValue, hashingFun, merkleHashVersion);
-};
-/**
- * @param {number} prefix
- * @param {Buffer} hashLeft
- * @param {Buffer} hashRight
- */
-MerkleHashCalculator.prototype.calculateNodeHashInternal = function (prefix, hashLeft, hashRight, hashFunc) {
-    var buf = Buffer$3.alloc(1);
-    buf.writeInt8(prefix);
-    var bufferSum = Buffer$3.concat([buf, hashLeft, hashRight]);
-    return hashFunc(bufferSum, this.cryptoSystem);
-};
-MerkleHashCalculator.prototype.calculateHashOfValueInternal = function (valuetoHash, serializeFun, hashFunc, merkleHashVersion) {
-    var buf = Buffer$3.alloc(1);
-    buf.writeInt8(HASH_PREFIX_LEAF);
-    var bufferSum = Buffer$3.concat([buf, serializeFun(valuetoHash)]);
-    return hashFunc(bufferSum, this.cryptoSystem, merkleHashVersion);
-};
-MerkleHashCalculator.prototype.isContainerProofValueLeaf = function (value) {
-    if (value == null) {
-        return false;
-    }
-    if (value.constructor === Array || typeof value === 'object') {
-        return true;
-    }
-    else {
-        return false;
-    }
-};
-var merklehashcalculator = { MerkleHashCalculator, CryptoSystem };
-
-var util = require$$0;
-const { Buffer: Buffer$2 } = require$$0$1;
-var PathSet = path.PathSet;
-var PathLeafElement$1 = path.PathLeafElement;
-var EmptyLeaf$1 = binarytree.EmptyLeaf;
-var Leaf$1 = binarytree.Leaf;
-var Node$1 = binarytree.Node;
-var BinaryTree = binarytree.BinaryTree;
-var ArrayHeadNode$1 = binarytree.ArrayHeadNode;
-var DictHeadNode$1 = binarytree.DictHeadNode;
-const NO_PATHS = new PathSet([]);
-/**
- * The factory does the conversion between list of elements and tree of elements.
- *
- * Note: The idea is that you should sub class for each type of element you want to build.
- */
-function BinaryTreeFactory$1() { }
-/**
- * Transforms the incoming leaf into an [BinaryTreeElement]
- * The idea with this function is that it can be recursive (if the leaf in turn is complex object with sub objects).
- *
- * Note: If we don't have a path here we can try to find the leaf in the cache.
- *
- * @param leaf the raw data we should wrap in a leaf
- * @param paths a collection of proof paths that might point to this leaf
- * @return the resulting [BinaryTreeElement] the leaf got converted to
- */
-BinaryTreeFactory$1.prototype.handleLeaf = function (leaf, paths, isRoot = false, merkleHashVersion) {
-    if (merkleHashVersion == undefined || merkleHashVersion == null) {
-        console.error("stack trace", new Error().stack);
-        throw new Error("Merkle hash version is undefined or null");
-    }
-    if (paths.length == 0 && !isRoot) {
-        return this.innerHandleLeaf(leaf, this.getEmptyPathSet(), merkleHashVersion);
-    }
-    else {
-        return this.innerHandleLeaf(leaf, paths, merkleHashVersion);
-    }
-};
-/**
- *
- */
-BinaryTreeFactory$1.prototype.getEmptyPathSet = function () {
-    return NO_PATHS;
-};
-/**
- * At this point we should have looked in cache.
- *
- * @param leaf we should turn into a tree element
- * @param {PathSet} paths
- * @return the tree element we created.
- */
-BinaryTreeFactory$1.prototype.innerHandleLeaf = function (leaf, paths, merkleHashVersion) {
-    if (leaf == null) {
-        return this.handlePrimitiveLeaf(leaf, paths);
-    }
-    if (Buffer$2.isBuffer(leaf)) {
-        return this.handlePrimitiveLeaf(leaf, paths);
-    }
-    if (typeof leaf === 'string') {
-        return this.handlePrimitiveLeaf(leaf, paths);
-    }
-    if (typeof leaf === 'number') {
-        return this.handlePrimitiveLeaf(leaf, paths);
-    }
-    if (typeof leaf === 'bigint') {
-        return this.handlePrimitiveLeaf(leaf, paths);
-    }
-    if (typeof leaf === 'boolean') {
-        return this.handlePrimitiveLeaf(leaf ? 1 : 0, paths);
-    }
-    if (leaf.constructor === Array) {
-        return this.buildFromArray(leaf, paths, merkleHashVersion);
-    }
-    if (typeof leaf === 'object') {
-        return this.buildFromDictionary(leaf, paths, merkleHashVersion);
-    }
-    else {
-        throw new Error("Unsupported data type");
-    }
-};
-/**
- * Just like [handleLeaf] but we know that this leaf should not be a complex type, but something we can
- * immediately wrap
- *
- * @param leaf
- * @param {PathSet} paths
- */
-BinaryTreeFactory$1.prototype.handlePrimitiveLeaf = function (leaf, paths) {
-    var pathElem = paths.getPathLeafOrElseAnyCurrentPathElement();
-    if (pathElem != null && !(pathElem instanceof PathLeafElement$1)) {
-        throw new Error("Path does not match the tree structure. We are at a leaf " + leaf + " but found path element " + pathElem);
-    }
-    return new Leaf$1(leaf, pathElem);
-};
-/**
- * Calls itself until the return value only holds 1 element
- *
- * Note: This method can only create standard [Node] that fills up the area between the "top" and the leaves.
- *        These "in-between" nodes cannot be "path leaf" or have any interesting properties.
- *
- * @param layer What layer we aim calculate
- * @param inList The args of nodes we should build from
- * @return All [BinaryTreeElement] nodes of the next layer
- */
-BinaryTreeFactory$1.prototype.buildHigherLayer = function (layer, inList) {
-    if (inList.length === 0) {
-        throw new Error("Cannot work on empty arrays. Layer: " + layer);
-    }
-    else if (inList.length === 1) {
-        return inList;
-    }
-    var returnArray = new Array();
-    var nrOfNodesToCreate = Math.floor(inList.length / 2);
-    var leftValue = null;
-    var isLeft = true;
-    for (var i = 0; i < inList.length; i++) {
-        if (isLeft) {
-            leftValue = inList[i];
-            isLeft = false;
-        }
-        else {
-            var tempNode = new Node$1(leftValue, inList[i]);
-            returnArray.push(tempNode);
-            nrOfNodesToCreate--;
-            isLeft = true;
-            leftValue = null;
-        }
-    }
-    if (!isLeft) {
-        // If there is odd number of nodes, then move the last node up one level
-        returnArray.push(leftValue);
-    }
-    // Extra check
-    if (nrOfNodesToCreate != 0) {
-        util.logDebug("Why didn't we build exactly the correct amount? Layer: " + layer + " , residue: " + nrOfNodesToCreate + " , input args size: " + inList.length + ".");
-    }
-    return this.buildHigherLayer((layer + 1), returnArray);
-};
-BinaryTreeFactory$1.prototype.build = function (data, merkleHashVersion) {
-    return this.buildWithPath(data, NO_PATHS, merkleHashVersion);
-};
-/**
- * @param {PathSet} paths
- */
-BinaryTreeFactory$1.prototype.buildWithPath = function (data, paths, merkleHashVersion) {
-    var result = this.handleLeaf(data, paths, true, merkleHashVersion);
-    return new BinaryTree(result);
-};
-/**
- * @param {Array} array
- * @param {PathSet} paths
- */
-BinaryTreeFactory$1.prototype.buildFromArray = function (array, paths, merkleHashVersion) {
-    if (merkleHashVersion == undefined || merkleHashVersion == null) {
-        console.error("stack trace", new Error().stack);
-        throw new Error("Merkle hash version is undefined or null");
-    }
-    var pathElem = paths.getPathLeafOrElseAnyCurrentPathElement();
-    // 1. Build leaf layer
-    if (array.length == 0) {
-        return new ArrayHeadNode$1(new EmptyLeaf$1(), new EmptyLeaf$1(), array, 0, 0, pathElem);
-    }
-    var leafArray = this.buildLeafElements(array, paths, merkleHashVersion);
-    //Merkle hash version 2 and above - check
-    if (leafArray.length == 1 && leafArray[0] instanceof Node$1 && merkleHashVersion >= 2) {
-        return new ArrayHeadNode$1(leafArray[0], new EmptyLeaf$1(), array, array.length, pathElem);
-    }
-    // 2. Build all higher layers
-    var result = this.buildHigherLayer(1, leafArray);
-    // 3. Fix and return the root node
-    var orgRoot = result[0];
-    if (orgRoot instanceof Node$1) {
-        return new ArrayHeadNode$1(orgRoot.left, orgRoot.right, array, array.length, pathElem);
-    }
-    if (orgRoot instanceof Leaf$1) {
-        return this.buildFromOneLeaf(array, orgRoot, pathElem);
-    }
-    else {
-        throw new Error("Should not find element of this type here");
-    }
-};
-/**
- *
- */
-BinaryTreeFactory$1.prototype.buildFromOneLeaf = function (array, orgRoot, pathElem) {
-    if (array.length > 1) {
-        throw new Error("How come we got a leaf returned when we had " + array.length + " elements is the args?");
-    }
-    else {
-        return new ArrayHeadNode$1(orgRoot, new EmptyLeaf$1(), array, array.length, pathElem);
-    }
-};
-/**
- * @param {PathSet} paths
- */
-BinaryTreeFactory$1.prototype.buildLeafElements = function (leafList, paths, merkleHashVersion) {
-    var leafArray = new Array();
-    var onlyArrayPaths = paths.keepOnlyArrayPaths(); // For performance, since we will loop soon
-    for (var i = 0; i < leafList.length; i++) {
-        var pathsRelevantForThisLeaf = onlyArrayPaths.getTailIfFirstElementIsArrayOfThisIndexFromList(i);
-        var leaf = leafList[i];
-        var binaryTreeElement = this.handleLeaf(leaf, pathsRelevantForThisLeaf, false, merkleHashVersion);
-        leafArray.push(binaryTreeElement);
-    }
-    return leafArray;
-};
-/**
- * @param {PathSet} paths
- */
-BinaryTreeFactory$1.prototype.buildFromDictionary = function (dict, paths, merkleHashVersion) {
-    var pathElem = paths.getPathLeafOrElseAnyCurrentPathElement();
-    // Needs to be sorted, or else the order is undefined
-    var keys = Object.keys(dict).sort();
-    if (keys.length == 0) {
-        return new DictHeadNode$1(new EmptyLeaf$1(), new EmptyLeaf$1(), dict, keys.length, 0, pathElem);
-    }
-    // 1. Build first (leaf) layer
-    var leafArray = this.buildLeafElementFromDict(keys, dict, paths, merkleHashVersion);
-    // 2. Build all higher layers
-    var result = this.buildHigherLayer(1, leafArray);
-    // 3. Fix and return the root node
-    var orgRoot = result[0];
-    if (orgRoot instanceof Node$1) {
-        return new DictHeadNode$1(orgRoot.left, orgRoot.right, dict, keys.length, pathElem);
-    }
-    else {
-        throw new Error("Should not find element of this type here: " + typeof orgRoot);
-    }
-};
-/**
- * @param {PathSet} paths
- */
-BinaryTreeFactory$1.prototype.buildLeafElementFromDict = function (keys, dict, paths, merkleHashVersion) {
-    var leafArray = new Array();
-    var onlyDictPaths = paths.keepOnlyDictPaths(); // For performance, since we will loop soon
-    for (var i = 0; i < keys.length; i++) {
-        // The key cannot not be proved, so NO_PATHS
-        var key = keys[i];
-        var keyElement = this.handleLeaf(key, NO_PATHS, false, merkleHashVersion);
-        leafArray.push(keyElement);
-        var content = dict[key];
-        var pathsRelevantForThisLeaf = onlyDictPaths.getTailIfFirstElementIsDictOfThisKeyFromList(key);
-        var contentElement = this.handleLeaf(content, pathsRelevantForThisLeaf, false, merkleHashVersion);
-        leafArray.push(contentElement);
-    }
-    return leafArray;
-};
-var binarytreefactory = { BinaryTreeFactory: BinaryTreeFactory$1 };
-
-var HASH_PREFIX_NODE = binarytree.HASH_PREFIX_NODE;
-var HASH_PREFIX_NODE_ARRAY = binarytree.HASH_PREFIX_NODE_ARRAY;
-var HASH_PREFIX_NODE_DICT = binarytree.HASH_PREFIX_NODE_DICT;
-/**
- *
- */
-function MerkleProofElement() { }
-/**
- *
- * @param {Buffer} prefix
- * @param {MerkleProofElement} left
- * @param {MerkleProofElement} right
- */
-function ProofNode$1(prefix, left, right) {
-    this.prefix = prefix;
-    this.left = left;
-    this.right = right;
-}
-ProofNode$1.prototype = Object.create(MerkleProofElement.prototype);
-ProofNode$1.prototype.constructor = ProofNode$1;
-/**
- *
- * @param {MerkleProofElement} left
- * @param {MerkleProofElement} right
- */
-function ProofNodeSimple$1(left, right) {
-    ProofNode$1.call(this, HASH_PREFIX_NODE, left, right);
-}
-ProofNodeSimple$1.prototype = Object.create(ProofNode$1.prototype);
-ProofNodeSimple$1.prototype.constructor = ProofNodeSimple$1;
-/**
- *
- * @param {*} content
- * @param {SearchablePathElement} pathElem
- */
-function ProofValueLeaf$2(content, pathElem) {
-    this.content = content;
-    this.pathElem = pathElem;
-}
-ProofValueLeaf$2.prototype = Object.create(MerkleProofElement.prototype);
-ProofValueLeaf$2.prototype.constructor = ProofValueLeaf$2;
-/**
- *
- * @param {Buffer} merkleHash
- */
-function ProofHashedLeaf$2(merkleHash) {
-    this.merkleHash = merkleHash;
-}
-ProofHashedLeaf$2.prototype = Object.create(MerkleProofElement.prototype);
-ProofHashedLeaf$2.prototype.constructor = ProofHashedLeaf$2;
-/**
- * @param {ProofHashedLeaf} other
- */
-ProofHashedLeaf$2.prototype.equals = function (other) {
-    if (other instanceof ProofHashedLeaf$2) {
-        return this.merkleHash.equals(other.merkleHash);
-    }
-    else {
-        return false;
-    }
-};
-/**
- *
- * @param {MerkleProofElement} left
- * @param {MerkleProofElement} right
- * @param {SearchablePathElement} pathElem
- */
-function ProofNodeArrayHead$1(left, right, pathElem = null) {
-    ProofNode$1.call(this, HASH_PREFIX_NODE_ARRAY, left, right);
-    this.pathElem = pathElem;
-}
-ProofNodeArrayHead$1.prototype = Object.create(ProofNode$1.prototype);
-ProofNodeArrayHead$1.prototype.constructor = ProofNodeArrayHead$1;
-/**
- *
- * @param {MerkleProofElement} left
- * @param {MerkleProofElement} right
- * @param {SearchablePathElement} pathElem
- */
-function ProofNodeDictHead$1(left, right, pathElem = null) {
-    ProofNode$1.call(this, HASH_PREFIX_NODE_DICT, left, right);
-    this.pathElem = pathElem;
-}
-ProofNodeDictHead$1.prototype = Object.create(ProofNode$1.prototype);
-ProofNodeDictHead$1.prototype.constructor = ProofNodeDictHead$1;
-/**
- *
- * @param {MerkleProofElement} root
- */
-function MerkleProofTree$1(root) {
-    this.root = root;
-}
-MerkleProofTree$1.prototype.maxLevel = function () {
-    return this.maxLevelInternal(this.root);
-};
-/**
- * @param {MerkleProofElement} node
- */
-MerkleProofTree$1.prototype.maxLevelInternal = function (node) {
-    if (node instanceof ProofValueLeaf$2) {
-        return 1;
-    }
-    else if (node instanceof ProofHashedLeaf$2) {
-        return 1;
-    }
-    else if (node instanceof ProofNode$1) {
-        return Math.max(this.maxLevelInternal(node.left), this.maxLevelInternal(node.right)) + 1;
-    }
-    else {
-        throw new Error("Should be able to handle node type: " + typeof node);
-    }
-};
-var merkleprooftree = { ProofNode: ProofNode$1, ProofNodeSimple: ProofNodeSimple$1, ProofHashedLeaf: ProofHashedLeaf$2, ProofValueLeaf: ProofValueLeaf$2,
-    ProofNodeArrayHead: ProofNodeArrayHead$1, ProofNodeDictHead: ProofNodeDictHead$1, MerkleProofElement, MerkleProofTree: MerkleProofTree$1 };
-
-const { Buffer: Buffer$1 } = require$$0$1;
-var Node = binarytree.Node;
-var Leaf = binarytree.Leaf;
-var EmptyLeaf = binarytree.EmptyLeaf;
-var ProofHashedLeaf$1 = merkleprooftree.ProofHashedLeaf;
-var ProofValueLeaf$1 = merkleprooftree.ProofValueLeaf;
-var MerkleProofTree = merkleprooftree.MerkleProofTree;
-var ProofNodeArrayHead = merkleprooftree.ProofNodeArrayHead;
-var ProofNodeDictHead = merkleprooftree.ProofNodeDictHead;
-var PathLeafElement = path.PathLeafElement;
-var SubTreeRootNode = binarytree.SubTreeRootNode;
-var ArrayHeadNode = binarytree.ArrayHeadNode;
-var DictHeadNode = binarytree.DictHeadNode;
-var ProofNodeSimple = merkleprooftree.ProofNodeSimple;
-const EMPTY_HASH = new Buffer$1.alloc(32);
-/**
- *
- */
-function MerkleProofTreeFactory$1() { }
-/**
- * @param {BinaryTree} originalTree
- */
-MerkleProofTreeFactory$1.prototype.buildFromBinaryTree = function (originalTree, calculator) {
-    var rootElem = this.buildFromBinaryTreeInternal(originalTree.root, calculator);
-    return new MerkleProofTree(rootElem);
-};
-/**
- * @param {BinaryTreeElement} elem
- * @param {*} calculator
- */
-MerkleProofTreeFactory$1.prototype.buildFromBinaryTreeInternal = function (elem, calculator) {
-    if (elem instanceof EmptyLeaf) {
-        return new ProofHashedLeaf$1(EMPTY_HASH);
-    }
-    else if (elem instanceof Leaf) {
-        var pathElem = elem.pathElem;
-        if (pathElem != null) {
-            if (pathElem instanceof PathLeafElement) {
-                return new ProofValueLeaf$1(elem.content, pathElem.previous);
-            }
-            else {
-                throw new Error("The path and structure don't match. We are at a leaf, but path elem is not a leaf: " + pathElem);
-            }
-        }
-        else {
-            // make a hash
-            var hash = calculator.calculateLeafHash(elem.content);
-            return new ProofHashedLeaf$1(hash);
-        }
-    }
-    else if (elem instanceof SubTreeRootNode) {
-        var pathElem = elem.pathElem;
-        if (pathElem != null) {
-            if (pathElem instanceof PathLeafElement) {
-                // Don't convert it
-                return new ProofValueLeaf$1(elem.content, pathElem.previous);
-            }
-            else {
-                return this.convertNode(elem, calculator);
-            }
-        }
-        else {
-            return this.convertNode(elem, calculator);
-        }
-    }
-    else if (elem instanceof Node) {
-        return this.convertNode(elem, calculator);
-    }
-    else {
-        throw new Error("Cannot handle " + elem);
-    }
-};
-/**
- * @param {Node} node
- */
-MerkleProofTreeFactory$1.prototype.convertNode = function (node, calculator) {
-    var left = this.buildFromBinaryTreeInternal(node.left, calculator);
-    var right = this.buildFromBinaryTreeInternal(node.right, calculator);
-    if (left instanceof ProofHashedLeaf$1 && right instanceof ProofHashedLeaf$1) {
-        var addedHash = calculator.calculateNodeHash(node.getPrefixByte(), left.merkleHash, right.merkleHash);
-        return new ProofHashedLeaf$1(addedHash);
-    }
-    else {
-        return this.buildNodeOfCorrectType(node, left, right);
-    }
-};
-/**
- * @param {ArrayHeadNode} node
- */
-MerkleProofTreeFactory$1.prototype.extractSearchablePathElement = function (node) {
-    var pathElem = node.pathElem;
-    if (pathElem != null) {
-        return pathElem.previous;
-    }
-    else {
-        return null;
-    }
-};
-/**
- * @param {Node} node
- * @param {MerkleProofElement} left
- * @param {MerkleProofElement} right
- */
-MerkleProofTreeFactory$1.prototype.buildNodeOfCorrectType = function (node, left, right) {
-    if (node instanceof ArrayHeadNode) {
-        return new ProofNodeArrayHead(left, right, this.extractSearchablePathElement(node));
-    }
-    else if (node instanceof DictHeadNode) {
-        return new ProofNodeDictHead(left, right, this.extractSearchablePathElement(node));
-    }
-    else if (node instanceof Node) {
-        return new ProofNodeSimple(left, right);
-    }
-    else {
-        throw new Error("Should have taken care of this node type: " + node);
-    }
-};
-var merkleprooftreefactory = { MerkleProofTreeFactory: MerkleProofTreeFactory$1 };
-
-/**
- *
- * @param {Buffer} merkleHash
- */
-function MerkleHashSummary$1(merkleHash) {
-    this.merkleHash = merkleHash;
-}
-/**
- * @param {MerkleHashSummary} other
- */
-MerkleHashSummary$1.prototype.equals = function (other) {
-    if (this === other)
-        return true;
-    if (typeof this != typeof other)
-        return false;
-    if (this.merkleHash.compare(other.merkleHash) === 0) {
-        return true;
-    }
-    return false;
-};
-var merklehashcarrier = { MerkleHashSummary: MerkleHashSummary$1 };
-
-var ProofHashedLeaf = merkleprooftree.ProofHashedLeaf;
-var ProofValueLeaf = merkleprooftree.ProofValueLeaf;
-var ProofNode = merkleprooftree.ProofNode;
-var MerkleHashSummary = merklehashcarrier.MerkleHashSummary;
-/**
- *
- * @param {BinaryTreeFactory} treeFactory
- * @param {MerkleProofTreeFactory} proofFactory
- */
-function MerkleHashSummaryFactory$1(treeFactory, proofFactory) {
-    this.treeFactory = treeFactory;
-    this.proofFactory = proofFactory;
-}
-/**
- * @param {any} value
- * @param {MerkleHashCalculator} calculator
- */
-MerkleHashSummaryFactory$1.prototype.calculateMerkleRoot = function (value, calculator, merkleHashVersion) {
-    var binaryTree = this.treeFactory.build(value, merkleHashVersion);
-    var proofTree = this.proofFactory.buildFromBinaryTree(binaryTree, calculator);
-    return this.calculateMerkleRootOfTree(proofTree, calculator);
-};
-/**
- * @param {MerkleProofTree} value
- * @param {MerkleHashCalculator} calculator
- */
-MerkleHashSummaryFactory$1.prototype.calculateMerkleTreeRoot = function (tree, calculator, merkleHashVersion) {
-    return this.calculateMerkleRootOfTree(tree, calculator, merkleHashVersion);
-};
-/**
- * @param {MerkleProofTree} proofTree
- * @param {MerkleHashCalculator} calculator
- */
-MerkleHashSummaryFactory$1.prototype.calculateMerkleRootOfTree = function (proofTree, calculator, merkleHashVersion) {
-    var calculatedSummary = this.calculateMerkleRootInternal(proofTree.root, calculator, merkleHashVersion);
-    return new MerkleHashSummary(calculatedSummary);
-};
-/**
- * @param {MerkleProofElement} currentElement
- * @param {MerkleHashCalculator} calculator
- */
-MerkleHashSummaryFactory$1.prototype.calculateMerkleRootInternal = function (currentElement, calculator, merkleHashVersion) {
-    if (currentElement instanceof ProofHashedLeaf) {
-        return currentElement.merkleHash;
-    }
-    else if (currentElement instanceof ProofValueLeaf) {
-        var value = currentElement.content;
-        if (calculator.isContainerProofValueLeaf(value)) {
-            // We have a container value to prove, so need to convert the value to a binary tree, and THEN hash it
-            var merkleProofTree = this.buildProofTree(value, calculator, merkleHashVersion);
-            return this.calculateMerkleRootInternal(merkleProofTree.root, calculator, merkleHashVersion);
-        }
-        else {
-            // This is a primitive value, just hash it
-            return calculator.calculateLeafHash(value, merkleHashVersion);
-        }
-    }
-    else if (currentElement instanceof ProofNode) {
-        var left = this.calculateMerkleRootInternal(currentElement.left, calculator, merkleHashVersion);
-        var right = this.calculateMerkleRootInternal(currentElement.right, calculator, merkleHashVersion);
-        return calculator.calculateNodeHash(currentElement.prefix, left, right);
-    }
-    else {
-        throw new Error("Should have handled this type? " + typeof currentElement);
-    }
-};
-/**
- * @param {any} value
- * @param {MerkleHashCalculator} calculator
- */
-MerkleHashSummaryFactory$1.prototype.buildProofTree = function (value, calculator, merkleHashVersion) {
-    var root = this.treeFactory.build(value, merkleHashVersion);
-    return this.proofFactory.buildFromBinaryTree(root, calculator);
-};
-var merklehashsummaryfactory = { MerkleHashSummaryFactory: MerkleHashSummaryFactory$1 };
-
-var MerkleHashSummaryFactory = merklehashsummaryfactory.MerkleHashSummaryFactory;
-var BinaryTreeFactory = binarytreefactory.BinaryTreeFactory;
-var MerkleProofTreeFactory = merkleprooftreefactory.MerkleProofTreeFactory;
-var treeFactory = new BinaryTreeFactory();
-var proofFactory = new MerkleProofTreeFactory();
-/**
- * Calculates the merkle root hash of the structure.
- *
- * @param {any} value
- * @param {MerkleHashCalculator} calculator describes the method we use for hashing and serialization
- * @return the merkle root hash (32 bytes) of the data structure.
- */
-function merkleHash(value, calculator, merkleHashVersion) {
-    return merkleHashSummary(value, calculator, merkleHashVersion).merkleHash;
-}
-/**
- *
- * @param {MerkleProofTree} tree
- * @param {MerkleHashCalculator} calculator
- */
-function merkleTreeHash(tree, calculator, merkleHashVersion) {
-    return merkleProofHashSummary(tree, calculator, merkleHashVersion).merkleHash;
-}
-/**
- * Calculates the merkle root hash of the structure
- *
- * @param {any} value
- * @param {MerkleHashCalculator} calculator describes the method we use for hashing and serialization
- * @return the merkle root hash summary
- */
-function merkleHashSummary(value, calculator, merkleHashVersion) {
-    var summaryFactory = new MerkleHashSummaryFactory(treeFactory, proofFactory);
-    return summaryFactory.calculateMerkleRoot(value, calculator, merkleHashVersion);
-}
-/**
- *
- * @param {MerkleProofTree} tree
- * @param {MerkleHashCalculator} calculator
- * @param {number} merkleHashVersion
- */
-function merkleProofHashSummary(tree, calculator, merkleHashVersion) {
-    var summaryFactory = new MerkleHashSummaryFactory(treeFactory, proofFactory);
-    return summaryFactory.calculateMerkleTreeRoot(tree, calculator, merkleHashVersion);
-}
-/**
- *
- * @param {any} value
- * @param {PathSet} pathSet
- * @param {MerkleHashCalculator} calculator
- * @param {number} merkleHashVersion
-*/
-function generateProof(value, pathSet, calculator, merkleHashVersion) {
-    var binaryTree = treeFactory.buildWithPath(value, pathSet, merkleHashVersion);
-    return proofFactory.buildFromBinaryTree(binaryTree, calculator);
-}
-var merkleproof = { merkleHash, merkleTreeHash, merkleHashSummary, generateProof };
-
-const theMerkleHashCalculator = new merklehashcalculator.MerkleHashCalculator(new merklehashcalculator.CryptoSystem());
-const gtvHash = (obj, merkleHashVersion) => {
-    return merkleproof.merkleHashSummary(obj, theMerkleHashCalculator, merkleHashVersion).merkleHash;
-};
-const encode$1 = encodeValue;
-const decode$1 = decodeValue;
-
-var index = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	decode: decode$1,
-	encode: encode$1,
-	gtvHash: gtvHash
+var encryption = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    checkDigestSignature: checkDigestSignature,
+    checkSignature: checkSignature,
+    createPublicKey: createPublicKey,
+    hash256: hash256,
+    hashConcat: hashConcat,
+    makeKeyPair: makeKeyPair,
+    makeTuid: makeTuid,
+    randomBytes: randomBytes,
+    sha256: sha256,
+    sign: sign$1,
+    signDigest: signDigest,
+    verifyKeyPair: verifyKeyPair
 });
 
 const encode = encodeValueGtx;
@@ -1776,17 +570,17 @@ function addSignerToGtx(signer, gtx) {
  * @param gtx the gtx to serialize
  */
 function getDigest(gtx, merkleHashVersion) {
-    return gtvHash(gtxToRawGtxBody(gtx), merkleHashVersion);
+    return gtvHash2(gtxToRawGtxBody(gtx), merkleHashVersion);
 }
 /**
  * Serializes the gtx for signing
  * @param gtx the gtx to serialize
  */
 function getDigestToSign(gtx, merkleHashVersion) {
-    return gtvHash(gtxToRawGtxBody(gtx), merkleHashVersion);
+    return gtvHash2(gtxToRawGtxBody(gtx), merkleHashVersion);
 }
 function getDigestToSignFromRawGtxBody(gtxBody, merkleHashVersion) {
-    return gtvHash(gtxBody, merkleHashVersion);
+    return gtvHash2(gtxBody, merkleHashVersion);
 }
 function gtxToRawGtxBody(gtx) {
     return [
@@ -1962,23 +756,23 @@ function rawGtvToRellOp(gtv) {
 }
 
 var gtx = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	addSignature: addSignature,
-	addSignerToGtx: addSignerToGtx,
-	addTransactionToGtx: addTransactionToGtx,
-	checkExistingGTXSignatures: checkExistingGTXSignatures,
-	checkGTXSignatures: checkGTXSignatures,
-	deserialize: deserialize,
-	emptyGtx: emptyGtx,
-	getDigest: getDigest,
-	getDigestToSign: getDigestToSign,
-	getDigestToSignFromRawGtxBody: getDigestToSignFromRawGtxBody,
-	gtxToRawGtx: gtxToRawGtx,
-	gtxToRawGtxBody: gtxToRawGtxBody,
-	newSignatureProvider: newSignatureProvider,
-	rawGtvToGtx: rawGtvToGtx,
-	serialize: serialize,
-	sign: sign
+    __proto__: null,
+    addSignature: addSignature,
+    addSignerToGtx: addSignerToGtx,
+    addTransactionToGtx: addTransactionToGtx,
+    checkExistingGTXSignatures: checkExistingGTXSignatures,
+    checkGTXSignatures: checkGTXSignatures,
+    deserialize: deserialize,
+    emptyGtx: emptyGtx,
+    getDigest: getDigest,
+    getDigestToSign: getDigestToSign,
+    getDigestToSignFromRawGtxBody: getDigestToSignFromRawGtxBody,
+    gtxToRawGtx: gtxToRawGtx,
+    gtxToRawGtxBody: gtxToRawGtxBody,
+    newSignatureProvider: newSignatureProvider,
+    rawGtvToGtx: rawGtvToGtx,
+    serialize: serialize,
+    sign: sign
 });
 
 var _a$1;
@@ -2084,129 +878,15 @@ function logger(moduleName) {
 }
 
 var logger$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	get LogLevel () { return LogLevel; },
-	debug: debug,
-	error: error,
-	getLogLevel: getLogLevel,
-	info: info,
-	logger: logger,
-	setLogLevel: setLogLevel,
-	warning: warning
-});
-
-var internalNodePrefix = Buffer.alloc(1, 0);
-var leafPrefix = Buffer.alloc(1, 1);
-var nonExistingNodeHash = Buffer.alloc(32);
-function calculateRoot(hashes, depth, leafDepth) {
-    var numTransactions = hashes.length;
-    if (numTransactions === 0) {
-        return 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 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;
-}
-/*
- * 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");
-    }
-    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) ? Buffer.from([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 merkleRoot.equals(currentHash);
-}
-
-var merkleHelper = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	calculateRoot: calculateRoot,
-	merklePath: merklePath,
-	validateMerklePath: validateMerklePath
+    __proto__: null,
+    get LogLevel () { return LogLevel; },
+    debug: debug,
+    error: error,
+    getLogLevel: getLogLevel,
+    info: info,
+    logger: logger,
+    setLogLevel: setLogLevel,
+    warning: warning
 });
 
 class MissingPubKeyError extends CustomError {
@@ -2347,6 +1027,8 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
     return {
         nodes,
         stickedNode: null,
+        useStickyNode: useStickyNode,
+        lastUsedNode: null,
         getAvailableNodes() {
             const shuffledAvailableNodes = shuffleArray(this.nodes.filter((node) => node.isAvailable));
             // set sticky node as the first node, and then shuffle the rest
@@ -2359,6 +1041,9 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
         setStickyNode(node) {
             this.stickedNode = node;
         },
+        setUseStickyNode(useSticky) {
+            this.useStickyNode = useSticky;
+        },
         getNode() {
             const nodes = this.getAvailableNodes();
             if (nodes.length === 0) {
@@ -2366,6 +1051,7 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
             }
             const index = Math.floor(Math.random() * nodes.length);
             const node = nodes[index];
+            this.lastUsedNode = node;
             if (!useStickyNode) {
                 return node;
             }
@@ -2373,6 +1059,7 @@ const createNodeManager = ({ nodeUrls, useStickyNode = false, unavailableDuratio
                 this.setStickyNode(node);
                 return node;
             }
+            this.lastUsedNode = this.stickedNode;
             return this.stickedNode;
         },
         makeAllNodesAvailable() {
@@ -2913,7 +1600,8 @@ function retryRequest({ method, path, config, postObject, validateStatusCode, })
                     return { error, statusCode, rspBody, transactionTimestamp };
                 }
                 if (isServerError) {
-                    nodeManager.makeNodeUnavailable(endpoint.url);
+                    // nodeManager.makeNodeUnavailable(endpoint.url);
+                    info(`server error on ${endpoint.url}`);
                 }
                 info(`${method} request failed on ${endpoint.url}. Attempt: ${attempt + 1} / ${config.attemptsPerEndpoint}`);
                 yield sleep(config.attemptInterval);
@@ -3390,12 +2078,14 @@ function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringStatusPol
         return clusterAnchoringConfirmation;
     });
 }
-function handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, dappStatusPolling, getTransactionStatus) {
+function handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, dappStatusPolling, getTransactionStatus, client) {
+    var _a, _b;
     return __awaiter$5(this, void 0, void 0, function* () {
         const transactionReceipt = {
             status: exports.ResponseStatus.Pending,
             statusCode: null,
             transactionRid: transactionRid,
+            node: (_a = client.config.nodeManager.lastUsedNode) === null || _a === void 0 ? void 0 : _a.url,
         };
         promiEvent.emit(exports.TransactionEvent.DappReceived, transactionReceipt);
         if (doStatusPolling === false || confirmationLevel === exports.ChainConfirmationLevel.None) {
@@ -3404,6 +2094,7 @@ function handleDappConfirmations(transactionRid, doStatusPolling, confirmationLe
         const dappConfirmationStatus = yield awaitDappConfirmation(transactionRid, dappStatusPolling, getTransactionStatus);
         transactionReceipt.statusCode = dappConfirmationStatus.statusCode;
         transactionReceipt.status = dappConfirmationStatus.status;
+        transactionReceipt.node = (_b = client.config.nodeManager.lastUsedNode) === null || _b === void 0 ? void 0 : _b.url;
         promiEvent.emit(exports.TransactionEvent.DappConfirmed, transactionReceipt);
         if (confirmationLevel === exports.ChainConfirmationLevel.Dapp) {
             return transactionReceipt;
@@ -3457,6 +2148,16 @@ function getSystemAnchoringTransaction(dappClientEndpointPool, anchoredTxRid, an
         return systemAnchoringTransactionValidation.data;
     });
 }
+/**
+ * Should be used to configure the `IClient` `ClientConfig` (config) properties
+ * `dappStatusPolling`, `clusterAnchoringStatusPolling` and `systemAnchoringStatusPolling` with
+ * the corresponding status polling configuration `interval` and `status`.
+ * If the values are not provided, they do default to `500` for `interval` and `20` for `count`
+ *
+ * @param statusPolling - An optional partial configuration object, that can set the status polling interval and count properties
+ * @returns - Returns a complete `StatusPolling` configuration object, with default values for any missing properties
+ * of the provided partial configuration
+ */
 function setStatusPolling(statusPolling) {
     var _a, _b;
     return {
@@ -3654,7 +2355,7 @@ function calculateBlockRID(decodedTxProof, merkleHashVersion) {
         throw new Error("Failed to get blockHeader from confirmation proof");
     }
     const decodeSourceBlockRid = decodeValue(sourceBlockHeader);
-    return gtvHash(decodeSourceBlockRid, merkleHashVersion);
+    return gtvHash2(decodeSourceBlockRid, merkleHashVersion);
 }
 // fetch tx from txRID and verifies with secp256k1.ecdsaVerify that txRID and signer creates signatures that are on the blockchain transaction
 function fetchAndVerifyTransaction(sourceClient, txToProveRID, proofHash, txToProveSigners) {
@@ -3662,7 +2363,7 @@ function fetchAndVerifyTransaction(sourceClient, txToProveRID, proofHash, txToPr
     return __awaiter$4(this, void 0, void 0, function* () {
         const rawTx = yield sourceClient.getTransaction(txToProveRID);
         const txGtv = decodeValue(rawTx);
-        const fetchedTxHash = gtvHash(txGtv, sourceClient.config.merkleHashVersion);
+        const fetchedTxHash = gtvHash2(txGtv, sourceClient.config.merkleHashVersion);
         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.
@@ -3726,7 +2427,7 @@ var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _argu
  * 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 {IClient} directoryClient - The client configured to communicate with the management chain.
  * @param {BufferId} 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.
@@ -3735,15 +2436,28 @@ var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _argu
  * @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).
  * @param {number} merkleHashVersion - The version of the merkle hash to use.
+ * @param {string} nodeIdentifierURL - The URL of the node to use.
  * @returns {Promise<IccfProof>} A promise that resolves to an ICCF proof object containing the ICCF proof transaction.
  */
-function createIccfProofTx(client, txToProveRid, txToProveHash, txToProveSigners, sourceBlockchainRid, targetBlockchainRid, iccfTxSigners = [], forceIntraNetworkIccfOperation = false, merkleHashVersion) {
+function createIccfProofTx(directoryClient, txToProveRid, txToProveHash, txToProveSigners, sourceBlockchainRid, targetBlockchainRid, iccfTxSigners = [], forceIntraNetworkIccfOperation = false, merkleHashVersion, nodeIdentifierURL) {
     return __awaiter$3(this, void 0, void 0, function* () {
-        const clientConfiguredToSource = yield createClient({
-            directoryNodeUrlPool: getUrlsFromEndpoints(client.config.endpointPool),
-            blockchainRid: ensureString(sourceBlockchainRid),
-            merkleHashVersion: merkleHashVersion,
-        });
+        let clientConfiguredToSource;
+        if (!nodeIdentifierURL) {
+            clientConfiguredToSource = yield createClient({
+                directoryNodeUrlPool: getUrlsFromEndpoints(directoryClient.config.endpointPool),
+                blockchainRid: ensureString(sourceBlockchainRid),
+                merkleHashVersion: merkleHashVersion,
+                useStickyNode: true,
+            });
+        }
+        else {
+            clientConfiguredToSource = yield createClient({
+                nodeUrlPool: nodeIdentifierURL,
+                blockchainRid: ensureString(sourceBlockchainRid),
+                merkleHashVersion: merkleHashVersion,
+                useStickyNode: true,
+            });
+        }
         const txProof = yield clientConfiguredToSource.getConfirmationProof(txToProveRid);
         if (!txProof || !txProof.hash) {
             throw new ConfirmationProofException(txToProveRid);
@@ -3752,8 +2466,8 @@ function createIccfProofTx(client, txToProveRid, txToProveHash, txToProveSigners
         const { verifiedTx, verifiedTxHash } = !txToProveHash.equals(proofHash)
             ? yield fetchAndVerifyTransaction(clientConfiguredToSource, txToProveRid, proofHash, txToProveSigners)
             : { verifiedTx: null, verifiedTxHash: txToProveHash };
-        const sourceCluster = yield getClusterOfBlockchain(client, ensureBuffer(sourceBlockchainRid));
-        const targetCluster = yield getClusterOfBlockchain(client, ensureBuffer(targetBlockchainRid));
+        const sourceCluster = yield getClusterOfBlockchain(directoryClient, ensureBuffer(sourceBlockchainRid));
+        const targetCluster = yield getClusterOfBlockchain(directoryClient, ensureBuffer(targetBlockchainRid));
         if (!forceIntraNetworkIccfOperation && sourceCluster === targetCluster) {
             // intra-cluster
             const intraClusterProofTx = composeProofTransactionObject(sourceBlockchainRid, verifiedTxHash, txProof, iccfTxSigners, undefined, undefined, false);
@@ -3761,7 +2475,7 @@ function createIccfProofTx(client, txToProveRid, txToProveHash, txToProveSigners
         }
         else {
             // intra-network
-            const systemClientUsingStickyNode = Object.assign(Object.assign({}, client), { config: Object.assign(Object.assign({}, client.config), { failoverStrategy: exports.FailoverStrategy.SingleEndpoint }) });
+            const systemClientUsingStickyNode = Object.assign(Object.assign({}, directoryClient), { config: Object.assign(Object.assign({}, directoryClient.config), { failoverStrategy: exports.FailoverStrategy.SingleEndpoint }) });
             const anchoringClient = yield getAnchoringClient(systemClientUsingStickyNode, sourceBlockchainRid, sourceCluster);
             const clusterAnchoredTx = yield getBlockAnchoringTransaction(clientConfiguredToSource, anchoringClient, undefined, txProof);
             if (!clusterAnchoredTx) {
@@ -4194,7 +2908,7 @@ function createClient(settings) {
             },
             sendTransaction(transaction, doStatusPolling = true, callback, confirmationLevel = exports.ChainConfirmationLevel.Dapp) {
                 const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter$1(this, void 0, void 0, function* () {
-                    var _a;
+                    var _a, _b;
                     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)) {
@@ -4210,6 +2924,7 @@ function createClient(settings) {
                                     status: exports.ResponseStatus.Waiting,
                                     statusCode,
                                     transactionRid: transactionRid,
+                                    node: (_b = config.nodeManager.lastUsedNode) === null || _b === void 0 ? void 0 : _b.url,
                                 });
                             }
                         }
@@ -4225,7 +2940,7 @@ function createClient(settings) {
                             clusterAnchoringStatusPolling: client.config.clusterAnchoringStatusPolling,
                             systemAnchoringStatusPolling: client.config.systemAnchoringStatusPolling,
                         };
-                        let transactionReceipt = yield handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusPollingConfig.dappStatusPolling, () => client.getTransactionStatus(transactionRid, callback));
+                        let transactionReceipt = yield handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusPollingConfig.dappStatusPolling, () => client.getTransactionStatus(transactionRid, callback), client);
                         if (confirmationLevel === exports.ChainConfirmationLevel.None ||
                             confirmationLevel === exports.ChainConfirmationLevel.Dapp) {
                             resolve(transactionReceipt);
@@ -4370,6 +3085,7 @@ function createClient(settings) {
                 });
             },
             getTransactionConfirmationLevel(transactionRid, callback) {
+                var _a;
                 return __awaiter$1(this, void 0, void 0, function* () {
                     try {
                         const client = this;
@@ -4378,6 +3094,7 @@ function createClient(settings) {
                             status: dappConfirmation.status,
                             statusCode: dappConfirmation.statusCode,
                             transactionRid: ensureBuffer(transactionRid),
+                            node: (_a = client.config.nodeManager.lastUsedNode) === null || _a === void 0 ? void 0 : _a.url,
                         };
                         if (dappConfirmation.status === exports.ResponseStatus.Waiting) {
                             return response;
@@ -4456,7 +3173,7 @@ function createClient(settings) {
                     });
                 });
             },
-            getBlocks({ limit, beforeTime, afterTime, beforeHeight, afterHeight, txs, callback, } = {}) {
+            getBlocks({ limit, beforeTime, afterTime, beforeHeight, afterHeight, excludeEmpty, txs, callback, } = {}) {
                 return __awaiter$1(this, void 0, void 0, function* () {
                     const searchValues = {
                         limit,
@@ -4465,6 +3182,7 @@ function createClient(settings) {
                         "after-time": afterTime,
                         "before-height": beforeHeight,
                         "after-height": afterHeight,
+                        "exclude-empty": excludeEmpty,
                     };
                     const searchParams = new URLSearchParams();
                     for (const [key, value] of Object.entries(searchValues)) {
@@ -4879,7 +3597,7 @@ exports.decodeTransactionToGtx = decodeTransactionToGtx;
 exports.dumpGtv = dumpGtv;
 exports.dumpGtx = dumpGtx;
 exports.encodeTransaction = encodeTransaction;
-exports.encryption = encryption$1;
+exports.encryption = encryption;
 exports.formatter = formatter;
 exports.getAnchoringClient = getAnchoringClient;
 exports.getAnchoringClientAndSystemChainRid = getAnchoringClientAndSystemChainRid;
@@ -4907,7 +3625,6 @@ exports.isTransactionInfoResponse = isTransactionInfoResponse;
 exports.isTransactionInfoResponseArray = isTransactionInfoResponseArray;
 exports.isTransactionsCount = isTransactionsCount;
 exports.logger = logger$1;
-exports.merkle = merkleHelper;
 exports.newSignatureProvider = newSignatureProvider;
 exports.requestWithFailoverStrategy = requestWithFailoverStrategy;
 exports.setStatusPolling = setStatusPolling;