evm-contracts-tools 0.0.55 → 0.0.62

package/libevm-contract-call

@@ -65,11 +65,21 @@ const
   _libcrash_module =
     await import(
       "libcrash-js");
+/* global
+     _dir_exists */
+const
+  _dir_exists =
+    _libcrash_module._dir_exists;
 /* global
      _dirname */
 const
   _dirname =
     _libcrash_module._dirname;
+/* global
+     _echo */
+const
+  _echo =
+    _libcrash_module._echo;
 /* global
      _file_exists */
 const
@@ -95,6 +105,11 @@ const
 const
   _lib_get =
     _libcrash_module._lib_get;
+/* global
+     _ls */
+const
+  _ls =
+    _libcrash_module._ls;
 /* global
      _msg_info */
 const
@@ -139,6 +154,24 @@ const
 const
   _address_check =
     _evm_contracts_tools_module._address_check;
+const
+  _evm_contract_deployment_address_module =
+    await import(
+      "./libevm-contract-deployment-address");
+/* global
+     _evm_contract_deployment_address */
+const
+  _evm_contract_deployment_address =
+    _evm_contract_deployment_address_module._evm_contract_deployment_address;
+const
+  _evm_contract_deployments_dir_module =
+    await import(
+      "./libevm-contract-deployments-dir");
+/* global
+     _evm_contract_deployments_dir */
+const
+  _evm_contract_deployments_dir =
+    _evm_contract_deployments_dir_module._evm_contract_deployments_dir;
 const
   _ethereum_data_module =
     await _require(
@@ -207,9 +240,33 @@ function
 
 function
   _default_artifact_path_get(
-    _type) {
+    _type,
+    _target_network,
+    _contract_address) {
   let
     _file_name;
+  const
+    _network_type =
+      typeof(
+        _target_network);
+  if ( _network_type === "undefined" ||
+       _target_network === "" ) {
+    _target_network =
+      _get(
+        "target",
+        "network");
+  }
+  const
+    _contract_address_type =
+      typeof(
+        _contract_address);
+  if ( _contract_address_type === "undefined" ||
+       _contract_address === "" ) {
+    _contract_address =
+      _get(
+        "contract",
+        "address");
+  }
   const
     _home =
       _homedir_get();
@@ -222,15 +279,15 @@ function
         "evm-contract-call" ]);
   if ( _type == "abi" ) {
     _file_name =
-      `${contract_address}.abi.json`;
+      `${_contract_address}.abi.json`;
   }
   else if ( _type == "bytecode" ) {
     _file_name =
-      `${contract_address}.bin`;
+      `${_contract_address}.bin`;
   }
   else if ( _type == "compiler_output" ) {
     _file_name =
-      `${contract_address}.json`;
+      `${_contract_address}.json`;
   }
   else {
     const
@@ -238,13 +295,14 @@ function
         `Unknown artifact type '${_type}'.`;
     _msg_error(
       _msg,
-      1);
+      0);
+    throw _msg;
   }
   const
     _artifact =
       _path_join( [
         _data_dir,
-        target_network,
+        _target_network,
         _file_name ]);
   return _artifact;
 }
