TornadoCash/archive-monorepo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed-merkle-tree 0.7.3-p0

Browse Source 
Signed-off-by: T-Hax <>
This commit is contained in:
T-Hax 2023-05-13 20:52:40 +00:00
parent 19124126f4
commit e676b48b59
No known key found for this signature in database
40 changed files with 2976 additions and 6343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.env.example
View File

@ -1 +1,4 @@
#!/bin/bash
export TARGET_REGISTRY_USER=
export TARGET_REGISTRY_DOMAIN=
export GITEA_AUTH_TOKEN=

17
.yarnrc.yml
View File

@ -2,13 +2,11 @@
# main repositories, so we are going to have to scope our packages properly.
npmScopes:
tornado:
# The @tornado scope can just be set to the right registry by editing the T-Hax here.
# I could even make it an env var but it seems too much, that is for secrets.
npmPublishRegistry: "https://development.tornadocash.community/api/packages/T-Hax/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
# Check the env.example, you will notice it's not a regular env
# So split your env files up, since this is only for manual actions
# Since there can be multiple repositories we select them via the .env we `source``.
# Check .env.example
npmRegistryServer: https://${TARGET_REGISTRY_DOMAIN}/api/packages/${TARGET_REGISTRY_USER}/npm/
npmPublishRegistry: https://${TARGET_REGISTRY_DOMAIN}/api/packages/${TARGET_REGISTRY_USER}/npm/
npmAuthToken: ${GITEA_AUTH_TOKEN}
# If the following isn't set you won't have a node_modules folder
@ -16,11 +14,6 @@ npmScopes:
# If you want to use the new linkers uncomment or change the following
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
enableTelemetry: false

2
@tornado/circomlib/package.json
View File

@ -19,7 +19,7 @@
],
"repository": {
"type": "git",
"url": "https://development.tornadocash.community/tornadocash/circomlib"
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
},
"author": "0Kims",
"license": "GPL-3.0",

9
@tornado/fixed-merkle-tree/.editorconfig Normal file
View 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
View 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
View File

@ -1,74 +1,6 @@
# Logs
logs
*.log
npm-debug.log*
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
node_modules
build
yarn-error.log
.idea
.nyc_output
# 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
.run

1
@tornado/fixed-merkle-tree/.nvmrc Normal file
View File

@ -0,0 +1 @@
14.17

7
@tornado/fixed-merkle-tree/.prettierrc Normal file
View File

@ -0,0 +1,7 @@
{
"semi": false,
"arrowParens": "always",
"singleQuote": true,
"printWidth": 110,
"trailingComma": "all"
}

77
@tornado/fixed-merkle-tree/README.md
View File

