postchain-client 1.0.2 → 1.0.3

package/built/cjs/index.js

@@ -0,0 +1,2571 @@
+'use strict';
+
+var bn_js = require('bn.js');
+var crypto = require('crypto');
+var secp256k1$1 = require('secp256k1');
+
+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 crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
+var secp256k1__namespace = /*#__PURE__*/_interopNamespaceDefault(secp256k1$1);
+
+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-next-line @typescript-eslint/no-var-requires
+const asn = require("asn1.js/lib/asn1");
+const ASNDictPair = asn.define("DictPair", function () {
+    this.seq().obj(this.key("name").utf8str(), this.key("value").use(rawGTV));
+});
+const rawGTV = asn.define("GtvValue", function () {
+    this.choice({
+        null: this.explicit(0).null_(),
+        byteArray: this.explicit(1).octstr(),
+        string: this.explicit(2).utf8str(),
+        integer: this.explicit(3).int(),
+        dict: this.explicit(4).seqof(ASNDictPair),
+        array: this.explicit(5).seqof(rawGTV),
+        bigInteger: this.explicit(6).int(),
+    });
+});
+asn.define("Buffer", function () {
+    this.octstr();
+});
+
+class UnexpectedArgumentTypeError extends Error {
+    constructor(typedArg) {
+        super(`Cannot parse typedArg ${JSON.stringify(typedArg)}. Unknown type ${typedArg.type}`);
+    }
+}
+class MissingGtxException extends Error {
+    constructor() {
+        super(`Missing instance of gtx protocol (used for communicating with postchain) to add operation to`);
+    }
+}
+class AlreadySignedTransactionException extends Error {
+    constructor(operation) {
+        super(`Cannot add ${operation} calls to an already signed gtx`);
+    }
+}
+class NumberOfSignersAndSignaturesException extends Error {
+    constructor() {
+        super(`Not matching number of signers and signatures`);
+    }
+}
+class MissingSignerException extends Error {
+    constructor() {
+        super(`No such signer, remember to call addSignerToGtx() before adding a signature`);
+    }
+}
+
+function pgBytes(buffer) {
+    if (!Buffer.isBuffer(buffer)) {
+        throw new PgBytesInputException(buffer);
+    }
+    return "\\x" + buffer.toString("hex");
+}
+/**
+ * Converts hex string to Buffer
+ * @param key: string
+ * @returns {Buffer}
+ */
+function toBuffer(key) {
+    return Buffer.from(key, "hex");
+}
+/**
+ * Converts Buffer to hex string
+ * @param buffer: Buffer
+ * @returns {string}
+ */
+function toString(buffer) {
+    return buffer.toString("hex");
+}
+function toQueryObjectGTV(object) {
+    const objectCopy = Object.assign({}, object);
+    const name = objectCopy.type;
+    delete objectCopy.type;
+    return [name, objectCopy];
+}
+class PgBytesInputException extends Error {
+    constructor(buffer) {
+        super(`util.pgBytes expects a buffer, but got ${typeof buffer}`);
+    }
+}
+function ensureBuffer(value) {
+    if (value instanceof Buffer) {
+        return value;
+    }
+    else {
+        return toBuffer(value);
+    }
+}
+function checkGtvType(value) {
+    try {
+        if (value == null) {
+            return true;
+        }
+        if (Buffer.isBuffer(value)) {
+            return true;
+        }
+        if (typeof value === "string") {
+            return true;
+        }
+        if (typeof value === "number") {
+            if (!Number.isInteger(value)) {
+                throw Error("User error: Only integers are supported");
+            }
+            return true;
+        }
+        if (typeof value === "bigint") {
+            return true;
+        }
+        if (value.constructor === Array) {
+            value.map((item) => checkGtvType(item));
+            return true;
+        }
+        if (typeof value === "object") {
+            Object.keys(value).map(function (key) {
+                checkGtvType(value[key]);
+            });
+            return true;
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to check type: ${error}`);
+    }
+    return false;
+}
+function rawGtxToGtx(rawGtx) {
+    const rawGtxBody = rawGtx[0];
+    const signatures = rawGtx[1];
+    const gtxBody = {
+        blockchainRID: rawGtxBody[0],
+        operations: rawGtxBody[1].map((operation) => ({
+            opName: operation[0],
+            args: operation[1],
+        })),
+        signers: rawGtxBody[2],
+    };
+    return {
+        blockchainRID: gtxBody.blockchainRID,
+        operations: gtxBody.operations,
+        signers: gtxBody.signers,
+        signatures,
+    };
+}
+function checkGtxType(value) {
+    try {
+        rawGtxToGtx(value);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function removeDuplicateSigners(signers) {
+    const signersAsString = [];
+    signers.forEach((item) => {
+        const itemAsString = item.toString("hex");
+        if (!signersAsString.includes(itemAsString)) {
+            signersAsString.push(itemAsString);
+        }
+    });
+    const result = [];
+    signersAsString.forEach((item) => {
+        result.push(Buffer.from(item, "hex"));
+    });
+    return result;
+}
+
+var formatter = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	PgBytesInputException: PgBytesInputException,
+	checkGtvType: checkGtvType,
+	checkGtxType: checkGtxType,
+	ensureBuffer: ensureBuffer,
+	pgBytes: pgBytes,
+	rawGtxToGtx: rawGtxToGtx,
+	removeDuplicateSigners: removeDuplicateSigners,
+	toBuffer: toBuffer,
+	toQueryObjectGTV: toQueryObjectGTV,
+	toString: toString
+});
+
+function encodeValue(rawGtv) {
+    return rawGTV.encode(createTypedArg(rawGtv));
+}
+function encodeValueGtx(rawGtx) {
+    return encodeValue(rawGtx);
+}
+function decodeValue(bytes) {
+    const obj = rawGTV.decode(bytes);
+    return parseValue(obj);
+}
+function decodeValueGtx(bytes) {
+    const decodedValue = decodeValue(bytes);
+    if (!checkGtxType(decodedValue)) {
+        throw new Error(`Unexpected type of value: ${decodedValue}, expected decoded value to be of type RawGtx`);
+    }
+    return decodedValue;
+}
+function parseValue(typedArg) {
+    if (typedArg.type === "null") {
+        return null;
+    }
+    else if (typedArg.type === "byteArray") {
+        return typedArg.value;
+    }
+    else if (typedArg.type === "string") {
+        return typedArg.value;
+    }
+    else if (typedArg.type === "integer") {
+        return Number(typedArg.value);
+    }
+    else if (typedArg.type === "array") {
+        const arrayValue = typedArg.value;
+        return arrayValue.map((item) => parseValue(item));
+    }
+    else if (typedArg.type === "bigInteger") {
+        return BigInt(typedArg.value);
+    }
+    else if (typedArg.type === "dict") {
+        const arrayValue = typedArg.value;
+        const result = {};
+        arrayValue.forEach((pair) => {
+            result[pair.name] = parseValue(pair.value);
+        });
+        return result;
+    }
+    else {
+        throw new UnexpectedArgumentTypeError(typedArg);
+    }
+}
+function createTypedArg(value) {
+    try {
+        if (value == null) {
+            return { type: "null", value: null };
+        }
+        if (Buffer.isBuffer(value)) {
+            return { type: "byteArray", value: value };
+        }
+        if (typeof value === "boolean") {
+            return { type: "integer", value: value ? 1 : 0 };
+        }
+        if (typeof value === "string") {
+            return { type: "string", value: value };
+        }
+        if (typeof value === "number") {
+            if (!Number.isInteger(value)) {
+                throw Error("User error: Only integers are supported");
+            }
+            return { type: "integer", value: new bn_js.BN(value) };
+        }
+        if (typeof value === "bigint") {
+            return { type: "bigInteger", value: new bn_js.BN(Number(value)) };
+        }
+        if (value.constructor === Array) {
+            return {
+                type: "array",
+                value: value.map((item) => createTypedArg(item)),
+            };
+        }
+        if (typeof value === "object") {
+            const valueAsDictPair = value;
+            return { type: "dict", value: Object.keys(valueAsDictPair).map(function (key) {
+                    return { name: key, value: createTypedArg(valueAsDictPair[key]) };
+                }) };
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to encode ${value.toString()}: ${error}`);
+    }
+    throw new Error(`value ${value} have unsupported type: ${typeof value}`);
+}
+
+var serialization$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	createTypedArg: createTypedArg,
+	decodeValue: decodeValue,
+	decodeValueGtx: decodeValueGtx,
+	encodeValue: encodeValue,
+	encodeValueGtx: encodeValueGtx,
+	parseValue: parseValue
+});
+
+var require$$0$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);
+};
+var path = { Path, PathElement, PathLeafElement: PathLeafElement$3, ArrayPathElement, SearchablePathElement, DictPathElement, PathSet: PathSet$1,
+    getTailIfFirstElementIsArrayOfThisIndex, buildPathFromArray };
+
+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 };
+
+class PrivKeyFormatException extends Error {
+    constructor(privKey) {
+        super(`Invalid key length. Expected 32, but got ${privKey.length}`);
+    }
+}
+class MissingPrivKeyArgumentException extends Error {
+    constructor() {
+        super(`Missing argument privKey`);
+    }
+}
+
+function createPublicKey(privKey) {
+    validatePrivKeyFormat(privKey);
+    return Buffer.from(secp256k1__namespace.publicKeyCreate(privKey, true).buffer);
+}
+function randomBytes(size) {
+    return crypto__namespace.randomBytes(size);
+}
+function sha256(buffer) {
+    return crypto__namespace.createHash("sha256").update(buffer).digest();
+}
+const hash256 = sha256;
+function hashConcat(items) {
+    return hash256(Buffer.concat(items));
+}
+/**
+ * @param content the content that the signature signs. It will be digested before validating.
+ * @param pubKey The pubKey to validate the signature with
+ * @param signature the signature to validate
+ *
+ * @return true if signature ok, false otherwise
+ */
+function checkSignature(content, pubKey, signature) {
+    const digest = hash256(content);
+    return checkDigestSignature(digest, pubKey, signature);
+}
+/**
+ * @param digest the signed digest. It will not be digested before validating.
+ * @param pubKey The pubKey to validate the signature with
+ * @param signature the signature to validate
+ *
+ * @return true if signature ok, false otherwise
+ */
+function checkDigestSignature(digest, pubKey, signature) {
+    return secp256k1__namespace.ecdsaVerify(signature, digest, pubKey);
+}
+/**
+ * @param content to sign. It will be digested before signing.
+ * @param privKey The private key to sign the content with
+ *
+ * @return the signature
+ */
+function sign$1(content, privKey) {
+    validatePrivKeyFormat(privKey);
+    const digestBuffer = sha256(content);
+    return signDigest(digestBuffer, privKey);
+}
+/**
+ * @param digestBuffer to sign. It will not be digested before signing.
+ * @param privKey The private key to sign the digest with
+ *
+ * @return the signature
+ */
+function signDigest(digestBuffer, privKey) {
+    return Buffer.from(secp256k1__namespace.ecdsaSign(digestBuffer, privKey).signature);
+}
+/**
+ * Creates a key pair (which usually represents one user)
+ * @param privKey to create key pair based on
+ * @returns {{pubKey: Buffer, privKey: Buffer}}
+ */
+function makeKeyPair(privKey) {
+    let pubKey;
+    if (privKey) {
+        privKey = ensureBuffer(privKey);
+        pubKey = createPublicKey(privKey);
+    }
+    else {
+        do {
+            privKey = randomBytes(32);
+        } while (!secp256k1__namespace.privateKeyVerify(privKey));
+        pubKey = Buffer.from(secp256k1__namespace.publicKeyCreate(privKey).buffer);
+    }
+    return { pubKey, privKey };
+}
+/**
+ * Generates a 16bytes TUID (Text unique ID) (a 32characters long string)
+ * @returns string
+ */
+function makeTuid() {
+    return randomBytes(16).toString("hex");
+}
+/**
+ * Verify that keypair is correct. Providing the private key, this function returns its associated public key
+ * @param privKey: Buffer
+ * @returns {{pubKey: Buffer, privKey: Buffer}}
+ */
+function verifyKeyPair(privKey) {
+    validatePrivKeyFormat(privKey);
+    const pubKey = Buffer.from(secp256k1__namespace.publicKeyCreate(privKey).buffer);
+    return { pubKey, privKey };
+}
+function validatePrivKeyFormat(privKey) {
+    if (!privKey) {
+        throw new MissingPrivKeyArgumentException();
+    }
+    if (!Buffer.isBuffer(privKey) || privKey.length !== 32) {
+        throw new PrivKeyFormatException(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$$2 = /*@__PURE__*/getAugmentedNamespace(encryption$1);
+
+var serialization = require$$0$1;
+var HASH_PREFIX_LEAF = binarytree.HASH_PREFIX_LEAF;
+var encryption = require$$2;
+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) {
+    return this.calculateHashOfValueInternal(value, serialization.encodeValue, hashingFun);
+};
+/**
+ * @param {number} prefix
+ * @param {Buffer} hashLeft
+ * @param {Buffer} hashRight
+ */
+MerkleHashCalculator.prototype.calculateNodeHashInternal = function (prefix, hashLeft, hashRight, hashFunc) {
+    var buf = Buffer.alloc(1);
+    buf.writeInt8(prefix);
+    var bufferSum = Buffer.concat([buf, hashLeft, hashRight]);
+    return hashFunc(bufferSum, this.cryptoSystem);
+};
+MerkleHashCalculator.prototype.calculateHashOfValueInternal = function (valuetoHash, serializeFun, hashFunc) {
+    var buf = Buffer.alloc(1);
+    buf.writeInt8(HASH_PREFIX_LEAF);
+    var bufferSum = Buffer.concat([buf, serializeFun(valuetoHash)]);
+    return hashFunc(bufferSum, this.cryptoSystem);
+};
+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;
+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) {
+    if (paths.length == 0 && !isRoot) {
+        return this.innerHandleLeaf(leaf, this.getEmptyPathSet());
+    }
+    else {
+        return this.innerHandleLeaf(leaf, paths);
+    }
+};
+/**
+ *
+ */
+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) {
+    if (leaf == null) {
+        return this.handlePrimitiveLeaf(leaf, paths);
+    }
+    if (Buffer.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 === 'boolean') {
+        return this.handlePrimitiveLeaf(leaf ? 1 : 0, paths);
+    }
+    if (leaf.constructor === Array) {
+        return this.buildFromArray(leaf, paths);
+    }
+    if (typeof leaf === 'object') {
+        return this.buildFromDictionary(leaf, paths);
+    }
+    else {
+        throw new Error("Unsupporting 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) {
+    return this.buildWithPath(data, NO_PATHS);
+};
+/**
+ * @param {PathSet} paths
+ */
+BinaryTreeFactory$1.prototype.buildWithPath = function (data, paths) {
+    var result = this.handleLeaf(data, paths, true);
+    return new BinaryTree(result);
+};
+/**
+ * @param {Array} array
+ * @param {PathSet} paths
+ */
+BinaryTreeFactory$1.prototype.buildFromArray = function (array, paths) {
+    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);
+    // 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) {
+    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);
+        leafArray.push(binaryTreeElement);
+    }
+    return leafArray;
+};
+/**
+ * @param {PathSet} paths
+ */
+BinaryTreeFactory$1.prototype.buildFromDictionary = function (dict, paths) {
+    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);
+    // 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) {
+    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);
+        leafArray.push(keyElement);
+        var content = dict[key];
+        var pathsRelevantForThisLeaf = onlyDictPaths.getTailIfFirstElementIsDictOfThisKeyFromList(key);
+        var contentElement = this.handleLeaf(content, pathsRelevantForThisLeaf);
+        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 };
+
+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.alloc(32);
+/**
+ *
+ */
+function MerkleProofTreeFactory$1() { }
+/**
+ * @param {BinaryTree} orginalTree
+ */
+MerkleProofTreeFactory$1.prototype.buildFromBinaryTree = function (orginalTree, calculator) {
+    var rootElem = this.buildFromBinaryTreeInternal(orginalTree.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) {
+    var binaryTree = this.treeFactory.build(value);
+    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) {
+    return this.calculateMerkleRootOfTree(tree, calculator);
+};
+/**
+ * @param {MerkleProofTree} proofTree
+ * @param {MerkleHashCalculator} calculator
+ */
+MerkleHashSummaryFactory$1.prototype.calculateMerkleRootOfTree = function (proofTree, calculator) {
+    var calculatedSummary = this.calculateMerkleRootInternal(proofTree.root, calculator);
+    return new MerkleHashSummary(calculatedSummary);
+};
+/**
+ * @param {MerkleProofElement} currentElement
+ * @param {MerkleHashCalculator} calculator
+ */
+MerkleHashSummaryFactory$1.prototype.calculateMerkleRootInternal = function (currentElement, calculator) {
+    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);
+            return this.calculateMerkleRootInternal(merkleProofTree.root, calculator);
+        }
+        else {
+            // This is a primitive value, just hash it
+            return calculator.calculateLeafHash(value);
+        }
+    }
+    else if (currentElement instanceof ProofNode) {
+        var left = this.calculateMerkleRootInternal(currentElement.left, calculator);
+        var right = this.calculateMerkleRootInternal(currentElement.right, calculator);
+        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) {
+    var root = this.treeFactory.build(value);
+    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) {
+    return merkleHashSummary(value, calculator).merkleHash;
+}
+/**
+ *
+ * @param {MerkleProofTree} tree
+ * @param {MerkleHashCalculator} calculator
+ */
+function merkleTreeHash(tree, calculator) {
+    return merkleProofHashSummary(tree, calculator).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) {
+    var summaryFactory = new MerkleHashSummaryFactory(treeFactory, proofFactory);
+    return summaryFactory.calculateMerkleRoot(value, calculator);
+}
+/**
+ *
+ * @param {MerkleProofTree} tree
+ * @param {MerkleHashCalculator} calculator
+ */
+function merkleProofHashSummary(tree, calculator) {
+    var summaryFactory = new MerkleHashSummaryFactory(treeFactory, proofFactory);
+    return summaryFactory.calculateMerkleTreeRoot(tree, calculator);
+}
+/**
+ *
+ * @param {any} value
+ * @param {PathSet} pathSet
+ * @param {MerkleHashCalculator} calculator
+ */
+function generateProof(value, pathSet, calculator) {
+    var binaryTree = treeFactory.buildWithPath(value, pathSet);
+    return proofFactory.buildFromBinaryTree(binaryTree, calculator);
+}
+var merkleproof = { merkleHash, merkleTreeHash, merkleHashSummary, generateProof };
+
+const theMerkleHashCalculator = new merklehashcalculator.MerkleHashCalculator(new merklehashcalculator.CryptoSystem());
+const gtvHash = (obj) => {
+    return merkleproof.merkleHashSummary(obj, theMerkleHashCalculator).merkleHash;
+};
+const encode$1 = encodeValue;
+const decode$1 = decodeValue;
+
+var index = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	decode: decode$1,
+	encode: encode$1,
+	gtvHash: gtvHash
+});
+
+const encode = encodeValueGtx;
+const decode = decodeValueGtx;
+
+function emptyGtx(blockchainRID) {
+    return { blockchainRID: blockchainRID, operations: [], signers: [] };
+}
+/**
+ * Adds a function call to a GTX. Creates a new GTX if none specified.
+ * This function will throw Error if gtx is already signed
+ * @param opName the name of the function to call
+ * @param args the array of arguments of the function call. If no args, this must be an empty array
+ * @param gtx the function call will be added to this gtx
+ * @returns the gtx
+ * @throws if gtx is null or if gtx is already signed
+ */
+function addTransactionToGtx(opName, args, gtx) {
+    if (gtx == null) {
+        throw new MissingGtxException();
+    }
+    if (gtx.signatures) {
+        throw new AlreadySignedTransactionException("function");
+    }
+    gtx.operations.push({ opName: opName, args: args });
+    return gtx;
+}
+function addSignerToGtx(signer, gtx) {
+    if (gtx.signatures) {
+        throw new AlreadySignedTransactionException("signer");
+    }
+    gtx.signers.push(signer);
+}
+/**
+ * Serializes the gtx for signing
+ * @param gtx the gtx to serialize
+ */
+function getDigestToSign(gtx) {
+    return gtvHash(gtvTxBody(gtx));
+}
+function gtvTxBody(gtx) {
+    return [
+        gtx.blockchainRID,
+        gtx.operations.map((op) => [op.opName, op.args]),
+        gtx.signers,
+    ];
+}
+/**
+ * Signs the gtx with the provided privKey. This is a convenience function
+ * for situations where you don't have to ask someone else to sign.
+ */
+function sign(privKey, pubKey, gtx) {
+    const digestToSign = getDigestToSign(gtx);
+    const signature = signDigest(digestToSign, privKey);
+    addSignature(pubKey, signature, gtx);
+}
+function signRawTransaction(_keyPair, _rawTransaction) {
+    throw Error("TODO");
+    //TODO
+    //const gtx = module.exports.deserialize(rawTransaction);
+    //module.exports.sign(keyPair.privKey, keyPair.pubKey, gtx);
+    // return module.exports.serialize(gtx)
+}
+/**
+ * Adds a signature to the gtx
+ */
+function addSignature(pubKeyBuffer, signatureBuffer, gtx) {
+    if (!gtx.signatures) {
+        gtx.signatures = Array(gtx.signers.length).fill(Buffer.alloc(64));
+    }
+    if (gtx.signers.length !== gtx.signatures.length) {
+        throw new NumberOfSignersAndSignaturesException();
+    }
+    const signerIndex = gtx.signers.findIndex((signer) => pubKeyBuffer.equals(signer));
+    if (signerIndex === -1) {
+        throw new MissingSignerException();
+    }
+    gtx.signatures[signerIndex] = signatureBuffer;
+}
+function serialize(gtx) {
+    if (!gtx.signatures) {
+        // TODO
+        // The gtx is not signed, but we must include
+        // the signatures attribute, so let's add that.
+        gtx.signatures = [];
+    }
+    return encode([gtvTxBody(gtx), gtx.signatures]);
+}
+function deserialize(gtxBytes) {
+    const deserializedTx = decode(gtxBytes);
+    const body = deserializedTx[0];
+    const gtvTxBody = {
+        blockchainRID: body[0],
+        operations: body[1].map((operation) => ({
+            opName: operation[0],
+            args: operation[1],
+        })),
+        signers: body[2],
+    };
+    const signatures = deserializedTx[1];
+    return {
+        blockchainRID: gtvTxBody.blockchainRID,
+        operations: gtvTxBody.operations,
+        signers: gtvTxBody.signers,
+        signatures,
+    };
+}
+function checkGTXSignatures(txHash, gtx) {
+    for (const i in gtx.signers) {
+        const signValid = checkDigestSignature(txHash, gtx.signers[i], gtx.signatures[i]);
+        if (!signValid)
+            return signValid;
+    }
+    return true;
+}
+
+var gtx = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	addSignature: addSignature,
+	addSignerToGtx: addSignerToGtx,
+	addTransactionToGtx: addTransactionToGtx,
+	checkGTXSignatures: checkGTXSignatures,
+	deserialize: deserialize,
+	emptyGtx: emptyGtx,
+	getDigestToSign: getDigestToSign,
+	gtvTxBody: gtvTxBody,
+	serialize: serialize,
+	sign: sign,
+	signRawTransaction: signRawTransaction
+});
+
+var MsgType;
+(function (MsgType) {
+    MsgType["debug"] = "DEBUG";
+    MsgType["info"] = "INFO";
+    MsgType["error"] = "ERROR";
+    MsgType["warning"] = "WARNING";
+})(MsgType || (MsgType = {}));
+var LogColor;
+(function (LogColor) {
+    LogColor["red"] = "\u001B[91m";
+    LogColor["green"] = "\u001B[92m";
+    LogColor["blue"] = "\u001B[36m";
+    LogColor["yellow"] = "\u001B[93m";
+    LogColor["stopColor"] = "\u001B[0m";
+})(LogColor || (LogColor = {}));
+let logLevel = 1;
+function setLogLevel(level) {
+    logLevel = level;
+}
+function getLogLevel() {
+    return logLevel;
+}
+function debug(message) {
+    if (logLevel >= 3) {
+        emitLogMessage(MsgType.debug, message, LogColor.blue);
+    }
+}
+function info(message) {
+    if (logLevel >= 2) {
+        emitLogMessage(MsgType.info, message, LogColor.green);
+    }
+}
+function error(message) {
+    if (logLevel != -1) {
+        emitLogMessage(MsgType.error, message, LogColor.red);
+    }
+}
+function warning(message) {
+    if (logLevel >= 1) {
+        emitLogMessage(MsgType.warning, message, LogColor.yellow);
+    }
+}
+function emitLogMessage(msgType, message, color) {
+    const time = getTimestamp();
+    console.log(`[${time}] ${color}${msgType}:${LogColor.stopColor} ${message}`);
+}
+function getTimestamp() {
+    const pad = (n, s = 2) => `${new Array(s).fill(0)}${n}`.slice(-s);
+    const date = new Date();
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}:${pad(date.getMilliseconds(), 3)}`;
+}
+
+var logger = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	debug: debug,
+	error: error,
+	getLogLevel: getLogLevel,
+	info: info,
+	setLogLevel: setLogLevel,
+	warning: warning
+});
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const secp256k1 = require("secp256k1");
+function createClient(restApiClient, blockchainRID, functionNames) {
+    functionNames.push("message");
+    function transaction(gtx$1) {
+        return {
+            gtx: gtx$1,
+            sign: function (privKey, pubKey) {
+                let pub = pubKey;
+                if (!pub) {
+                    debug(`pubKey not provided, will instead be generated using secp256k1`);
+                    pub = Buffer.from(secp256k1.publicKeyCreate(privKey));
+                }
+                debug(`signing transaction with privKey: ${privKey}, pubKey: ${pub}`);
+                sign(privKey, pub, this.gtx);
+            },
+            getTxRID: function () {
+                return this.getDigestToSign();
+            },
+            getDigestToSign: function () {
+                return getDigestToSign(this.gtx);
+            },
+            addSignature: function (pubKey, signature) {
+                addSignature(pubKey, signature, this.gtx);
+            },
+            // raw call
+            addOperation: function (name, ...args) {
+                addTransactionToGtx(name, args, this.gtx);
+            },
+            postAndWaitConfirmation() {
+                return restApiClient.postAndWaitConfirmation(serialize(this.gtx), this.getTxRID());
+            },
+            send: function (callback) {
+                const gtxBytes = serialize(this.gtx);
+                restApiClient.postTransaction(gtxBytes, callback);
+                this.gtx = null;
+                this.gtxBytes = gtxBytes;
+            },
+            encode: function () {
+                return serialize(this.gtx);
+            },
+        };
+    }
+    function addFunctions(req) {
+        functionNames.forEach((functionName) => {
+            req[functionName] = function (...args) {
+                addTransactionToGtx(functionName, args, this.gtx);
+            };
+        });
+    }
+    const client = {
+        newTransaction: function (signers) {
+            signers = removeDuplicateSigners(signers);
+            const newGtx = emptyGtx(Buffer.from(blockchainRID, "hex"));
+            signers.forEach((signer) => addSignerToGtx(signer, newGtx));
+            const req = transaction(newGtx);
+            addFunctions(req);
+            return req;
+        },
+        transactionFromRawTransaction: function (rawTransaction) {
+            const gtx$1 = deserialize(rawTransaction);
+            debug(`Output from deserializing a raw transaction: ${JSON.stringify(gtx$1)}`);
+            const req = transaction(gtx$1);
+            addFunctions(req);
+            return req;
+        },
+        query: function (queryObject, callback) {
+            return restApiClient.query(queryObject, callback);
+        },
+    };
+    return client;
+}
+
+var gtxclient = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	createClient: createClient
+});
+
+var ResponseStatus;
+(function (ResponseStatus) {
+    ResponseStatus["Confirmed"] = "confirmed";
+    ResponseStatus["Rejected"] = "rejected";
+    ResponseStatus["Unknown"] = "unknown";
+    ResponseStatus["Waiting"] = "waiting";
+})(ResponseStatus || (ResponseStatus = {}));
+var Method;
+(function (Method) {
+    Method["GET"] = "get";
+    Method["POST"] = "post";
+})(Method || (Method = {}));
+
+class TxRejectedError extends Error {
+    constructor(rejectReason) {
+        super("Transaction was rejected");
+        this.name = "TxRejectedError";
+        this.fullReason = rejectReason;
+        const parsed = rejectReason.match(/^\[(.+)\] Operation '(.+)' failed: (.+)$/);
+        if (parsed) {
+            this.shortReason = parsed[3];
+            this.rellLine = parsed[1];
+            this.operation = parsed[2];
+        }
+    }
+}
+class UnexpectedStatusError extends Error {
+    constructor(status) {
+        super(`Unexpected status code from server: ${status}`);
+    }
+}
+class LostMessageError extends Error {
+    constructor() {
+        super(`Server lost our message`);
+    }
+}
+class UnexpectedResponseError extends Error {
+    constructor() {
+        super(`got unexpected response from server`);
+    }
+}
+class UnvalidTxRidException extends Error {
+    constructor(txRID) {
+        super(`expected length 32 of txRID, but got ${txRID.length}`);
+    }
+}
+class SerializedTransactionFormatException extends Error {
+    constructor() {
+        super(`messageHash is not a Buffer`);
+    }
+}
+class GetBridFromChainException extends Error {
+    constructor(chainId, reason) {
+        super(`Error resolving BRID for chainId ${chainId}, reason: ${reason}`);
+    }
+}
+class EmptyListOfUrlsException extends Error {
+    constructor() {
+        super(`Failed to initialize rest client with empty list of urls`);
+    }
+}
+
+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 getBrid(urlBase, chainId) {
+    if (chainId >= 0) {
+        const url = `${urlBase}/brid/iid_${chainId}`;
+        return fetch(url).then((response) => {
+            if (response.ok)
+                return response.text();
+            throw new GetBridFromChainException(chainId, response.statusText);
+        });
+    }
+    else {
+        const url = `${urlBase}/_debug`;
+        return fetch(url).then((response) => {
+            if (response.ok)
+                return response
+                    .json()
+                    .then((json) => json.blockchain[json.blockchain.length - 1].brid);
+            throw new GetBridFromChainException(chainId, response.statusText);
+        });
+    }
+}
+function requestWithRetry(method, path, config, postObject) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let statusCode, rspBody, error;
+        const noRetryStatusCodes = [200, 400, 409, 500];
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const _endpoint of config.endpointPool) {
+            const endpoint = nextEndpoint(config.endpointPool);
+            for (let attempt = 0; attempt < config.attemptsPerEndpoint; attempt++) {
+                ({ error, statusCode, rspBody } = yield handleRequest(method, path, endpoint, postObject));
+                if (noRetryStatusCodes.includes(statusCode)) {
+                    return { error, statusCode, rspBody };
+                }
+                if (statusCode == 503) {
+                    break;
+                }
+                info(`${method} request failed on ${endpoint}. Attempt: ${attempt + 1} / ${config.attemptsPerEndpoint}`);
+                yield sleep(config.attemptInterval);
+            }
+        }
+        return { error, statusCode, rspBody };
+    });
+}
+function handleRequest(method, path, endpoint, postObject) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        if (method == Method.GET) {
+            return yield get(path, endpoint);
+        }
+        else {
+            return yield post(path, endpoint, postObject);
+        }
+    });
+}
+/**
+ * Sends request to get data from a given API endpoint.
+ * @param path API endpoint of Rell backend
+ * @param endpoint
+ */
+function get(path, endpoint) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        debug("GET URL " + new URL(path, endpoint).href);
+        try {
+            const response = yield fetch(new URL(path, endpoint).href);
+            if (response.status == 404) {
+                return { error: null, statusCode: response.status, rspBody: null };
+            }
+            const rspBody = yield response.json();
+            return { error: null, statusCode: response.status, rspBody };
+        }
+        catch (error$1) {
+            error(error$1.message);
+            return { error: error$1, statusCode: null, rspBody: null };
+        }
+    });
+}
+/**
+ * Sends request to post data to a given API endpoint.
+ * @param path API endpoint of Rell backend
+ * @param endpoint
+ * @param requestBody request body
+ */
+function post(path, endpoint, requestBody) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        debug("POST URL " + new URL(path, endpoint).href);
+        debug("POST body " + JSON.stringify(requestBody));
+        if (Buffer.isBuffer(requestBody)) {
+            try {
+                const requestOptions = {
+                    method: "post",
+                    body: requestBody,
+                };
+                const response = yield fetch(new URL(path, endpoint).href, requestOptions);
+                return {
+                    error: null,
+                    statusCode: response.status,
+                    rspBody: decodeValue(Buffer.from(yield response.arrayBuffer())),
+                };
+            }
+            catch (error) {
+                return { error, statusCode: null, rspBody: null };
+            }
+        }
+        else {
+            try {
+                const response = yield fetch(new URL(path, endpoint).href, {
+                    method: "post",
+                    body: JSON.stringify(requestBody),
+                });
+                return {
+                    error: null,
+                    statusCode: response.status,
+                    rspBody: yield response.json(),
+                };
+            }
+            catch (error) {
+                return { error, statusCode: null, rspBody: null };
+            }
+        }
+    });
+}
+function nextEndpoint(endpointPool) {
+    return endpointPool[Math.floor(Math.random() * endpointPool.length)];
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+var restclientutil = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	getBrid: getBrid,
+	handleRequest: handleRequest,
+	nextEndpoint: nextEndpoint,
+	requestWithRetry: requestWithRetry,
+	sleep: sleep
+});
+
+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 createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingInterval = 500, failOverConfig) {
+    validateInput(endpointPool, failOverConfig);
+    return {
+        config: {
+            endpointPool: endpointPool,
+            pool: { maxSockets },
+            pollingInterval,
+            attemptsPerEndpoint: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptsPerEndpoint) || 3,
+            attemptInterval: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptInterval) || 500,
+        },
+        /**
+         * Retrieves the client message with the specified double-sha256 hash
+         * @param txRID the id of the transaction
+         * @param callback parameters (error, serializedMessage) if first
+         * parameter is not null, an error occurred.
+         * If first parameter is null, then the second parameter is a buffer
+         * with the serialized client message. If no such client message exists,
+         * the callback will be called with (null, null).
+         */
+        getTransaction: function (txRID, callback) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                if (!validTxRID(txRID)) {
+                    callback(new UnvalidTxRidException(txRID), null);
+                }
+                else {
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, "tx/" + blockchainRID + "/" + txRID.toString("hex"), this.config);
+                    handleGetResponse(error, statusCode, statusCode === 200 ? toBuffer(rspBody.tx) : rspBody, callback);
+                }
+            });
+        },
+        /**
+         * Sends a transaction to postchain for inclusion in a block.
+         * Use status() to monitor progress once this transaction is
+         * posted.
+         *
+         * @param serializedTransaction The transaction (a buffer) to send
+         * @param callback taking parameter (error, responseObject) if error is null
+         * then resonseObject is also null. If error is not null, then responseObject
+         * is an object with the string property 'error'
+         */
+        postTransaction: function (serializedTransaction, callback) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                if (!Buffer.isBuffer(serializedTransaction)) {
+                    throw new SerializedTransactionFormatException();
+                }
+                const transactionObject = {
+                    tx: serializedTransaction.toString("hex"),
+                };
+                const { error, statusCode, rspBody } = yield requestWithRetry(Method.POST, "tx/" + blockchainRID, this.config, transactionObject);
+                handlePostResponse(error, statusCode, rspBody, callback);
+            });
+        },
+        /**
+         * Retrieves a confirmation proof for a client message with the specified double-sha256
+         * hash.
+         * @param txRID the id of the transaction
+         * @param callback parameters (error, responseObjectProof) if first
+         * parameter is not null, an error occurred.
+         * If first parameter is null, then the second parameter is an object
+         * like the following:
+         *
+         * {hash: messageHashBuffer,
+         *  blockHeader: blockHeaderBuffer,
+         *  signatures: [{pubKey: pubKeyBuffer, signature: sigBuffer}, ...],
+         *  merklePath: [{side: <0|1>, hash: <hash buffer level n-1>},
+         *               ...
+         *               {side: <0|1>, hash: <hash buffer level 1>}]}
+         *
+         * If no such client message exists, the callback will be called with (null, null).
+         *
+         * The proof object can be validated using
+         * postchain-common.util.validateMerklePath(proof.merklePath, proof.hash,
+         * proof.blockHeader.slice(32, 64))
+         *
+         * The signatures must be validated agains some know trusted source for valid signers
+         * at this specific block height.
+         */
+        getConfirmationProof: function (txRID, callback) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                if (!validTxRID(txRID)) {
+                    callback(new UnvalidTxRidException(txRID), null);
+                }
+                else {
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, "tx/" +
+                        blockchainRID +
+                        "/" +
+                        txRID.toString("hex") +
+                        "/confirmationProof", this.config);
+                    const confirmationProof = {
+                        hash: undefined,
+                        blockHeader: undefined,
+                        signatures: [],
+                        merklePath: [],
+                    };
+                    if (statusCode === 200 || statusCode === 503) {
+                        confirmationProof.hash = toBuffer(rspBody.hash);
+                        confirmationProof.blockHeader = toBuffer(rspBody.blockHeader);
+                        if (rspBody.signatures) {
+                            confirmationProof.signatures = rspBody.signatures.map((item) => ({
+                                pubKey: toBuffer(item.pubKey),
+                                signature: toBuffer(item.signature),
+                            }));
+                        }
+                        if (rspBody.merklePath) {
+                            confirmationProof.merklePath = rspBody.merklePath.map((item) => {
+                                return { side: item.side, hash: toBuffer(item.hash) };
+                            });
+                        }
+                    }
+                    handleGetResponse(error, statusCode, confirmationProof, callback);
+                }
+            });
+        },
+        /**
+         * Queries the status of a certain transaction.
+         * @param txRID the id of the transaction
+         * @param callback taking parameters (error, responseBody). If error is null
+         * then responseBody is an object on the form
+         * { status: '<confirmed|waiting|rejected|unknown>' }
+         * If error is not null, then responseBody
+         * is an object with the string property 'error'
+         */
+        status: function (txRID, callback) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                if (!validTxRID(txRID)) {
+                    callback(new UnvalidTxRidException(txRID), null);
+                }
+                else {
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, "tx/" + blockchainRID + "/" + txRID.toString("hex") + "/status", this.config);
+                    handleGetResponse(error, statusCode, rspBody, callback);
+                }
+            });
+        },
+        /**
+         * Interfaces the query enpoint of the Rell backend. Returns either a resolved or rejected promise.
+         * @param queryObject an object that must contain a "type" and follows this pattern: { type: "nameOfQuery", arg1: argValue1, arg2: argvalue2 }
+         */
+        query: function (queryObject) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                // eslint-disable-next-line no-async-promise-executor
+                return new Promise((resolve, reject) => __awaiter$1(this, void 0, void 0, function* () {
+                    const callback = (error, result) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    };
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.POST, `query_gtv/${blockchainRID}`, this.config, encodeValue(toQueryObjectGTV(queryObject)));
+                    handlePostResponse(error, statusCode, rspBody, callback);
+                }));
+            });
+        },
+        /**
+         * Polls for status while waiting for response; confirmed, rejected or unknown. Returns either a resolved or rejected promise.
+         * @param txRID the id of the transaction
+         */
+        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());
+                        }
+                    }
+                });
+            });
+        },
+        /**
+         * Posts a transaction and polls for status while waiting for status response; confirmed, rejected or unknown. Returns either a resolved or rejected promise.
+         * @param serializedTransaction The transaction (a buffer) to send
+         * @param txRID the id of the transaction
+         * @param validate true if the transaction needs to be validated
+         */
+        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, reject), 1011);
+                    }
+                });
+            });
+        },
+        /**
+         * Returns a string array with the endpoints hosting the dApp the client
+         * is connected to
+         */
+        getEndpointPool() {
+            return this.config.endpointPool;
+        },
+    };
+}
+/**
+ * Validates that txRID is a Buffer of 32 bytes.
+ * @param txRID A buffer of 32 bytes
+ */
+function validTxRID(txRID) {
+    if (txRID.length != 32) {
+        const error$1 = new UnvalidTxRidException(txRID);
+        error(error$1.toString());
+        return false;
+    }
+    return true;
+}
+function validateInput(endpointPool, failOverConfig) {
+    if (!endpointPool.length) {
+        throw new EmptyListOfUrlsException();
+    }
+    if ((failOverConfig === null || failOverConfig === void 0 ? void 0 : 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 {
+        debug(`error: ${error$1}, status code: ${statusCode}, response body: ${JSON.stringify(responseObject)}`);
+        if (error$1) {
+            callback(error$1, null);
+        }
+        else if (statusCode === 404) {
+            error("404 received");
+            callback(null, null);
+        }
+        else if (statusCode != 200) {
+            callback(new UnexpectedStatusError(statusCode), responseObject);
+        }
+        else {
+            callback(null, responseObject);
+        }
+    }
+    catch (error$1) {
+        error("restclient.handleGetResponse(): Failed to call callback function " +
+            error$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 handlePostResponse(error$1, statusCode, responseObject, callback) {
+    debug(`error: ${error$1}, status code: ${statusCode}, response body: ${JSON.stringify(responseObject)}`);
+    try {
+        if (error$1) {
+            error(`In restclient post(). ${error$1}`);
+            callback(error$1);
+        }
+        else if (statusCode != 200) {
+            error(`Unexpected status code from server: ${statusCode}`);
+            callback(new UnexpectedStatusError(statusCode), responseObject);
+        }
+        else {
+            info(`Calling responseCallback with responseObject: ${JSON.stringify(responseObject)}`);
+            callback(null, responseObject);
+        }
+    }
+    catch (error$1) {
+        error("restclient.handlePostResponse(): Failed to call callback function " +
+            error$1);
+    }
+}
+
+var restclient = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	createRestClient: createRestClient
+});
+
+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
+});
+
+class BlockchainUrlUndefinedException extends Error {
+    constructor(brid) {
+        super(`Cannot find nodes hosting the blockchain with RID ${brid}`);
+    }
+}
+
+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());
+    });
+};
+/**
+ * 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(rest, chain0BRID, []);
+    return {
+        blockchainConnection: function (dappBRID) {
+            return __awaiter(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);
+            });
+        },
+    };
+}
+
+var chromiaClientProvider$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	chromiaClientProvider: chromiaClientProvider
+});
+
+exports.chromiaClient = chromiaClientProvider$1;
+exports.encryption = encryption$1;
+exports.formatter = formatter;
+exports.gtv = index;
+exports.gtx = gtx;
+exports.gtxClient = gtxclient;
+exports.logger = logger;
+exports.merkle = merkleHelper;
+exports.restClient = restclient;
+exports.restClientutil = restclientutil;
+//# sourceMappingURL=index.js.map