postchain-client 1.0.2 → 1.1.0

package/built/src/merkle/binarytreefactory.js

@@ -0,0 +1,235 @@
+"use strict";
+var util = require('../formatter');
+var PathSet = require('./path').PathSet;
+var PathLeafElement = require('./path').PathLeafElement;
+var EmptyLeaf = require('./binarytree').EmptyLeaf;
+var Leaf = require('./binarytree').Leaf;
+var Node = require('./binarytree').Node;
+var BinaryTree = require('./binarytree').BinaryTree;
+var ArrayHeadNode = require('./binarytree').ArrayHeadNode;
+var DictHeadNode = require('./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() { }
+/**
+ * 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.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.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.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.prototype.handlePrimitiveLeaf = function (leaf, paths) {
+    var pathElem = paths.getPathLeafOrElseAnyCurrentPathElement();
+    if (pathElem != null && !(pathElem instanceof PathLeafElement)) {
+        throw new Error("Path does not match the tree structure. We are at a leaf " + leaf + " but found path element " + pathElem);
+    }
+    return new Leaf(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.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(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.prototype.build = function (data) {
+    return this.buildWithPath(data, NO_PATHS);
+};
+/**
+ * @param {PathSet} paths
+ */
+BinaryTreeFactory.prototype.buildWithPath = function (data, paths) {
+    var result = this.handleLeaf(data, paths, true);
+    return new BinaryTree(result);
+};
+/**
+ * @param {Array} array
+ * @param {PathSet} paths
+ */
+BinaryTreeFactory.prototype.buildFromArray = function (array, paths) {
+    var pathElem = paths.getPathLeafOrElseAnyCurrentPathElement();
+    // 1. Build leaf layer
+    if (array.length == 0) {
+        return new ArrayHeadNode(new EmptyLeaf(), new EmptyLeaf(), 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) {
+        return new ArrayHeadNode(orgRoot.left, orgRoot.right, array, array.length, pathElem);
+    }
+    if (orgRoot instanceof Leaf) {
+        return this.buildFromOneLeaf(array, orgRoot, pathElem);
+    }
+    else {
+        throw new Error("Should not find element of this type here");
+    }
+};
+/**
+ *
+ */
+BinaryTreeFactory.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(orgRoot, new EmptyLeaf(), array, array.length, pathElem);
+    }
+};
+/**
+ * @param {PathSet} paths
+ */
+BinaryTreeFactory.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.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(new EmptyLeaf(), new EmptyLeaf(), 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) {
+        return new DictHeadNode(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.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;
+};
+module.exports = { BinaryTreeFactory };
+//# sourceMappingURL=binarytreefactory.js.map

package/built/src/merkle/binarytreefactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binarytreefactory.js","sourceRoot":"","sources":["../../../src/merkle/binarytreefactory.js"],"names":[],"mappings":"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"}

package/built/src/merkle/merkleHelper.js

@@ -0,0 +1,109 @@
+import { hashConcat } from "../encryption/encryption";
+var internalNodePrefix = Buffer.alloc(1, 0);
+var leafPrefix = Buffer.alloc(1, 1);
+var nonExistingNodeHash = Buffer.alloc(32);
+export 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);
+    var prefix = depth == leafDepth - 1 ? leafPrefix : internalNodePrefix;
+    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>}]}
+ */
+export 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.
+ */
+export 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);
+}
+//# sourceMappingURL=merkleHelper.js.map

package/built/src/merkle/merkleHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkleHelper.js","sourceRoot":"","sources":["../../../src/merkle/merkleHelper.ts"],"names":[],"mappings":"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"}

package/built/src/merkle/merklehashcalculator.d.ts

