evm-contracts-tools 0.0.57 → 0.0.62

package/libevm-contract-call

@@ -75,6 +75,11 @@ const
 const
   _dirname =
     _libcrash_module._dirname;
+/* global
+     _echo */
+const
+  _echo =
+    _libcrash_module._echo;
 /* global
      _file_exists */
 const
@@ -158,6 +163,15 @@ const
 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(
@@ -226,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();
@@ -241,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
@@ -257,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;
 }
@@ -335,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");
@@ -476,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_type == "string" ) {
+    if ( _call_type.length < 1 ) {
+      // Properly
+      _call_type =
+        "static";
+    }
+    else {
+      _echo(
+        _call_type);
+    }
   }
-  else if ( _call_type == "dynamic" ) {
-    _out =
-      "";
+  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
@@ -680,6 +755,7 @@ async function
   let
     _app,
     _contract_dir,
+    _is_dir,
     _msg;
   const
     _lib =
@@ -699,8 +775,14 @@ async function
         "deployments",
         _contract_name
       ]);
-    if ( _dir_exists(
-           _contract_dir) ) {
+    // _echo(_contract_dir);
+    _is_dir =
+      await _dir_exists(
+        _contract_dir);
+    // _echo(_is_dir);
+    if ( _is_dir ) {
+      // _echo(
+      //   _contract_dir);
       _target_apps[
         _app] =
         1;
@@ -747,7 +829,7 @@ async function
     0];
 }
 