@@ -316,8 +374,8 @@ function
   _abi_target =
     _abi;
   if ( typeof(
-         _abi_target) == "undefined" ||
-       _abi_target == "" ) {
+         _abi_target) === "undefined" ||
+       _abi_target === "" ) {
     _abi_target =
       _default_artifact_path_get(
         "abi");
@@ -457,33 +515,69 @@ async function
     _contract_compiler_output,
     _contract_method,
     _method_args) {
-  let
-    _explorer,
-    _out,
-    _result,
-    _rpc;
-  if ( _call_type == "static" ) {
-    const
-      _infos =
-        [];
-    _out =
-      "";
+  // let
+  //   _msg,
+  //   _out;
+  const
+    _call_type_type =
+      typeof(
+        _call_type);
+  if ( _call_type_type == "undefined" ) {
+    _call_type =
+      "static";
   }
-  else if ( _call_type == "dynamic" ) {
-    _out =
-      "";
+  else if ( _call_type_type == "string" ) {
+    if ( _call_type.length < 1 ) {
+      // Properly
+      _call_type =
+        "static";
+    }
+    else {
+      _echo(
+        _call_type);
+    }
+  }
+  else if ( _call_type_type == "object" ) {
+    _echo(
+      _call_type);
   }
   else {
-    const
-      _msg =
-        `Unknown call type ` +
-        `'${_call_type}'.`;
-    _msg_error(
-      _msg,
-      0);
-    throw _msg;
+    _echo(
+      _call_type);
   }
-  return _out;
+  return [ _call_type ];
+  // _msg =
+  //   "Running EVM network call " +
+  //   `of type '${_call_type}'.`;
+  // _msg_info(
+  //   _msg);
+  // if ( _call_type == "static" ) {
+  //   _out =
+  //     "static";
+  //   _echo(
+  //     "static");
+  //   // const
+  //   //   _infos =
+  //   //     [];
+  //   // _out =
+  //   //   "";
+  // }
+  // else if ( _call_type == "dynamic" ) {
+  //   _echo(
+  //     "dynamic");
+  //   _out =
+  //     "static";
+  // }
+  // else {
+  //   _msg =
+  //     `Unknown call type ` +
+  //     `'${_call_type}'.`;
+  //   _msg_error(
+  //     _msg,
+  //     0);
+  //   throw _msg;
+  // }
+  // return _out;
 }
 
 function
@@ -513,17 +607,474 @@ function
   }
 }
 