@@ -0,0 +1,35 @@
+/**
+ *
+ * @param {CryptoSystem} cryptoSystem
+ */
+export function MerkleHashCalculator(cryptoSystem: CryptoSystem): void;
+export class MerkleHashCalculator {
+    /**
+     *
+     * @param {CryptoSystem} cryptoSystem
+     */
+    constructor(cryptoSystem: CryptoSystem);
+    cryptoSystem: CryptoSystem;
+    /**
+     * @param {number} prefix
+     * @param {Buffer} hashLeft
+     * @param {Buffer} hashRight
+     */
+    calculateNodeHash(prefix: number, hashLeft: Buffer, hashRight: Buffer): any;
+    /**
+     * @param {*} value
+     */
+    calculateLeafHash(value: any): any;
+    /**
+     * @param {number} prefix
+     * @param {Buffer} hashLeft
+     * @param {Buffer} hashRight
+     */
+    calculateNodeHashInternal(prefix: number, hashLeft: Buffer, hashRight: Buffer, hashFunc: any): any;
+    calculateHashOfValueInternal(valuetoHash: any, serializeFun: any, hashFunc: any): any;
+    isContainerProofValueLeaf(value: any): boolean;
+}
+export function CryptoSystem(): void;
+export class CryptoSystem {
+    digest(buffer: any): Buffer;
+}

package/built/src/merkle/merklehashcalculator.js

@@ -0,0 +1,71 @@
+var serialization = require('../gtx/serialization');
+var HASH_PREFIX_LEAF = require('./binarytree').HASH_PREFIX_LEAF;
+var encryption = require('../../src/encryption/encryption');
+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;
+    }
+};
+module.exports = { MerkleHashCalculator, CryptoSystem };
+//# sourceMappingURL=merklehashcalculator.js.map

package/built/src/merkle/merklehashcalculator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merklehashcalculator.js","sourceRoot":"","sources":["../../../src/merkle/merklehashcalculator.js"],"names":[],"mappings":"AAAA,IAAI,aAAa,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;AACnD,IAAI,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,gBAAgB,CAAA;AAC/D,IAAI,UAAU,GAAG,OAAO,CAAC,iCAAiC,CAAC,CAAA;AAE3D,SAAS,YAAY,KAAI,CAAC;AAC1B,YAAY,CAAC,SAAS,CAAC,MAAM,GAAG,UAAS,MAAM;IAC7C,OAAO,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;AACnC,CAAC,CAAA;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,MAAM,EAAE,YAAY;IACtC,IAAI,YAAY,KAAK,IAAI,EAAE;QACzB,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAA;KAC/E;SAAM;QACL,OAAO,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;KACnC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAAC,YAAY;IACxC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;AAClC,CAAC;AAED;;;;GAIG;AACH,oBAAoB,CAAC,SAAS,CAAC,iBAAiB,GAAG,UAAS,MAAM,EAAE,QAAQ,EAAE,SAAS;IACrF,OAAO,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAA;AAChF,CAAC,CAAA;AAED;;GAEG;AACH,oBAAoB,CAAC,SAAS,CAAC,iBAAiB,GAAG,UAAS,KAAK;IAC/D,OAAO,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;AACxF,CAAC,CAAA;AAED;;;;GAIG;AACH,oBAAoB,CAAC,SAAS,CAAC,yBAAyB,GAAG,UAAS,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ;IACvG,IAAI,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACzB,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IACrB,IAAI,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;IACzD,OAAO,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;AAC/C,CAAC,CAAA;AAED,oBAAoB,CAAC,SAAS,CAAC,4BAA4B,GAAG,UAAS,WAAW,EAAE,YAAY,EAAE,QAAQ;IACxG,IAAI,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACzB,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAA;IAC/B,IAAI,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;IAC/D,OAAO,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;AAC/C,CAAC,CAAA;AAED,oBAAoB,CAAC,SAAS,CAAC,yBAAyB,GAAG,UAAS,KAAK;IACvE,IAAI,KAAK,IAAI,IAAI,EAAE;QACjB,OAAO,KAAK,CAAA;KACb;IACD,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC5D,OAAO,IAAI,CAAA;KACZ;SAAM;QACL,OAAO,KAAK,CAAA;KACb;AACH,CAAC,CAAA;AAED,MAAM,CAAC,OAAO,GAAG,EAAC,oBAAoB,EAAE,YAAY,EAAC,CAAC"}

