fixed-merkle-tree 0.7.3-p0
Signed-off-by: T-Hax <>
This commit is contained in:
T-Hax
parent
19124126f4
commit
e676b48b59
@ -1 +1,4 @@
|
|||||||
|
#!/bin/bash
|
||||||
|
export TARGET_REGISTRY_USER=
|
||||||
|
export TARGET_REGISTRY_DOMAIN=
|
||||||
export GITEA_AUTH_TOKEN=
|
export GITEA_AUTH_TOKEN=
|
||||||
19
.yarnrc.yml
19
.yarnrc.yml
@ -2,25 +2,18 @@
|
|||||||
# main repositories, so we are going to have to scope our packages properly.
|
# main repositories, so we are going to have to scope our packages properly.
|
||||||
npmScopes:
|
npmScopes:
|
||||||
tornado:
|
tornado:
|
||||||
# The @tornado scope can just be set to the right registry by editing the T-Hax here.
|
# Since there can be multiple repositories we select them via the .env we `source``.
|
||||||
# I could even make it an env var but it seems too much, that is for secrets.
|
# Check .env.example
|
||||||
npmPublishRegistry: "https://development.tornadocash.community/api/packages/T-Hax/npm/"
|
npmRegistryServer: https://${TARGET_REGISTRY_DOMAIN}/api/packages/${TARGET_REGISTRY_USER}/npm/
|
||||||
npmRegistryServer: "https://development.tornadocash.community/api/packages/T-Hax/npm/"
|
|
||||||
# The below can be EXPORTED via some env file which actually exports the variables though
|
npmPublishRegistry: https://${TARGET_REGISTRY_DOMAIN}/api/packages/${TARGET_REGISTRY_USER}/npm/
|
||||||
# Check the env.example, you will notice it's not a regular env
|
npmAuthToken: ${GITEA_AUTH_TOKEN}
|
||||||
# So split your env files up, since this is only for manual actions
|
|
||||||
npmAuthToken: ${GITEA_AUTH_TOKEN}
|
|
||||||
|
|
||||||
# If the following isn't set you won't have a node_modules folder
|
# If the following isn't set you won't have a node_modules folder
|
||||||
# You might be used to a node_modules folder instead of a pnp or other folder type
|
# You might be used to a node_modules folder instead of a pnp or other folder type
|
||||||
# If you want to use the new linkers uncomment or change the following
|
# If you want to use the new linkers uncomment or change the following
|
||||||
nodeLinker: "node-modules"
|
nodeLinker: "node-modules"
|
||||||
|
|
||||||
# So the tornadocash org, the person who maintains it, might setup something (in future) like,
|
|
||||||
# tornadocash:
|
|
||||||
# npmPublishRegistry: "https://development.tornadocash.community/api/packages/tornadocash/npm/"
|
|
||||||
# npmRegistryServer: "https://development.tornadocash.community/api/packages/tornadocash/npm/"
|
|
||||||
|
|
||||||
# We disable telemetry for obvious reasons. enableTelemetry: false
|
# We disable telemetry for obvious reasons. enableTelemetry: false
|
||||||
enableTelemetry: false
|
enableTelemetry: false
|
||||||
|
|
||||||
|
|||||||
@ -19,7 +19,7 @@
|
|||||||
],
|
],
|
||||||
"repository": {
|
"repository": {
|
||||||
"type": "git",
|
"type": "git",
|
||||||
"url": "https://development.tornadocash.community/tornadocash/circomlib"
|
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
|
||||||
},
|
},
|
||||||
"author": "0Kims",
|
"author": "0Kims",
|
||||||
"license": "GPL-3.0",
|
"license": "GPL-3.0",
|
||||||
|
|||||||
9
@tornado/fixed-merkle-tree/.editorconfig
Normal file
9
@tornado/fixed-merkle-tree/.editorconfig
Normal file
@ -0,0 +1,9 @@
|
|||||||
|
root = true
|
||||||
|
|
||||||
|
[*]
|
||||||
|
indent_style = space
|
||||||
|
indent_size = 2
|
||||||
|
end_of_line = lf
|
||||||
|
charset = utf-8
|
||||||
|
trim_trailing_whitespace = true
|
||||||
|
insert_final_newline = true
|
||||||
57
@tornado/fixed-merkle-tree/.eslintrc
Normal file
57
@tornado/fixed-merkle-tree/.eslintrc
Normal file
@ -0,0 +1,57 @@
|
|||||||
|
{
|
||||||
|
"globals": {
|
||||||
|
"Atomics": "readonly",
|
||||||
|
"SharedArrayBuffer": "readonly"
|
||||||
|
},
|
||||||
|
"parser": "@typescript-eslint/parser",
|
||||||
|
"plugins": [
|
||||||
|
"@typescript-eslint"
|
||||||
|
],
|
||||||
|
"extends": [
|
||||||
|
"eslint:recommended",
|
||||||
|
"plugin:@typescript-eslint/recommended",
|
||||||
|
"prettier"
|
||||||
|
],
|
||||||
|
"ignorePatterns": [
|
||||||
|
"test/*.spec.ts",
|
||||||
|
"lib"
|
||||||
|
],
|
||||||
|
"rules": {
|
||||||
|
"@typescript-eslint/no-unused-vars": "error",
|
||||||
|
"@typescript-eslint/consistent-type-definitions": [
|
||||||
|
"error",
|
||||||
|
"type"
|
||||||
|
],
|
||||||
|
"indent": [
|
||||||
|
"error",
|
||||||
|
2
|
||||||
|
],
|
||||||
|
"linebreak-style": [
|
||||||
|
"error",
|
||||||
|
"unix"
|
||||||
|
],
|
||||||
|
"quotes": [
|
||||||
|
"error",
|
||||||
|
"single"
|
||||||
|
],
|
||||||
|
"semi": [
|
||||||
|
"error",
|
||||||
|
"never"
|
||||||
|
],
|
||||||
|
"object-curly-spacing": [
|
||||||
|
"error",
|
||||||
|
"always"
|
||||||
|
],
|
||||||
|
"comma-dangle": [
|
||||||
|
"error",
|
||||||
|
"always-multiline"
|
||||||
|
],
|
||||||
|
"require-await": "error"
|
||||||
|
},
|
||||||
|
"env": {
|
||||||
|
"browser": true,
|
||||||
|
"es2021": true,
|
||||||
|
"node": true,
|
||||||
|
"mocha": true
|
||||||
|
}
|
||||||
|
}
|
||||||
78
@tornado/fixed-merkle-tree/.gitignore
vendored
78
@tornado/fixed-merkle-tree/.gitignore
vendored
@ -1,74 +1,6 @@
|
|||||||
# Logs
|
node_modules
|
||||||
logs
|
build
|
||||||
*.log
|
yarn-error.log
|
||||||
npm-debug.log*
|
.idea
|
||||||
yarn-debug.log*
|
|
||||||
yarn-error.log*
|
|
||||||
|
|
||||||
# Runtime data
|
|
||||||
pids
|
|
||||||
*.pid
|
|
||||||
*.seed
|
|
||||||
*.pid.lock
|
|
||||||
|
|
||||||
# Directory for instrumented libs generated by jscoverage/JSCover
|
|
||||||
lib-cov
|
|
||||||
|
|
||||||
# Coverage directory used by tools like istanbul
|
|
||||||
coverage
|
|
||||||
|
|
||||||
# nyc test coverage
|
|
||||||
.nyc_output
|
.nyc_output
|
||||||
|
.run
|
||||||
# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
|
|
||||||
.grunt
|
|
||||||
|
|
||||||
# Bower dependency directory (https://bower.io/)
|
|
||||||
bower_components
|
|
||||||
|
|
||||||
# node-waf configuration
|
|
||||||
.lock-wscript
|
|
||||||
|
|
||||||
# Compiled binary addons (https://nodejs.org/api/addons.html)
|
|
||||||
build/Release
|
|
||||||
|
|
||||||
# Dependency directories
|
|
||||||
node_modules/
|
|
||||||
jspm_packages/
|
|
||||||
|
|
||||||
# Typescript v1 declaration files
|
|
||||||
typings/
|
|
||||||
|
|
||||||
# Optional npm cache directory
|
|
||||||
.npm
|
|
||||||
|
|
||||||
# Optional eslint cache
|
|
||||||
.eslintcache
|
|
||||||
|
|
||||||
# Optional REPL history
|
|
||||||
.node_repl_history
|
|
||||||
|
|
||||||
# Output of 'npm pack'
|
|
||||||
*.tgz
|
|
||||||
|
|
||||||
# Yarn Integrity file
|
|
||||||
.yarn-integrity
|
|
||||||
|
|
||||||
# dotenv environment variables file
|
|
||||||
.env
|
|
||||||
|
|
||||||
# next.js build output
|
|
||||||
.next
|
|
||||||
|
|
||||||
tmp
|
|
||||||
|
|
||||||
.DS_Store
|
|
||||||
|
|
||||||
# yarn v3
|
|
||||||
.pnp.*
|
|
||||||
.yarn/*
|
|
||||||
!.yarn/patches
|
|
||||||
!.yarn/plugins
|
|
||||||
!.yarn/releases
|
|
||||||
!.yarn/sdks
|
|
||||||
!.yarn/versions
|
|
||||||
|
|||||||
1
@tornado/fixed-merkle-tree/.nvmrc
Normal file
1
@tornado/fixed-merkle-tree/.nvmrc
Normal file
@ -0,0 +1 @@
|
|||||||
|
14.17
|
||||||
7
@tornado/fixed-merkle-tree/.prettierrc
Normal file
7
@tornado/fixed-merkle-tree/.prettierrc
Normal file
@ -0,0 +1,7 @@
|
|||||||
|
{
|
||||||
|
"semi": false,
|
||||||
|
"arrowParens": "always",
|
||||||
|
"singleQuote": true,
|
||||||
|
"printWidth": 110,
|
||||||
|
"trailingComma": "all"
|
||||||
|
}
|
||||||
@ -1,7 +1,3 @@
|
|||||||
# @T-Hax/fixed-merkle-tree
|
|
||||||
|
|
||||||
This repository serves to configure the equivalent Tornado Cash repository for npm publishing. Below the rest of the description.
|
|
||||||
|
|
||||||
# Merkle Tree [](https://github.com/tornadocash/fixed-merkle-tree/actions) [](https://www.npmjs.com/package/fixed-merkle-tree)
|
# Merkle Tree [](https://github.com/tornadocash/fixed-merkle-tree/actions) [](https://www.npmjs.com/package/fixed-merkle-tree)
|
||||||
|
|
||||||
This is a fixed depth merkle tree implementation with sequential inserts
|
This is a fixed depth merkle tree implementation with sequential inserts
|
||||||
@ -9,27 +5,68 @@ This is a fixed depth merkle tree implementation with sequential inserts
|
|||||||
## Usage
|
## Usage
|
||||||
|
|
||||||
```javascript
|
```javascript
|
||||||
const MerkleTree = require('MerkleTree')
|
import { MerkleTree, PartialMerkleTree } from 'fixed-merkle-tree'
|
||||||
|
|
||||||
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
tree.insert(6)
|
tree.insert(6)
|
||||||
tree.update(3, 42)
|
tree.update(3, 42)
|
||||||
const path = tree.path(tree.indexOf(2))
|
const path = tree.proof(3)
|
||||||
console.log(path)
|
console.log(path)
|
||||||
|
// output
|
||||||
// output:
|
|
||||||
{
|
{
|
||||||
pathIndex: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
||||||
pathElements: [
|
pathElements: [
|
||||||
'42',
|
42,
|
||||||
'19814528709687996974327303300007262407299502847885145507292406548098437687919',
|
'4027992409016347597424110157229339967488',
|
||||||
'11545490348087423460235196042660837039811055736960842865648632633825765931887',
|
'2008015086710634950773855228781840564224',
|
||||||
'14506027710748750947258687001455876266559341618222612722926156490737302846427',
|
'938972308169430750202858820582946897920',
|
||||||
'4766583705360062980279572762279781527342845808161105063909171241304075622345',
|
'3743880566844110745576746962917825445888',
|
||||||
'16640205414190175414380077665118269450294358858897019640557533278896634808665',
|
'2074434463882483178614385966084599578624',
|
||||||
'13024477302430254842915163302704885770955784224100349847438808884122720088412',
|
'2808856778596740691845240322870189490176',
|
||||||
'11345696205391376769769683860277269518617256738724086786512014734609753488820',
|
'4986731814143931240516913804278285467648',
|
||||||
'17235543131546745471991808272245772046758360534180976603221801364506032471936',
|
'1918547053077726613961101558405545328640',
|
||||||
'155962837046691114236524362966874066300454611955781275944230309195800494087'
|
'5444383861051812288142814494928935059456'
|
||||||
]
|
],
|
||||||
|
pathIndices: [
|
||||||
|
0, 1, 0, 0, 0,
|
||||||
|
0, 0, 0, 0, 0
|
||||||
|
],
|
||||||
|
pathPositions: [
|
||||||
|
3, 0, 1, 0, 0,
|
||||||
|
0, 0, 0, 0, 0
|
||||||
|
],
|
||||||
|
pathRoot: '3917789723822252567979048877718291611648'
|
||||||
}
|
}
|
||||||
|
|
||||||
|
const treeEdge = tree.getTreeEdge(2)
|
||||||
|
const partialTree = new PartialMerkleTree(10, treeEdge, tree.elements.slice(treeEdge.edgeIndex))
|
||||||
|
console.log(partialTree.elements)
|
||||||
|
// [<2 empty items >, 3, 42, 5, 6]
|
||||||
|
|
||||||
|
const proofPath = partialTree.proof(3)
|
||||||
|
console.log(proofPath)
|
||||||
|
// output
|
||||||
|
{
|
||||||
|
pathElements: [
|
||||||
|
42,
|
||||||
|
'4027992409016347597424110157229339967488',
|
||||||
|
'2008015086710634950773855228781840564224',
|
||||||
|
'938972308169430750202858820582946897920',
|
||||||
|
'3743880566844110745576746962917825445888',
|
||||||
|
'2074434463882483178614385966084599578624',
|
||||||
|
'2808856778596740691845240322870189490176',
|
||||||
|
'4986731814143931240516913804278285467648',
|
||||||
|
'1918547053077726613961101558405545328640',
|
||||||
|
'5444383861051812288142814494928935059456'
|
||||||
|
],
|
||||||
|
pathIndices: [
|
||||||
|
0, 1, 0, 0, 0,
|
||||||
|
0, 0, 0, 0, 0
|
||||||
|
],
|
||||||
|
pathPositions: [
|
||||||
|
3, 0, 1, 0, 0,
|
||||||
|
0, 0, 0, 0, 0
|
||||||
|
],
|
||||||
|
pathRoot: '3917789723822252567979048877718291611648'
|
||||||
|
}
|
||||||
|
|
||||||
```
|
```
|
||||||
|
|||||||
112
@tornado/fixed-merkle-tree/index.d.ts
vendored
112
@tornado/fixed-merkle-tree/index.d.ts
vendored
@ -1,112 +0,0 @@
|
|||||||
declare module "src/mimc" {
|
|
||||||
function _exports(left: any, right: any): any;
|
|
||||||
export = _exports;
|
|
||||||
}
|
|
||||||
declare module "fixed-merkle-tree/src/merkleTree" {
|
|
||||||
export = MerkleTree;
|
|
||||||
/**
|
|
||||||
* @callback hashFunction
|
|
||||||
* @param left Left leaf
|
|
||||||
* @param right Right leaf
|
|
||||||
*/
|
|
||||||
/**
|
|
||||||
* Merkle tree
|
|
||||||
*/
|
|
||||||
export class MerkleTree {
|
|
||||||
/**
|
|
||||||
* Deserialize data into a MerkleTree instance
|
|
||||||
* Make sure to provide the same hashFunction as was used in the source tree,
|
|
||||||
* otherwise the tree state will be invalid
|
|
||||||
*
|
|
||||||
* @param data
|
|
||||||
* @param hashFunction
|
|
||||||
* @returns {MerkleTree}
|
|
||||||
*/
|
|
||||||
static deserialize(data: any, hashFunction: any): MerkleTree;
|
|
||||||
/**
|
|
||||||
* Constructor
|
|
||||||
* @param {number} levels Number of levels in the tree
|
|
||||||
* @param {Array} [elements] Initial elements
|
|
||||||
* @param {Object} options
|
|
||||||
* @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
|
|
||||||
* @param [options.zeroElement] Value for non-existent leaves
|
|
||||||
*/
|
|
||||||
constructor(levels: number, elements?: any[], { hashFunction, zeroElement }?: {
|
|
||||||
hashFunction?: hashFunction;
|
|
||||||
zeroElement?: any;
|
|
||||||
});
|
|
||||||
levels: number;
|
|
||||||
capacity: number;
|
|
||||||
_hash: (left: any, right: any) => any;
|
|
||||||
zeroElement: any;
|
|
||||||
_zeros: any[];
|
|
||||||
_layers: any[][];
|
|
||||||
_rebuild(): void;
|
|
||||||
/**
|
|
||||||
* Get tree root
|
|
||||||
* @returns {*}
|
|
||||||
*/
|
|
||||||
root(): any;
|
|
||||||
/**
|
|
||||||
* Insert new element into the tree
|
|
||||||
* @param element Element to insert
|
|
||||||
*/
|
|
||||||
insert(element: any): void;
|
|
||||||
/**
|
|
||||||
* Insert multiple elements into the tree.
|
|
||||||
* @param {Array} elements Elements to insert
|
|
||||||
*/
|
|
||||||
bulkInsert(elements: any[]): void;
|
|
||||||
/**
|
|
||||||
* Change an element in the tree
|
|
||||||
* @param {number} index Index of element to change
|
|
||||||
* @param element Updated element value
|
|
||||||
*/
|
|
||||||
update(index: number, element: any): void;
|
|
||||||
/**
|
|
||||||
* Get merkle path to a leaf
|
|
||||||
* @param {number} index Leaf index to generate path for
|
|
||||||
* @returns {{pathElements: Object[], pathIndex: number[]}} An object containing adjacent elements and left-right index
|
|
||||||
*/
|
|
||||||
path(index: number): {
|
|
||||||
pathElements: any[];
|
|
||||||
pathIndex: number[];
|
|
||||||
};
|
|
||||||
/**
|
|
||||||
* Find an element in the tree
|
|
||||||
* @param element An element to find
|
|
||||||
* @param comparator A function that checks leaf value equality
|
|
||||||
* @returns {number} Index if element is found, otherwise -1
|
|
||||||
*/
|
|
||||||
indexOf(element: any, comparator: any): number;
|
|
||||||
/**
|
|
||||||
* Returns a copy of non-zero tree elements
|
|
||||||
* @returns {Object[]}
|
|
||||||
*/
|
|
||||||
elements(): any[];
|
|
||||||
/**
|
|
||||||
* Returns a copy of n-th zero elements array
|
|
||||||
* @returns {Object[]}
|
|
||||||
*/
|
|
||||||
zeros(): any[];
|
|
||||||
/**
|
|
||||||
* Serialize entire tree state including intermediate layers into a plain object
|
|
||||||
* Deserializing it back will not require to recompute any hashes
|
|
||||||
* Elements are not converted to a plain type, this is responsibility of the caller
|
|
||||||
*/
|
|
||||||
serialize(): {
|
|
||||||
levels: number;
|
|
||||||
_zeros: any[];
|
|
||||||
_layers: any[][];
|
|
||||||
};
|
|
||||||
}
|
|
||||||
namespace MerkleTree {
|
|
||||||
export { hashFunction };
|
|
||||||
}
|
|
||||||
type hashFunction = (left: any, right: any) => any;
|
|
||||||
}
|
|
||||||
declare module "fixed-merkle-tree" {
|
|
||||||
const _exports: typeof import("fixed-merkle-tree/src/merkleTree");
|
|
||||||
export = _exports;
|
|
||||||
}
|
|
||||||
//# sourceMappingURL=index.d.ts.map
|
|
||||||
@ -1 +0,0 @@
|
|||||||
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/mimc.js","src/merkleTree.js","index.js"],"names":[],"mappings":";IAEiB,8CAA+E;;;;;ICKhG;;;;OAIG;IACH;;OAEG;IACH;QAkLE;;;;;;;;WAQG;QACH,kDAFa,UAAU,CAQtB;QAhMD;;;;;;;WAOG;QACH,oBANW,MAAM;YAGiB,YAAY,GAAnC,YAAY;YACJ,WAAW;WAkB7B;QAfC,eAAoB;QACpB,iBAA2B;QAI3B,sCAAwC;QACxC,iBAA8B;QAC9B,cAAgB;QAKhB,iBAAiB;QAKnB,iBAYC;QAED;;;WAGG;QACH,YAEC;QAED;;;WAGG;QACH,2BAKC;QAED;;;WAGG;QACH,kCAyBC;QAED;;;;WAIG;QACH,cAHW,MAAM,sBAiBhB;QAED;;;;WAIG;QACH,YAHW,MAAM;0BACW,KAAQ;uBAAa,MAAM,EAAE;UAkBxD;QAED;;;;;WAKG;QACH,wCAFa,MAAM,CAQlB;QAED;;;WAGG;QACH,YAFa,KAAQ,CAIpB;QAED;;;WAGG;QACH,SAFa,KAAQ,CAIpB;QAED;;;;WAIG;QACH;;;;UAMC;KAkBF"}
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module.exports = require("./src/merkleTree")
|
|
||||||
43
@tornado/fixed-merkle-tree/lib/BaseTree.d.ts
vendored
Normal file
43
@tornado/fixed-merkle-tree/lib/BaseTree.d.ts
vendored
Normal file
@ -0,0 +1,43 @@
|
|||||||
|
import { Element, HashFunction, ProofPath } from './';
|
||||||
|
export declare class BaseTree {
|
||||||
|
levels: number;
|
||||||
|
protected _hashFn: HashFunction<Element>;
|
||||||
|
protected zeroElement: Element;
|
||||||
|
protected _zeros: Element[];
|
||||||
|
protected _layers: Array<Element[]>;
|
||||||
|
get capacity(): number;
|
||||||
|
get layers(): Array<Element[]>;
|
||||||
|
get zeros(): Element[];
|
||||||
|
get elements(): Element[];
|
||||||
|
get root(): Element;
|
||||||
|
/**
|
||||||
|
* Find an element in the tree
|
||||||
|
* @param elements elements of tree
|
||||||
|
* @param element An element to find
|
||||||
|
* @param comparator A function that checks leaf value equality
|
||||||
|
* @param fromIndex The index to start the search at. If the index is greater than or equal to the array's length, -1 is returned
|
||||||
|
* @returns {number} Index if element is found, otherwise -1
|
||||||
|
*/
|
||||||
|
static indexOf(elements: Element[], element: Element, fromIndex?: number, comparator?: <T>(arg0: T, arg1: T) => boolean): number;
|
||||||
|
/**
|
||||||
|
* Insert new element into the tree
|
||||||
|
* @param element Element to insert
|
||||||
|
*/
|
||||||
|
insert(element: Element): void;
|
||||||
|
bulkInsert(elements: Element[]): void;
|
||||||
|
/**
|
||||||
|
* Change an element in the tree
|
||||||
|
* @param {number} index Index of element to change
|
||||||
|
* @param element Updated element value
|
||||||
|
*/
|
||||||
|
update(index: number, element: Element): void;
|
||||||
|
/**
|
||||||
|
* Get merkle path to a leaf
|
||||||
|
* @param {number} index Leaf index to generate path for
|
||||||
|
* @returns {{pathElements: Object[], pathIndex: number[]}} An object containing adjacent elements and left-right index
|
||||||
|
*/
|
||||||
|
path(index: number): ProofPath;
|
||||||
|
protected _buildZeros(): void;
|
||||||
|
protected _processNodes(nodes: Element[], layerIndex: number): any[];
|
||||||
|
protected _processUpdate(index: number): void;
|
||||||
|
}
|
||||||
154
@tornado/fixed-merkle-tree/lib/BaseTree.js
Normal file
154
@tornado/fixed-merkle-tree/lib/BaseTree.js
Normal file
@ -0,0 +1,154 @@
|
|||||||
|
"use strict";
|
||||||
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||||||
|
exports.BaseTree = void 0;
|
||||||
|
class BaseTree {
|
||||||
|
get capacity() {
|
||||||
|
return 2 ** this.levels;
|
||||||
|
}
|
||||||
|
get layers() {
|
||||||
|
return this._layers.slice();
|
||||||
|
}
|
||||||
|
get zeros() {
|
||||||
|
return this._zeros.slice();
|
||||||
|
}
|
||||||
|
get elements() {
|
||||||
|
return this._layers[0].slice();
|
||||||
|
}
|
||||||
|
get root() {
|
||||||
|
var _a;
|
||||||
|
return (_a = this._layers[this.levels][0]) !== null && _a !== void 0 ? _a : this._zeros[this.levels];
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Find an element in the tree
|
||||||
|
* @param elements elements of tree
|
||||||
|
* @param element An element to find
|
||||||
|
* @param comparator A function that checks leaf value equality
|
||||||
|
* @param fromIndex The index to start the search at. If the index is greater than or equal to the array's length, -1 is returned
|
||||||
|
* @returns {number} Index if element is found, otherwise -1
|
||||||
|
*/
|
||||||
|
static indexOf(elements, element, fromIndex, comparator) {
|
||||||
|
if (comparator) {
|
||||||
|
return elements.findIndex((el) => comparator(element, el));
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return elements.indexOf(element, fromIndex);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Insert new element into the tree
|
||||||
|
* @param element Element to insert
|
||||||
|
*/
|
||||||
|
insert(element) {
|
||||||
|
if (this._layers[0].length >= this.capacity) {
|
||||||
|
throw new Error('Tree is full');
|
||||||
|
}
|
||||||
|
this.update(this._layers[0].length, element);
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* Insert multiple elements into the tree.
|
||||||
|
* @param {Array} elements Elements to insert
|
||||||
|
*/
|
||||||
|
bulkInsert(elements) {
|
||||||
|
if (!elements.length) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (this._layers[0].length + elements.length > this.capacity) {
|
||||||
|
throw new Error('Tree is full');
|
||||||
|
}
|
||||||
|
// First we insert all elements except the last one
|
||||||
|
// updating only full subtree hashes (all layers where inserted element has odd index)
|
||||||
|
// the last element will update the full path to the root making the tree consistent again
|
||||||
|
for (let i = 0; i < elements.length - 1; i++) {
|
||||||
|
this._layers[0].push(elements[i]);
|
||||||
|
let level = 0;
|
||||||
|
let index = this._layers[0].length - 1;
|
||||||
|
while (index % 2 === 1) {
|
||||||
|
level++;
|
||||||
|
index >>= 1;
|
||||||
|
const left = this._layers[level - 1][index * 2];
|
||||||
|
const right = this._layers[level - 1][index * 2 + 1];
|
||||||
|
this._layers[level][index] = this._hashFn(left, right);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
this.insert(elements[elements.length - 1]);
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Change an element in the tree
|
||||||
|
* @param {number} index Index of element to change
|
||||||
|
* @param element Updated element value
|
||||||
|
*/
|
||||||
|
update(index, element) {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index > this._layers[0].length || index >= this.capacity) {
|
||||||
|
throw new Error('Insert index out of bounds: ' + index);
|
||||||
|
}
|
||||||
|
this._layers[0][index] = element;
|
||||||
|
this._processUpdate(index);
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Get merkle path to a leaf
|
||||||
|
* @param {number} index Leaf index to generate path for
|
||||||
|
* @returns {{pathElements: Object[], pathIndex: number[]}} An object containing adjacent elements and left-right index
|
||||||
|
*/
|
||||||
|
path(index) {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index >= this._layers[0].length) {
|
||||||
|
throw new Error('Index out of bounds: ' + index);
|
||||||
|
}
|
||||||
|
let elIndex = +index;
|
||||||
|
const pathElements = [];
|
||||||
|
const pathIndices = [];
|
||||||
|
const pathPositions = [];
|
||||||
|
for (let level = 0; level < this.levels; level++) {
|
||||||
|
pathIndices[level] = elIndex % 2;
|
||||||
|
const leafIndex = elIndex ^ 1;
|
||||||
|
if (leafIndex < this._layers[level].length) {
|
||||||
|
pathElements[level] = this._layers[level][leafIndex];
|
||||||
|
pathPositions[level] = leafIndex;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
pathElements[level] = this._zeros[level];
|
||||||
|
pathPositions[level] = 0;
|
||||||
|
}
|
||||||
|
elIndex >>= 1;
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
pathElements,
|
||||||
|
pathIndices,
|
||||||
|
pathPositions,
|
||||||
|
pathRoot: this.root,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
_buildZeros() {
|
||||||
|
this._zeros = [this.zeroElement];
|
||||||
|
for (let i = 1; i <= this.levels; i++) {
|
||||||
|
this._zeros[i] = this._hashFn(this._zeros[i - 1], this._zeros[i - 1]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_processNodes(nodes, layerIndex) {
|
||||||
|
const length = nodes.length;
|
||||||
|
let currentLength = Math.ceil(length / 2);
|
||||||
|
const currentLayer = new Array(currentLength);
|
||||||
|
currentLength--;
|
||||||
|
const starFrom = length - ((length % 2) ^ 1);
|
||||||
|
let j = 0;
|
||||||
|
for (let i = starFrom; i >= 0; i -= 2) {
|
||||||
|
if (nodes[i - 1] === undefined)
|
||||||
|
break;
|
||||||
|
const left = nodes[i - 1];
|
||||||
|
const right = (i === starFrom && length % 2 === 1) ? this._zeros[layerIndex - 1] : nodes[i];
|
||||||
|
currentLayer[currentLength - j] = this._hashFn(left, right);
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
return currentLayer;
|
||||||
|
}
|
||||||
|
_processUpdate(index) {
|
||||||
|
for (let level = 1; level <= this.levels; level++) {
|
||||||
|
index >>= 1;
|
||||||
|
const left = this._layers[level - 1][index * 2];
|
||||||
|
const right = index * 2 + 1 < this._layers[level - 1].length
|
||||||
|
? this._layers[level - 1][index * 2 + 1]
|
||||||
|
: this._zeros[level - 1];
|
||||||
|
this._layers[level][index] = this._hashFn(left, right);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
exports.BaseTree = BaseTree;
|
||||||
32
@tornado/fixed-merkle-tree/lib/FixedMerkleTree.d.ts
vendored
Normal file
32
@tornado/fixed-merkle-tree/lib/FixedMerkleTree.d.ts
vendored
Normal file
@ -0,0 +1,32 @@
|
|||||||
|
import { Element, HashFunction, MerkleTreeOptions, ProofPath, SerializedTreeState, TreeEdge, TreeSlice } from './';
|
||||||
|
import { BaseTree } from './BaseTree';
|
||||||
|
export default class MerkleTree extends BaseTree {
|
||||||
|
constructor(levels: number, elements?: Element[], { hashFunction, zeroElement, }?: MerkleTreeOptions);
|
||||||
|
private _buildHashes;
|
||||||
|
/**
|
||||||
|
* Insert multiple elements into the tree.
|
||||||
|
* @param {Array} elements Elements to insert
|
||||||
|
*/
|
||||||
|
bulkInsert(elements: Element[]): void;
|
||||||
|
indexOf(element: Element, comparator?: <T>(arg0: T, arg1: T) => boolean): number;
|
||||||
|
proof(element: Element): ProofPath;
|
||||||
|
getTreeEdge(edgeIndex: number): TreeEdge;
|
||||||
|
/**
|
||||||
|
* 🪓
|
||||||
|
* @param count
|
||||||
|
*/
|
||||||
|
getTreeSlices(count?: number): TreeSlice[];
|
||||||
|
/**
|
||||||
|
* Serialize entire tree state including intermediate layers into a plain object
|
||||||
|
* Deserializing it back will not require to recompute any hashes
|
||||||
|
* Elements are not converted to a plain type, this is responsibility of the caller
|
||||||
|
*/
|
||||||
|
serialize(): SerializedTreeState;
|
||||||
|
/**
|
||||||
|
* Deserialize data into a MerkleTree instance
|
||||||
|
* Make sure to provide the same hashFunction as was used in the source tree,
|
||||||
|
* otherwise the tree state will be invalid
|
||||||
|
*/
|
||||||
|
static deserialize(data: SerializedTreeState, hashFunction?: HashFunction<Element>): MerkleTree;
|
||||||
|
toString(): string;
|
||||||
|
}
|
||||||
114
@tornado/fixed-merkle-tree/lib/FixedMerkleTree.js
Normal file
114
@tornado/fixed-merkle-tree/lib/FixedMerkleTree.js
Normal file
@ -0,0 +1,114 @@
|
|||||||
|
"use strict";
|
||||||
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||||
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||||
|
};
|
||||||
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||||||
|
const simpleHash_1 = __importDefault(require("./simpleHash"));
|
||||||
|
const BaseTree_1 = require("./BaseTree");
|
||||||
|
class MerkleTree extends BaseTree_1.BaseTree {
|
||||||
|
constructor(levels, elements = [], { hashFunction = simpleHash_1.default, zeroElement = 0, } = {}) {
|
||||||
|
super();
|
||||||
|
this.levels = levels;
|
||||||
|
if (elements.length > this.capacity) {
|
||||||
|
throw new Error('Tree is full');
|
||||||
|
}
|
||||||
|
this._hashFn = hashFunction;
|
||||||
|
this.zeroElement = zeroElement;
|
||||||
|
this._layers = [];
|
||||||
|
const leaves = elements.slice();
|
||||||
|
this._layers = [leaves];
|
||||||
|
this._buildZeros();
|
||||||
|
this._buildHashes();
|
||||||
|
}
|
||||||
|
_buildHashes() {
|
||||||
|
for (let layerIndex = 1; layerIndex <= this.levels; layerIndex++) {
|
||||||
|
const nodes = this._layers[layerIndex - 1];
|
||||||
|
this._layers[layerIndex] = this._processNodes(nodes, layerIndex);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Insert multiple elements into the tree.
|
||||||
|
* @param {Array} elements Elements to insert
|
||||||
|
*/
|
||||||
|
bulkInsert(elements) {
|
||||||
|
if (!elements.length) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (this._layers[0].length + elements.length > this.capacity) {
|
||||||
|
throw new Error('Tree is full');
|
||||||
|
}
|
||||||
|
// First we insert all elements except the last one
|
||||||
|
// updating only full subtree hashes (all layers where inserted element has odd index)
|
||||||
|
// the last element will update the full path to the root making the tree consistent again
|
||||||
|
for (let i = 0; i < elements.length - 1; i++) {
|
||||||
|
this._layers[0].push(elements[i]);
|
||||||
|
let level = 0;
|
||||||
|
let index = this._layers[0].length - 1;
|
||||||
|
while (index % 2 === 1) {
|
||||||
|
level++;
|
||||||
|
index >>= 1;
|
||||||
|
this._layers[level][index] = this._hashFn(this._layers[level - 1][index * 2], this._layers[level - 1][index * 2 + 1]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
this.insert(elements[elements.length - 1]);
|
||||||
|
}
|
||||||
|
indexOf(element, comparator) {
|
||||||
|
return BaseTree_1.BaseTree.indexOf(this._layers[0], element, 0, comparator);
|
||||||
|
}
|
||||||
|
proof(element) {
|
||||||
|
const index = this.indexOf(element);
|
||||||
|
return this.path(index);
|
||||||
|
}
|
||||||
|
getTreeEdge(edgeIndex) {
|
||||||
|
const edgeElement = this._layers[0][edgeIndex];
|
||||||
|
if (edgeElement === undefined) {
|
||||||
|
throw new Error('Element not found');
|
||||||
|
}
|
||||||
|
const edgePath = this.path(edgeIndex);
|
||||||
|
return { edgePath, edgeElement, edgeIndex, edgeElementsCount: this._layers[0].length };
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* 🪓
|
||||||
|
* @param count
|
||||||
|
*/
|
||||||
|
getTreeSlices(count = 4) {
|
||||||
|
const length = this._layers[0].length;
|
||||||
|
let size = Math.ceil(length / count);
|
||||||
|
if (size % 2)
|
||||||
|
size++;
|
||||||
|
const slices = [];
|
||||||
|
for (let i = 0; i < length; i += size) {
|
||||||
|
const edgeLeft = i;
|
||||||
|
const edgeRight = i + size;
|
||||||
|
slices.push({ edge: this.getTreeEdge(edgeLeft), elements: this.elements.slice(edgeLeft, edgeRight) });
|
||||||
|
}
|
||||||
|
return slices;
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Serialize entire tree state including intermediate layers into a plain object
|
||||||
|
* Deserializing it back will not require to recompute any hashes
|
||||||
|
* Elements are not converted to a plain type, this is responsibility of the caller
|
||||||
|
*/
|
||||||
|
serialize() {
|
||||||
|
return {
|
||||||
|
levels: this.levels,
|
||||||
|
_zeros: this._zeros,
|
||||||
|
_layers: this._layers,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Deserialize data into a MerkleTree instance
|
||||||
|
* Make sure to provide the same hashFunction as was used in the source tree,
|
||||||
|
* otherwise the tree state will be invalid
|
||||||
|
*/
|
||||||
|
static deserialize(data, hashFunction) {
|
||||||
|
const instance = Object.assign(Object.create(this.prototype), data);
|
||||||
|
instance._hashFn = hashFunction || simpleHash_1.default;
|
||||||
|
instance.zeroElement = instance._zeros[0];
|
||||||
|
return instance;
|
||||||
|
}
|
||||||
|
toString() {
|
||||||
|
return JSON.stringify(this.serialize());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
exports.default = MerkleTree;
|
||||||
35
@tornado/fixed-merkle-tree/lib/PartialMerkleTree.d.ts
vendored
Normal file
35
@tornado/fixed-merkle-tree/lib/PartialMerkleTree.d.ts
vendored
Normal file
@ -0,0 +1,35 @@
|
|||||||
|
import { Element, HashFunction, MerkleTreeOptions, ProofPath, SerializedPartialTreeState, TreeEdge } from './';
|
||||||
|
import { BaseTree } from './BaseTree';
|
||||||
|
export declare class PartialMerkleTree extends BaseTree {
|
||||||
|
private _leaves;
|
||||||
|
private _leavesAfterEdge;
|
||||||
|
private _edgeLeaf;
|
||||||
|
private _initialRoot;
|
||||||
|
private _edgeLeafProof;
|
||||||
|
private _proofMap;
|
||||||
|
constructor(levels: number, { edgePath, edgeElement, edgeIndex, edgeElementsCount, }: TreeEdge, leaves: Element[], { hashFunction, zeroElement }?: MerkleTreeOptions);
|
||||||
|
get edgeIndex(): number;
|
||||||
|
get edgeElement(): Element;
|
||||||
|
get edgeLeafProof(): ProofPath;
|
||||||
|
private _createProofMap;
|
||||||
|
private _buildTree;
|
||||||
|
private _buildHashes;
|
||||||
|
/**
|
||||||
|
* Change an element in the tree
|
||||||
|
* @param {number} index Index of element to change
|
||||||
|
* @param element Updated element value
|
||||||
|
*/
|
||||||
|
update(index: number, element: Element): void;
|
||||||
|
path(index: number): ProofPath;
|
||||||
|
indexOf(element: Element, comparator?: <T>(arg0: T, arg1: T) => boolean): number;
|
||||||
|
proof(element: Element): ProofPath;
|
||||||
|
/**
|
||||||
|
* Shifts edge of tree to left
|
||||||
|
* @param edge new TreeEdge below current edge
|
||||||
|
* @param elements leaves between old and new edge
|
||||||
|
*/
|
||||||
|
shiftEdge(edge: TreeEdge, elements: Element[]): void;
|
||||||
|
serialize(): SerializedPartialTreeState;
|
||||||
|
static deserialize(data: SerializedPartialTreeState, hashFunction?: HashFunction<Element>): PartialMerkleTree;
|
||||||
|
toString(): string;
|
||||||
|
}
|
||||||
159
@tornado/fixed-merkle-tree/lib/PartialMerkleTree.js
Normal file
159
@tornado/fixed-merkle-tree/lib/PartialMerkleTree.js
Normal file
@ -0,0 +1,159 @@
|
|||||||
|
"use strict";
|
||||||
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||||
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||||
|
};
|
||||||
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||||||
|
exports.PartialMerkleTree = void 0;
|
||||||
|
const simpleHash_1 = __importDefault(require("./simpleHash"));
|
||||||
|
const BaseTree_1 = require("./BaseTree");
|
||||||
|
class PartialMerkleTree extends BaseTree_1.BaseTree {
|
||||||
|
constructor(levels, { edgePath, edgeElement, edgeIndex, edgeElementsCount, }, leaves, { hashFunction, zeroElement } = {}) {
|
||||||
|
super();
|
||||||
|
if (edgeIndex + leaves.length !== edgeElementsCount)
|
||||||
|
throw new Error('Invalid number of elements');
|
||||||
|
this._edgeLeafProof = edgePath;
|
||||||
|
this._initialRoot = edgePath.pathRoot;
|
||||||
|
this.zeroElement = zeroElement !== null && zeroElement !== void 0 ? zeroElement : 0;
|
||||||
|
this._edgeLeaf = { data: edgeElement, index: edgeIndex };
|
||||||
|
this._leavesAfterEdge = leaves;
|
||||||
|
this.levels = levels;
|
||||||
|
this._hashFn = hashFunction || simpleHash_1.default;
|
||||||
|
this._createProofMap();
|
||||||
|
this._buildTree();
|
||||||
|
}
|
||||||
|
get edgeIndex() {
|
||||||
|
return this._edgeLeaf.index;
|
||||||
|
}
|
||||||
|
get edgeElement() {
|
||||||
|
return this._edgeLeaf.data;
|
||||||
|
}
|
||||||
|
get edgeLeafProof() {
|
||||||
|
return this._edgeLeafProof;
|
||||||
|
}
|
||||||
|
_createProofMap() {
|
||||||
|
this._proofMap = this.edgeLeafProof.pathPositions.reduce((p, c, i) => {
|
||||||
|
p.set(i, [c, this.edgeLeafProof.pathElements[i]]);
|
||||||
|
return p;
|
||||||
|
}, new Map());
|
||||||
|
this._proofMap.set(this.levels, [0, this.edgeLeafProof.pathRoot]);
|
||||||
|
}
|
||||||
|
_buildTree() {
|
||||||
|
const edgeLeafIndex = this._edgeLeaf.index;
|
||||||
|
this._leaves = Array(edgeLeafIndex).concat(this._leavesAfterEdge);
|
||||||
|
if (this._proofMap.has(0)) {
|
||||||
|
const [proofPos, proofEl] = this._proofMap.get(0);
|
||||||
|
this._leaves[proofPos] = proofEl;
|
||||||
|
}
|
||||||
|
this._layers = [this._leaves];
|
||||||
|
this._buildZeros();
|
||||||
|
this._buildHashes();
|
||||||
|
}
|
||||||
|
_buildHashes() {
|
||||||
|
for (let layerIndex = 1; layerIndex <= this.levels; layerIndex++) {
|
||||||
|
const nodes = this._layers[layerIndex - 1];
|
||||||
|
const currentLayer = this._processNodes(nodes, layerIndex);
|
||||||
|
if (this._proofMap.has(layerIndex)) {
|
||||||
|
const [proofPos, proofEl] = this._proofMap.get(layerIndex);
|
||||||
|
if (!currentLayer[proofPos])
|
||||||
|
currentLayer[proofPos] = proofEl;
|
||||||
|
}
|
||||||
|
this._layers[layerIndex] = currentLayer;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Change an element in the tree
|
||||||
|
* @param {number} index Index of element to change
|
||||||
|
* @param element Updated element value
|
||||||
|
*/
|
||||||
|
update(index, element) {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index > this._layers[0].length || index >= this.capacity) {
|
||||||
|
throw new Error('Insert index out of bounds: ' + index);
|
||||||
|
}
|
||||||
|
if (index < this._edgeLeaf.index) {
|
||||||
|
throw new Error(`Index ${index} is below the edge: ${this._edgeLeaf.index}`);
|
||||||
|
}
|
||||||
|
this._layers[0][index] = element;
|
||||||
|
this._processUpdate(index);
|
||||||
|
}
|
||||||
|
path(index) {
|
||||||
|
var _a;
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index >= this._layers[0].length) {
|
||||||
|
throw new Error('Index out of bounds: ' + index);
|
||||||
|
}
|
||||||
|
if (index < this._edgeLeaf.index) {
|
||||||
|
throw new Error(`Index ${index} is below the edge: ${this._edgeLeaf.index}`);
|
||||||
|
}
|
||||||
|
let elIndex = Number(index);
|
||||||
|
const pathElements = [];
|
||||||
|
const pathIndices = [];
|
||||||
|
const pathPositions = [];
|
||||||
|
for (let level = 0; level < this.levels; level++) {
|
||||||
|
pathIndices[level] = elIndex % 2;
|
||||||
|
const leafIndex = elIndex ^ 1;
|
||||||
|
if (leafIndex < this._layers[level].length) {
|
||||||
|
pathElements[level] = this._layers[level][leafIndex];
|
||||||
|
pathPositions[level] = leafIndex;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
pathElements[level] = this._zeros[level];
|
||||||
|
pathPositions[level] = 0;
|
||||||
|
}
|
||||||
|
const [proofPos, proofEl] = this._proofMap.get(level);
|
||||||
|
pathElements[level] = (_a = pathElements[level]) !== null && _a !== void 0 ? _a : (proofPos === leafIndex ? proofEl : this._zeros[level]);
|
||||||
|
elIndex >>= 1;
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
pathElements,
|
||||||
|
pathIndices,
|
||||||
|
pathPositions,
|
||||||
|
pathRoot: this.root,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
indexOf(element, comparator) {
|
||||||
|
return BaseTree_1.BaseTree.indexOf(this._layers[0], element, this.edgeIndex, comparator);
|
||||||
|
}
|
||||||
|
proof(element) {
|
||||||
|
const index = this.indexOf(element);
|
||||||
|
return this.path(index);
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Shifts edge of tree to left
|
||||||
|
* @param edge new TreeEdge below current edge
|
||||||
|
* @param elements leaves between old and new edge
|
||||||
|
*/
|
||||||
|
shiftEdge(edge, elements) {
|
||||||
|
if (this._edgeLeaf.index <= edge.edgeIndex) {
|
||||||
|
throw new Error(`New edgeIndex should be smaller then ${this._edgeLeaf.index}`);
|
||||||
|
}
|
||||||
|
if (elements.length !== (this._edgeLeaf.index - edge.edgeIndex)) {
|
||||||
|
throw new Error(`Elements length should be ${this._edgeLeaf.index - edge.edgeIndex}`);
|
||||||
|
}
|
||||||
|
this._edgeLeafProof = edge.edgePath;
|
||||||
|
this._edgeLeaf = { index: edge.edgeIndex, data: edge.edgeElement };
|
||||||
|
this._leavesAfterEdge = [...elements, ...this._leavesAfterEdge];
|
||||||
|
this._createProofMap();
|
||||||
|
this._buildTree();
|
||||||
|
}
|
||||||
|
serialize() {
|
||||||
|
return {
|
||||||
|
_edgeLeafProof: this._edgeLeafProof,
|
||||||
|
_edgeLeaf: this._edgeLeaf,
|
||||||
|
_layers: this._layers,
|
||||||
|
_zeros: this._zeros,
|
||||||
|
levels: this.levels,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
static deserialize(data, hashFunction) {
|
||||||
|
const instance = Object.assign(Object.create(this.prototype), data);
|
||||||
|
instance._hashFn = hashFunction || simpleHash_1.default;
|
||||||
|
instance._initialRoot = data._edgeLeafProof.pathRoot;
|
||||||
|
instance.zeroElement = instance._zeros[0];
|
||||||
|
instance._leavesAfterEdge = instance._layers[0].slice(data._edgeLeaf.index);
|
||||||
|
instance._createProofMap();
|
||||||
|
return instance;
|
||||||
|
}
|
||||||
|
toString() {
|
||||||
|
return JSON.stringify(this.serialize());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
exports.PartialMerkleTree = PartialMerkleTree;
|
||||||
45
@tornado/fixed-merkle-tree/lib/index.d.ts
vendored
Normal file
45
@tornado/fixed-merkle-tree/lib/index.d.ts
vendored
Normal file
@ -0,0 +1,45 @@
|
|||||||
|
import { default as MerkleTree } from './FixedMerkleTree';
|
||||||
|
export { PartialMerkleTree } from './PartialMerkleTree';
|
||||||
|
export { simpleHash } from './simpleHash';
|
||||||
|
export { MerkleTree };
|
||||||
|
export default MerkleTree;
|
||||||
|
export declare type HashFunction<T> = {
|
||||||
|
(left: T, right: T): string;
|
||||||
|
};
|
||||||
|
export declare type MerkleTreeOptions = {
|
||||||
|
hashFunction?: HashFunction<Element>;
|
||||||
|
zeroElement?: Element;
|
||||||
|
};
|
||||||
|
export declare type Element = string | number;
|
||||||
|
export declare type SerializedTreeState = {
|
||||||
|
levels: number;
|
||||||
|
_zeros: Array<Element>;
|
||||||
|
_layers: Array<Element[]>;
|
||||||
|
};
|
||||||
|
export declare type SerializedPartialTreeState = {
|
||||||
|
levels: number;
|
||||||
|
_layers: Element[][];
|
||||||
|
_zeros: Array<Element>;
|
||||||
|
_edgeLeafProof: ProofPath;
|
||||||
|
_edgeLeaf: LeafWithIndex;
|
||||||
|
};
|
||||||
|
export declare type ProofPath = {
|
||||||
|
pathElements: Element[];
|
||||||
|
pathIndices: number[];
|
||||||
|
pathPositions: number[];
|
||||||
|
pathRoot: Element;
|
||||||
|
};
|
||||||
|
export declare type TreeEdge = {
|
||||||
|
edgeElement: Element;
|
||||||
|
edgePath: ProofPath;
|
||||||
|
edgeIndex: number;
|
||||||
|
edgeElementsCount: number;
|
||||||
|
};
|
||||||
|
export declare type TreeSlice = {
|
||||||
|
edge: TreeEdge;
|
||||||
|
elements: Element[];
|
||||||
|
};
|
||||||
|
export declare type LeafWithIndex = {
|
||||||
|
index: number;
|
||||||
|
data: Element;
|
||||||
|
};
|
||||||
13
@tornado/fixed-merkle-tree/lib/index.js
Normal file
13
@tornado/fixed-merkle-tree/lib/index.js
Normal file
@ -0,0 +1,13 @@
|
|||||||
|
"use strict";
|
||||||
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||||
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||||
|
};
|
||||||
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||||||
|
exports.MerkleTree = exports.simpleHash = exports.PartialMerkleTree = void 0;
|
||||||
|
const FixedMerkleTree_1 = __importDefault(require("./FixedMerkleTree"));
|
||||||
|
Object.defineProperty(exports, "MerkleTree", { enumerable: true, get: function () { return FixedMerkleTree_1.default; } });
|
||||||
|
var PartialMerkleTree_1 = require("./PartialMerkleTree");
|
||||||
|
Object.defineProperty(exports, "PartialMerkleTree", { enumerable: true, get: function () { return PartialMerkleTree_1.PartialMerkleTree; } });
|
||||||
|
var simpleHash_1 = require("./simpleHash");
|
||||||
|
Object.defineProperty(exports, "simpleHash", { enumerable: true, get: function () { return simpleHash_1.simpleHash; } });
|
||||||
|
exports.default = FixedMerkleTree_1.default;
|
||||||
10
@tornado/fixed-merkle-tree/lib/simpleHash.d.ts
vendored
Normal file
10
@tornado/fixed-merkle-tree/lib/simpleHash.d.ts
vendored
Normal file
@ -0,0 +1,10 @@
|
|||||||
|
import { Element } from './';
|
||||||
|
/***
|
||||||
|
* This is insecure hash function, just for example only
|
||||||
|
* @param data
|
||||||
|
* @param seed
|
||||||
|
* @param hashLength
|
||||||
|
*/
|
||||||
|
export declare function simpleHash<T>(data: T[], seed?: number, hashLength?: number): string;
|
||||||
|
declare const _default: (left: Element, right: Element) => string;
|
||||||
|
export default _default;
|
||||||
21
@tornado/fixed-merkle-tree/lib/simpleHash.js
Normal file
21
@tornado/fixed-merkle-tree/lib/simpleHash.js
Normal file
@ -0,0 +1,21 @@
|
|||||||
|
"use strict";
|
||||||
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||||||
|
exports.simpleHash = void 0;
|
||||||
|
/***
|
||||||
|
* This is insecure hash function, just for example only
|
||||||
|
* @param data
|
||||||
|
* @param seed
|
||||||
|
* @param hashLength
|
||||||
|
*/
|
||||||
|
function simpleHash(data, seed, hashLength = 40) {
|
||||||
|
const str = data.join('');
|
||||||
|
let i, l, hval = seed !== null && seed !== void 0 ? seed : 0x811c9dcc5;
|
||||||
|
for (i = 0, l = str.length; i < l; i++) {
|
||||||
|
hval ^= str.charCodeAt(i);
|
||||||
|
hval += (hval << 1) + (hval << 4) + (hval << 6) + (hval << 8) + (hval << 24);
|
||||||
|
}
|
||||||
|
const hash = (hval >>> 0).toString(16);
|
||||||
|
return BigInt('0x' + hash.padEnd(hashLength - (hash.length - 1), '0')).toString(10);
|
||||||
|
}
|
||||||
|
exports.simpleHash = simpleHash;
|
||||||
|
exports.default = (left, right) => simpleHash([left, right]);
|
||||||
5411
@tornado/fixed-merkle-tree/package-lock.json
generated
5411
@tornado/fixed-merkle-tree/package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@ -1,15 +1,20 @@
|
|||||||
{
|
{
|
||||||
"name": "@tornado/fixed-merkle-tree",
|
"name": "@tornado/fixed-merkle-tree",
|
||||||
"version": "0.6.1-p2",
|
"version": "0.7.3-p0",
|
||||||
"description": "Fixed depth merkle tree implementation with sequential inserts",
|
"description": "Fixed depth merkle tree implementation with sequential inserts",
|
||||||
"repository": {
|
"repository": {
|
||||||
"type": "git",
|
"type": "git",
|
||||||
"url": "https://github.com/tornadocash/fixed-merkle-tree.git"
|
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
|
||||||
},
|
},
|
||||||
"main": "index.js",
|
"main": "lib/index.js",
|
||||||
|
"types": "lib/index.d.ts",
|
||||||
"scripts": {
|
"scripts": {
|
||||||
"test": "mocha",
|
"test": "ts-mocha 'test/*.spec.ts' -s 10",
|
||||||
"lint": "eslint ."
|
"coverage": "nyc npm run test",
|
||||||
|
"build": "tsc",
|
||||||
|
"clean": "rm -rf lib/",
|
||||||
|
"prepare": "npm run clean && npm run build",
|
||||||
|
"lint": "eslint src"
|
||||||
},
|
},
|
||||||
"keywords": [
|
"keywords": [
|
||||||
"merkle",
|
"merkle",
|
||||||
@ -18,15 +23,20 @@
|
|||||||
],
|
],
|
||||||
"author": "Roman Semenov <semenov.roma@gmail.com>",
|
"author": "Roman Semenov <semenov.roma@gmail.com>",
|
||||||
"license": "ISC",
|
"license": "ISC",
|
||||||
"dependencies": {
|
"files": [
|
||||||
"@tornado/circomlib": "workspace:*",
|
"src/*",
|
||||||
"@tornado/snarkjs": "workspace:*"
|
"lib/*"
|
||||||
},
|
],
|
||||||
"devDependencies": {
|
"devDependencies": {
|
||||||
"babel-eslint": "^10.1.0",
|
"@types/expect": "^24.3.0",
|
||||||
|
"@types/mocha": "^9.1.0",
|
||||||
|
"@typescript-eslint/eslint-plugin": "^5.12.0",
|
||||||
|
"@typescript-eslint/parser": "^5.12.0",
|
||||||
"chai": "^4.2.0",
|
"chai": "^4.2.0",
|
||||||
"eslint": "^7.5.0",
|
"eslint": "^8.9.0",
|
||||||
"mocha": "^8.1.0",
|
"eslint-config-prettier": "^8.3.0",
|
||||||
"typescript": "^5.0.2"
|
"mocha": "^9.2.2",
|
||||||
|
"ts-mocha": "^9.0.2",
|
||||||
|
"typescript": "^4.6.2"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
169
@tornado/fixed-merkle-tree/src/BaseTree.ts
Normal file
169
@tornado/fixed-merkle-tree/src/BaseTree.ts
Normal file
@ -0,0 +1,169 @@
|
|||||||
|
import { Element, HashFunction, ProofPath } from './'
|
||||||
|
|
||||||
|
export class BaseTree {
|
||||||
|
levels: number
|
||||||
|
protected _hashFn: HashFunction<Element>
|
||||||
|
protected zeroElement: Element
|
||||||
|
protected _zeros: Element[]
|
||||||
|
protected _layers: Array<Element[]>
|
||||||
|
|
||||||
|
get capacity() {
|
||||||
|
return 2 ** this.levels
|
||||||
|
}
|
||||||
|
|
||||||
|
get layers(): Array<Element[]> {
|
||||||
|
return this._layers.slice()
|
||||||
|
}
|
||||||
|
|
||||||
|
get zeros(): Element[] {
|
||||||
|
return this._zeros.slice()
|
||||||
|
}
|
||||||
|
|
||||||
|
get elements(): Element[] {
|
||||||
|
return this._layers[0].slice()
|
||||||
|
}
|
||||||
|
|
||||||
|
get root(): Element {
|
||||||
|
return this._layers[this.levels][0] ?? this._zeros[this.levels]
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Find an element in the tree
|
||||||
|
* @param elements elements of tree
|
||||||
|
* @param element An element to find
|
||||||
|
* @param comparator A function that checks leaf value equality
|
||||||
|
* @param fromIndex The index to start the search at. If the index is greater than or equal to the array's length, -1 is returned
|
||||||
|
* @returns {number} Index if element is found, otherwise -1
|
||||||
|
*/
|
||||||
|
static indexOf(elements: Element[], element: Element, fromIndex?: number, comparator?: <T> (arg0: T, arg1: T) => boolean): number {
|
||||||
|
if (comparator) {
|
||||||
|
return elements.findIndex((el) => comparator<Element>(element, el))
|
||||||
|
} else {
|
||||||
|
return elements.indexOf(element, fromIndex)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Insert new element into the tree
|
||||||
|
* @param element Element to insert
|
||||||
|
*/
|
||||||
|
insert(element: Element) {
|
||||||
|
if (this._layers[0].length >= this.capacity) {
|
||||||
|
throw new Error('Tree is full')
|
||||||
|
}
|
||||||
|
this.update(this._layers[0].length, element)
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Insert multiple elements into the tree.
|
||||||
|
* @param {Array} elements Elements to insert
|
||||||
|
*/
|
||||||
|
bulkInsert(elements: Element[]): void {
|
||||||
|
if (!elements.length) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if (this._layers[0].length + elements.length > this.capacity) {
|
||||||
|
throw new Error('Tree is full')
|
||||||
|
}
|
||||||
|
// First we insert all elements except the last one
|
||||||
|
// updating only full subtree hashes (all layers where inserted element has odd index)
|
||||||
|
// the last element will update the full path to the root making the tree consistent again
|
||||||
|
for (let i = 0; i < elements.length - 1; i++) {
|
||||||
|
this._layers[0].push(elements[i])
|
||||||
|
let level = 0
|
||||||
|
let index = this._layers[0].length - 1
|
||||||
|
while (index % 2 === 1) {
|
||||||
|
level++
|
||||||
|
index >>= 1
|
||||||
|
const left = this._layers[level - 1][index * 2]
|
||||||
|
const right = this._layers[level - 1][index * 2 + 1]
|
||||||
|
this._layers[level][index] = this._hashFn(left, right)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
this.insert(elements[elements.length - 1])
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Change an element in the tree
|
||||||
|
* @param {number} index Index of element to change
|
||||||
|
* @param element Updated element value
|
||||||
|
*/
|
||||||
|
update(index: number, element: Element) {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index > this._layers[0].length || index >= this.capacity) {
|
||||||
|
throw new Error('Insert index out of bounds: ' + index)
|
||||||
|
}
|
||||||
|
this._layers[0][index] = element
|
||||||
|
this._processUpdate(index)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get merkle path to a leaf
|
||||||
|
* @param {number} index Leaf index to generate path for
|
||||||
|
* @returns {{pathElements: Object[], pathIndex: number[]}} An object containing adjacent elements and left-right index
|
||||||
|
*/
|
||||||
|
path(index: number): ProofPath {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index >= this._layers[0].length) {
|
||||||
|
throw new Error('Index out of bounds: ' + index)
|
||||||
|
}
|
||||||
|
let elIndex = +index
|
||||||
|
const pathElements: Element[] = []
|
||||||
|
const pathIndices: number[] = []
|
||||||
|
const pathPositions: number [] = []
|
||||||
|
for (let level = 0; level < this.levels; level++) {
|
||||||
|
pathIndices[level] = elIndex % 2
|
||||||
|
const leafIndex = elIndex ^ 1
|
||||||
|
if (leafIndex < this._layers[level].length) {
|
||||||
|
pathElements[level] = this._layers[level][leafIndex]
|
||||||
|
pathPositions[level] = leafIndex
|
||||||
|
} else {
|
||||||
|
pathElements[level] = this._zeros[level]
|
||||||
|
pathPositions[level] = 0
|
||||||
|
}
|
||||||
|
elIndex >>= 1
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
pathElements,
|
||||||
|
pathIndices,
|
||||||
|
pathPositions,
|
||||||
|
pathRoot: this.root,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
protected _buildZeros() {
|
||||||
|
this._zeros = [this.zeroElement]
|
||||||
|
for (let i = 1; i <= this.levels; i++) {
|
||||||
|
this._zeros[i] = this._hashFn(this._zeros[i - 1], this._zeros[i - 1])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
protected _processNodes(nodes: Element[], layerIndex: number) {
|
||||||
|
const length = nodes.length
|
||||||
|
let currentLength = Math.ceil(length / 2)
|
||||||
|
const currentLayer = new Array(currentLength)
|
||||||
|
currentLength--
|
||||||
|
const starFrom = length - ((length % 2) ^ 1)
|
||||||
|
let j = 0
|
||||||
|
for (let i = starFrom; i >= 0; i -= 2) {
|
||||||
|
if (nodes[i - 1] === undefined) break
|
||||||
|
const left = nodes[i - 1]
|
||||||
|
const right = (i === starFrom && length % 2 === 1) ? this._zeros[layerIndex - 1] : nodes[i]
|
||||||
|
currentLayer[currentLength - j] = this._hashFn(left, right)
|
||||||
|
j++
|
||||||
|
}
|
||||||
|
return currentLayer
|
||||||
|
}
|
||||||
|
|
||||||
|
protected _processUpdate(index: number) {
|
||||||
|
for (let level = 1; level <= this.levels; level++) {
|
||||||
|
index >>= 1
|
||||||
|
const left = this._layers[level - 1][index * 2]
|
||||||
|
const right = index * 2 + 1 < this._layers[level - 1].length
|
||||||
|
? this._layers[level - 1][index * 2 + 1]
|
||||||
|
: this._zeros[level - 1]
|
||||||
|
this._layers[level][index] = this._hashFn(left, right)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
128
@tornado/fixed-merkle-tree/src/FixedMerkleTree.ts
Normal file
128
@tornado/fixed-merkle-tree/src/FixedMerkleTree.ts
Normal file
@ -0,0 +1,128 @@
|
|||||||
|
import { Element, HashFunction, MerkleTreeOptions, ProofPath, SerializedTreeState, TreeEdge, TreeSlice } from './'
|
||||||
|
import defaultHash from './simpleHash'
|
||||||
|
import { BaseTree } from './BaseTree'
|
||||||
|
|
||||||
|
|
||||||
|
export default class MerkleTree extends BaseTree {
|
||||||
|
constructor(levels: number, elements: Element[] = [], {
|
||||||
|
hashFunction = defaultHash,
|
||||||
|
zeroElement = 0,
|
||||||
|
}: MerkleTreeOptions = {}) {
|
||||||
|
super()
|
||||||
|
this.levels = levels
|
||||||
|
if (elements.length > this.capacity) {
|
||||||
|
throw new Error('Tree is full')
|
||||||
|
}
|
||||||
|
this._hashFn = hashFunction
|
||||||
|
this.zeroElement = zeroElement
|
||||||
|
this._layers = []
|
||||||
|
const leaves = elements.slice()
|
||||||
|
this._layers = [leaves]
|
||||||
|
this._buildZeros()
|
||||||
|
this._buildHashes()
|
||||||
|
}
|
||||||
|
|
||||||
|
private _buildHashes() {
|
||||||
|
for (let layerIndex = 1; layerIndex <= this.levels; layerIndex++) {
|
||||||
|
const nodes = this._layers[layerIndex - 1]
|
||||||
|
this._layers[layerIndex] = this._processNodes(nodes, layerIndex)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Insert multiple elements into the tree.
|
||||||
|
* @param {Array} elements Elements to insert
|
||||||
|
*/
|
||||||
|
bulkInsert(elements: Element[]): void {
|
||||||
|
if (!elements.length) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if (this._layers[0].length + elements.length > this.capacity) {
|
||||||
|
throw new Error('Tree is full')
|
||||||
|
}
|
||||||
|
// First we insert all elements except the last one
|
||||||
|
// updating only full subtree hashes (all layers where inserted element has odd index)
|
||||||
|
// the last element will update the full path to the root making the tree consistent again
|
||||||
|
for (let i = 0; i < elements.length - 1; i++) {
|
||||||
|
this._layers[0].push(elements[i])
|
||||||
|
let level = 0
|
||||||
|
let index = this._layers[0].length - 1
|
||||||
|
while (index % 2 === 1) {
|
||||||
|
level++
|
||||||
|
index >>= 1
|
||||||
|
this._layers[level][index] = this._hashFn(
|
||||||
|
this._layers[level - 1][index * 2],
|
||||||
|
this._layers[level - 1][index * 2 + 1],
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
this.insert(elements[elements.length - 1])
|
||||||
|
}
|
||||||
|
|
||||||
|
indexOf(element: Element, comparator?: <T> (arg0: T, arg1: T) => boolean): number {
|
||||||
|
return BaseTree.indexOf(this._layers[0], element, 0, comparator)
|
||||||
|
}
|
||||||
|
|
||||||
|
proof(element: Element): ProofPath {
|
||||||
|
const index = this.indexOf(element)
|
||||||
|
return this.path(index)
|
||||||
|
}
|
||||||
|
|
||||||
|
getTreeEdge(edgeIndex: number): TreeEdge {
|
||||||
|
const edgeElement = this._layers[0][edgeIndex]
|
||||||
|
if (edgeElement === undefined) {
|
||||||
|
throw new Error('Element not found')
|
||||||
|
}
|
||||||
|
const edgePath = this.path(edgeIndex)
|
||||||
|
return { edgePath, edgeElement, edgeIndex, edgeElementsCount: this._layers[0].length }
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 🪓
|
||||||
|
* @param count
|
||||||
|
*/
|
||||||
|
getTreeSlices(count = 4): TreeSlice[] {
|
||||||
|
const length = this._layers[0].length
|
||||||
|
let size = Math.ceil(length / count)
|
||||||
|
if (size % 2) size++
|
||||||
|
const slices: TreeSlice[] = []
|
||||||
|
for (let i = 0; i < length; i += size) {
|
||||||
|
const edgeLeft = i
|
||||||
|
const edgeRight = i + size
|
||||||
|
slices.push({ edge: this.getTreeEdge(edgeLeft), elements: this.elements.slice(edgeLeft, edgeRight) })
|
||||||
|
}
|
||||||
|
return slices
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Serialize entire tree state including intermediate layers into a plain object
|
||||||
|
* Deserializing it back will not require to recompute any hashes
|
||||||
|
* Elements are not converted to a plain type, this is responsibility of the caller
|
||||||
|
*/
|
||||||
|
serialize(): SerializedTreeState {
|
||||||
|
return {
|
||||||
|
levels: this.levels,
|
||||||
|
_zeros: this._zeros,
|
||||||
|
_layers: this._layers,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Deserialize data into a MerkleTree instance
|
||||||
|
* Make sure to provide the same hashFunction as was used in the source tree,
|
||||||
|
* otherwise the tree state will be invalid
|
||||||
|
*/
|
||||||
|
static deserialize(data: SerializedTreeState, hashFunction?: HashFunction<Element>): MerkleTree {
|
||||||
|
const instance: MerkleTree = Object.assign(Object.create(this.prototype), data)
|
||||||
|
instance._hashFn = hashFunction || defaultHash
|
||||||
|
instance.zeroElement = instance._zeros[0]
|
||||||
|
return instance
|
||||||
|
}
|
||||||
|
|
||||||
|
toString() {
|
||||||
|
return JSON.stringify(this.serialize())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
186
@tornado/fixed-merkle-tree/src/PartialMerkleTree.ts
Normal file
186
@tornado/fixed-merkle-tree/src/PartialMerkleTree.ts
Normal file
@ -0,0 +1,186 @@
|
|||||||
|
import {
|
||||||
|
Element,
|
||||||
|
HashFunction,
|
||||||
|
LeafWithIndex,
|
||||||
|
MerkleTreeOptions,
|
||||||
|
ProofPath,
|
||||||
|
SerializedPartialTreeState,
|
||||||
|
TreeEdge,
|
||||||
|
} from './'
|
||||||
|
import defaultHash from './simpleHash'
|
||||||
|
import { BaseTree } from './BaseTree'
|
||||||
|
|
||||||
|
export class PartialMerkleTree extends BaseTree {
|
||||||
|
private _leaves: Element[]
|
||||||
|
private _leavesAfterEdge: Element[]
|
||||||
|
private _edgeLeaf: LeafWithIndex
|
||||||
|
private _initialRoot: Element
|
||||||
|
private _edgeLeafProof: ProofPath
|
||||||
|
private _proofMap: Map<number, [i: number, el: Element]>
|
||||||
|
|
||||||
|
constructor(levels: number, {
|
||||||
|
edgePath,
|
||||||
|
edgeElement,
|
||||||
|
edgeIndex,
|
||||||
|
edgeElementsCount,
|
||||||
|
}: TreeEdge, leaves: Element[], { hashFunction, zeroElement }: MerkleTreeOptions = {}) {
|
||||||
|
super()
|
||||||
|
if (edgeIndex + leaves.length !== edgeElementsCount) throw new Error('Invalid number of elements')
|
||||||
|
this._edgeLeafProof = edgePath
|
||||||
|
this._initialRoot = edgePath.pathRoot
|
||||||
|
this.zeroElement = zeroElement ?? 0
|
||||||
|
this._edgeLeaf = { data: edgeElement, index: edgeIndex }
|
||||||
|
this._leavesAfterEdge = leaves
|
||||||
|
this.levels = levels
|
||||||
|
this._hashFn = hashFunction || defaultHash
|
||||||
|
this._createProofMap()
|
||||||
|
this._buildTree()
|
||||||
|
}
|
||||||
|
|
||||||
|
get edgeIndex(): number {
|
||||||
|
return this._edgeLeaf.index
|
||||||
|
}
|
||||||
|
|
||||||
|
get edgeElement(): Element {
|
||||||
|
return this._edgeLeaf.data
|
||||||
|
}
|
||||||
|
|
||||||
|
get edgeLeafProof(): ProofPath {
|
||||||
|
return this._edgeLeafProof
|
||||||
|
}
|
||||||
|
|
||||||
|
private _createProofMap() {
|
||||||
|
this._proofMap = this.edgeLeafProof.pathPositions.reduce((p, c, i) => {
|
||||||
|
p.set(i, [c, this.edgeLeafProof.pathElements[i]])
|
||||||
|
return p
|
||||||
|
}, new Map())
|
||||||
|
this._proofMap.set(this.levels, [0, this.edgeLeafProof.pathRoot])
|
||||||
|
}
|
||||||
|
|
||||||
|
private _buildTree(): void {
|
||||||
|
const edgeLeafIndex = this._edgeLeaf.index
|
||||||
|
this._leaves = Array(edgeLeafIndex).concat(this._leavesAfterEdge)
|
||||||
|
if (this._proofMap.has(0)) {
|
||||||
|
const [proofPos, proofEl] = this._proofMap.get(0)
|
||||||
|
this._leaves[proofPos] = proofEl
|
||||||
|
}
|
||||||
|
this._layers = [this._leaves]
|
||||||
|
this._buildZeros()
|
||||||
|
this._buildHashes()
|
||||||
|
}
|
||||||
|
|
||||||
|
private _buildHashes() {
|
||||||
|
for (let layerIndex = 1; layerIndex <= this.levels; layerIndex++) {
|
||||||
|
const nodes = this._layers[layerIndex - 1]
|
||||||
|
const currentLayer = this._processNodes(nodes, layerIndex)
|
||||||
|
if (this._proofMap.has(layerIndex)) {
|
||||||
|
const [proofPos, proofEl] = this._proofMap.get(layerIndex)
|
||||||
|
if (!currentLayer[proofPos]) currentLayer[proofPos] = proofEl
|
||||||
|
}
|
||||||
|
this._layers[layerIndex] = currentLayer
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Change an element in the tree
|
||||||
|
* @param {number} index Index of element to change
|
||||||
|
* @param element Updated element value
|
||||||
|
*/
|
||||||
|
update(index: number, element: Element) {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index > this._layers[0].length || index >= this.capacity) {
|
||||||
|
throw new Error('Insert index out of bounds: ' + index)
|
||||||
|
}
|
||||||
|
if (index < this._edgeLeaf.index) {
|
||||||
|
throw new Error(`Index ${index} is below the edge: ${this._edgeLeaf.index}`)
|
||||||
|
}
|
||||||
|
this._layers[0][index] = element
|
||||||
|
this._processUpdate(index)
|
||||||
|
}
|
||||||
|
|
||||||
|
path(index: number): ProofPath {
|
||||||
|
if (isNaN(Number(index)) || index < 0 || index >= this._layers[0].length) {
|
||||||
|
throw new Error('Index out of bounds: ' + index)
|
||||||
|
}
|
||||||
|
if (index < this._edgeLeaf.index) {
|
||||||
|
throw new Error(`Index ${index} is below the edge: ${this._edgeLeaf.index}`)
|
||||||
|
}
|
||||||
|
let elIndex = Number(index)
|
||||||
|
const pathElements: Element[] = []
|
||||||
|
const pathIndices: number[] = []
|
||||||
|
const pathPositions: number [] = []
|
||||||
|
for (let level = 0; level < this.levels; level++) {
|
||||||
|
pathIndices[level] = elIndex % 2
|
||||||
|
const leafIndex = elIndex ^ 1
|
||||||
|
if (leafIndex < this._layers[level].length) {
|
||||||
|
pathElements[level] = this._layers[level][leafIndex]
|
||||||
|
pathPositions[level] = leafIndex
|
||||||
|
} else {
|
||||||
|
pathElements[level] = this._zeros[level]
|
||||||
|
pathPositions[level] = 0
|
||||||
|
}
|
||||||
|
const [proofPos, proofEl] = this._proofMap.get(level)
|
||||||
|
pathElements[level] = pathElements[level] ?? (proofPos === leafIndex ? proofEl : this._zeros[level])
|
||||||
|
elIndex >>= 1
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
pathElements,
|
||||||
|
pathIndices,
|
||||||
|
pathPositions,
|
||||||
|
pathRoot: this.root,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
indexOf(element: Element, comparator?: <T> (arg0: T, arg1: T) => boolean): number {
|
||||||
|
return BaseTree.indexOf(this._layers[0], element, this.edgeIndex, comparator)
|
||||||
|
}
|
||||||
|
|
||||||
|
proof(element: Element): ProofPath {
|
||||||
|
const index = this.indexOf(element)
|
||||||
|
return this.path(index)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Shifts edge of tree to left
|
||||||
|
* @param edge new TreeEdge below current edge
|
||||||
|
* @param elements leaves between old and new edge
|
||||||
|
*/
|
||||||
|
|
||||||
|
shiftEdge(edge: TreeEdge, elements: Element[]) {
|
||||||
|
if (this._edgeLeaf.index <= edge.edgeIndex) {
|
||||||
|
throw new Error(`New edgeIndex should be smaller then ${this._edgeLeaf.index}`)
|
||||||
|
}
|
||||||
|
if (elements.length !== (this._edgeLeaf.index - edge.edgeIndex)) {
|
||||||
|
throw new Error(`Elements length should be ${this._edgeLeaf.index - edge.edgeIndex}`)
|
||||||
|
}
|
||||||
|
this._edgeLeafProof = edge.edgePath
|
||||||
|
this._edgeLeaf = { index: edge.edgeIndex, data: edge.edgeElement }
|
||||||
|
this._leavesAfterEdge = [...elements, ...this._leavesAfterEdge]
|
||||||
|
this._createProofMap()
|
||||||
|
this._buildTree()
|
||||||
|
}
|
||||||
|
|
||||||
|
serialize(): SerializedPartialTreeState {
|
||||||
|
return {
|
||||||
|
_edgeLeafProof: this._edgeLeafProof,
|
||||||
|
_edgeLeaf: this._edgeLeaf,
|
||||||
|
_layers: this._layers,
|
||||||
|
_zeros: this._zeros,
|
||||||
|
levels: this.levels,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static deserialize(data: SerializedPartialTreeState, hashFunction?: HashFunction<Element>): PartialMerkleTree {
|
||||||
|
const instance: PartialMerkleTree = Object.assign(Object.create(this.prototype), data)
|
||||||
|
instance._hashFn = hashFunction || defaultHash
|
||||||
|
instance._initialRoot = data._edgeLeafProof.pathRoot
|
||||||
|
instance.zeroElement = instance._zeros[0]
|
||||||
|
instance._leavesAfterEdge = instance._layers[0].slice(data._edgeLeaf.index)
|
||||||
|
instance._createProofMap()
|
||||||
|
return instance
|
||||||
|
}
|
||||||
|
|
||||||
|
toString() {
|
||||||
|
return JSON.stringify(this.serialize())
|
||||||
|
}
|
||||||
|
}
|
||||||
46
@tornado/fixed-merkle-tree/src/index.ts
Normal file
46
@tornado/fixed-merkle-tree/src/index.ts
Normal file
@ -0,0 +1,46 @@
|
|||||||
|
import { default as MerkleTree } from './FixedMerkleTree'
|
||||||
|
export { PartialMerkleTree } from './PartialMerkleTree'
|
||||||
|
export { simpleHash } from './simpleHash'
|
||||||
|
export { MerkleTree }
|
||||||
|
export default MerkleTree
|
||||||
|
export type HashFunction<T> = {
|
||||||
|
(left: T, right: T): string
|
||||||
|
}
|
||||||
|
|
||||||
|
export type MerkleTreeOptions = {
|
||||||
|
hashFunction?: HashFunction<Element>
|
||||||
|
zeroElement?: Element
|
||||||
|
}
|
||||||
|
|
||||||
|
export type Element = string | number
|
||||||
|
|
||||||
|
export type SerializedTreeState = {
|
||||||
|
levels: number,
|
||||||
|
_zeros: Array<Element>,
|
||||||
|
_layers: Array<Element[]>
|
||||||
|
}
|
||||||
|
|
||||||
|
export type SerializedPartialTreeState = {
|
||||||
|
levels: number
|
||||||
|
_layers: Element[][]
|
||||||
|
_zeros: Array<Element>
|
||||||
|
_edgeLeafProof: ProofPath
|
||||||
|
_edgeLeaf: LeafWithIndex
|
||||||
|
}
|
||||||
|
|
||||||
|
export type ProofPath = {
|
||||||
|
pathElements: Element[],
|
||||||
|
pathIndices: number[],
|
||||||
|
pathPositions: number[],
|
||||||
|
pathRoot: Element
|
||||||
|
}
|
||||||
|
export type TreeEdge = {
|
||||||
|
edgeElement: Element;
|
||||||
|
edgePath: ProofPath;
|
||||||
|
edgeIndex: number;
|
||||||
|
edgeElementsCount: number;
|
||||||
|
}
|
||||||
|
|
||||||
|
export type TreeSlice = { edge: TreeEdge, elements: Element[] }
|
||||||
|
export type LeafWithIndex = { index: number, data: Element }
|
||||||
|
|
||||||
@ -1,212 +0,0 @@
|
|||||||
// keccak256("tornado") % BN254_FIELD_SIZE
|
|
||||||
const DEFAULT_ZERO = '21663839004416932945382355908790599225266501822907911457504978515578255421292'
|
|
||||||
const defaultHash = require('./mimc')
|
|
||||||
|
|
||||||
// todo ensure consistent types in tree and inserted elements?
|
|
||||||
// todo make sha3 default hasher (and update tests) to get rid of mimc/snarkjs/circomlib dependency
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @callback hashFunction
|
|
||||||
* @param left Left leaf
|
|
||||||
* @param right Right leaf
|
|
||||||
*/
|
|
||||||
/**
|
|
||||||
* Merkle tree
|
|
||||||
*/
|
|
||||||
class MerkleTree {
|
|
||||||
/**
|
|
||||||
* Constructor
|
|
||||||
* @param {number} levels Number of levels in the tree
|
|
||||||
* @param {Array} [elements] Initial elements
|
|
||||||
* @param {Object} options
|
|
||||||
* @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
|
|
||||||
* @param [options.zeroElement] Value for non-existent leaves
|
|
||||||
*/
|
|
||||||
constructor(levels, elements = [], { hashFunction, zeroElement = DEFAULT_ZERO } = {}) {
|
|
||||||
this.levels = levels
|
|
||||||
this.capacity = 2 ** levels
|
|
||||||
if (elements.length > this.capacity) {
|
|
||||||
throw new Error('Tree is full')
|
|
||||||
}
|
|
||||||
this._hash = hashFunction || defaultHash
|
|
||||||
this.zeroElement = zeroElement
|
|
||||||
this._zeros = []
|
|
||||||
this._zeros[0] = zeroElement
|
|
||||||
for (let i = 1; i <= levels; i++) {
|
|
||||||
this._zeros[i] = this._hash(this._zeros[i - 1], this._zeros[i - 1])
|
|
||||||
}
|
|
||||||
this._layers = []
|
|
||||||
this._layers[0] = elements.slice()
|
|
||||||
this._rebuild()
|
|
||||||
}
|
|
||||||
|
|
||||||
_rebuild() {
|
|
||||||
for (let level = 1; level <= this.levels; level++) {
|
|
||||||
this._layers[level] = []
|
|
||||||
for (let i = 0; i < Math.ceil(this._layers[level - 1].length / 2); i++) {
|
|
||||||
this._layers[level][i] = this._hash(
|
|
||||||
this._layers[level - 1][i * 2],
|
|
||||||
i * 2 + 1 < this._layers[level - 1].length
|
|
||||||
? this._layers[level - 1][i * 2 + 1]
|
|
||||||
: this._zeros[level - 1],
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Get tree root
|
|
||||||
* @returns {*}
|
|
||||||
*/
|
|
||||||
root() {
|
|
||||||
return this._layers[this.levels].length > 0 ? this._layers[this.levels][0] : this._zeros[this.levels]
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Insert new element into the tree
|
|
||||||
* @param element Element to insert
|
|
||||||
*/
|
|
||||||
insert(element) {
|
|
||||||
if (this._layers[0].length >= this.capacity) {
|
|
||||||
throw new Error('Tree is full')
|
|
||||||
}
|
|
||||||
this.update(this._layers[0].length, element)
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Insert multiple elements into the tree.
|
|
||||||
* @param {Array} elements Elements to insert
|
|
||||||
*/
|
|
||||||
bulkInsert(elements) {
|
|
||||||
if (!elements.length) {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if (this._layers[0].length + elements.length > this.capacity) {
|
|
||||||
throw new Error('Tree is full')
|
|
||||||
}
|
|
||||||
// First we insert all elements except the last one
|
|
||||||
// updating only full subtree hashes (all layers where inserted element has odd index)
|
|
||||||
// the last element will update the full path to the root making the tree consistent again
|
|
||||||
for (let i = 0; i < elements.length - 1; i++) {
|
|
||||||
this._layers[0].push(elements[i])
|
|
||||||
let level = 0
|
|
||||||
let index = this._layers[0].length - 1
|
|
||||||
while (index % 2 === 1) {
|
|
||||||
level++
|
|
||||||
index >>= 1
|
|
||||||
this._layers[level][index] = this._hash(
|
|
||||||
this._layers[level - 1][index * 2],
|
|
||||||
this._layers[level - 1][index * 2 + 1],
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
this.insert(elements[elements.length - 1])
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Change an element in the tree
|
|
||||||
* @param {number} index Index of element to change
|
|
||||||
* @param element Updated element value
|
|
||||||
*/
|
|
||||||
update(index, element) {
|
|
||||||
if (isNaN(Number(index)) || index < 0 || index > this._layers[0].length || index >= this.capacity) {
|
|
||||||
throw new Error('Insert index out of bounds: ' + index)
|
|
||||||
}
|
|
||||||
this._layers[0][index] = element
|
|
||||||
for (let level = 1; level <= this.levels; level++) {
|
|
||||||
index >>= 1
|
|
||||||
this._layers[level][index] = this._hash(
|
|
||||||
this._layers[level - 1][index * 2],
|
|
||||||
index * 2 + 1 < this._layers[level - 1].length
|
|
||||||
? this._layers[level - 1][index * 2 + 1]
|
|
||||||
: this._zeros[level - 1],
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Get merkle path to a leaf
|
|
||||||
* @param {number} index Leaf index to generate path for
|
|
||||||
* @returns {{pathElements: Object[], pathIndex: number[]}} An object containing adjacent elements and left-right index
|
|
||||||
*/
|
|
||||||
path(index) {
|
|
||||||
if (isNaN(Number(index)) || index < 0 || index >= this._layers[0].length) {
|
|
||||||
throw new Error('Index out of bounds: ' + index)
|
|
||||||
}
|
|
||||||
const pathElements = []
|
|
||||||
const pathIndices = []
|
|
||||||
for (let level = 0; level < this.levels; level++) {
|
|
||||||
pathIndices[level] = index % 2
|
|
||||||
pathElements[level] =
|
|
||||||
(index ^ 1) < this._layers[level].length ? this._layers[level][index ^ 1] : this._zeros[level]
|
|
||||||
index >>= 1
|
|
||||||
}
|
|
||||||
return {
|
|
||||||
pathElements,
|
|
||||||
pathIndices,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Find an element in the tree
|
|
||||||
* @param element An element to find
|
|
||||||
* @param comparator A function that checks leaf value equality
|
|
||||||
* @returns {number} Index if element is found, otherwise -1
|
|
||||||
*/
|
|
||||||
indexOf(element, comparator) {
|
|
||||||
if (comparator) {
|
|
||||||
return this._layers[0].findIndex((el) => comparator(element, el))
|
|
||||||
} else {
|
|
||||||
return this._layers[0].indexOf(element)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a copy of non-zero tree elements
|
|
||||||
* @returns {Object[]}
|
|
||||||
*/
|
|
||||||
elements() {
|
|
||||||
return this._layers[0].slice()
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a copy of n-th zero elements array
|
|
||||||
* @returns {Object[]}
|
|
||||||
*/
|
|
||||||
zeros() {
|
|
||||||
return this._zeros.slice()
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Serialize entire tree state including intermediate layers into a plain object
|
|
||||||
* Deserializing it back will not require to recompute any hashes
|
|
||||||
* Elements are not converted to a plain type, this is responsibility of the caller
|
|
||||||
*/
|
|
||||||
serialize() {
|
|
||||||
return {
|
|
||||||
levels: this.levels,
|
|
||||||
_zeros: this._zeros,
|
|
||||||
_layers: this._layers,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Deserialize data into a MerkleTree instance
|
|
||||||
* Make sure to provide the same hashFunction as was used in the source tree,
|
|
||||||
* otherwise the tree state will be invalid
|
|
||||||
*
|
|
||||||
* @param data
|
|
||||||
* @param hashFunction
|
|
||||||
* @returns {MerkleTree}
|
|
||||||
*/
|
|
||||||
static deserialize(data, hashFunction) {
|
|
||||||
const instance = Object.assign(Object.create(this.prototype), data)
|
|
||||||
instance._hash = hashFunction || defaultHash
|
|
||||||
instance.capacity = 2 ** instance.levels
|
|
||||||
instance.zeroElement = instance._zeros[0]
|
|
||||||
return instance
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
module.exports = MerkleTree
|
|
||||||
@ -1,3 +0,0 @@
|
|||||||
const { mimcsponge } = require('@tornado/circomlib')
|
|
||||||
const { bigInt } = require('@tornado/snarkjs')
|
|
||||||
module.exports = (left, right) => mimcsponge.multiHash([bigInt(left), bigInt(right)]).toString()
|
|
||||||
22
@tornado/fixed-merkle-tree/src/simpleHash.ts
Normal file
22
@tornado/fixed-merkle-tree/src/simpleHash.ts
Normal file
@ -0,0 +1,22 @@
|
|||||||
|
import { Element } from './'
|
||||||
|
|
||||||
|
/***
|
||||||
|
* This is insecure hash function, just for example only
|
||||||
|
* @param data
|
||||||
|
* @param seed
|
||||||
|
* @param hashLength
|
||||||
|
*/
|
||||||
|
|
||||||
|
export function simpleHash<T>(data: T[], seed?: number, hashLength = 40): string {
|
||||||
|
const str = data.join('')
|
||||||
|
let i, l,
|
||||||
|
hval = seed ?? 0x811c9dcc5
|
||||||
|
for (i = 0, l = str.length; i < l; i++) {
|
||||||
|
hval ^= str.charCodeAt(i)
|
||||||
|
hval += (hval << 1) + (hval << 4) + (hval << 6) + (hval << 8) + (hval << 24)
|
||||||
|
}
|
||||||
|
const hash = (hval >>> 0).toString(16)
|
||||||
|
return BigInt('0x' + hash.padEnd(hashLength - (hash.length - 1), '0')).toString(10)
|
||||||
|
}
|
||||||
|
|
||||||
|
export default (left: Element, right: Element): string => simpleHash([left, right])
|
||||||
428
@tornado/fixed-merkle-tree/test/fixedMerkleTree.spec.ts
Normal file
428
@tornado/fixed-merkle-tree/test/fixedMerkleTree.spec.ts
Normal file
@ -0,0 +1,428 @@
|
|||||||
|
import { MerkleTree, PartialMerkleTree, TreeEdge } from '../src'
|
||||||
|
import { assert, should } from 'chai'
|
||||||
|
import { createHash } from 'crypto'
|
||||||
|
import { it } from 'mocha'
|
||||||
|
|
||||||
|
const sha256Hash = (left, right) => createHash('sha256').update(`${left}${right}`).digest('hex')
|
||||||
|
const ZERO_ELEMENT = '21663839004416932945382355908790599225266501822907911457504978515578255421292'
|
||||||
|
|
||||||
|
describe('MerkleTree', () => {
|
||||||
|
|
||||||
|
describe('#constructor', () => {
|
||||||
|
|
||||||
|
it('should have correct zero root', () => {
|
||||||
|
const tree = new MerkleTree(10, [])
|
||||||
|
return should().equal(tree.root, '3060353338620102847451617558650138132480')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should have correct 1 element root', () => {
|
||||||
|
const tree = new MerkleTree(10, [1])
|
||||||
|
should().equal(tree.root, '4059654748770657324723044385589999697920')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should have correct even elements root', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2])
|
||||||
|
should().equal(tree.root, '3715471817149864798706576217905179918336')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should have correct odd elements root', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3])
|
||||||
|
should().equal(tree.root, '5199180210167621115778229238102210117632')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should be able to create a full tree', () => {
|
||||||
|
new MerkleTree(2, [1, 2, 3, 4])
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to create tree with too many elements', () => {
|
||||||
|
const call = () => new MerkleTree(2, [1, 2, 3, 4, 5])
|
||||||
|
should().throw(call, 'Tree is full')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should work with optional hash function and zero element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5, 6], { hashFunction: sha256Hash, zeroElement: 'zero' })
|
||||||
|
should().equal(tree.root, 'a377b9fa0ed41add83e56f7e1d0e2ebdb46550b9d8b26b77dece60cb67283f19')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#insert', () => {
|
||||||
|
it('should insert into empty tree', () => {
|
||||||
|
const tree = new MerkleTree(10)
|
||||||
|
tree.insert(42)
|
||||||
|
should().equal(tree.root, '750572848877730275626358141391262973952')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should insert into odd tree', () => {
|
||||||
|
const tree = new MerkleTree(10, [1])
|
||||||
|
tree.insert(42)
|
||||||
|
should().equal(tree.root, '5008383558940708447763798816817296703488')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should insert into even tree', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2])
|
||||||
|
tree.insert(42)
|
||||||
|
should().equal(tree.root, '5005864318873356880627322373636156817408')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should insert last element', () => {
|
||||||
|
const tree = new MerkleTree(2, [1, 2, 3])
|
||||||
|
tree.insert(4)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to insert when tree is full', () => {
|
||||||
|
const tree = new MerkleTree(2, [1, 2, 3, 4])
|
||||||
|
const call = () => tree.insert(5)
|
||||||
|
should().throw(call, 'Tree is full')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#bulkInsert', () => {
|
||||||
|
it('should work', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3])
|
||||||
|
tree.bulkInsert([4, 5, 6])
|
||||||
|
should().equal(tree.root, '4066635800770511602067209448381558554624')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should give the same result as sequential inserts', () => {
|
||||||
|
const initialArray = [
|
||||||
|
[1],
|
||||||
|
[1, 2],
|
||||||
|
[1, 2, 3],
|
||||||
|
[1, 2, 3, 4],
|
||||||
|
]
|
||||||
|
const insertedArray = [
|
||||||
|
[11],
|
||||||
|
[11, 12],
|
||||||
|
[11, 12, 13],
|
||||||
|
[11, 12, 13, 14],
|
||||||
|
]
|
||||||
|
for (const initial of initialArray) {
|
||||||
|
for (const inserted of insertedArray) {
|
||||||
|
const tree1 = new MerkleTree(10, initial)
|
||||||
|
const tree2 = new MerkleTree(10, initial)
|
||||||
|
tree1.bulkInsert(inserted)
|
||||||
|
for (const item of inserted) {
|
||||||
|
tree2.insert(item)
|
||||||
|
}
|
||||||
|
should().equal(tree1.root, tree2.root)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should work with max elements', () => {
|
||||||
|
const tree = new MerkleTree(2, [1, 2])
|
||||||
|
tree.bulkInsert([3, 4])
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to insert too many elements', () => {
|
||||||
|
const tree = new MerkleTree(2, [1, 2])
|
||||||
|
const call = () => tree.bulkInsert([3, 4, 5])
|
||||||
|
should().throw(call, 'Tree is full')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should bypass empty elements', () => {
|
||||||
|
const elements = [1, 2, 3, 4]
|
||||||
|
const tree = new MerkleTree(2, elements)
|
||||||
|
tree.bulkInsert([])
|
||||||
|
assert.deepEqual(tree.elements, elements, 'No elements inserted')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#update', () => {
|
||||||
|
it('should update first element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
tree.update(0, 42)
|
||||||
|
should().equal(tree.root, '3884161948856565981263417078389340635136')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should update last element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
tree.update(4, 42)
|
||||||
|
should().equal(tree.root, '3564959811529894228734180300843252711424')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should update odd element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
tree.update(1, 42)
|
||||||
|
should().equal(tree.root, '4576704573778433422699674477203122290688')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should update even element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
tree.update(2, 42)
|
||||||
|
should().equal(tree.root, '1807994110952186123819489133812038762496')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should update extra element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4])
|
||||||
|
tree.update(4, 5)
|
||||||
|
should().equal(tree.root, '1099080610107164849381389194938128793600')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to update incorrect index', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
should().throw((() => tree.update(-1, 42)), 'Insert index out of bounds: -1')
|
||||||
|
should().throw((() => tree.update(6, 42)), 'Insert index out of bounds: 6')
|
||||||
|
// @ts-ignore
|
||||||
|
should().throw((() => tree.update('qwe', 42)), 'Insert index out of bounds: qwe')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to update over capacity', () => {
|
||||||
|
const tree = new MerkleTree(2, [1, 2, 3, 4])
|
||||||
|
const call = () => tree.update(4, 42)
|
||||||
|
should().throw(call, 'Insert index out of bounds: 4')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#indexOf', () => {
|
||||||
|
it('should find index', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
should().equal(tree.indexOf(3), 2)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should work with comparator', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
should().equal(tree.indexOf(4, (arg0, arg1) => arg0 === arg1), 3)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return -1 for non existent element', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
should().equal(tree.indexOf(42), -1)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#path', () => {
|
||||||
|
it('should work for even index', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
const path = tree.path(2)
|
||||||
|
assert.deepEqual(path.pathIndices, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0])
|
||||||
|
assert.deepEqual(path.pathElements, [
|
||||||
|
4,
|
||||||
|
'4027992409016347597424110157229339967488',
|
||||||
|
'3591172241203040147397382471352592629760',
|
||||||
|
'938972308169430750202858820582946897920',
|
||||||
|
'3743880566844110745576746962917825445888',
|
||||||
|
'2074434463882483178614385966084599578624',
|
||||||
|
'2808856778596740691845240322870189490176',
|
||||||
|
'4986731814143931240516913804278285467648',
|
||||||
|
'1918547053077726613961101558405545328640',
|
||||||
|
'5444383861051812288142814494928935059456',
|
||||||
|
|
||||||
|
])
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should work for odd index', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
const path = tree.path(3)
|
||||||
|
assert.deepEqual(path.pathIndices, [1, 1, 0, 0, 0, 0, 0, 0, 0, 0])
|
||||||
|
assert.deepEqual(path.pathElements, [
|
||||||
|
3,
|
||||||
|
'4027992409016347597424110157229339967488',
|
||||||
|
'3591172241203040147397382471352592629760',
|
||||||
|
'938972308169430750202858820582946897920',
|
||||||
|
'3743880566844110745576746962917825445888',
|
||||||
|
'2074434463882483178614385966084599578624',
|
||||||
|
'2808856778596740691845240322870189490176',
|
||||||
|
'4986731814143931240516913804278285467648',
|
||||||
|
'1918547053077726613961101558405545328640',
|
||||||
|
'5444383861051812288142814494928935059456',
|
||||||
|
])
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail on incorrect index', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4])
|
||||||
|
should().throw((() => tree.path(-1)), 'Index out of bounds: -1')
|
||||||
|
should().throw((() => tree.path(5)), 'Index out of bounds: 5')
|
||||||
|
// @ts-ignore
|
||||||
|
should().throw((() => tree.path('qwe')), 'Index out of bounds: qwe')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should work for correct string index', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
// @ts-ignore
|
||||||
|
const path = tree.path('2')
|
||||||
|
assert.deepEqual(path.pathIndices, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0])
|
||||||
|
assert.deepEqual(path.pathElements, [
|
||||||
|
4,
|
||||||
|
'4027992409016347597424110157229339967488',
|
||||||
|
'3591172241203040147397382471352592629760',
|
||||||
|
'938972308169430750202858820582946897920',
|
||||||
|
'3743880566844110745576746962917825445888',
|
||||||
|
'2074434463882483178614385966084599578624',
|
||||||
|
'2808856778596740691845240322870189490176',
|
||||||
|
'4986731814143931240516913804278285467648',
|
||||||
|
'1918547053077726613961101558405545328640',
|
||||||
|
'5444383861051812288142814494928935059456',
|
||||||
|
|
||||||
|
])
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#proof', () => {
|
||||||
|
it('should return proof for leaf', () => {
|
||||||
|
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
|
||||||
|
assert.deepEqual(tree.proof(4), tree.path(3))
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#getTreeEdge', () => {
|
||||||
|
it('should return correct treeEdge', () => {
|
||||||
|
const expectedEdge: TreeEdge = {
|
||||||
|
edgePath: {
|
||||||
|
pathElements: [
|
||||||
|
5,
|
||||||
|
'1390935134112885103361924701261056180224',
|
||||||
|
'1952916572242076545231119328171167580160',
|
||||||
|
'938972308169430750202858820582946897920',
|
||||||
|
],
|
||||||
|
pathIndices: [0, 0, 1, 0],
|
||||||
|
pathPositions: [5, 0, 0, 0],
|
||||||
|
pathRoot: '3283298202329284319899364273680487022592',
|
||||||
|
},
|
||||||
|
edgeElement: 4,
|
||||||
|
edgeIndex: 4,
|
||||||
|
edgeElementsCount: 6,
|
||||||
|
}
|
||||||
|
const tree = new MerkleTree(4, [0, 1, 2, 3, 4, 5])
|
||||||
|
assert.deepEqual(tree.getTreeEdge(4), expectedEdge)
|
||||||
|
})
|
||||||
|
it('should fail if element not found', () => {
|
||||||
|
const tree = new MerkleTree(4, [0, 1, 2, 3, 4, 5])
|
||||||
|
const call = () => tree.getTreeEdge(6)
|
||||||
|
should().throw(call, 'Element not found')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#getTreeSlices', () => {
|
||||||
|
let fullTree: MerkleTree
|
||||||
|
before(async () => {
|
||||||
|
const elements = Array.from({ length: 2 ** 10 }, (_, i) => i)
|
||||||
|
fullTree = new MerkleTree(10, elements)
|
||||||
|
return Promise.resolve()
|
||||||
|
})
|
||||||
|
it('should return correct slices count', () => {
|
||||||
|
const count = 4
|
||||||
|
const slicesCount = fullTree.getTreeSlices(4).length
|
||||||
|
should().equal(count, slicesCount)
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should be able to create partial tree from last slice', () => {
|
||||||
|
const [, , , lastSlice] = fullTree.getTreeSlices()
|
||||||
|
const partialTree = new PartialMerkleTree(10, lastSlice.edge, lastSlice.elements)
|
||||||
|
assert.deepEqual(fullTree.root, partialTree.root)
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should be able to build full tree from slices', () => {
|
||||||
|
const slices = fullTree.getTreeSlices()
|
||||||
|
const lastSlice = slices.pop()
|
||||||
|
const partialTree = new PartialMerkleTree(10, lastSlice.edge, lastSlice.elements)
|
||||||
|
slices.reverse().forEach(({ edge, elements }) => {
|
||||||
|
partialTree.shiftEdge(edge, elements)
|
||||||
|
})
|
||||||
|
assert.deepEqual(fullTree.layers, partialTree.layers)
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should return same path', () => {
|
||||||
|
const slices = fullTree.getTreeSlices()
|
||||||
|
const lastSlice = slices.pop()
|
||||||
|
const partialTree = new PartialMerkleTree(10, lastSlice.edge, lastSlice.elements)
|
||||||
|
slices.reverse().forEach(({ edge, elements }) => {
|
||||||
|
partialTree.shiftEdge(edge, elements)
|
||||||
|
})
|
||||||
|
assert.deepEqual(fullTree.path(100), partialTree.path(100))
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should throw if invalid number of elements', () => {
|
||||||
|
const [firstSlice] = fullTree.getTreeSlices()
|
||||||
|
const call = () => new PartialMerkleTree(10, firstSlice.edge, firstSlice.elements)
|
||||||
|
should().throw(call, 'Invalid number of elements')
|
||||||
|
}).timeout(10000)
|
||||||
|
})
|
||||||
|
describe('#getters', () => {
|
||||||
|
const elements = [1, 2, 3, 4, 5]
|
||||||
|
const layers = [
|
||||||
|
[1, 2, 3, 4, 5],
|
||||||
|
[
|
||||||
|
'4027992409016347597424110157229339967488',
|
||||||
|
'923221781152860005594997320673730232320',
|
||||||
|
'752191049236692618445397735417537626112',
|
||||||
|
|
||||||
|
],
|
||||||
|
[
|
||||||
|
'81822854828781486047086122479545722339328',
|
||||||
|
'3591172241203040147397382471352592629760',
|
||||||
|
|
||||||
|
],
|
||||||
|
['2729943778107054496417267081388406865920'],
|
||||||
|
['4562739390655416913642128116127918718976'],
|
||||||
|
]
|
||||||
|
|
||||||
|
it('should return same elements in array', () => {
|
||||||
|
const tree = new MerkleTree(10, elements)
|
||||||
|
assert.deepEqual(tree.elements, elements)
|
||||||
|
})
|
||||||
|
it('should return copy of elements array', () => {
|
||||||
|
const tree = new MerkleTree(10, elements)
|
||||||
|
const elements1 = tree.elements
|
||||||
|
tree.insert(6)
|
||||||
|
const elements2 = tree.elements
|
||||||
|
should().not.equal(elements1, elements2)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return same layers in array', () => {
|
||||||
|
const tree = new MerkleTree(4, elements)
|
||||||
|
assert.deepEqual(tree.layers, layers)
|
||||||
|
})
|
||||||
|
it('should return copy of elements array', () => {
|
||||||
|
const tree = new MerkleTree(4, elements)
|
||||||
|
const layers1 = tree.layers
|
||||||
|
tree.insert(6)
|
||||||
|
const layers2 = tree.layers
|
||||||
|
should().not.equal(layers1, layers2)
|
||||||
|
})
|
||||||
|
it('should return correct zeros array', () => {
|
||||||
|
const zeros = [
|
||||||
|
0,
|
||||||
|
'1390935134112885103361924701261056180224',
|
||||||
|
'3223901263414086620636498663535535980544',
|
||||||
|
'938972308169430750202858820582946897920',
|
||||||
|
'3743880566844110745576746962917825445888',
|
||||||
|
]
|
||||||
|
const tree = new MerkleTree(4, [])
|
||||||
|
assert.deepEqual(tree.zeros, zeros, 'Not equal')
|
||||||
|
})
|
||||||
|
it('should return copy of zeros array', () => {
|
||||||
|
const tree = new MerkleTree(4, [])
|
||||||
|
const zeros1 = tree.zeros
|
||||||
|
tree.insert(6)
|
||||||
|
const zeros2 = tree.zeros
|
||||||
|
should().not.equal(zeros1, zeros2)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#serialize', () => {
|
||||||
|
it('should work', () => {
|
||||||
|
const src = new MerkleTree(10, [1, 2, 3, 4, 5, 6, 7, 8, 9])
|
||||||
|
const data = src.serialize()
|
||||||
|
const dst = MerkleTree.deserialize(data)
|
||||||
|
should().equal(src.root, dst.root)
|
||||||
|
|
||||||
|
src.insert(10)
|
||||||
|
dst.insert(10)
|
||||||
|
|
||||||
|
should().equal(src.root, dst.root)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#toString', () => {
|
||||||
|
it('should return correct stringified representation', () => {
|
||||||
|
const src = new MerkleTree(10, [1, 2, 3, 4, 5, 6, 7, 8, 9])
|
||||||
|
const str = src.toString()
|
||||||
|
const dst = MerkleTree.deserialize(JSON.parse(str))
|
||||||
|
should().equal(src.root, dst.root)
|
||||||
|
|
||||||
|
src.insert(10)
|
||||||
|
dst.insert(10)
|
||||||
|
|
||||||
|
should().equal(src.root, dst.root)
|
||||||
|
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
297
@tornado/fixed-merkle-tree/test/partialMerkleTree.spec.ts
Normal file
297
@tornado/fixed-merkle-tree/test/partialMerkleTree.spec.ts
Normal file
@ -0,0 +1,297 @@
|
|||||||
|
import { Element, MerkleTree, MerkleTreeOptions, PartialMerkleTree } from '../src'
|
||||||
|
import { it } from 'mocha'
|
||||||
|
import { should } from 'chai'
|
||||||
|
import * as assert from 'assert'
|
||||||
|
import { createHash } from 'crypto'
|
||||||
|
|
||||||
|
const sha256Hash = (left, right) => createHash('sha256').update(`${left}${right}`).digest('hex')
|
||||||
|
|
||||||
|
describe('PartialMerkleTree', () => {
|
||||||
|
const getTestTrees = (levels: number, elements: Element[], edgeIndex: number, treeOptions: MerkleTreeOptions = {}) => {
|
||||||
|
const fullTree = new MerkleTree(levels, elements, treeOptions)
|
||||||
|
const edge = fullTree.getTreeEdge(edgeIndex)
|
||||||
|
const leavesAfterEdge = elements.slice(edge.edgeIndex)
|
||||||
|
const partialTree = new PartialMerkleTree(levels, edge, leavesAfterEdge, treeOptions)
|
||||||
|
return { fullTree, partialTree }
|
||||||
|
}
|
||||||
|
describe('#constructor', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(20, ['0', '1', '2', '3', '4', '5'], 2)
|
||||||
|
it('should initialize merkle tree with same root', () => {
|
||||||
|
should().equal(fullTree.root, partialTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should initialize merkle tree with same leaves count', () => {
|
||||||
|
should().equal(fullTree.elements.length, partialTree.elements.length)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should work with optional hash function and zero element', () => {
|
||||||
|
const { partialTree, fullTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6], 3, {
|
||||||
|
hashFunction: sha256Hash,
|
||||||
|
zeroElement: 'zero',
|
||||||
|
})
|
||||||
|
should().equal(partialTree.root, fullTree.root)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#insert', () => {
|
||||||
|
|
||||||
|
it('should have equal root to full tree after insertion ', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, ['0', '1', '2', '3', '4', '5', '6', '7'], 5)
|
||||||
|
fullTree.insert('9')
|
||||||
|
partialTree.insert('9')
|
||||||
|
should().equal(fullTree.root, partialTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to insert when tree is full', () => {
|
||||||
|
const { partialTree } = getTestTrees(3, ['0', '1', '2', '3', '4', '5', '6', '7'], 5)
|
||||||
|
const call = () => partialTree.insert('8')
|
||||||
|
should().throw(call, 'Tree is full')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#bulkInsert', () => {
|
||||||
|
|
||||||
|
it('should work like full tree', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(20, [1, 2, 3, 4, 5], 2)
|
||||||
|
partialTree.bulkInsert([6, 7, 8])
|
||||||
|
fullTree.bulkInsert([6, 7, 8])
|
||||||
|
should().equal(fullTree.root, partialTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should give the same result as sequential inserts', () => {
|
||||||
|
const initialArray = [
|
||||||
|
[1],
|
||||||
|
[1, 2],
|
||||||
|
[1, 2, 3],
|
||||||
|
[1, 2, 3, 4],
|
||||||
|
]
|
||||||
|
const insertedArray = [
|
||||||
|
[11],
|
||||||
|
[11, 12],
|
||||||
|
[11, 12, 13],
|
||||||
|
[11, 12, 13, 14],
|
||||||
|
]
|
||||||
|
for (const initial of initialArray) {
|
||||||
|
for (const inserted of insertedArray) {
|
||||||
|
const { partialTree: tree1 } = getTestTrees(10, initial, initial.length - 1)
|
||||||
|
const { partialTree: tree2 } = getTestTrees(10, initial, initial.length - 1)
|
||||||
|
tree1.bulkInsert(inserted)
|
||||||
|
for (const item of inserted) {
|
||||||
|
tree2.insert(item)
|
||||||
|
}
|
||||||
|
should().equal(tree1.root, tree2.root)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should fail to insert too many elements', () => {
|
||||||
|
const { partialTree } = getTestTrees(2, [1, 2, 3, 4], 2)
|
||||||
|
const call = () => partialTree.bulkInsert([5, 6, 7])
|
||||||
|
should().throw(call, 'Tree is full')
|
||||||
|
})
|
||||||
|
it('should bypass empty elements', () => {
|
||||||
|
const elements = [1, 2, 3, 4]
|
||||||
|
const { partialTree } = getTestTrees(2, elements, 2)
|
||||||
|
partialTree.bulkInsert([])
|
||||||
|
should().equal(partialTree.elements.length, elements.length, 'No elements inserted')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#update', () => {
|
||||||
|
it('should update last element', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
partialTree.update(4, 42)
|
||||||
|
fullTree.update(4, 42)
|
||||||
|
should().equal(partialTree.root, fullTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
|
||||||
|
it('should update odd element', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6, 7, 8], 2)
|
||||||
|
partialTree.update(4, 42)
|
||||||
|
fullTree.update(4, 42)
|
||||||
|
should().equal(partialTree.root, fullTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should update even element', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6, 7, 8], 2)
|
||||||
|
partialTree.update(3, 42)
|
||||||
|
fullTree.update(3, 42)
|
||||||
|
should().equal(partialTree.root, fullTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should update extra element', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
partialTree.update(5, 6)
|
||||||
|
fullTree.update(5, 6)
|
||||||
|
should().equal(fullTree.root, partialTree.root)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to update incorrect index', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 3)
|
||||||
|
should().throw((() => partialTree.update(-1, 42)), 'Insert index out of bounds: -1')
|
||||||
|
should().throw((() => partialTree.update(6, 42)), 'Insert index out of bounds: 6')
|
||||||
|
should().throw((() => partialTree.update(2, 42)), 'Index 2 is below the edge: 3')
|
||||||
|
// @ts-ignore
|
||||||
|
should().throw((() => partialTree.update('qwe', 42)), 'Insert index out of bounds: qwe')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail to update over capacity', () => {
|
||||||
|
const { partialTree } = getTestTrees(2, [1, 2, 3, 4], 1)
|
||||||
|
const call = () => partialTree.update(4, 42)
|
||||||
|
should().throw(call, 'Insert index out of bounds: 4')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#indexOf', () => {
|
||||||
|
it('should return same result as full tree', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6, 7, 8], 3)
|
||||||
|
should().equal(partialTree.indexOf(5), fullTree.indexOf(5))
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should find index', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
should().equal(partialTree.indexOf(3), 2)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should work with comparator', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
should().equal(partialTree.indexOf(4, (arg0, arg1) => arg0 === arg1), 3)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return -1 for non existent element', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
should().equal(partialTree.indexOf(42), -1)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#proof', () => {
|
||||||
|
it('should return proof for known leaf', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
assert.deepEqual(partialTree.proof(4), partialTree.path(3))
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#getters', () => {
|
||||||
|
it('should return capacity', () => {
|
||||||
|
const levels = 10
|
||||||
|
const capacity = 2 ** levels
|
||||||
|
const { fullTree, partialTree } = getTestTrees(levels, [1, 2, 3, 4, 5], 2)
|
||||||
|
should().equal(fullTree.capacity, capacity)
|
||||||
|
should().equal(partialTree.capacity, capacity)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return same elements count as full tree', () => {
|
||||||
|
const levels = 10
|
||||||
|
const capacity = 2 ** levels
|
||||||
|
const elements = Array.from({ length: capacity }, (_, i) => i)
|
||||||
|
const { fullTree, partialTree } = getTestTrees(levels, elements, 200)
|
||||||
|
should().equal(partialTree.elements.length, fullTree.elements.length)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return copy of layers', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
const layers = partialTree.layers
|
||||||
|
should().not.equal(layers, partialTree.layers)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return copy of zeros', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
const zeros = partialTree.zeros
|
||||||
|
should().not.equal(zeros, partialTree.zeros)
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should return edge leaf', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5], 2)
|
||||||
|
should().equal(partialTree.edgeElement, 3)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
describe('#path', () => {
|
||||||
|
|
||||||
|
it('should return path for known nodes', () => {
|
||||||
|
const levels = 10
|
||||||
|
const capacity = 2 ** levels
|
||||||
|
const elements = Array.from({ length: capacity / 2 }, (_, i) => i)
|
||||||
|
const { fullTree, partialTree } = getTestTrees(levels, elements, 250)
|
||||||
|
assert.deepEqual(fullTree.path(251), partialTree.path(251))
|
||||||
|
}).timeout(1000)
|
||||||
|
|
||||||
|
it('should fail on incorrect index', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6, 7, 8, 9], 4)
|
||||||
|
should().throw((() => partialTree.path(-1)), 'Index out of bounds: -1')
|
||||||
|
should().throw((() => partialTree.path(10)), 'Index out of bounds: 10')
|
||||||
|
// @ts-ignore
|
||||||
|
should().throw((() => partialTree.path('qwe')), 'Index out of bounds: qwe')
|
||||||
|
})
|
||||||
|
|
||||||
|
it('should fail if index is below edge', () => {
|
||||||
|
const { partialTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6, 7, 8, 9], 4)
|
||||||
|
const call = () => partialTree.path(2)
|
||||||
|
should().throw(call, 'Index 2 is below the edge: 4')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#shiftEdge', () => {
|
||||||
|
const levels = 20
|
||||||
|
const elements: Element[] = Array.from({ length: 2 ** 18 }, (_, i) => i)
|
||||||
|
const tree = new MerkleTree(levels, elements)
|
||||||
|
it('should work', () => {
|
||||||
|
const edge1 = tree.getTreeEdge(200)
|
||||||
|
const edge2 = tree.getTreeEdge(100)
|
||||||
|
const partialTree = new PartialMerkleTree(levels, edge1, elements.slice(edge1.edgeIndex))
|
||||||
|
partialTree.shiftEdge(edge2, elements.slice(edge2.edgeIndex, partialTree.edgeIndex))
|
||||||
|
tree.insert('1111')
|
||||||
|
partialTree.insert('1111')
|
||||||
|
assert.deepEqual(partialTree.path(150), tree.path(150))
|
||||||
|
})
|
||||||
|
it('should be able to build full tree from slices', () => {
|
||||||
|
const slices = tree.getTreeSlices(6)
|
||||||
|
const lastSlice = slices.pop()
|
||||||
|
const partialTree = new PartialMerkleTree(levels, lastSlice.edge, lastSlice.elements)
|
||||||
|
for (let i = slices.length - 1; i >= 0; i--) {
|
||||||
|
partialTree.shiftEdge(slices[i].edge, slices[i].elements)
|
||||||
|
}
|
||||||
|
partialTree.insert('1')
|
||||||
|
tree.insert('1')
|
||||||
|
assert.deepStrictEqual(partialTree.path(432), tree.path(432))
|
||||||
|
}).timeout(10000)
|
||||||
|
|
||||||
|
it('should fail if new edge index is over current edge', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 4)
|
||||||
|
const newEdge = fullTree.getTreeEdge(4)
|
||||||
|
const call = () => partialTree.shiftEdge(newEdge, [1, 2])
|
||||||
|
should().throw(call, 'New edgeIndex should be smaller then 4')
|
||||||
|
})
|
||||||
|
it('should fail if elements length are incorrect', () => {
|
||||||
|
const { fullTree, partialTree } = getTestTrees(10, [1, 2, 3, 4, 5, 6, 7, 8, 9], 4)
|
||||||
|
const newEdge = fullTree.getTreeEdge(3)
|
||||||
|
const call = () => partialTree.shiftEdge(newEdge, [1, 2])
|
||||||
|
should().throw(call, 'Elements length should be 1')
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#serialize', () => {
|
||||||
|
it('should work', () => {
|
||||||
|
const { partialTree } = getTestTrees(5, [1, 2, 3, 4, 5, 6, 7, 8, 9], 5)
|
||||||
|
const data = partialTree.serialize()
|
||||||
|
const dst = PartialMerkleTree.deserialize(data)
|
||||||
|
should().equal(partialTree.root, dst.root)
|
||||||
|
|
||||||
|
partialTree.insert(10)
|
||||||
|
dst.insert(10)
|
||||||
|
assert.deepStrictEqual(partialTree.path(6), dst.path(6))
|
||||||
|
should().equal(partialTree.root, dst.root)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
describe('#toString', () => {
|
||||||
|
it('should return correct stringified representation', () => {
|
||||||
|
const { partialTree } = getTestTrees(5, [1, 2, 3, 4, 5, 6, 7, 8, 9], 5)
|
||||||
|
const str = partialTree.toString()
|
||||||
|
const dst = PartialMerkleTree.deserialize(JSON.parse(str))
|
||||||
|
assert.deepStrictEqual(partialTree.path(6), dst.path(6))
|
||||||
|
partialTree.insert(10)
|
||||||
|
dst.insert(10)
|
||||||
|
|
||||||
|
assert.deepStrictEqual(partialTree.path(6), dst.path(6))
|
||||||
|
assert.deepStrictEqual(partialTree.root, dst.root)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
18
@tornado/fixed-merkle-tree/test/simpleHash.spec.ts
Normal file
18
@tornado/fixed-merkle-tree/test/simpleHash.spec.ts
Normal file
@ -0,0 +1,18 @@
|
|||||||
|
import { it } from 'mocha'
|
||||||
|
import { should } from 'chai'
|
||||||
|
import { simpleHash } from '../src'
|
||||||
|
|
||||||
|
describe('SimpleHash', () => {
|
||||||
|
it('should return correct hash string with default params', () => {
|
||||||
|
const hash = simpleHash([1, 2, 3])
|
||||||
|
return should().equal(hash, '3530513397947785053296897142557895557120')
|
||||||
|
})
|
||||||
|
it('should return correct hash string with length param', () => {
|
||||||
|
const hash = simpleHash([1, 2, 3], null, 77)
|
||||||
|
return should().equal(hash, '1259729275322113643079999203492506359813191573070980317691663537897682854338069790720')
|
||||||
|
})
|
||||||
|
it('should return correct hash string with seed param', () => {
|
||||||
|
const hash = simpleHash(['1', '2', '3'], 123)
|
||||||
|
return should().equal(hash, '1371592418687375416654554138100746944512')
|
||||||
|
})
|
||||||
|
})
|
||||||
@ -1,22 +1,25 @@
|
|||||||
{
|
{
|
||||||
// Change this to match your project
|
|
||||||
"include": ["src/**/*", "index.js"],
|
|
||||||
"exclude": ["node_modules"],
|
|
||||||
"compilerOptions": {
|
"compilerOptions": {
|
||||||
// Tells TypeScript to read JS files, as
|
"lib": [
|
||||||
// normally they are ignored as source files
|
"es2020"
|
||||||
"allowJs": true,
|
],
|
||||||
// Generate d.ts files
|
"target": "es2017",
|
||||||
"declaration": true,
|
"module": "CommonJS",
|
||||||
// This compiler run should
|
"moduleResolution": "Node",
|
||||||
// only output d.ts files
|
"outDir": "./lib",
|
||||||
"emitDeclarationOnly": true,
|
"rootDir": "./src",
|
||||||
// Types should go into this directory.
|
"esModuleInterop": true,
|
||||||
// Removing this would place the .d.ts files
|
"sourceMap": false,
|
||||||
// next to the .js files
|
"allowSyntheticDefaultImports": true,
|
||||||
"outFile": "index.d.ts",
|
"forceConsistentCasingInFileNames": true,
|
||||||
// go to js file when using IDE functions like
|
"declaration": true
|
||||||
// "Go to Definition" in VSCode
|
},
|
||||||
"declarationMap": true
|
"include": [
|
||||||
}
|
"src"
|
||||||
|
],
|
||||||
|
"exclude": [
|
||||||
|
"node_modules",
|
||||||
|
"types",
|
||||||
|
"**/*.spec.ts"
|
||||||
|
]
|
||||||
}
|
}
|
||||||
@ -25,7 +25,7 @@
|
|||||||
"license": "GPL-3.0",
|
"license": "GPL-3.0",
|
||||||
"repository": {
|
"repository": {
|
||||||
"type": "git",
|
"type": "git",
|
||||||
"url": "https://development.tornadocash.community/tornadocash/snarkjs"
|
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
|
||||||
},
|
},
|
||||||
"dependencies": {
|
"dependencies": {
|
||||||
"big-integer": "^1.6.43",
|
"big-integer": "^1.6.43",
|
||||||
|
|||||||
@ -4,7 +4,7 @@
|
|||||||
"description": "Module to handle web3 RPC connections over HTTP.",
|
"description": "Module to handle web3 RPC connections over HTTP.",
|
||||||
"repository": {
|
"repository": {
|
||||||
"type": "git",
|
"type": "git",
|
||||||
"url": "https://github.com/ethereum/web3.js/tree/1.x/packages/web3-providers-http"
|
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
|
||||||
},
|
},
|
||||||
"license": "LGPL-3.0",
|
"license": "LGPL-3.0",
|
||||||
"engines": {
|
"engines": {
|
||||||
|
|||||||
@ -22,7 +22,7 @@
|
|||||||
"license": "GPL-3.0",
|
"license": "GPL-3.0",
|
||||||
"repository": {
|
"repository": {
|
||||||
"type": "git",
|
"type": "git",
|
||||||
"url": "https://development.tornadocash.community/tornadocash/websnark"
|
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
|
||||||
},
|
},
|
||||||
"devDependencies": {
|
"devDependencies": {
|
||||||
"browserify": "^16.2.3",
|
"browserify": "^16.2.3",
|
||||||
|
|||||||
@ -6,7 +6,7 @@
|
|||||||
"description": "XMLHttpRequest polyfill for node.js",
|
"description": "XMLHttpRequest polyfill for node.js",
|
||||||
"repository": {
|
"repository": {
|
||||||
"type": "git",
|
"type": "git",
|
||||||
"url": "https://github.com/souldreamer/xhr2-cookies.git"
|
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
|
||||||
},
|
},
|
||||||
"keywords": [
|
"keywords": [
|
||||||
"XMLHttpRequest",
|
"XMLHttpRequest",
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user