Sarvesh/merkel patricia proof generator

.travis.yml

@@ -6,7 +6,7 @@ branches:
   - master
   - develop
   - release-0.9
-  - balances_model_and_cache
+  - feature/proof
 notifications:
   email:
     recipients:
@@ -45,7 +45,8 @@ script:
   - source $HOME/openst-setup/openst_env_vars.sh
   - node tools/setup/branded_token/register.js "ACME Coin" "ACME" 10
   - node tools/setup/branded_token/mint.js "ACME" 1000000000000000000000
-  - mocha --timeout 120000 test/* --exit
+  - npm run unit_test
+  - npm run integration_test
 after_script:
   - kill $(ps aux | grep 'tools/setup/start_services.js' | awk '{print $2}')
   - kill $(ps aux | grep 'DynamoDBLocal.jar' | awk '{print $2}')

config/core_constants.js

@@ -156,7 +156,12 @@ CoreConstants.prototype = {
    */
   STANDALONE_MODE: process.env.OST_STANDALONE_MODE || 0,
 
-  AUTO_SCALE_DYNAMO: process.env.AUTO_SCALE_DYNAMO
+  AUTO_SCALE_DYNAMO: process.env.AUTO_SCALE_DYNAMO,
+
+  /**
+   * PROOF BATCH SIZE
+   */
+  PROOF_BATCH_SIZE: 10
 };
 
 module.exports = new CoreConstants();

config/error/general.json

@@ -189,5 +189,50 @@
     "http_code": "422",
     "code": "UNPROCESSABLE_ENTITY",
     "message": "No new blocks on chain."
+  },
+  "exception": {
+    "http_code": "500",
+    "code": "INTERNAL_SERVER_ERROR",
+    "message": "Something went wrong exception."
+  },
+  "db_path_undefined": {
+    "http_code": "422",
+    "code": "REQUIRED_ARGUMENT_MISSING",
+    "message": "Required argument db path is missing"
+  },
+  "state_root_undefined": {
+    "http_code": "422",
+    "code": "REQUIRED_ARGUMENT_MISSING",
+    "message": "Required argument state root is missing"
+  },
+  "account_address_undefined": {
+    "http_code": "422",
+    "code": "REQUIRED_ARGUMENT_MISSING",
+    "message": "Required argument account address is missing"
+  },
+  "account_node_not_found": {
+    "http_code": "422",
+    "code": "ACCOUNT_NOT_FOUND",
+    "message": "Account not found"
+  },
+  "storage_node_not_found": {
+    "http_code": "422",
+    "code": "STORAGE_NOT_FOUND",
+    "message": "Storage node not found"
+  },
+  "storage_index_undefined": {
+    "http_code": "422",
+    "code": "REQUIRED_ARGUMENT_MISSING",
+    "message": "Required argument storage index is missing"
+  },
+  "tree_not_initialized": {
+    "http_code": "422",
+    "code": "TRIE_UNINITIALIZED",
+    "message": "Trie not initialized"
+  },
+  "proof_batch_size_exceeds": {
+    "http_code": "422",
+    "code": "BATCH_SIZE_EXCEEDS",
+    "message": "Tree batch size exceeds"
   }
 }

lib/db/leveldb.js

@@ -0,0 +1,38 @@
+const leveldown = require('leveldown')
+  , levelup = require('levelup')
+;
+
+/**
+ * @constructor
+ */
+function LevelDBFactory() {
+  this.instanceMap = {};
+}
+
+LevelDBFactory.prototype = {
+  /**
+   * Returns leveldb instance, it creates new in not already exists  otherwise returns existing instance
+   * @param dbPath
+   * @return leveldb instance
+   */
+  getInstance: function (dbPath) {
+    const oThis = this;
+
+    let lowerCasePath = dbPath.toLowerCase();
+
+    if (!oThis.instanceMap[lowerCasePath]) {
+      oThis.instanceMap[lowerCasePath] = oThis.create(lowerCasePath);
+    }
+    return oThis.instanceMap[lowerCasePath];
+  },
+
+  /**
+   *
+   * @param dbPath
+   * @return leveldb instance
+   */
+  create: function (dbPath) {
+    return levelup(leveldown(dbPath));
+  },
+};
+module.exports = new LevelDBFactory();