package/built/src/merkle/path.d.ts

@@ -0,0 +1,155 @@
+/**
+ *
+ * @param {Array} pathElements
+ */
+export function Path(pathElements: any[]): void;
+export class Path {
+    /**
+     *
+     * @param {Array} pathElements
+     */
+    constructor(pathElements: any[]);
+    pathElements: any[];
+    /**
+     *
+     */
+    getCurrentPathElement(): any;
+    /**
+     *
+     */
+    size(): number;
+    /**
+     *
+     */
+    tail(): Path;
+    debugString(): string;
+    /**
+     * @param {Path} other
+     */
+    equals(other: Path): boolean;
+}
+export function PathElement(previous: any): void;
+export class PathElement {
+    constructor(previous: any);
+    previous: any;
+    getSearchKey(): void;
+}
+export function PathLeafElement(previous: any): void;
+export class PathLeafElement {
+    constructor(previous: any);
+    constructor: typeof PathLeafElement;
+    equals(other: any): boolean;
+}
+/**
+ *
+ * @param {SearchablePathElement} previous
+ * @param {number} index
+ */
+export function ArrayPathElement(previous: SearchablePathElement, index: number): void;
+export class ArrayPathElement {
+    /**
+     *
+     * @param {SearchablePathElement} previous
+     * @param {number} index
+     */
+    constructor(previous: SearchablePathElement, index: number);
+    index: number;
+    constructor: typeof ArrayPathElement;
+    getSearchKey(): number;
+    /**
+     * @param {ArrayPathElement} other
+     */
+    equals(other: ArrayPathElement): boolean;
+}
+export function SearchablePathElement(previous: any): void;
+export class SearchablePathElement {
+    constructor(previous: any);
+    constructor: typeof SearchablePathElement;
+    getSearchKey(): void;
+}
+/**
+ *
+ * @param {SearchablePathElement} previous
+ * @param {string} key
+ */
+export function DictPathElement(previous: SearchablePathElement, key: string): void;
+export class DictPathElement {
+    /**
+     *
+     * @param {SearchablePathElement} previous
+     * @param {string} key
+     */
+    constructor(previous: SearchablePathElement, key: string);
+    key: string;
+    constructor: typeof DictPathElement;
+    getSearchKey(): string;
+    /**
+     * @param {DictPathElement} other
+     */
+    equals(other: DictPathElement): boolean;
+}
+/**
+ *
+ * @param {Array} paths
+ */
+export function PathSet(paths: any[]): void;
+export class PathSet {
+    /**
+     *
+     * @param {Array} paths
+     */
+    constructor(paths: any[]);
+    paths: any[];
+    /**
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     *
+     */
+    getPathLeafOrElseAnyCurrentPathElement(): any;
+    /**
+     * 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
+     */
+    errorCheckUnequalParent(currPath: Path, currElem: PathElement, prevPath: Path, prevElem: PathElement): {
+        path: Path;
+        elem: PathElement;
+    };
+    /**
+     *
+     */
+    keepOnlyArrayPaths(): PathSet;
+    /**
+     *
+     */
+    keepOnlyDictPaths(): PathSet;
+    /**
+     *
+     */
+    getTailIfFirstElementIsArrayOfThisIndexFromList(index: any): PathSet;
+    /**
+     *
+     */
+    getTailIfFirstElementIsDictOfThisKeyFromList(key: any): PathSet;
+    /**
+     *
+     */
+    getTailFromList(searchKey: any, filterFunc: any): PathSet;
+}
+/**
+ * @param {number} index
+ * @param {Path} path
+ */
+export function getTailIfFirstElementIsArrayOfThisIndex(index: number, path: Path): Path;
+/**
+ *
+ * @param {Array} arr
+ */
+export function buildPathFromArray(arr: any[]): Path;