-function
+async function
   _target_app_auto_detect() {
   let
     _target_app;
@@ -765,7 +847,7 @@ function
   if ( _contract_address_type != "undefined" &&
        _contract_address != "" ) {
     _target_app =
-      _target_app_get(
+      await _target_app_get(
         _contract_address);
   }
   _override_set(
@@ -774,12 +856,42 @@ function
     _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;
+    _msg,
+    _network;
+  const
+    _target_networks_index =
+      {};
   _contract_address =
     _get(
       "contract",
@@ -790,10 +902,10 @@ async function
         "target",
         "app");
   const
-    _target_network =
+    _target_networks =
       _get(
         "target",
-        "network");
+        "networks");
   const
     _target_contract =
       _get(
@@ -804,14 +916,37 @@ async function
       _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 ) {
+    if ( _address_valid ) {
+      _msg =
+        `Address '${_contract_address}' ` +
+        `is valid.`;
+      _msg_info(
+        _msg);
+    }
+    else {
       if ( _target_app != "" &&
-           _target_network != "" &&
+           0 < _target_networks.length &&
            _target_contract != "" ) {
         _msg =
           "Looking for address " +
@@ -819,12 +954,13 @@ async function
           `'${_target_contract}' for the ` +
           `'${_target_app}' ` +
           "libEVM application on network " +
-          `'${_target_network}'.`;
+          `'${_target_networks}' at deployments ` +
+          `directory '${_deployments_dir}'.`;
         _msg_info(
           _msg);
         _evm_contract_deployment_address_args = [
-          [ _target_network ],       // target networks
-          [ _target_network ],       // target chain ids
+          _target_networks_set,      // target networks
+          _target_networks_set,      // target chain ids
           "n",                       // all networks
           _target_app,
           _target_contract,
@@ -833,16 +969,35 @@ async function
           "",                        // configuration format
           _deployments_dir
         ];
-        _contract_address =
-          await _evm_contract_deployment_address.apply(
-            null,
-            _evm_contract_deployment_address_args);
+        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_network}' ` +
+          `the network '${_target_networks_set}' ` +
           `or the contract '${_target_contract}' ` +
           `has not been specified.`;
         _msg_info(
@@ -919,6 +1074,7 @@ export {
   _default_artifact_path_get,
   _evm_contract_call,
   _target_app_auto_detect,
+  _target_contract_auto_detect,
   _target_networks_auto_detect,
   _target_networks_get
 };
@@ -954,6 +1110,8 @@ export {
 //     _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
 // };

package/libevm-contract-deployment

@@ -85,6 +85,11 @@ const
 const
   _dir_exists =
     _libcrash_module._dir_exists;
+/* global
+     _echo */
+const
+  _echo =
+    _libcrash_module._echo;
 /* global
      _file_exists */
 const
@@ -100,6 +105,11 @@ const
 const
   _from_bash_ass_array =
     _libcrash_module._from_bash_ass_array;
+/* global
+     _get */
+const
+  _get =
+    _libcrash_module._get;
 /* global
      _homedir_get */
 const
@@ -154,33 +164,12 @@ const
 const
   _evm_chains_info =
     _evm_chains_info_module._evm_chains_info;
-const
-  _libevm_contract_deployments_dir_module =
-    await import(
-      "./libevm-contract-deployments-dir");
-/* global
-     _evm_contract_deployments_dir */
-const
-  _evm_contract_deployments_dir =
-    _libevm_contract_deployments_dir_module._evm_contract_deployments_dir;
-const
-  _libevm_contract_deployment_networks_module =
-    await import(
-      "./libevm-contract-deployment-networks");
+  /* global
+       _evm_contract_deployments_dir */
 /* global
      _evm_contract_deployment_networks */
-const
-  _evm_contract_deployment_networks =
-    _libevm_contract_deployment_networks_module._evm_contract_deployment_networks;
-const
-  _libevm_contract_deployment_versions_module =
-    await import(
-      "./libevm-contract-deployment-versions");
 /* global
      _evm_contract_deployment_versions */
-const
-  _evm_contract_deployment_versions =
-    _libevm_contract_deployment_versions_module._evm_contract_deployment_versions;
 
 async function
   _network_check(
@@ -189,18 +178,45 @@ async function
     _target_network,
     _target_network_id) {
   let
+    _contract_deployments_path,
     _error_flag,
+    _evm_contract_deployment_networks,
+    _evm_chains_info_args,
     _msg,
     _network_id;
+  _msg =
+    "Network check for deployments " +
+    `'${_deployments}', contract '${_contract}', ` +
+    `network '${_target_network}' and network with ID ` +
+    `'${_target_network_id}'.`;
+  _msg_info(
+    _msg);
+  _evm_contract_deployment_networks =
+    _get(
+      "_evm_contract",
+      "deployment_networks");
+  const
+    _evm_contract_deployment_networks_type =
+      typeof(
+        _evm_contract_deployment_networks_dir);
+  if ( _evm_contract_deployment_networks_type == "undefined" ||
+       _evm_contract_deployment_networks == "" ) {
+    const
+      _libevm_contract_deployment_networks_module =
+        await import(
+          "./libevm-contract-deployment-networks");
+      _evm_contract_deployment_networks =
+        _libevm_contract_deployment_networks_module._evm_contract_deployment_networks;
+  }
   _error_flag =
     false;
-  _deployments_path =
+  _contract_deployments_path =
     _path_join( [
       _deployments,
       _contract ]);
   const
     _evm_contract_deployment_networks_args = [
-      _deployments_path,
+      _contract_deployments_path,
       "y",                  // Display all
       "n",                  // Display safest
       "n"                   // Display cheapest
@@ -240,7 +256,8 @@ async function
   if ( _error_flag ) {
     _msg_error(
       _msg,
-      1);
+      0);
+    throw _msg;
   }
   if ( _target_network_id == "" ) {
     _evm_chains_info_args = [
@@ -256,12 +273,29 @@ async function
       _target_network,
       []                 // database paths
     ];
-    _network_id =
-      await _evm_chains_info.apply(
-        null,
-        _evm_chains_info_args);
+    try {
+      _network_id =
+        await _evm_chains_info.apply(
+          null,
+          _evm_chains_info_args);
+    }
+    catch(
+      _error) {
+      _msg = 
+        "Error while running '_evm_chains_info' " +
+        `with arguments '${_evm_chains_info_args}'.`;
+      _msg_error(
+        _msg,
+        0);
+      _msg_error(
+        _error,
+        0);
+      throw _error;
+    }
   }
   else if ( _target_network == "" ) {
+    _network_id =
+      _target_network_id;
     _evm_chains_info_args = [
       "get",             // target command
       "id"  ,            // input type
@@ -275,9 +309,25 @@ async function
       _target_network_id,
       []                 // database paths
     ];
-    _target_network =
-      await _evm_chains_info(
-        _evm_chains_info_args);
+    try {
+      _target_network =
+        await _evm_chains_info.apply(
+          null,
+          _evm_chains_info_args);
+    }
+    catch(
+      _error) {
+      _msg = 
+        "Error while running '_evm_chains_info' " +
+        `with arguments '${_evm_chains_info_args}'.`;
+      _msg_error(
+        _msg,
+        0);
+      _msg_error(
+        _error,
+        0);
+      throw _error;
+    }
   }
   if ( _target_network_id != "" ) {
     if ( _target_network_id != _network_id ) {
@@ -288,18 +338,45 @@ async function
         `known ID '${_network_id}'.`;
       _msg_error(
         _msg,
-        1);
+        0);
+      throw _msg;
     }
   }
+  _msg =
+    "Network check for deployments " +
+    `'${_deployments}', contract '${_contract}', ` +
+    `network '${_target_network}' and network with ID ` +
+    `'${_target_network_id}' completed.`;
+  _msg_info(
+    _msg);
 }
 
 async function
   _user_deployments_init(
     _app,
     _deployments_dir) {
+  let
+    _evm_contract_deployments_dir;
   const
     _user_defined =
       "y";
+  _evm_contract_deployments_dir =
+    _get(
+      "_evm_contract",
+      "deployments_dir");
+  const
+    _evm_contract_deployments_dir_type =
+      typeof(
+        _evm_contract_deployments_dir);
+  if ( _evm_contract_deployments_dir_type == "undefined" ||
+       _evm_contract_deployments_dir == "" ) {
+    const
+      _libevm_contract_deployments_dir_module =
+        await import(
+          "./libevm-contract-deployments-dir");
+      _evm_contract_deployments_dir =
+        _libevm_contract_deployments_dir_module._evm_contract_deployments_dir;
+  }
   const
     _evm_contract_deployments_dir_args = [
       _app,
@@ -347,7 +424,8 @@ async function
 async function
   _deployments_dir_auto_detect() {
   let
-    _deployments;
+    _deployments,
+    _evm_contract_deployments_dir;
   _deployments =
     "";
   const
@@ -362,6 +440,23 @@ async function
     const
       _user_defined =
         user_defined;
+    _evm_contract_deployments_dir =
+      _get(
+        "_evm_contract",
+        "deployments_dir");
+    const
+      _evm_contract_deployments_dir_type =
+        typeof(
+          _evm_contract_deployments_dir);
+    if ( _evm_contract_deployments_dir_type == "undefined" ||
+         _evm_contract_deployments_dir == "" ) {
+      const
+        _libevm_contract_deployments_dir_module =
+          await import(
+            "./libevm-contract-deployments-dir");
+        _evm_contract_deployments_dir =
+          _libevm_contract_deployments_dir_module._evm_contract_deployments_dir;
+    }
     const
       _evm_contract_deployments_dir_args = [
         _app,
@@ -384,6 +479,7 @@ async function
     _config,
     _config_ext,
     _deployments,
+    _evm_contracts_deployment_versions,
     _found,
     _net,
     _network,
@@ -485,6 +581,27 @@ async function
           _msg,
           1);
       }
+      const
+        _libevm_contract_deployment_versions_module =
+          await import(
+            "./libevm-contract-deployment-versions");
+      _evm_contract_deployment_versions =
+        _get(
+          "_evm_contract",
+          "deployment_versions");
+      const
+        _evm_contract_deployment_versions_type =
+          typeof(
+            _evm_contract_deployment_versions_dir);
+      if ( _evm_contract_deployment_versions_type == "undefined" ||
+           _evm_contract_deployment_versions == "" ) {
+        const
+          _libevm_contract_deployment_versions_module =
+            await import(
+              "./libevm-contract-deployment-versions");
+          _evm_contract_deployment_versions =
+            _libevm_contract_deployment_versions_module._evm_contract_deployment_versions;
+      }
       const
         _evm_contract_deployment_versions_args = [
           _config,
@@ -548,6 +665,7 @@ async function
   const
     _user_defined =
       user_defined;
+
   const
     _evm_contract_deployments_dir_args = [
       _dir_current_name,