+async function
+  _target_app_get(
+    _contract_address) {
+  let
+    _target_app;
+  _target_app =
+    "";
+  const
+    _contract_address_type =
+      typeof(
+        _contract_address);
+  if ( _contract_address_type != "undefined" &&
+       _contract_address != "" ) {
+    const
+      _address_valid =
+        _address_check(
+          _contract_address);
+    if ( ! _address_valid ) {
+      _target_app =
+        await _app_lookup_contract(
+          _contract_address);
+    }
+  }
+  return _target_app;
+}
+
+async function
+  _contract_lookup_address(
+    _target_app,
+    _address,
+    _target_network) {
+  let
+    _contract,
+    _contract_address,
+    _contract_dir,
+    _contract_networks,
+    _evm_contract_deployment_address_args,
+    _exception,
+    _msg,
+    _network;
+  const
+    _target_contracts =
+      {};
+  const
+    _lib =
+      await _lib_get();
+  const
+    _deployments_dir =
+      _path_join([
+        _lib,
+        _target_app,
+        "deployments"
+      ]);
+  const
+    _contracts =
+      await _ls(
+        _deployments_dir);
+  for ( _contract of _contracts ) {
+    _contract_dir =
+      _path_join([
+        _deployments_dir,
+        _contract
+      ]);
+    _contract_networks =
+      await _ls(
+        _contract_dir);
+    for ( _network in _contract_networks ) {
+      _evm_contract_deployment_address_args = [
+        [ _target_network ],       // target networks
+        [ _target_network ],       // target chain ids
+        "n",                       // all networks
+        _target_app,
+        _contract,
+        "",                        // contract version
+        "n",                       // user-level
+        "",                        // configuration format
+        _deployments_dir
+      ];
+      _contract_address =
+        await _evm_contract_deployment_address.apply(
+          null,
+          _evm_contract_deployment_address_args);
+      if ( _address == _contract_address ) {
+        if ( _target_network == "" ) {
+          _target_contracts[
+            _contract] =
+            1;
+        }
+        else {
+          if ( _network == _target_network ) {
+            _target_contracts[
+              _contract] =
+              1;
+          }
+	}
+      }
+    }
+  }
+  const
+    _target_contracts_set =
+      Object.keys(
+        _target_contracts);
+  const
+    _target_contracts_amount =
+      _target_contracts_set.length; 
+  if ( _target_contracts_amount < 1 ) {
+    _msg =
+      "No contract found for " +
+      `address '${_address}' ` +
+      `on network '${_network}' in '${_lib}'.`;
+    _msg_error(
+      _msg,
+      0);
+    _exception = {
+      "msg":
+        _msg
+    };
+    throw _exception;
+  }
+  if ( 1 < _target_contracts_amount ) {
+    _msg =
+      "Found more than one contract for " +
+      `contract '${_contract}' ` +
+      `in '${_lib}':\n`;
+    for ( _contract of _target_contracts_set ) {
+      _msg =
+        _msg + `${_contract}\n`;
+    }
+    _msg_error(
+      _msg,
+      0);
+    _exception = {
+      "msg":
+        _msg
+    };
+    throw _exception;
+  }
+  else {
+    return _target_contracts_set;
+  }
+}
+
+async function
+  _app_lookup_contract(
+    _contract_name) {
+  let
+    _app,
+    _contract_dir,
+    _is_dir,
+    _msg;
+  const
+    _lib =
+      await _lib_get();
+  const
+    _target_apps =
+      {};
+  const
+    _apps =
+      await _ls(
+      _lib);
+  for ( _app of _apps ) {
+    _contract_dir =
+      _path_join([
+        _lib,
+        _app,
+        "deployments",
+        _contract_name
+      ]);
+    // _echo(_contract_dir);
+    _is_dir =
+      await _dir_exists(
+        _contract_dir);
+    // _echo(_is_dir);
+    if ( _is_dir ) {
+      // _echo(
+      //   _contract_dir);
+      _target_apps[
+        _app] =
+        1;
+    }
+  }
+  const
+    _target_apps_set =
+      Object.keys(
+        _target_apps);
+  const
+    _target_apps_amount =
+      _target_apps_set.length;
+  if ( _target_apps_amount < 1 ) {
+    _msg =
+      "No apps found for " +
+      `contract '${_contract_name}' ` +
+      `in '${_lib}'.`;
+    _msg_error(
+      _msg,
+      0);
+    const
+      _exception = {
+        "msg":
+          _msg
+      };
+    throw _exception;
+  }
+  else if ( 1 < _target_apps_amount ) {
+    _msg =
+      "Found more than one app for " +
+      `contract '${_contract_name}' ` +
+      `in '${_lib}': '${_target_apps_set}'.`;
+    _msg_error(
+      _msg,
+      0);
+    const
+      _exception = {
+        "msg":
+          _msg
+      };
+    throw _exception;
+  }
+  return _target_apps_set[
+    0];
+}
+
+async function
+  _target_app_auto_detect() {
+  let
+    _target_app;
+  _target_app =
+    "";
+  const
+    _contract_address =
+      _get(
+        "contract",
+        "address");
+  const
+    _contract_address_type =
+      typeof(
+        _contract_address);
+  if ( _contract_address_type != "undefined" &&
+       _contract_address != "" ) {
+    _target_app =
+      await _target_app_get(
+        _contract_address);
+  }
+  _override_set(
+    "target",
+    "app",
+    _target_app);
+}
+
+async function
+  _target_contract_auto_detect() {
+  let
+    _target_contract;
+  _target_contract =
+    "";
+  const
+    _contract_address =
+      _get(
+        "contract",
+        "address");
+  const
+    _address_valid =
+      await _address_check(
+        _contract_address);
+  if ( ! _address_valid ) {
+    _target_contract =
+      _contract_address;
+  }
+  _override_set(
+    "target",
+    "contract",
+    _target_contract);
+}
+
+async function
+  _contract_address_auto_detect() {
+  let
+    _contract_address,
+    _contract_addresses,
+    _evm_contract_deployment_address_args,
+    _msg,
+    _network;
+  const
+    _target_networks_index =
+      {};
+  _contract_address =
+    _get(
+      "contract",
+      "address");
+  const
+    _target_app =
+      _get(
+        "target",
+        "app");
+  const
+    _target_networks =
+      _get(
+        "target",
+        "networks");
+  const
+    _target_contract =
+      _get(
+        "target",
+        "contract");
+  const
+    _deployments_dir =
+      _get(
+        "deployments",
+        "dir");
+  for ( _network of _target_networks ) {
+    _target_networks_index[
+      _network] =
+        1;
+  }
+  const
+    _target_networks_set =
+      Object.keys(
+        _target_networks_index);
+  _msg =
+    "Auto-detecting address " +
+    `for contract '${_contract_address}' ` +
+    `on network '${_target_networks_set}' ` +
+    `for application '${_target_app}'.`;
+  _msg_info(
+    _msg);
+  if ( _contract_address != "" ) {
+    const
+      _address_valid =
+        await _address_check(
+          _contract_address);
+    if ( _address_valid ) {
+      _msg =
+        `Address '${_contract_address}' ` +
+        `is valid.`;
+      _msg_info(
+        _msg);
+    }
+    else {
+      if ( _target_app != "" &&
+           0 < _target_networks.length &&
+           _target_contract != "" ) {
+        _msg =
+          "Looking for address " +
+          "corresponding to contract " +
+          `'${_target_contract}' for the ` +
+          `'${_target_app}' ` +
+          "libEVM application on network " +
+          `'${_target_networks}' at deployments ` +
+          `directory '${_deployments_dir}'.`;
+        _msg_info(
+          _msg);
+        _evm_contract_deployment_address_args = [
+          _target_networks_set,      // target networks
+          _target_networks_set,      // target chain ids
+          "n",                       // all networks
+          _target_app,
+          _target_contract,
+          "",                        // contract version
+          "n",                       // user-level
+          "",                        // configuration format
+          _deployments_dir
+        ];
+        try {
+          _contract_addresses =
+            await _evm_contract_deployment_address.apply(
+              null,
+              _evm_contract_deployment_address_args);
+          _contract_address =
+            _contract_addresses[
+              0];
+        }
+        catch(
+          _error) {
+          _msg =
+            "Error while looking for contract " +
+            "address from local libEVM applications " +
+            "deployments directories.";
+          _msg_error(
+            _msg,
+            0);
+          _msg_error(
+            _error,
+            0);
+          throw _error;
+        }
+      }
+      else {
+        _msg =
+          "One between the " +
+          `application '${_target_app}', ` +
+          `the network '${_target_networks_set}' ` +
+          `or the contract '${_target_contract}' ` +
+          `has not been specified.`;
+        _msg_info(
+          _msg);
+      }
+    }
+  }
+  _set(
+    "contract",
+    "address",
+    _contract_address);
+}
+
+function
+  _data_dir_auto_detect() {
+  const
+    _homedir =
+      _homedir_get();
+  const
+    _app_name =
+      _get(
+        "app",
+        "name");
+  const
+    _data_dir =
+      _path_join([
+        _homedir,
+        ".local",
+        "share",
+        _app_name
+      ]);
+  _override_set(
+    "data",
+    "dir",
+    _data_dir);
+}
+
+function
+  _cache_dir_auto_detect() {
+  const
+    _homedir =
+      _homedir_get();
+  const
+    _app_name =
+      _get(
+        "app",
+        "name");
+  const
+    _cache_dir =
+      _path_join([
+        _homedir,
+        ".cache",
+        _app_name
+      ]);
+  _override_set(
+    "cache",
+    "dir",
+    _cache_dir);
+}
+
 // ES6 module exports
 
 export {
   _address_check,
+  _app_lookup_contract,
   _artifact_local_auto_detect,
+  _cache_dir_auto_detect,
   _call_auth_auto_detect,
   _call_auth_get,
   _contract_abi_auto_detect,
   _contract_abi_get,
+  _contract_address_auto_detect,
+  _data_dir_auto_detect,
   _default_artifact_path_get,
   _evm_contract_call,
+  _target_app_auto_detect,
+  _target_contract_auto_detect,
   _target_networks_auto_detect,
   _target_networks_get
 };
@@ -533,8 +1084,12 @@ export {
 // module.exports = {
 //   _address_check:
 //     _address_check,
+//   _app_lookup_contract:
+//     _app_lookup_contract,
 //   _artifact_local_auto_detect:
 //     _artifact_local_auto_detect,
+//   _cache_dir_auto_detect:
+//     _cache_dir_auto_detect,
 //   _call_auth_auto_detect:
 //     _call_auth_auto_detect,
 //   _call_auth_get:
@@ -543,12 +1098,20 @@ export {
 //     _contract_abi_auto_detect,
 //   _contract_abi_get:
 //     _contract_abi_get,
+//   _contract_address_auto_detect:
+//     _contract_address_auto_detect,
+//   _data_dir_auto_detect:
+//     _data_dir_auto_detect,
 //   _default_artifact_path_get:
 //     _default_artifact_path_get,
 //   _evm_contract_call:
 //     _evm_contract_call,
+//   _target_app_auto_detect:
+//     _target_app_auto_detect,
 //   _target_networks_auto_detect:
 //     _target_networks_auto_detect,
+//   _target_contract_auto_detect:
+//     _target_contract_auto_detect,
 //   _target_networks_get:
 //     _target_networks_get
 // };