lib/proof/account_proof.js

@@ -0,0 +1,73 @@
+const Trie = require('merkle-patricia-tree');
+
+const rootPrefix = "../.."
+  , logger = require(rootPrefix + '/helpers/custom_console_logger')
+  , responseHelper = require(rootPrefix + '/lib/formatter/response')
+  , proof = require(rootPrefix + "/lib/proof/proof")
+  , basicHelper = require(rootPrefix + '/helpers/basic_helper')
+;
+
+/**
+ * @constructor
+ * @param stateRoot
+ * @param db
+ */
+function AccountProof(stateRoot, db) {
+  const oThis = this;
+
+  oThis.trie = new Trie(db, stateRoot);
+}
+
+AccountProof.prototype = {
+
+  /**
+   * Validate and _build proof
+   * @param address
+   * @return {Promise<proof>}
+   */
+  perform: async function (address) {
+    const oThis = this;
+
+    await oThis._validate(address);
+    return oThis._build(address);
+  },
+  /**
+   * Delegates call to _build account proof to lib
+   * @param address
+   * @return {Promise<proof>}
+   */
+  _build: async function (address) {
+    const oThis = this;
+
+    return proof.accountProof(address, oThis.trie);
+  },
+  /**
+   * Validate input
+   * @param address
+   * @private
+   */
+  _validate: async function (address) {
+    const oThis = this;
+
+    let errorConf = {
+      internal_error_identifier: "s_p_ap_validate_2",
+      debug_options: {},
+      error_config: basicHelper.fetchErrorConfig()
+    };
+
+    if (!oThis.trie || oThis.trie.root === oThis.trie.EMPTY_TRIE_ROOT) {
+      errorConf.api_error_identifier = "tree_not_initialized";
+      let errorResponse = responseHelper.error(errorConf);
+      return Promise.reject(errorResponse);
+    }
+    if (address === undefined) {
+      logger.error("Account address is invalid");
+      errorConf.api_error_identifier = "account_address_undefined";
+      let errorResponse = responseHelper.error(errorConf);
+      return Promise.reject(errorResponse);
+    }
+  }
+};
+
+module.exports = AccountProof;
+

lib/proof/helper.js

@@ -0,0 +1,64 @@
+const ethUtils = require('ethereumjs-util');
+
+const rootPrefix = '../..'
+  , AccountProof = require(rootPrefix + '/lib/proof/account_proof')
+;
+
+/**
+ * Constructor for helper methods class - ProofHelperKlass
+ * @constructor
+ */
+
+const ProofHelperKlass = function () {
+};
+
+ProofHelperKlass.prototype = {
+
+  /**
+   * @notice left-pad value to make length 32 bytes
+   * @param value
+   * @return {string} padded value of length 32 bytes i.e. 64 nibbles
+   * @private
+   */
+  _leftPad: function (value) {
+    return ("0000000000000000000000000000000000000000000000000000000000000000" + value).substring(value.length)
+  },
+  /**
+   *@notice generates storagePath of a variable in the storage
+   * @param storageIndex
+   * @param mappings, key of mapping variable
+   * @return {Buffer2}
+   */
+  storagePath: function (storageIndex, mappings) {
+
+    let path = Buffer.from(this._leftPad(storageIndex), 'hex');
+    if (mappings && mappings.length > 0) {
+      mappings.map(mapping => {
+        path = Buffer.concat([Buffer.from(this._leftPad(mapping), 'hex'), path])
+      });
+      path = Buffer.from(ethUtils.sha3(path), 'hex')
+    }
+    path = Buffer.from(ethUtils.sha3(path), 'hex');
+    return path;
+  },
+
+  /**
+   * @notice generates storage root of a contract
+   * @param stateRoot
+   * @param contractAddress
+   * @param db level db instace
+   * @return {Promise<string>}
+   * @private
+   */
+  fetchStorageRoot: async function (stateRoot, contractAddress, db) {
+
+    let accountProofInstance = new AccountProof(stateRoot, db)
+      , accountProof = await accountProofInstance.perform(contractAddress)
+      , accountValue = accountProof.toHash().data.value
+      , decodedValue = ethUtils.rlp.decode('0x' + accountValue);
+
+    return '0x' + decodedValue[2].toString('hex');
+  }
+};
+
+module.exports = new ProofHelperKlass();

