@ocap/merkle-tree 1.6.10

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2019 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,15 @@
+# OCAP Config
+
+Create or validate config object for ocap server
+
+## Usage
+
+```shell
+yarn add @ocap/config
+```
+
+Then:
+
+```javascript
+// TODO
+```

package/lib/abi.js

@@ -0,0 +1,227 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable func-names */
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable prefer-rest-params */
+// Ported from: https://github.com/ChainSafe/web3.js/blob/1.x/packages/web3-utils/src/soliditySha3.js
+
+const Mcrypto = require('@ocap/mcrypto');
+const { BN, isHexStrict, isBigNumber, isBN, utf8ToHex, leftPad, rightPad } = require('@ocap/util');
+
+const keccak256 = Mcrypto.Hasher.Keccak.hash256;
+
+const isAddress = (address) => {
+  if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+    return false;
+  }
+  if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {
+    return true;
+  }
+  return checkAddressChecksum(address);
+};
+
+const checkAddressChecksum = (address) => {
+  const origin = address.replace(/^0x/i, '');
+  const addressHash = keccak256(origin.toLowerCase()).replace(/^0x/i, '');
+  for (let i = 0; i < 40; i++) {
+    if (
+      (parseInt(addressHash[i], 16) > 7 && origin[i].toUpperCase() !== origin[i]) ||
+      (parseInt(addressHash[i], 16) <= 7 && origin[i].toLowerCase() !== origin[i])
+    ) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const _elementaryName = function (name) {
+  if (name.startsWith('int[')) {
+    return `int256${name.slice(3)}`;
+  }
+  if (name === 'int') {
+    return 'int256';
+  }
+  if (name.startsWith('uint[')) {
+    return `uint256${name.slice(4)}`;
+  }
+  if (name === 'uint') {
+    return 'uint256';
+  }
+  if (name.startsWith('fixed[')) {
+    return `fixed128x128${name.slice(5)}`;
+  }
+  if (name === 'fixed') {
+    return 'fixed128x128';
+  }
+  if (name.startsWith('ufixed[')) {
+    return `ufixed128x128${name.slice(6)}`;
+  }
+  if (name === 'ufixed') {
+    return 'ufixed128x128';
+  }
+  return name;
+};
+
+// Parse N from type<N>
+const _parseTypeN = function (type) {
+  const size = /^\D+(\d+).*$/.exec(type);
+  return size ? parseInt(size[1], 10) : null;
+};
+
+// Parse N from type[<N>]
+const _parseTypeNArray = function (type) {
+  const arraySize = /^\D+\d*\[(\d+)\]$/.exec(type);
+  return arraySize ? parseInt(arraySize[1], 10) : null;
+};
+
+const _parseNumber = function (arg) {
+  const type = typeof arg;
+  if (type === 'string') {
+    if (isHexStrict(arg)) {
+      return new BN(arg.replace(/0x/i, ''), 16);
+    }
+    return new BN(arg, 10);
+  }
+  if (type === 'number') {
+    return new BN(arg);
+  }
+  if (isBigNumber(arg)) {
+    return new BN(arg.toString(10));
+  }
+  if (isBN(arg)) {
+    return arg;
+  }
+  throw new Error(`${arg} is not a number`);
+};
+
+const _solidityPack = function (type, value, arraySize) {
+  let size;
+  let num;
+  type = _elementaryName(type);
+
+  if (type === 'bytes') {
+    if (value.replace(/^0x/i, '').length % 2 !== 0) {
+      throw new Error(`Invalid bytes characters ${value.length}`);
+    }
+
+    return value;
+  }
+  if (type === 'string') {
+    return utf8ToHex(value);
+  }
+  if (type === 'bool') {
+    return value ? '01' : '00';
+  }
+  if (type.startsWith('address')) {
+    if (arraySize) {
+      size = 64;
+    } else {
+      size = 40;
+    }
+
+    if (!isAddress(value)) {
+      throw new Error(`${value} is not a valid address, or the checksum is invalid.`);
+    }
+
+    return leftPad(value.toLowerCase(), size, '0');
+  }
+
+  size = _parseTypeN(type);
+
+  if (type.startsWith('bytes')) {
+    if (!size) {
+      throw new Error('bytes[] not yet supported in solidity');
+    }
+
+    // must be 32 byte slices when in an array
+    if (arraySize) {
+      size = 32;
+    }
+
+    if (size < 1 || size > 32 || size < value.replace(/^0x/i, '').length / 2) {
+      throw new Error(`Invalid bytes${size} for ${value}`);
+    }
+
+    return rightPad(value, size * 2, '0');
+  }
+  if (type.startsWith('uint')) {
+    if (size % 8 || size < 8 || size > 256) {
+      throw new Error(`Invalid uint${size} size`);
+    }
+
+    num = _parseNumber(value);
+    if (num.bitLength() > size) {
+      throw new Error(`Supplied uint exceeds width: ${size} vs ${num.bitLength()}`);
+    }
+
+    if (num.lt(new BN(0))) {
+      throw new Error(`Supplied uint ${num.toString()} is negative`);
+    }
+
+    return size ? leftPad(num.toString('hex'), (size / 8) * 2, '0') : num;
+  }
+  if (type.startsWith('int')) {
+    if (size % 8 || size < 8 || size > 256) {
+      throw new Error(`Invalid int${size} size`);
+    }
+
+    num = _parseNumber(value);
+    if (num.bitLength() > size) {
+      throw new Error(`Supplied int exceeds width: ${size} vs ${num.bitLength()}`);
+    }
+
+    if (num.lt(new BN(0))) {
+      return num.toTwos(size).toString('hex');
+    }
+    return size ? leftPad(num.toString('hex'), (size / 8) * 2, '0') : num;
+  }
+
+  // FIXME: support all other types
+  throw new Error(`Unsupported or invalid type: ${type}`);
+};
+
+const _processSolidityEncodePackedArgs = function (arg) {
+  if (!arg || typeof arg !== 'object') {
+    throw new Error('arg must be an object');
+  }
+
+  let arraySize;
+
+  const type = arg.t || arg.type;
+  let value = arg.v || arg.value;
+
+  if ((type.startsWith('int') || type.startsWith('uint')) && typeof value === 'string' && !/^(-)?0x/i.test(value)) {
+    value = new BN(value);
+  }
+
+  // get the array size
+  if (Array.isArray(value)) {
+    arraySize = _parseTypeNArray(type);
+    if (arraySize && value.length !== arraySize) {
+      throw new Error(`${type} is not matching the given array ${JSON.stringify(value)}`);
+    } else {
+      arraySize = value.length;
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((val) => _solidityPack(type, val, arraySize).toString('hex').replace('0x', '')).join('');
+  }
+
+  return _solidityPack(type, value, arraySize).toString('hex').replace('0x', '');
+};
+
+/**
+ * Encode packed args to hex
+ *
+ * @method encodePacked
+ * @return {String} the hex encoded arguments
+ */
+const encodePacked = function () {
+  const args = Array.prototype.slice.call(arguments);
+  const hexArgs = args.map(_processSolidityEncodePackedArgs);
+  return `0x${hexArgs.join('').toLowerCase()}`;
+};
+
+module.exports = {
+  encodePacked,
+};

package/lib/index.js

@@ -0,0 +1,194 @@
+const Mcrypto = require('@ocap/mcrypto');
+const { toHex, toBuffer } = require('@ocap/util');
+
+const { encodePacked } = require('./abi');
+
+const keccak256 = Mcrypto.Hasher.Keccak.hash256;
+const keccakFromString = (str) => toBuffer(keccak256(str));
+
+class MerkleTree {
+  constructor(elements) {
+    // Filter empty strings and hash elements
+    this.elements = elements.filter(Boolean).map((x) => keccakFromString(x));
+
+    // Sort elements
+    this.elements.sort(Buffer.compare);
+
+    // Deduplicate elements
+    this.elements = this.bufDeduplicate(this.elements);
+
+    // Create layers
+    this.layers = this.getLayers(this.elements);
+  }
+
+  getLayers(elements) {
+    if (elements.length === 0) {
+      return [['']];
+    }
+
+    const layers = [];
+    layers.push(elements);
+
+    // Get next layer until we reach the root
+    while (layers[layers.length - 1].length > 1) {
+      layers.push(this.getNextLayer(layers[layers.length - 1]));
+    }
+
+    return layers;
+  }
+
+  getNextLayer(elements) {
+    return elements.reduce((layer, el, idx, arr) => {
+      if (idx % 2 === 0) {
+        // Hash the current element with its pair element
+        layer.push(this.combinedHash(el, arr[idx + 1]));
+      }
+
+      return layer;
+    }, []);
+  }
+
+  combinedHash(first, second) {
+    if (!first) {
+      return second;
+    }
+    if (!second) {
+      return first;
+    }
+
+    return toBuffer(keccak256(this.sortAndConcat(first, second)));
+  }
+
+  getRoot() {
+    return this.layers[this.layers.length - 1][0];
+  }
+
+  getHexRoot() {
+    return toHex(this.getRoot());
+  }
+
+  getProof(el) {
+    let idx = this.bufIndexOf(el, this.elements);
+
+    if (idx === -1) {
+      throw new Error('Element does not exist in Merkle tree');
+    }
+
+    return this.layers.reduce((proof, layer) => {
+      const pairElement = this.getPairElement(idx, layer);
+
+      if (pairElement) {
+        proof.push(pairElement);
+      }
+
+      idx = Math.floor(idx / 2);
+
+      return proof;
+    }, []);
+  }
+
+  getHexProof(el) {
+    const proof = this.getProof(el);
+    return this.bufArrToHexArr(proof);
+  }
+
+  verify(proofs, merkleRoot, leaf) {
+    let computedHash = toBuffer(leaf);
+
+    for (let i = 0; i < proofs.length; i++) {
+      const proofElement = toBuffer(proofs[i]);
+      computedHash = this.combinedHash(proofElement, computedHash);
+    }
+
+    return toHex(computedHash) === merkleRoot;
+  }
+
+  getPairElement(idx, layer) {
+    const pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
+
+    if (pairIdx < layer.length) {
+      return layer[pairIdx];
+    }
+    return null;
+  }
+
+  bufIndexOf(el, arr) {
+    let hash;
+
+    // Convert element to 32 byte hash if it is not one already
+    if (el.length !== 32 || !Buffer.isBuffer(el)) {
+      hash = keccakFromString(el);
+    } else {
+      hash = el;
+    }
+
+    for (let i = 0; i < arr.length; i++) {
+      if (hash.equals(arr[i])) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  bufDeduplicate(elements) {
+    return elements.filter((el, idx) => idx === 0 || !elements[idx - 1].equals(el));
+  }
+
+  bufArrToHexArr(arr) {
+    if (arr.some((el) => !Buffer.isBuffer(el))) {
+      throw new Error('Array is not an array of buffers');
+    }
+
+    return arr.map((el) => `0x${el.toString('hex')}`);
+  }
+
+  sortAndConcat(...args) {
+    return Buffer.concat([...args].sort(Buffer.compare));
+  }
+}
+
+module.exports = MerkleTree;
+
+module.exports.keccak256 = keccak256;
+module.exports.encodePacked = encodePacked;
+
+module.exports.getListHash = (list) =>
+  list.length
+    ? keccak256(
+        list
+          .map((x) => (x.startsWith('0x') ? x : `0x${x}`))
+          .reduce((acc, x) => encodePacked({ type: 'bytes', value: acc }, { type: 'bytes', value: x }), '')
+      )
+    : '';
+
+module.exports.getBlockHash = (block) =>
+  block
+    ? keccak256(
+        encodePacked(
+          { type: 'uint256', value: block.height },
+          { type: 'bytes32', value: block.previousHash },
+          { type: 'bytes32', value: block.merkleRoot },
+          { type: 'bytes32', value: block.txsHash }
+        )
+      )
+    : '';
+
+module.exports.getBlockMerkleTree = (txs) =>
+  txs.length
+    ? new MerkleTree(
+        txs.map((x) =>
+          encodePacked(
+            { type: 'bytes32', value: x.hash.startsWith('0x') ? x.hash : `0x${x.hash}` },
+            { type: 'address', value: x.to },
+            { type: 'uint256', value: x.amount }
+          )
+        )
+      )
+    : {
+        getHexRoot: () => '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+        getHexProof: () => [],
+        elements: [],
+        layers: [],
+        verify: () => false,
+      };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ocap/merkle-tree",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.6.10",
+  "description": "Merkle tree implementation that powers DID Rollup",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint tests lib",
+    "lint:fix": "eslint --fix tests lib",
+    "test": "jest --forceExit --detectOpenHandles",
+    "coverage": "npm run test -- --coverage"
+  },
+  "keywords": [],
+  "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^27.3.1"
+  },
+  "dependencies": {
+    "@ocap/mcrypto": "1.6.10",
+    "@ocap/util": "1.6.10"
+  },
+  "gitHead": "ab272e8db3a15c6571cc7fae7cc3d3e0fdd4bdb1"
+}