@ -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 [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/tornadocash/fixed-merkle-tree/build)](https://github.com/tornadocash/fixed-merkle-tree/actions) [![npm](https://img.shields.io/npm/v/fixed-merkle-tree)](https://www.npmjs.com/package/fixed-merkle-tree)
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
```javascript
const MerkleTree = require('MerkleTree')
import { MerkleTree, PartialMerkleTree } from 'fixed-merkle-tree'
const tree = new MerkleTree(10, [1, 2, 3, 4, 5])
tree.insert(6)
tree.update(3, 42)
const path = tree.path(tree.indexOf(2))
const path = tree.proof(3)
console.log(path)
// output:
// output
{
pathIndex: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
pathElements: [
'42',
'19814528709687996974327303300007262407299502847885145507292406548098437687919',
'11545490348087423460235196042660837039811055736960842865648632633825765931887',
'14506027710748750947258687001455876266559341618222612722926156490737302846427',
'4766583705360062980279572762279781527342845808161105063909171241304075622345',
'16640205414190175414380077665118269450294358858897019640557533278896634808665',
'13024477302430254842915163302704885770955784224100349847438808884122720088412',
'11345696205391376769769683860277269518617256738724086786512014734609753488820',
'17235543131546745471991808272245772046758360534180976603221801364506032471936',
'155962837046691114236524362966874066300454611955781275944230309195800494087'
]
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'
}
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
View File

@ -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
@tornado/fixed-merkle-tree/index.d.ts.map
View File

@ -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
@tornado/fixed-merkle-tree/index.js
View File

@ -1 +0,0 @@
module.exports = require("./src/merkleTree")

43
@tornado/fixed-merkle-tree/lib/BaseTree.d.ts vendored Normal file
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View File

File diff suppressed because it is too large Load Diff

36
@tornado/fixed-merkle-tree/package.json
View File

@ -1,15 +1,20 @@
{
"name": "@tornado/fixed-merkle-tree",
"version": "0.6.1-p2",
"version": "0.7.3-p0",
"description": "Fixed depth merkle tree implementation with sequential inserts",
"repository": {
"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": {
"test": "mocha",
"lint": "eslint ."
"test": "ts-mocha 'test/*.spec.ts' -s 10",
"coverage": "nyc npm run test",
"build": "tsc",
"clean": "rm -rf lib/",
"prepare": "npm run clean && npm run build",
"lint": "eslint src"
},
"keywords": [
"merkle",
@ -18,15 +23,20 @@
],
"author": "Roman Semenov <semenov.roma@gmail.com>",
"license": "ISC",
"dependencies": {
"@tornado/circomlib": "workspace:*",
"@tornado/snarkjs": "workspace:*"
},
"files": [
"src/*",
"lib/*"
],
"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",
"eslint": "^7.5.0",
"mocha": "^8.1.0",
"typescript": "^5.0.2"
"eslint": "^8.9.0",
"eslint-config-prettier": "^8.3.0",
"mocha": "^9.2.2",
"ts-mocha": "^9.0.2",
"typescript": "^4.6.2"
}
}

169
@tornado/fixed-merkle-tree/src/BaseTree.ts Normal file
View 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
View 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
View 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
View 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 }

212
@tornado/fixed-merkle-tree/src/merkleTree.js
View File

@ -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

3
@tornado/fixed-merkle-tree/src/mimc.js
View File

@ -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
View 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
View 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
View 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
View 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')
})
})

41
@tornado/fixed-merkle-tree/tsconfig.json
View File

@ -1,22 +1,25 @@
{
// Change this to match your project
"include": ["src/**/*", "index.js"],
"exclude": ["node_modules"],
"compilerOptions": {
// Tells TypeScript to read JS files, as
// normally they are ignored as source files
"allowJs": true,
// Generate d.ts files
"declaration": true,
// This compiler run should
// only output d.ts files
"emitDeclarationOnly": true,
// Types should go into this directory.
// Removing this would place the .d.ts files
// next to the .js files
"outFile": "index.d.ts",
// go to js file when using IDE functions like
// "Go to Definition" in VSCode
"declarationMap": true
}
"lib": [
"es2020"
],
"target": "es2017",
"module": "CommonJS",
"moduleResolution": "Node",
"outDir": "./lib",
"rootDir": "./src",
"esModuleInterop": true,
"sourceMap": false,
"allowSyntheticDefaultImports": true,
"forceConsistentCasingInFileNames": true,
"declaration": true
},
"include": [
"src"
],
"exclude": [
"node_modules",
"types",
"**/*.spec.ts"
]
}

2
@tornado/snarkjs/package.json
View File

@ -25,7 +25,7 @@
"license": "GPL-3.0",
"repository": {
"type": "git",
"url": "https://development.tornadocash.community/tornadocash/snarkjs"
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
},
"dependencies": {
"big-integer": "^1.6.43",

2
@tornado/web3-providers-http/package.json
View File

@ -4,7 +4,7 @@
"description": "Module to handle web3 RPC connections over HTTP.",
"repository": {
"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",
"engines": {

2
@tornado/websnark/package.json
View File

@ -22,7 +22,7 @@
"license": "GPL-3.0",
"repository": {
"type": "git",
"url": "https://development.tornadocash.community/tornadocash/websnark"
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
},
"devDependencies": {
"browserify": "^16.2.3",

2
@tornado/xhr2-cookies/package.json
View File

@ -6,7 +6,7 @@
"description": "XMLHttpRequest polyfill for node.js",
"repository": {
"type": "git",
"url": "https://github.com/souldreamer/xhr2-cookies.git"
"url": "https://development.tornadocash.community/T-Hax/archive-monorepo"
},
"keywords": [
"XMLHttpRequest",

1311
yarn.lock
View File

File diff suppressed because it is too large Load Diff