lib/proof/proof.js

@@ -0,0 +1,87 @@
+const rootPrefix = "../.."
+  , ethUtils = require('ethereumjs-util')
+  , logger = require(rootPrefix + '/helpers/custom_console_logger')
+  , responseHelper = require(rootPrefix + '/lib/formatter/response')
+  , basicHelper = require(rootPrefix + '/helpers/basic_helper')
+;
+
+
+function Proof() {
+
+}
+
+
+Proof.prototype = {
+  /**
+   * Generate Account proof for give address in merkel patricia tree
+   * @param address
+   * @param trie
+   * @return {Promise<proof>}
+   */
+  accountProof: function (address, trie) {
+
+  let errorConf = {
+    internal_error_identifier: "l_p_accountProof_1",
+    debug_options: {},
+    error_config: basicHelper.fetchErrorConfig()
+  }
+    , path = Buffer.from(ethUtils.sha3(Buffer.from(address, 'hex')), 'hex');
+
+  logger.info('Generating account proof');
+  return new Promise(function (resolve, reject) {
+
+    return trie.findPath(path, function (error, accountNode, keyRemainder, rootToLeafPath) {
+      if (error || !accountNode || keyRemainder.length > 0) {
+        errorConf.api_error_identifier = "account_node_not_found";
+        errorConf.debug_options = {error};
+        let errorResponse = responseHelper.error(errorConf);
+        return reject(errorResponse);
+      }
+      let parentNodes = rootToLeafPath.map(node => node.raw)
+        , proof = {
+        address: address,
+        parentNodes: ethUtils.rlp.encode(parentNodes).toString('hex'),
+        value: accountNode.value.toString('hex')
+      };
+      return resolve(responseHelper.successWithData(proof));
+    });
+  });
+  },
+
+  /**
+   * Generate Storage proof for give storagePath in merkel patricia tree
+   * @param storagePath
+   * @param trie
+   * @return {Promise<proof>}
+   */
+  storageProof: function (storagePath, trie) {
+
+  let errorConf = {
+    internal_error_identifier: "l_p_accountProof_2",
+    debug_options: {},
+    error_config: basicHelper.fetchErrorConfig()
+  };
+  return new Promise(function (resolve, reject) {
+    return trie.findPath(storagePath, function (error, storageNode, keyRemainder, rootToLeafPath) {
+
+      if (error || !storageNode || keyRemainder.length > 0) {
+        logger.error(error || 'Unable to find storage node in the tree');
+        errorConf.api_error_identifier = "storage_node_not_found";
+        errorConf.debug_options = {error};
+        let errorResponse = responseHelper.error(errorConf);
+        return reject(errorResponse);
+      }
+      let parentNodes = rootToLeafPath.map(node => node.raw)
+        , proof = {
+        parentNodes: ethUtils.rlp.encode(parentNodes).toString('hex'),
+        value: storageNode.value.toString('hex')
+      };
+      return resolve(responseHelper.successWithData(proof));
+    })
+  });
+  }
+
+};
+
+module.exports = new Proof();
+