evm-contracts-tools 0.0.62 → 0.0.65

package/libevm-contract-deployment

@@ -2,25 +2,27 @@
 
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-/**    ----------------------------------------------------------------
+/**    ----------------------------------------------------------
  *     libevm-contract-deployment
- *     ----------------------------------------------------------------
+ *     ----------------------------------------------------------
  *     Copyright ©
  *       Pellegrino Prevete
  *         2025, 2026
  * 
  *     All rights reserved
- *     ----------------------------------------------------------------
+ *     ----------------------------------------------------------
  * 
- *     This program is free software: you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation, either version 3 of
- *     the License, or (at your option) any later version.
+ *     This program is free software: you can redistribute it
+ *     and/or modify it under the terms of the GNU General
+ *     Public License as published by the Free Software
+ *     Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
  * 
- *     This program is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
+ *     This program is distributed in the hope that it will
+ *     be useful, but WITHOUT ANY WARRANTY; without even the
+ *     implied warranty of MERCHANTABILITY or FITNESS FOR A
+ *     PARTICULAR PURPOSE.
+ *     See the GNU General Public License for more details.
  * 
  *     You should have received a copy of the
  *     GNU General Public License
@@ -80,6 +82,11 @@ const
 const
   _cp =
     _libcrash_module._cp;
+/* global
+     _dirname */
+const
+  _dirname =
+    _libcrash_module._dirname;
 /* global
      _dir_exists */
 const
@@ -90,6 +97,11 @@ const
 const
   _echo =
     _libcrash_module._echo;
+/* global
+     _echo2 */
+const
+  _echo2 =
+    _libcrash_module._echo2;
 /* global
      _file_exists */
 const
@@ -110,6 +122,11 @@ const
 const
   _get =
     _libcrash_module._get;
+/* global
+     _global_get */
+const
+  _global_get =
+    _libcrash_module._global_get;
 /* global
      _homedir_get */
 const
@@ -135,6 +152,11 @@ const
 const
   _msg_error =
     _libcrash_module._msg_error;
+/* global
+     _msg_warning */
+const
+  _msg_warning =
+    _libcrash_module._msg_warning;
 /* global
      _override_set */
 const
@@ -155,6 +177,11 @@ const
 const
   _require =
     _libcrash_module._require;
+/* global
+     _set */
+const
+  _set =
+    _libcrash_module._set;
 const
   _evm_chains_info_module =
     await _require(
@@ -164,595 +191,4465 @@ const
 const
   _evm_chains_info =
     _evm_chains_info_module._evm_chains_info;
-  /* global
-       _evm_contract_deployments_dir */
+/* global
+     _evm_contract_deployments_dir */
 /* global
      _evm_contract_deployment_networks */
 /* global
      _evm_contract_deployment_versions */
+const
+  _evm_contracts_tools_module =
+    await import(
+      "./evm-contracts-tools");
+/* global
+     _address_check */
+const
+  _address_check =
+    _evm_contracts_tools_module._address_check;
 
-async function
-  _network_check(
-    _deployments,
-    _contract,
-    _target_network,
-    _target_network_id) {
+function
+  _configuration_format_check(
+    _configuration_format) {
   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");
+    _msg;
   const
-    _evm_contract_deployment_networks_type =
+    _configuration_format_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;
+        _configuration_format);
+  if ( _configuration_format_type === "undefined" ) {
+    _msg =
+      "Configuration format not set, " +
+      "setting default (bash).";
+    _msg_info(
+      _msg);
+    _configuration_format =
+      "bash";
   }
-  _error_flag =
-    false;
-  _contract_deployments_path =
-    _path_join( [
-      _deployments,
-      _contract ]);
-  const
-    _evm_contract_deployment_networks_args = [
-      _contract_deployments_path,
-      "y",                  // Display all
-      "n",                  // Display safest
-      "n"                   // Display cheapest
-    ];
-  const
-    _networks =
-      await _evm_contract_deployment_networks.apply(
-        null,
-        _evm_contract_deployment_networks_args);
-  if ( _target_network_id != "" ) {
-    if ( ! _networks.includes(
-             _target_network_id) ) {
+  else if ( _configuration_format_type === "string" ) {
+    if ( _configuration_format.length < 1 ) {
       _msg =
-        "The contract does not result deployed on " +
-        `network with id '${_target_network_id}'.`;
-      _error_flag =
-        true;
+        "Configuration format not set, " +
+        "setting default (bash).";
+      _msg_info(
+        _msg);
+      _configuration_format =
+        "bash";
     }
-  }
-  else if ( _target_network != "" ) {
-    if ( ! _networks.includes(
-             _target_network) ) {
+    else {
       _msg =
-        "The contract does not result deployed on " +
-        `network '${_target_network}'.`;
-      _error_flag =
-        true;
+        "Setting configuration format " +
+        `'${_configuration_format}'.`;
     }
   }
   else {
     _msg =
-      "Provide one between a target network name " +
-      "or ID.";
-    _error_flag =
-      true;
-  }
-  if ( _error_flag ) {
+      "Type of variable " +
+      "'configuration format' must be string.";
     _msg_error(
       _msg,
       0);
     throw _msg;
   }
-  if ( _target_network_id == "" ) {
-    _evm_chains_info_args = [
-      "get",             // target command
-      "name",            // input type
-      "id",              // output type
-      "offline",
-      [ "system",        // db types
-        "node" ],
-      "kirsh",           // selection method, first
-      "n",               // api keys
-      "n",               // query all networks
-      _target_network,
-      []                 // database paths
-    ];
-    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
-      "name",            // output type
-      "offline",
-      [ "system",        // db types
-        "node" ],
-      "kirsh",           // selection method, first
-      "n",               // api keys
-      "n",               // query all networks
-      _target_network_id,
-      []                 // database paths
-    ];
-    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 ) {
-      _msg =
-        "Requested target network ID " +
-        `'${_target_network_id}' does ` +
-        `not correspond to '${_target_network}' ` +
-        `known ID '${_network_id}'.`;
-      _msg_error(
-        _msg,
-        0);
-      throw _msg;
-    }
+  if ( _configuration_format !== "bash" &&
+       _configuration_format !== "json" ) {
+    _msg =
+      "Unknown configuration format " +
+      `'${_configuration_format}'.`
+    _msg_error(
+      _msg,
+      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);
+  return _configuration_format;
 }
 
-async function
-  _user_deployments_init(
-    _app,
-    _deployments_dir) {
+function
+  _default_artifact_path_get(
+    _type,
+    _target_network,
+    _contract_address) {
   let
-    _evm_contract_deployments_dir;
-  const
-    _user_defined =
-      "y";
-  _evm_contract_deployments_dir =
-    _get(
-      "_evm_contract",
-      "deployments_dir");
+    _file_name;
   const
-    _evm_contract_deployments_dir_type =
+    _network_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;
+        _target_network);
+  if ( _network_type === "undefined" ||
+       _target_network === "" ) {
+    _target_network =
+      _get(
+        "target",
+        "network");
   }
   const
-    _evm_contract_deployments_dir_args = [
-      _app,
-      _user_defined
-    ];
+    _contract_address_type =
+      typeof(
+        _contract_address);
+  if ( _contract_address_type === "undefined" ||
+       _contract_address === "" ) {
+    _contract_address =
+      _get(
+        "contract",
+        "address");
+  }
   const
-    _system_deployments =
-      await _evm_contract_deployments_dir.apply(
-        null,
-        _evm_contract_deployments_dir_args);
-  _chmod(
-    _deployments_dir,
-    "0700");
+    _home =
+      _homedir_get();
   const
-    _files =
-      await _ls(
-        _system_deployments);
-  for ( _file of _files ) {
-    _cp(
-      _file,
-      _deployments_dir);
+    _data_dir =
+      _path_join( [
+        _home,
+        ".local",
+        "share",
+        "evm-contract-call" ]);
+  if ( _type == "abi" ) {
+    _file_name =
+      `${_contract_address}.abi.json`;
   }
-  return true;
-}
-
-async function
-  _user_deployments_check(
-    _app,
-    _deployments_dir) {
-  if ( ! _file_exists(
-           _deployments_dir) ) {
-    const
-      _user_deployments_init_args = [
-        _app,
-        _deployments_dir
-      ];
+  else if ( _type == "bytecode" ) {
+    _file_name =
+      `${_contract_address}.bin`;
+  }
+  else if ( _type == "compiler_output" ) {
+    _file_name =
+      `${_contract_address}.json`;
+  }
+  else {
     const
-      _initialized =
-        await _user_deployments_init.apply(
-          null,
-          _user_deployments_init_args);
+      _msg =
+        `Unknown artifact type '${_type}'.`;
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
   }
+  const
+    _artifact =
+      _path_join( [
+        _data_dir,
+        _target_network,
+        _file_name ]);
+  return _artifact;
 }
 
 async function
-  _deployments_dir_auto_detect() {
+  _contract_abi_check(
+    _abi,
+    _network,
+    _address,
+    _api_key,
+    _compiler_output,
+    _app,
+    _contract,
+    _configuration_format,
+    _deployments_dir,
+    _user_defined,
+    _local) {
   let
-    _deployments,
-    _evm_contract_deployments_dir;
-  _deployments =
-    "";
-  const
-    _app =
-      target_app;
+    _abi_get,
+    _abi_target,
+    _abi_targets,
+    _evm_contract_deployment_abi,
+    _msg;
+  _abi_get =
+    false;
+  _local =
+    _local_check(
+      _local);
   const
-    _app_type =
+    _abi_type =
       typeof(
-        _app);
-  if ( _app_type != "undefined" &&
-       _app != "" ) {
-    const
-      _user_defined =
-        user_defined;
-    _evm_contract_deployments_dir =
+        _abi);
+  _user_defined =
+    _user_defined_check(
+      _user_defined);
+  if ( _abi_type === "undefined" ) {
+    _msg =
+      "ABI undefined, setting default.";
+    _msg_info(
+      _msg);
+    _abi_get =
+      true;
+  }
+  else if ( _abi_type === "string" ) {
+    if ( _abi.length < 1 ) {
+      _abi_get =
+        true;
+    }
+  }
+  else {
+    _msg =
+      "ABI path must be a string.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  if ( _abi_get ) {
+    if ( ! _local ) {
+      _abi =
+        _get(
+          "contract",
+          "abi");
+      _msg =
+        "Variable '_abi' not defined, " +
+        "defaulting to global variable " +
+        "'contract_abi', which has value " +
+        `'${_abi}'.`;
+      _msg_info(
+        _msg);
+    }
+    else {
+      const
+        _network_type =
+          typeof(
+            _network);
+      if ( _network_type === "undefined" ) {
+        _network =
+          _get(
+            "target",
+            "network");
+        _msg =
+          "Variable '_network' not defined, " +
+          "defaulting to global variable " +
+          "'target_network', which has value " +
+          `'${_network}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _api_key_type =
+          typeof(
+            _api_key);
+      if ( _api_key_type == "undefined" ) {
+        _api_key =
+          _get(
+            "api",
+            "key");
+        _msg =
+          "Variable '_api_key' not defined, " +
+          "defaulting to global variable " +
+          "'api_key', which has value " +
+          `'${_api_key}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _compiler_output_type =
+          typeof(
+            _compiler_output);
+      if ( _compiler_output_type == "undefined" ) {
+        _compiler_output =
+          _get(
+            "contract",
+            "compiler_output");
+        _msg =
+          "Variable '_compiler_output' not defined, " +
+          "defaulting to global variable " +
+          "'contract_compiler_output', which has value " +
+          `'${_compiler_output}'.`;
+        _msg_info(
+          _msg);
+      }
+      _app =
+        _app_check(
+          _app);
+      const
+        _contract_type =
+          typeof(
+            _contract);
+      if ( _contract_type == "undefined" ) {
+        _contract =
+          _get(
+            "target",
+            "contract");
+        _msg =
+          "Variable '_contract' not defined, " +
+          "defaulting to global variable " +
+          "'target_contract', which has value " +
+          `'${_contract}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _address_type =
+          typeof(
+            _address);
+      if ( _address_type == "undefined" ) {
+        _address =
+          _get(
+            "contract",
+            "address");
+        _msg =
+          "Variable '_address' not defined, " +
+          "defaulting to global variable " +
+          "'contract_address', which has value " +
+          `'${_address}'.`;
+        _msg_info(
+          _msg);
+      }
+      _abi_target =
+        _abi;
+      _abi_target =
+        _default_artifact_path_get(
+          "abi");
+      const
+        _abi_target_exists =
+          _file_exists(
+            _abi_target);
+      if ( ! _abi_target_exists ) {
+        if ( _app !== "" &&
+             _contract !== "" ) {
+          _evm_contract_deployment_abi =
+            _get(
+              "_evm_contract_deployment",
+              "abi");
+          try {
+            _evm_contract_deployment_abi =
+              await _evm_contract_deployment_abi_check.apply(
+                null,
+                _evm_contract_deployment_abi);
+          }
+          catch(
+            _error) {
+            _msg =
+              "Error running " +
+              "'_evm_contract_deployment_abi_check' " +
+              "with parameters:";
+            _msg_error(
+              _msg,
+              0);
+            _echo2(
+              _evm_contract_deployment_abi);
+            _echo2(
+              _error);
+            throw _error;
+          }
+          const
+            _configuration_format_check_args = [
+              _configuration_format
+            ];
+          _configuration_format =
+            _configuration_format_check.apply(
+              null,
+              _configuration_format_check_args);
+          const
+            _deployments_dir_check_args = [
+              _deployments_dir,
+              _app,
+              _user_defined
+            ];
+          try {
+            _deployments_dir =
+              await _deployments_dir_check.apply(
+                null,
+                _deployments_dir_check_args);
+          }
+          catch(
+            _error) {
+            _msg =
+              "Error running '_deployments_dir_check' " +
+              "with parameters:";
+            _msg_error(
+              _msg,
+              0);
+            _echo2(
+              _deployments_dir_check_args);
+            _echo2(
+              _error);
+            throw _error;
+          }
+          _msg =
+            `Getting LibEVM app '${_app}' ` +
+            `ABI for contract '${_contract}' for ` +
+            `network '${_network}' in format ` +
+            `'${_configuration_format}' at deployments ` +
+            `directory '${_deployments_dir}'.`;
+          _msg_info(
+            _msg);
+          const
+            _evm_contract_deployment_abi_args = [
+              [ _network ] ,
+              [ _network ],
+              "n",
+              _app,
+              _contract,
+              "",                     // version
+              "n",                    // user level
+              _configuration_format,
+              _deployments_dir
+            ];
+          try {
+            _abi_targets =
+              await _evm_contract_deployment_abi.apply(
+                null,
+                _evm_contract_deployment_abi_args);
+          }
+          catch(
+            _error) {
+            _msg =
+              `Error retrieving LibEVM app '${_app}' ` +
+              `ABI for contract '${_contract}'.`;
+            _msg_error(
+              _msg,
+              0);
+            throw _error;
+          }
+          if ( 0 < _abi_target.length ) {
+            _abi_target =
+              _abi_targets[
+                0];
+          }
+          else if ( _abi_target.length < 1 ) {
+            _msg =
+              "Got no results.";
+            _msg_warning(
+              _msg);
+          }
+        }
+      }
+      else {
+        _msg =
+          "Selecting abi target " +
+          `'${_abi_target}' for auto-detection.`;
+        _msg_info(
+          _msg);
+      }
+    }
+  }
+  if ( ! _file_exists(
+           _abi) &&
+       ! _file_exists(
+           _compiler_output) ) {
+    if ( _file_exists(
+           _abi_target) ) {
+      _abi =
+        _abi_target;
+    }
+    else {
+      _msg =
+        `ABI '${_abi}' does not ` +
+        `exist and '${_abi_target}' neither.`;
+      _msg_info(
+        _msg);
+      const
+        _abi_dir =
+          _dirname(
+            _abi);
+      _contract_artifacts_retrieve(
+        _abi_dir);
+    }
+  }
+  return _abi;
+}
+
+async function
+  _contract_bytecode_check(
+    _bytecode,
+    _network,
+    _address,
+    _api_key,
+    _compiler_output,
+    _app,
+    _contract,
+    _configuration_format,
+    _deployments_dir,
+    _user_defined,
+    _local) {
+  let
+    _bytecode_get,
+    _bytecode_target,
+    _bytecode_targets,
+    _evm_contract_deployment_bytecode,
+    _msg;
+  _bytecode_get =
+    false;
+  _local =
+    _local_check(
+      _local);
+  const
+    _bytecode_type =
+      typeof(
+        _bytecode);
+  _user_defined =
+    _user_defined_check(
+      _user_defined);
+  if ( _bytecode_type === "undefined" ) {
+    _msg =
+      "Bytecode undefined, setting default.";
+    _msg_info(
+      _msg);
+    _bytecode_get =
+      true;
+  }
+  else if ( _bytecode_type === "string" ) {
+    if ( _bytecode.length < 1 ) {
+      _bytecode_get =
+        true;
+    }
+  }
+  else {
+    _msg =
+      "Bytecode path must be a string.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  if ( _bytecode_get ) {
+    if ( ! _local ) {
+      _bytecode =
+        _get(
+          "contract",
+          "bytecode");
+      _msg =
+        "Variable '_bytecode' not defined, " +
+        "defaulting to global variable " +
+        "'contract_bytecode', which has value " +
+        `'${_bytecode}'.`;
+      _msg_info(
+        _msg);
+    }
+    else {
+      const
+        _network_type =
+          typeof(
+            _network);
+      if ( _network_type === "undefined" ) {
+        _network =
+          _get(
+            "target",
+            "network");
+        _msg =
+          "Variable '_network' not defined, " +
+          "defaulting to global variable " +
+          "'target_network', which has value " +
+          `'${_network}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _api_key_type =
+          typeof(
+            _api_key);
+      if ( _api_key_type == "undefined" ) {
+        _api_key =
+          _get(
+            "api",
+            "key");
+        _msg =
+          "Variable '_api_key' not defined, " +
+          "defaulting to global variable " +
+          "'api_key', which has value " +
+          `'${_api_key}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _compiler_output_type =
+          typeof(
+            _compiler_output);
+      if ( _compiler_output_type == "undefined" ) {
+        _compiler_output =
+          _get(
+            "contract",
+            "compiler_output");
+        _msg =
+          "Variable '_compiler_output' not defined, " +
+          "defaulting to global variable " +
+          "'contract_compiler_output', which has value " +
+          `'${_compiler_output}'.`;
+        _msg_info(
+          _msg);
+      }
+      _app =
+        _app_check(
+          _app);
+      const
+        _contract_type =
+          typeof(
+            _contract);
+      if ( _contract_type == "undefined" ) {
+        _contract =
+          _get(
+            "target",
+            "contract");
+        _msg =
+          "Variable '_contract' not defined, " +
+          "defaulting to global variable " +
+          "'target_contract', which has value " +
+          `'${_contract}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _address_type =
+          typeof(
+            _address);
+      if ( _address_type == "undefined" ) {
+        _address =
+          _get(
+            "contract",
+            "address");
+        _msg =
+          "Variable '_address' not defined, " +
+          "defaulting to global variable " +
+          "'contract_address', which has value " +
+          `'${_address}'.`;
+        _msg_info(
+          _msg);
+      }
+      _bytecode_target =
+        _bytecode;
+      _bytecode_target =
+        _default_artifact_path_get(
+          "bytecode");
+      const
+        _bytecode_target_exists =
+          _file_exists(
+            _bytecode_target);
+      if ( ! _bytecode_target_exists ) {
+        if ( _app !== "" &&
+             _contract !== "" ) {
+          _evm_contract_deployment_bytecode =
+            _get(
+              "_evm_contract_deployment",
+              "bytecode");
+          try {
+            _evm_contract_deployment_bytecode =
+              await _evm_contract_deployment_bytecode_check.apply(
+                null,
+                _evm_contract_deployment_bytecode);
+          }
+          catch(
+            _error) {
+            _msg =
+              "Error running " +
+              "'_evm_contract_deployment_bytecode_check' " +
+              "with parameters:";
+            _msg_error(
+              _msg,
+              0);
+            _echo2(
+              _evm_contract_deployment_bytecode);
+            _echo2(
+              _error);
+            throw _error;
+          }
+          const
+            _configuration_format_check_args = [
+              _configuration_format
+            ];
+          _configuration_format =
+            _configuration_format_check.apply(
+              null,
+              _configuration_format_check_args);
+          const
+            _deployments_dir_check_args = [
+              _deployments_dir,
+              _app,
+              _user_defined
+            ];
+          try {
+            _deployments_dir =
+              await _deployments_dir_check.apply(
+                null,
+                _deployments_dir_check_args);
+          }
+          catch(
+            _error) {
+            _msg =
+              "Error running '_deployments_dir_check' " +
+              "with parameters:";
+            _msg_error(
+              _msg,
+              0);
+            _echo2(
+              _deployments_dir_check_args);
+            _echo2(
+              _error);
+            throw _error;
+          }
+          _msg =
+            `Getting LibEVM app '${_app}' ` +
+            `bytecode for contract '${_contract}' for ` +
+            `network '${_network}' in format ` +
+            `'${_configuration_format}' at deployments ` +
+            `directory '${_deployments_dir}'.`;
+          _msg_info(
+            _msg);
+          const
+            _evm_contract_deployment_bytecode_args = [
+              [ _network ] ,
+              [ _network ],
+              "n",
+              _app,
+              _contract,
+              "",                     // version
+              "n",                    // user level
+              _configuration_format,
+              _deployments_dir
+            ];
+          try {
+            _bytecode_targets =
+              await _evm_contract_deployment_bytecode.apply(
+                null,
+                _evm_contract_deployment_bytecode_args);
+          }
+          catch(
+            _error) {
+            _msg =
+              `Error retrieving LibEVM app '${_app}' ` +
+              `bytecode for contract '${_contract}'.`;
+            _msg_error(
+              _msg,
+              0);
+            throw _error;
+          }
+          if ( 0 < _bytecode_target.length ) {
+            _bytecode_target =
+              _bytecode_targets[
+                0];
+          }
+          else if ( _bytecode_target.length < 1 ) {
+            _msg =
+              "Got no results.";
+            _msg_warning(
+              _msg);
+          }
+        }
+      }
+      else {
+        _msg =
+          "Selecting abi target " +
+          `'${_bytecode_target}' for auto-detection.`;
+        _msg_info(
+          _msg);
+      }
+    }
+  }
+  if ( ! _file_exists(
+           _bytecode) &&
+       ! _file_exists(
+           _compiler_output) ) {
+    if ( _file_exists(
+           _bytecode_target) ) {
+      _bytecode =
+        _bytecode_target;
+    }
+    else {
+      _msg =
+        `Bytecode '${_bytecode}' does not ` +
+        `exist and '${_bytecode_target}' neither.`;
+      _msg_info(
+        _msg);
+      const
+        _bytecode_dir =
+          _dirname(
+            _bytecode);
+      _contract_artifacts_retrieve(
+        _bytecode_dir);
+    }
+  }
+  return _bytecode;
+}
+
+async function
+  _contract_compiler_output_check(
+    _compiler_output,
+    _network,
+    _address,
+    _api_key,
+    _app,
+    _contract,
+    _configuration_format,
+    _deployments_dir,
+    _user_defined,
+    _local) {
+  let
+    _compiler_output_get,
+    _compiler_output_target,
+    _compiler_output_targets,
+    _evm_contract_deployment_compiler_output,
+    _msg;
+  _compiler_output_get =
+    false;
+  _local =
+    _local_check(
+      _local);
+  const
+    _compiler_output_type =
+      typeof(
+        _compiler_output);
+  _user_defined =
+    _user_defined_check(
+      _user_defined);
+  if ( _compiler_output_type === "undefined" ) {
+    _msg =
+      "Compiler output undefined, setting default.";
+    _msg_info(
+      _msg);
+    _compiler_output_get =
+      true;
+  }
+  else if ( _compiler_output_type === "string" ) {
+    if ( _compiler_output.length < 1 ) {
+      _compiler_output_get =
+        true;
+    }
+  }
+  else {
+    _msg =
+      "Compiler output path must be a string.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  if ( _compiler_output_get ) {
+    if ( ! _local ) {
+      _compiler_output =
+        _get(
+          "contract",
+          "compiler_output");
+      _msg =
+        "Variable '_compiler_output' not defined, " +
+        "defaulting to global variable " +
+        "'contract_compiler_output', which has value " +
+        `'${_compiler_output}'.`;
+      _msg_info(
+        _msg);
+    }
+    else {
+      const
+        _network_type =
+          typeof(
+            _network);
+      if ( _network_type === "undefined" ) {
+        _network =
+          _get(
+            "target",
+            "network");
+        _msg =
+          "Variable '_network' not defined, " +
+          "defaulting to global variable " +
+          "'target_network', which has value " +
+          `'${_network}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _api_key_type =
+          typeof(
+            _api_key);
+      if ( _api_key_type == "undefined" ) {
+        _api_key =
+          _get(
+            "api",
+            "key");
+        _msg =
+          "Variable '_api_key' not defined, " +
+          "defaulting to global variable " +
+          "'api_key', which has value " +
+          `'${_api_key}'.`;
+        _msg_info(
+          _msg);
+      }
+      _app =
+        _app_check(
+          _app);
+      const
+        _contract_type =
+          typeof(
+            _contract);
+      if ( _contract_type == "undefined" ) {
+        _contract =
+          _get(
+            "target",
+            "contract");
+        _msg =
+          "Variable '_contract' not defined, " +
+          "defaulting to global variable " +
+          "'target_contract', which has value " +
+          `'${_contract}'.`;
+        _msg_info(
+          _msg);
+      }
+      const
+        _address_type =
+          typeof(
+            _address);
+      if ( _address_type == "undefined" ) {
+        _address =
+          _get(
+            "contract",
+            "address");
+        _msg =
+          "Variable '_address' not defined, " +
+          "defaulting to global variable " +
+          "'contract_address', which has value " +
+          `'${_address}'.`;
+        _msg_info(
+          _msg);
+      }
+      _compiler_output_target =
+        _compiler_output;
+      _compiler_output_target =
+        _default_artifact_path_get(
+          "compiler_output");
+      const
+        _compiler_output_target_exists =
+          _file_exists(
+            _compiler_output_target);
+      if ( ! _compiler_output_target_exists ) {
+        if ( _app !== "" &&
+             _contract !== "" ) {
+          _evm_contract_deployment_compiler_output =
+            _get(
+              "_evm_contract_deployment",
+              "compiler_output");
+          try {
+            _evm_contract_deployment_compiler_output =
+              await _evm_contract_deployment_compiler_output_check.apply(
+                null,
+                _evm_contract_deployment_compiler_output);
+          }
+          catch(
+            _error) {
+            _msg =
+              "Error importing " +
+              "'_evm_contract_deployment_compiler_output' " +
+              "function by running " +
+              "'_evm_contract_deployment_compiler_output_check' " +
+              "with parameters:";
+            _msg_error(
+              _msg,
+              0);
+            _echo2(
+              _evm_contract_deployment_compiler_output);
+            _echo2(
+              _error);
+            throw _error;
+          }
+          const
+            _configuration_format_check_args = [
+              _configuration_format
+            ];
+          _configuration_format =
+            _configuration_format_check.apply(
+              null,
+              _configuration_format_check_args);
+          const
+            _deployments_dir_check_args = [
+              _deployments_dir,
+              _app,
+              _user_defined
+            ];
+          try {
+            _deployments_dir =
+              await _deployments_dir_check.apply(
+                null,
+                _deployments_dir_check_args);
+          }
+          catch(
+            _error) {
+            _msg =
+              "Error running '_deployments_dir_check' " +
+              "with parameters:";
+            _msg_error(
+              _msg,
+              0);
+            _echo2(
+              _deployments_dir_check_args);
+            _echo2(
+              _error);
+            throw _error;
+          }
+          _msg =
+            `Getting LibEVM app '${_app}' ` +
+            `compiler output for contract '${_contract}' for ` +
+            `network '${_network}' in format ` +
+            `'${_configuration_format}' at deployments ` +
+            `directory '${_deployments_dir}'.`;
+          _msg_info(
+            _msg);
+          const
+            _evm_contract_deployment_compiler_output_args = [
+              [ _network ] ,
+              [ _network ],
+              "n",
+              _app,
+              _contract,
+              "",                     // version
+              "n",                    // user level
+              _configuration_format,
+              _deployments_dir
+            ];
+          try {
+            _compiler_output_targets =
+              await _evm_contract_deployment_compiler_output.apply(
+                null,
+                _evm_contract_deployment_compiler_output_args);
+          }
+          catch(
+            _error) {
+            _msg =
+              `Error retrieving LibEVM app '${_app}' ` +
+              `compiler output for contract '${_contract}'.`;
+            _msg_error(
+              _msg,
+              0);
+            throw _error;
+          }
+          if ( 0 < _compiler_output_target.length ) {
+            _compiler_output_target =
+              _compiler_output_targets[
+                0];
+          }
+          else if ( _compiler_output_target.length < 1 ) {
+            _msg =
+              "Got no results.";
+            _msg_warning(
+              _msg);
+          }
+        }
+      }
+      else {
+        _msg =
+          "Selecting compiler output target " +
+          `'${_compiler_output_target}' for auto-detection.`;
+        _msg_info(
+          _msg);
+      }
+    }
+  }
+  const
+    _abi =
+      _get(
+        "contract",
+        "abi");
+  const
+    _bytecode =
+      _get(
+        "contract",
+        "bytecode");
+  if ( ! _file_exists(
+           _compiler_output) &&
+       ( ! _file_exists(
+             _abi) &&
+         ! _file_exists(
+             _bytecode) ) ) {
+    if ( _file_exists(
+           _compiler_output_target) ) {
+      _compiler_output =
+        _compiler_output_target;
+    }
+    else {
+      _msg =
+        `Compiler output '${_compiler_output}' does not ` +
+        `exist and '${_compiler_output_target}' neither.`;
+      _msg_info(
+        _msg);
+      const
+        _compiler_output_dir =
+          _dirname(
+            _compiler_output);
+      _contract_artifacts_retrieve(
+        _compiler_output_dir);
+    }
+  }
+  return _compiler_output;
+}
+
+async function
+  _network_check(
+    _deployments_dir,
+    _contract,
+    _target_network,
+    _target_network_id,
+    _app,
+    _user_defined) {
+  let
+    _contract_deployments_dir,
+    _error_flag,
+    _evm_contract_deployment_networks,
+    _evm_chains_info_args,
+    _msg,
+    _network_id,
+    _networks;
+  _error_flag =
+    false;
+  _app =
+    _app_check(
+      _app,
+      false);
+  _user_defined =
+    _user_defined_check(
+      _user_defined);
+  const
+    _deployments_dir_check_args = [
+      _deployments_dir,
+      _app,
+      _user_defined
+    ];
+  try {
+    _deployments_dir =
+      await _deployments_dir_check.apply(
+        null,
+        _deployments_dir_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error checking '_deployments_dir' " +
+      "variable in '_network_check' function:";
+    _msg_error(
+      _msg,
+      0);
+    throw _error;
+  }
+  _msg =
+    "Network check for deployments " +
+    `'${_deployments_dir}', contract '${_contract}', ` +
+    `network '${_target_network}' and network with ID ` +
+    `'${_target_network_id}'.`;
+  _msg_info(
+    _msg);
+  _evm_contract_deployment_networks =
+    _get(
+      "_evm_contract_deployment",
+      "networks");
+  try {
+    _evm_contract_deployment_networks =
+      await _evm_contract_deployment_networks_check(
+        _evm_contract_deployment_networks);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error importing '_evm_contract_deployment_networks'.";
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  _contract_deployments_dir =
+    _path_join( [
+      _deployments_dir,
+      _contract ]);
+  const
+    _evm_contract_deployment_networks_args = [
+      _contract_deployments_dir,
+      "y",                  // Display all
+      "n",                  // Display safest
+      "n"                   // Display cheapest
+    ];
+  try {
+    _networks =
+      await _evm_contract_deployment_networks.apply(
+        null,
+        _evm_contract_deployment_networks_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_evm_contract_deployment_networks' " +
+      `with parameters:`;
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _evm_contract_deployment_networks_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  if ( _target_network_id != "" ) {
+    if ( ! _networks.includes(
+             _target_network_id) ) {
+      _msg =
+        `The contract '${_contract}' ` +
+        `does not result deployed on ` +
+        `network with id '${_target_network_id}'.`;
+      _error_flag =
+        true;
+    }
+  }
+  else if ( _target_network != "" ) {
+    if ( ! _networks.includes(
+             _target_network) ) {
+      _msg =
+        "The contract does not result deployed on " +
+        `network '${_target_network}'.`;
+      _error_flag =
+        true;
+    }
+  }
+  else {
+    _msg =
+      "Provide one between a target network name " +
+      "or ID.";
+    _error_flag =
+      true;
+  }
+  if ( _error_flag ) {
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  if ( _target_network_id == "" ) {
+    _evm_chains_info_args = [
+      "get",             // target command
+      "name",            // input type
+      "id",              // output type
+      "offline",
+      [ "system",        // db types
+        "node" ],
+      "kirsh",           // selection method, first
+      "n",               // api keys
+      "n",               // query all networks
+      _target_network,
+      []                 // database paths
+    ];
+    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
+      "name",            // output type
+      "offline",
+      [ "system",        // db types
+        "node" ],
+      "kirsh",           // selection method, first
+      "n",               // api keys
+      "n",               // query all networks
+      _target_network_id,
+      []                 // database paths
+    ];
+    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 ) {
+      _msg =
+        "Requested target network ID " +
+        `'${_target_network_id}' does ` +
+        `not correspond to '${_target_network}' ` +
+        `known ID '${_network_id}'.`;
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  _msg =
+    "Network check for deployments " +
+    `'${_deployments_dir}', 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 =
+      "n";
+  _evm_contract_deployments_dir =
+    _get(
+      "_evm_contract",
+      "deployments_dir");
+  try {
+    _evm_contract_deployments_dir =
+      await _evm_contract_deployments_dir_check(
+        _evm_contract_deployments_dir);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error getting '_evm_cotract_deployments_dir' " +
+      "function.";
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _evm_contract_deployments_dir_args = [
+      _app,
+      _user_defined
+    ];
+  const
+    _system_deployments =
+      await _evm_contract_deployments_dir.apply(
+        null,
+        _evm_contract_deployments_dir_args);
+  _chmod(
+    _deployments_dir,
+    "0700");
+  const
+    _files =
+      await _ls(
+        _system_deployments);
+  for ( _file of _files ) {
+    _cp(
+      _file,
+      _deployments_dir);
+  }
+  return true;
+}
+
+async function
+  _user_deployments_check(
+    _app,
+    _deployments_dir) {
+  if ( ! _file_exists(
+           _deployments_dir) ) {
+    const
+      _user_deployments_init_args = [
+        _app,
+        _deployments_dir
+      ];
+    const
+      _initialized =
+        await _user_deployments_init.apply(
+          null,
+          _user_deployments_init_args);
+  }
+}
+
+function
+  _user_defined_check(
+    _user_defined) {
+  let
+    _msg;
+  const
+    _user_defined_type =
+      typeof(
+        _user_defined);
+  if ( _user_defined_type === "undefined" ) {
+    _msg =
+      "Variable '_user_defined' undefined, " +
+      "setting default value 'n'.";
+    _msg_info(
+      _msg);
+    _user_defined =
+      "n";
+  }
+  else if ( _user_defined_type === "string" ) {
+    if ( _user_defined.length < 1 ) {
+      _msg =
+        "Variable '_user_defined' not set, " +
+        "setting default value 'n'.";
+      _msg_info(
+        _msg);
+      _user_defined =
+        "n";
+    }
+    else if ( _user_defined.length > 1 ||
+              ( _user_defined !== "n" &&
+                _user_defined !== "y" ) ) {
+      _msg =
+        "Variable '_user_defined' can have " +
+        "value 'y' or 'n'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  else {
+    _msg =
+      "Variable '_user_defined' must be of type " +
+      "string and have value 'y' or 'n'.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  return _user_defined;
+}
+
+function
+  _user_level_check(
+    _user_level) {
+  let
+    _msg;
+  const
+    _user_level_type =
+      typeof(
+        _user_level);
+  if ( _user_level_type === "undefined" ) {
+    _msg =
+      "Variable '_user_level' undefined, " +
+      "setting default value 'n'.";
+    _msg_info(
+      _msg);
+    _user_level =
+      "n";
+  }
+  else if ( _user_level_type === "string" ) {
+    if ( _user_level.length < 1 ) {
+      _msg =
+        "Variable '_user_level' not set, " +
+        "setting default value 'n'.";
+      _msg_info(
+        _msg);
+      _user_level =
+        "n";
+    }
+    else if ( _user_level.length > 1 ||
+              ( _user_level !== "n" &&
+                _user_level !== "y" ) ) {
+      _msg =
+        "Variable '_user_level' can have " +
+        "value 'y' or 'n' (current value " +
+        `'${_user_level}'.`;
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  else {
+    _msg =
+      "Variable '_user_level' must be of type " +
+      "string and have value 'y' or 'n'.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  return _user_level;
+}
+
+async function
+  _deployments_dir_check(
+    _deployments,
+    _app,
+    _user_defined) {
+  let
+    _evm_contract_deployments_dir,
+    _msg;
+  _evm_contract_deployments_dir =
+    _get(
+      "_evm_contract",
+      "deployments_dir");
+  try {
+    _evm_contract_deployments_dir =
+      await _evm_contract_deployments_dir_check(
+        _evm_contract_deployments_dir);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error getting '_evm_contract_deployments_dir' " +
+      "function.";
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  _app =
+    _app_check(
+      _app);
+  _user_defined =
+    _user_defined_check(
+      _user_defined);
+  const
+    _evm_contract_deployments_dir_args = [
+      _app,
+      _user_defined
+    ];
+  try {
+    _deployments =
+      await _evm_contract_deployments_dir.apply(
+        null,
+        _evm_contract_deployments_dir_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_evm_contract_deployments_dir' " +
+      "function with arguments:";
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _evm_contract_deployments_dir_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  return _deployments;
+}
+
+async function
+  _deployments_dir_auto_detect() {
+  let
+    _app,
+    _deployments_dir,
+    _evm_contract_deployments_dir,
+    _msg,
+    _user_defined;
+  _deployments_dir =
+    _get(
+      "deployments",
+      "dir");
+  _app =
+    _get(
+      "target",
+      "app");
+  _app =
+    _app_check(
+      _app);
+  if ( _app != "" ) {
+    _user_defined =
+      _get(
+        "user",
+        "defined");
+    _user_defined =
+      _user_defined_check(
+        _user_defined);
+    const
+      _deployments_dir_check_args = [
+        _deployments_dir,
+        _app,
+        _user_defined
+      ];
+    try {
+      _deployments_dir =
+        await _deployments_dir_check.apply(
+          null,
+          _deployments_dir_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error checking '_deployments_dir' " +
+        "variable."
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _error);
+      throw _error;
+    }
+  }
+  _override_set(
+    "deployments",
+    "dir",
+    _deployments_dir);
+}
+
+function
+  _local_check(
+    _local) {
+  let
+    _msg;
+  const
+    _local_type =
+      typeof(
+        _local);
+  if ( _local_type === "undefined" ) {
+    _msg =
+      "Local not specified, setting default " +
+      "value 'true'.";
+    _msg_info(
+      _msg);
+    _local =
+      true;
+  }
+  else if ( _local_type === "string" ) {
+    if ( _local.length < 1 ) {
+      _msg =
+        "Local not specified, setting default " +
+        "value 'true'.";
+      _msg_info(
+        _msg);
+      _local =
+        true;
+    }
+  }
+  else if ( _local_type !== "boolean" ) {
+    _msg =
+      "Variable '_local' must be a boolean.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  return _local;
+}
+
+function
+  _app_check(
+    _app,
+    _local) {
+  let
+    _undefined_flag,
+    _msg;
+  _local =
+    _local_check(
+      _local);
+  const
+    _app_type =
+      typeof(
+        _app);
+  if ( _app_type === "undefined" ) {
+    _msg =
+      "No application specified.";
+    _undefined_flag =
+      true;
+  }
+  else if ( _app_type === "string" ) {
+    if ( _app.length < 1 ) {
+      _msg =
+        "No application specified.";
+      _undefined_flag =
+        true;
+    }
+  }
+  else {
+    _msg =
+      "Application argument must be of " +
+      `type string (current type: '${_app_type}').`;
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  if ( _undefined_flag ) {
+    if ( _local ) {
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+    else {
+      _msg =
+        "Local option disabled, " +
+        "getting '_app' variable from " +
+        "global variable 'target_app'.";
+      _msg_info(
+        _msg);
+      const
+        _global =
+          _global_get();
+      const
+        _target_app =
+          _get(
+            "target",
+            "app");
+      const
+        _target_app_type =
+          typeof(
+            _target_app);
+      if ( _target_app_type === "string" ) {
+        if ( 0 < _target_app.length ) {
+          _msg =
+            "Getting '_app' variable value from " +
+            "global variable 'target_app'.";
+          _msg_info(
+            _msg);
+          _app =
+            _target_app;
+        }
+        else {
+          _msg =
+            "Error while auto-detecting '_app' variable " +
+            "value, global variable 'target_app' " +
+            "also not set.";
+          _msg_error(
+            _msg,
+            0);
+          throw _msg;
+        }
+      }
+      else {
+        _msg =
+          "Global variable 'target_app' has " +
+          "the wrong type for the local " +
+          `variable '_app' ('${_target_app_variable}')`;
+        _msg_error(
+          _msg,
+          0);
+        throw _msg;
+      }
+    }
+  }
+  return _app;
+}
+
+async function
+  _contract_version_auto_detect() {
+  let
+    _config,
+    _config_ext,
+    _contract,
+    _deployments_dir,
+    _evm_contracts_deployment_versions,
+    _found,
+    _net,
+    _network,
+    _network_id,
+    _networks,
+    _version,
+    _msg;
+  _networks =
+    [];
+  _contract =
+    _get(
+      "target",
+      "contract");
+  _deployments_dir =
+    _get(
+      "deployments",
+      "dir");
+  _found =
+    false;
+  if ( configuration_format == "bash" ) {
+    _config_ext =
+      "sh";
+  }
+  else if ( configuration_format == "bash" ) {
+    _config_ext =
+      "json";
+  }
+  const
+    _contract_type =
+      typeof(
+        _contract);
+  if ( _contract != "" &&
+       _contract_type != "undefined" ) {
+    const
+      _deployments_dir_type =
+        typeof(
+          _deployments_dir);
+    if ( _deployments_dir_type !== "undefined" &&
+         deployments_dir !== "" ) {
+      _deployments =
+        deployments_dir;
+      if ( 0 < target_networks.length ) {
+        _network =
+          target_networks[
+            0];
+      }
+      if ( 0 < network_ids.length ) {
+        _network_id =
+          _network_ids[
+            0];
+      }
+      const
+        _deployments_path =
+          _path_join( [
+            _deployments,
+            _contract ] );
+      if ( networks_all == "n" ) {
+        _networks.push(
+          _network,
+          _network_id);
+      }
+      else if ( networks_all == "y" ) {
+        const
+          _evm_contract_deployment_networks_args = [
+            _deployments_path,
+            "y",                  // Display all
+            "n",                  // Display safest
+            "n"                   // Display cheapest
+          ];
+        _networks_new =
+          await _evm_contract_deployment_networks.apply(
+            null,
+            _evm_contract_deployment_networks_args);
+        _networks =
+          _networks.concat(
+            _networks_new);
+      }
+      for ( _net of _networks ) {
+        _config =
+          _path_join( [
+            _deployments_path,
+            _net,
+            `config.${_config_ext}`
+            ]);
+        if ( _file_exists(
+               _config) ) {
+          _found =
+            true;
+          _msg =
+            `Found deployment configuration ` +
+            `at location '${_config}'.`;
+          _msg_info(
+            _msg);
+          break;
+        }
+      }
+      if ( ! _found ) {
+        _msg =
+          "No deployment configuration " +
+          "file found for network " +
+          `'${_network}' with ID ` +
+          `'${_network_id}'.`;
+        _msg_error(
+          _msg,
+          1);
+      }
+      _evm_contract_deployment_versions =
+        _get(
+          "_evm_contract_deployment",
+          "versions");
+      try {
+        _evm_contract_deployment_versions =
+          await _evm_contract_deployment_versions_check(
+            _evm_contract_deployment_versions);
+      }
+      catch(
+        _error) {
+        _msg =
+          "Error checking '_evm_contract_deployment_versions'.";
+        _msg_error(
+          _msg,
+          0);
+        throw _msg;
+      }
+      const
+        _evm_contract_deployment_versions_args = [
+          _config,
+          "y",                  // display highest
+          "n",                  // display lowest
+          configuration_format
+        ];
+      _version =
+        await _evm_contract_deployment_versions.apply(
+          null,
+          _evm_contract_deployment_versions_args);
+    }
+    else if ( _deployments_dir_type == "undefined" ||
+              deployments_dir == "" ) {
+      const
+        _msg =
+          "If no target application is specified " +
+          "then the user-defined deployments " +
+          "switch must be enabled with '-u' and " +
+          "a deployments directory must be specified " +
+          "with '-d'.";
+      _msg_error(
+        _msg,
+        1);
+    }
+  }
+  _override_set(
+    "contract",
+    "version",
+    _version);
+  return true;
+}
+
+function
+  _networks_all_auto_detect() {
+  let
+    _networks_all;
+  _networks_all =
+    "n";
+  if ( target_networks.length < 1 &&
+       network_ids.length < 1 ) {
+    _networks_all =
+      "y";
+  }
+  _override_set(
+    "networks",
+    "all",
+    _networks_all);
+}
+
+async function
+  _evm_contract_deployment_abi_check(
+    _evm_contract_deployment_abi) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployment_abi_type =
+      typeof(
+        _evm_contract_deployment_abi);
+  if ( _evm_contract_deployment_abi_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployment_abi' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployment_abi_type === "string" ) {
+    if ( _evm_contract_deployment_abi.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployment_abi' " +
+        "undefined, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployment_abi' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      const
+        _libevm_contract_deployment_abi_module =
+          await import(
+            "./libevm-contract-deployment-abi");
+        _evm_contract_deployment_abi =
+          _libevm_contract_deployment_abi_module._evm_contract_deployment_abi;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployment-abi'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployment_abi;
+}
+
+async function
+  _evm_contract_deployment_address_check(
+    _evm_contract_deployment_address) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployment_address_type =
+      typeof(
+        _evm_contract_deployment_address);
+  if ( _evm_contract_deployment_address_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployment_address' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployment_address_type === "string" ) {
+    if ( _evm_contract_deployment_address.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployment_address' " +
+        "undefined, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployment_address' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      const
+        _libevm_contract_deployment_address_module =
+          await import(
+            "./libevm-contract-deployment-address");
+        _evm_contract_deployment_address =
+          _libevm_contract_deployment_address_module._evm_contract_deployment_address;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployment-address'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployment_address;
+}
+
+async function
+  _evm_contract_deployment_bytecode_check(
+    _evm_contract_deployment_bytecode) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployment_bytecode_type =
+      typeof(
+        _evm_contract_deployment_bytecode);
+  if ( _evm_contract_deployment_bytecode_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployment_bytecode' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployment_bytecode_type === "string" ) {
+    if ( _evm_contract_deployment_bytecode.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployment_bytecode' " +
+        "is an empty string, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployment_bytecode' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      const
+        _libevm_contract_deployment_bytecode_module =
+          await import(
+            "./libevm-contract-deployment-bytecode");
+        _evm_contract_deployment_bytecode =
+          _libevm_contract_deployment_bytecode_module._evm_contract_deployment_bytecode;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployment-bytecode'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployment_bytecode;
+}
+
+async function
+  _evm_contract_deployment_compiler_output_check(
+    _evm_contract_deployment_compiler_output) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployment_compiler_output_type =
+      typeof(
+        _evm_contract_deployment_compiler_output);
+  if ( _evm_contract_deployment_compiler_output_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployment_compiler_output' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployment_compiler_output_type === "string" ) {
+    if ( _evm_contract_deployment_compiler_output.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployment_compiler_output' " +
+        "is an empty string, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployment_compiler_output' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      const
+        _libevm_contract_deployment_compiler_output_module =
+          await import(
+            "./libevm-contract-deployment-compiler-output");
+        _evm_contract_deployment_compiler_output =
+          _libevm_contract_deployment_compiler_output_module._evm_contract_deployment_compiler_output;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployment-compiler-output'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployment_compiler_output;
+}
+
+async function
+  _evm_contract_deployment_networks_check(
+    _evm_contract_deployment_networks) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployment_networks_type =
+      typeof(
+        _evm_contract_deployment_networks);
+  if ( _evm_contract_deployment_networks_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployment_networks' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployment_networks_type === "string" ) {
+    if ( _evm_contract_deployment_networks.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployment_networks' " +
+        "undefined, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployment_networks' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      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;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployment-networks'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployment_networks;
+}
+
+async function
+  _evm_contract_deployment_versions_check(
+    _evm_contract_deployment_versions) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployment_versions_type =
+      typeof(
+        _evm_contract_deployment_versions);
+  if ( _evm_contract_deployment_versions_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployment_versions' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployment_versions_type === "string" ) {
+    if ( _evm_contract_deployment_versions.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployment_versions' " +
+        "undefined, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployment_versions' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      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;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployment-versions'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployment_versions;
+}
+
+async function
+  _evm_contract_deployments_dir_check(
+    _evm_contract_deployments_dir) {
+  let
+    _import,
+    _msg;
+  _import =
+    false;
+  const
+    _evm_contract_deployments_dir_type =
+      typeof(
+        _evm_contract_deployments_dir);
+  if ( _evm_contract_deployments_dir_type === "undefined" ) {
+    _msg =
+      "Function '_evm_contract_deployments_dir' " +
+      "undefined, importing.";
+    _import =
+      true;
+  }
+  else if ( _evm_contract_deployments_dir_type === "string" ) {
+    if ( _evm_contract_deployments_dir.length < 1 ) {
+      _msg =
+        "Function '_evm_contract_deployments_dir' " +
+        "undefined, importing.";
+      _import =
+        true;
+    }
+    else {
+      _msg =
+        "Function '_evm_contract_deployments_dir' " +
+        "is a string.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  if ( _import ) {
+    try {
+      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;
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing './libevm-contract-deployments-dir'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  return _evm_contract_deployments_dir;
+}
+
+async function
+  _target_app_auto_detect() {
+  let
+    _address_missing,
+    _app,
+    _evm_contract_deployments_dir;
+  const
+    _contract_address =
+      _get(
+        "contract",
+        "address");
+  const
+    _contract_address_type =
+      typeof(
+        _contract_address);
+  if ( _contract_address_type === "undefined" ) {
+    _msg =
+      "Contract address undefined, skipping ",
+      "application auto-detection.";
+    _msg_info(
+      _msg);
+    _address_missing =
+      true;
+  }
+  else if ( _contract_address_type === "string" ) {
+    if ( _contract_address.length < 1 ) {
+      _msg =
+        "Contract address undefined, skipping ",
+        "application auto-detection.";
+      _msg_info(
+        _msg);
+      _address_missing =
+        true;
+    }
+    else {
+      _msg =
+        "Contract address correctly detected, auto-detecting " +
+        "application.";
+      _msg_info(
+        _msg);
+      _address_missing =
+        false;
+    }
+  }
+  else {
+    _msg =
+      `Unknown type '${_contract_address_type}' ` +
+      `for global variable 'contract_address':`;
+    _msg_info(
+      _msg);
+    _echo2(
+      _contract_address);
+    throw _msg;
+  }
+  _app =
+    "";
+  if ( ! _address_missing ) {
+    const
+      _dir_current_name =
+        _basename(
+          _pwd());
+    const
+      _user_defined =
+        _get(
+          "user",
+          "defined");
+    _user_defined =
+      _user_defined_check(
+        _user_defined);
+    _evm_contract_deployments_dir =
+      _get(
+        "_evm_contract",
+        "deployments_dir");
+    try {
+      _evm_contract_deployments_dir =
+        await _evm_contract_deployments_dir_check(
+          _evm_contract_deployments_dir);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error getting '_evm_contract_deployments_dir' " +
+        "function.";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _evm_contract_deployments_dir_args = [
+        _dir_current_name,
+        _user_defined
+      ];
+    try {
+      const
+        _target_dir =
+          await _evm_contract_deployments_dir.apply(
+            null,
+            _evm_contract_deployments_dir_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_evm_contract_deployments_dir' " +
+        "with arguments:";
+      _echo2(
+        _evm_contract_deployments_dir_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    if ( _dir_exists(
+           _target_dir) ) {
+      _msg =
+        "Found existing directory " +
+        `'${_target_dir}', setting ` +
+        `'${_dir_current_name}' as application name.`;
+      _msg_info(
+        _msg);
+      _app =
+        _dir_current_name;
+    }
+    else {
+      _msg =
+        `Directory '${_target_dir}' ` +
+        "not found, impossible auto-detecting " +
+        "application name for given contract.";
+      _msg_info(
+        _msg);
+    }
+  }
+  _override_set(
+    "target",
+    "app",
+    _app);
+}
+
+async function
+  _config_file_path_check(
+    _config_file_path,
+    _app,
+    _deployments_dir,
+    _contract,
+    _network,
+    _network_id,
+    _configuration_format,
+    _user_defined) {
+  let
+    _config_file_ext,
+    _config_file_path_get,
+    _found,
+    _msg,
+    _net;
+  const
+    _config_file_path_type =
+      typeof(
+        _config_file_path);
+  _config_file_path_get =
+    false;
+  if ( _config_file_path_type == "undefined" ) {
+    _msg =
+      "Configuration file path undefined, " +
+      "auto-detecting.";
+    _msg_info(
+      _msg);
+    _config_file_path_get =
+      true;
+  }
+  else if ( _config_file_path_type == "string" ) {
+    if ( _config_file_path.length < 1 ) {
+    _msg =
+      "Configuration file path not set, " +
+      "auto-detecting.";
+    _msg_info(
+      _msg);
+    _config_file_path_get =
+      true;
+    }
+    else {
+      if ( ! _file_exists(
+             _config_file_path) ) {
+        _msg =
+          `File at location '${_config_file_path}' ` +
+          `does not exist.`;
+        _msg_error(
+          _msg,
+          0);
+        throw _msg;
+      }
+    }
+  }
+  else {
+    _msg =
+      `Unknown type '${_config_file_path_type}' ` +
+      `for '_config_file_path' variable (correct ` +
+      `type: string).`;
+    _msg_error(
+      _msg,
+      0);
+  }
+  const
+    _global =
+      _global_get();
+  const
+    _quiet =
+      _global[
+        "quiet"];
+  if ( _config_file_path_get ) {
+    const
+      _contract_type =
+        typeof(
+          _contract);
+    if ( _contract_type === "undefined" ) {
+      _msg =
+        "A contract name must be specified a contract name."
+    }
+    _user_defined =
+      await _user_defined_check(
+        _user_defined);
+    _configuration_format =
+      _configuration_format_check(
+        _configuration_format);
+    if ( _configuration_format == "bash" ) {
+      _config_file_ext =
+        "sh";
+    }
+    else if ( _configuration_format == "json" ) {
+      _config_file_ext =
+        "json";
+    }
+    else {
+      _msg =
+        "Unknown configuration format " +
+        `${_configuration_format}'.`;
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+    const
+      _deployments_dir_check_args = [
+        _deployments_dir,
+        _app,
+        _user_defined
+      ];
+    try {
+      _deployments_dir =
+        await _deployments_dir_check.apply(
+          null,
+          _deployments_dir_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error checking '_deployments_dir' " +
+        "variable."
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _networks = [
+        _network,
+        _network_id
+      ];
+    _found =
+      false;
+    for ( _net of _networks ) {
+      _config_file_path =
+        _path_join( [
+          _deployments_dir,
+          _contract,
+          _net,
+          `config.${_config_file_ext}` ]);
+      if ( _file_exists(
+             _config_file_path) ) {
+        _found =
+          true;
+        break;
+      }
+    }
+  }
+  return _config_file_path;
+}
+
+function
+  _configuration_format_get(
+    _config_file) {
+  let
+    _configuration_format,
+    _msg;
+  _msg =
+    "Getting configuration format " +
+    `for configuration file '${_config_file}'.`;
+  _msg_info(
+    _msg);
+  if ( _config_file.endsWith(
+         ".sh") ) {
+    _configuration_format =
+      "bash";
+  }
+  else if ( _config_file.endsWith(
+         ".json") ) {
+    _configuration_format =
+      "json";
+  }
+  else {
+    _msg =
+      "Impossible determining " +
+      "configuration format from file " +
+      "extension, defaulting to 'json'.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  return _configuration_format;
+}
+
+async function
+  _configuration_format_auto_detect() {
+  let
+    _config_file_path,
+    _configuration_format,
+    _msg;
+  _configuration_format =
+    _get(
+      "configuration",
+      "format");
+  _config_file_path =
+    _get(
+      "config",
+      "file");
+  const
+    _app =
+      _get(
+        "target",
+        "app");
+  const
+    _deployments_dir =
+      _get(
+        "deployments",
+        "dir");
+  const
+    _target_contract =
+      _get(
+        "target",
+        "contract");
+  const
+    _target_network =
+      _get(
+        "target",
+        "network");
+  const
+    _user_defined =
+      _get(
+        "user",
+        "defined");
+  const
+    _config_file_path_check_args = [
+      _config_file_path,
+      _app,
+      _deployments_dir,
+      _contract,
+      _target_network,
+      _target_network,
+      _configuration_format,
+      _user_defined
+    ];
+  try {
+    _config_file_path =
+      await _config_file_path_check.apply(
+        null,
+        _config_file_path_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error checking 'config_file' variable.";
+    _msg_error(
+      _msg,
+      0);
+    echo2(
+      _error);
+    throw _error;
+  }
+  _configuration_format =
+    _configuration_format_get(
+      _config_file);
+  _override_set(
+    "configuration",
+    "format",
+    _configuration_format);
+}
+
+async function
+  _version_check(
+    _version,
+    _app,
+    _contract,
+    _address,
+    _network,
+    _user_defined,
+    _deployments_dir,
+    _config_file,
+    _configuration_format) {
+  let
+    _evm_contract_deployment_versions,
+    _msg,
+    _version_get;
+  _configuration_format = 
+    _configuration_format_check(
+      _configuration_format);
+  const
+    _version_type =
+      typeof(
+        _version);
+  _version_get =
+    false;
+  if ( _version_type === "undefined" ) {
+    _msg =
+      "Variable 'version' undefined, " +
+      "auto-detecting.";
+    _version_get =
+      true;
+  }
+  if ( _version_type === "string" ) {
+    if ( _version.length < 1 ) {
+      _msg =
+        "Variable 'version' not specified, " +
+        "auto-detecting.";
+    _version_get =
+      true;
+    }
+  }
+  if ( _version_get ) {
+    _app =
+      _app_check(
+        _app,
+        false);
+    _user_defined =
+      _user_defined_check(
+        _user_defined);
+    const
+      _deployments_dir_check_args = [
+        _deployments_dir,
+        _app,
+        _user_defined
+      ];
+    try {
+      _deployments_dir =
+        await _deployments_dir_check.apply(
+          null,
+          _deployments_dir_check_args);
+      _msg_info(
+        `Got '${_deployments_dir}'`);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error checking variable " +
+        "'_deployments_dir'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _error;
+    }
+    _evm_contract_deployment_versions =
       _get(
-        "_evm_contract",
-        "deployments_dir");
+        "_evm_contract_deployment",
+        "versions");
+    try {
+      _evm_contract_deployment_versions =
+        await _evm_contract_deployment_versions_check(
+          _evm_contract_deployment_versions);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error importing '_evm-contract-deployment-versions'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _error;
+    }
+    const
+      _target_contract_check_args = [
+        _contract,
+        _address,
+        _app,
+        _deployments_dir
+      ];
+    try {
+      _contract =
+        await _target_contract_check.apply(
+          null,
+          _target_contract_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_target_contract_check' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _target_contract_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _config_file_path_check_args = [
+        _config_file,
+        _app,
+        _deployments_dir,
+        _contract,
+        _network,
+        _network,
+        _configuration_format,
+        _user_defined
+      ];
+    try {
+      _config_file =
+        await _config_file_path_check.apply(
+          null,
+          _config_file_path_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_config_file_path_check' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _config_file_path_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
     const
-      _evm_contract_deployments_dir_type =
+      _evm_contract_deployment_versions_args = [
+        _config_file,
+        "y",                   // display highest version
+        "n",                   // display lowest version
+        _configuration_format
+      ];
+    try {
+      _version =
+        await _evm_contract_deployment_versions.apply(
+          null,
+          _evm_contract_deployment_versions_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error auto-retrieving version.";
+      _msg_error(
+        _msg,
+        0);
+      throw _error;
+    }
+  }
+  return _version;
+}
+
+async function
+  _target_networks_check(
+    _target_networks,
+    _local) {
+  let
+    _msg,
+    _target_networks_get,
+    _target_networks_type;
+  _local =
+    _local_check(
+      _local);
+  _target_networks_get =
+    false;
+  _target_networks_type =
+    typeof(
+      _target_networks);
+  if ( _target_networks_type === "undefined" ) {
+    _msg =
+      "Variable '_target_networks' undefined, " +
+      "auto-detecting.";
+    _msg_info(
+      _msg);
+    _target_networks_get =
+      true;
+  }
+  else if ( _target_networks_type === "string" ) {
+    _msg =
+      "Variable '_target_networks' must be of type " +
+      "'array'.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  else if ( _target_networks_type === "array" ||
+            _target_networks_type === "object" ) {
+    if ( _target_networks.length < 1 ) {
+      _msg =
+        "Variable '_target_networks' not " +
+        "specified, auto-detecting.";
+      _msg_info(
+        _msg);
+      _target_networks_get =
+        true;
+    }
+  }
+  else {
+    _msg =
+      "Variable '_target_networks' must be of type " +
+      `'array' (current type: '${_target_networks_type}'):`;
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _target_networks);
+    throw _msg;
+  }
+  if ( _target_networks_get ) {
+    if ( _local ) {
+      true;
+      // _networks_check
+    }
+    else {
+      _target_networks =
+        _get(
+          "target",
+          "networks");
+      _target_networks_type =
         typeof(
-          _evm_contract_deployments_dir);
-    if ( _evm_contract_deployments_dir_type == "undefined" ||
-         _evm_contract_deployments_dir == "" ) {
+          _target_networks);
+      if ( _target_networks_type === "array" ||
+           _target_networks_type === "object" ) {
+        if ( _target_networks.length < 1 ) {
+          _msg =
+            "Global variable 'target_networks' " +
+            "empty.";
+          _msg_error(
+            _msg,
+            0);
+          throw _msg;
+        }
+        else {
+          _msg =
+            "Variable '_target_networks'." +
+            "set from public global variable " +
+            "'target_networks'.";
+          _msg_info(
+            _msg);
+        }
+      }
+      else if ( _target_networks_type === "undefined" ) {
+        _msg =
+          "Global variable 'target_networks' " +
+          "undefined.";
+        _msg_error(
+          _msg,
+          0);
+        throw _msg;
+      }
+      else {
+        _msg =
+          `Unknown type '${_target_networks_type}' for` +
+          "global variable 'target_networks':";
+        _msg_error(
+          _msg,
+          0);
+        _echo2(
+          _target_networks);
+        throw _msg;
+      }
+    }
+  }
+  return _target_networks;
+}
+
+async function
+  _contract_address_check(
+    _contract_address,
+    _deployments_dir,
+    _app,
+    _user_defined,
+    _networks) {
+  let
+    _address_valid,
+    _contract,
+    _contract_address_get,
+    _evm_contract_deployment_address,
+    _msg;
+  _contract_address_get =
+    false;
+  _user_defined =
+    _user_defined_check(
+      _user_defined);
+  const
+    _contract_address_type =
+      typeof(
+        _contract_address);
+  if ( _contract_address_type === "undefined" ) {
+    _msg =
+      "Contract address not set, " +
+      "auto-detecting given input data.";
+    _msg_info(
+      _msg);
+    _contract_address_get =
+      true;
+  }
+  else if ( _contract_address_type === "string" ) {
+    if ( _contract_address.length < 1 ) {
+      _msg =
+        "Contract address not set, " +
+        "auto-detecting given input data.";
+      _msg_info(
+        _msg);
+      _contract_address_get =
+        true;
+    }
+    else {
+      try {
+        const
+          _address_valid =
+            await _address_check(
+              _contract_address);
+      }
+      catch(
+        _error) {
+        _msg =
+          "Error verifying validity of " +
+          `address '${_contract_address}'.`;
+        _msg_error(
+          _msg,
+          0);
+        throw _msg;
+      }
+      if ( ! _address_valid ) {
+        _msg =
+          "Address not valid, getting " +
+          "contract address.";
+        _contract_address_get =
+          true;
+        _contract =
+          _get(
+            "target",
+            "contract");
+        const
+          _target_contract_check_args = [
+            _contract_address
+          ];
+        try {
+          _contract =
+            await _target_contract_check.apply(
+              null,
+              _target_contract_check_args);
+          _override_set(
+            "target",
+            "contract",
+            _contract);
+        }
+        catch(
+          _error) {
+          _msg =
+            "Error running '_target_contract_check' " +
+            `with parameters:`;
+          _msg_error(
+            _msg,
+            0);
+          _echo2(
+            _target_contract_check_args);
+          _echo2(
+            _error);
+          throw _error;
+        }
+      }
+      else {
+        _msg =
+          `Address '${_contract_address}' ` +
+          `valid.`;
+        _msg_info(
+          _msg);
+      }
+    }
+  }
+  else {
+    _msg =
+      "Invalid type for variable " +
+      `'_contract_address' (${_contract_address_type}):`;
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _contract_address);
+    throw _msg;
+  }
+  if ( _contract_address_get ) {
+    _app =
+      _app_check(
+        _app,
+        false);
+    const
+      _deployments_dir_check_args = [
+        _deployments_dir,
+        _app,
+        _user_defined
+      ];
+    try {
+      _deployments_dir =
+        await _deployments_dir_check.apply(
+          null,
+          _deployments_dir_check_args);
+      _msg_info(
+        `Got '${_deployments_dir}'`);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error checking variable " +
+        "'_deployments_dir'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _error;
+    }
+    const
+      _target_networks_check_args = [
+        _networks,
+        false
+      ];
+    try {
+      _networks =
+        await _target_networks_check.apply(
+          null,
+          _target_networks_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_target_networks_check' " +
+        "with parameters:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _target_networks_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    _contract =
+      _get(
+        "target",
+        "contract");
+    _msg =
+      "Looking for address " +
+      "corresponding to contract " +
+      `'${_contract}' for the ` +
+      `'${_app}' ` +
+      "libEVM application on networks " +
+      `'${_networks}' at deployments ` +
+      `directory '${_deployments_dir}'.`;
+    _msg_info(
+      _msg);
+    try {
+      _evm_contract_deployment_address =
+        await _evm_contract_deployment_address_check(
+          _evm_contract_deployment_address);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_evm_contract_deployment_address_check'.";
+      _msg_error(
+        _msg,
+        0);
+      throw _error;
+    }
+    const
+      _evm_contract_deployment_address_args = [
+        _networks,                 // target networks
+        _networks,                 // target chain ids
+        "n",                       // all networks
+        _app,
+        _contract,
+        "",                        // contract version
+        "n",                       // user-level
+        "",                        // configuration format
+        _deployments_dir
+      ];
+    try {
       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;
+        _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;
+    }
+  }
+  return _contract_address;
+}
+
+async function
+  _contract_address_auto_detect() {
+  let
+    _contract_address,
+    _contract_addresses,
+    _evm_contract_deployment_address,
+    _evm_contract_deployment_address_args,
+    _msg,
+    _network,
+    _target_contract;
+  const
+    _target_networks_index =
+      {};
+  _contract_address =
+    _get(
+      "contract",
+      "address");
+  const
+    _target_app =
+      _get(
+        "target",
+        "app");
+  const
+    _target_networks =
+      _get(
+        "target",
+        "networks");
+  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 {
+      _target_contract =
+        _get(
+          "target",
+          "contract");
+      const
+        _target_contract_check_args = [
+          _target_contract,
+          _contract_address,
+          _target_app,
+          _deployments_dir
+	];
+      try {
+        _target_contract =
+          await _target_contract_check.apply(
+            null,
+            _target_contract_check_args);
+      }
+      catch(
+        _error) {
+        _msg =
+          "Error running '_target_contract_check' " +
+          `with parameters:`;
+        _msg_error(
+          _msg,
+          0);
+        _echo2(
+          _target_contract_check_args);
+        _echo2(
+          _error);
+        throw _error;
+      }
+      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);
+        try {
+          _evm_contract_deployment_address =
+            await _evm_contract_deployment_address_check(
+              _evm_contract_deployment_address);
+        }
+        catch(
+          _error) {
+          _msg =
+            "Error running '_evm_contract_deployment_address_check'.";
+          _msg_error(
+            _msg,
+            0);
+          throw _error;
+        }
+        _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);
+}
+
+async function
+  _target_contract_check(
+    _target_contract,
+    _contract_address,
+    _target_app,
+    _deployments_dir,
+    _user_defined,
+    _networks) {
+  let
+    _msg,
+    _target_contract_get;
+  const
+    _target_contract_type =
+      typeof(
+        _target_contract); 
+  if ( _target_contract_type === "undefined" ) {
+    _msg =
+      "Target contract undefined, auto-detecting.";
+    _msg_info(
+      _msg);
+    _target_contract_get =
+      true;
+  }
+  else if ( _target_contract_type === "string" ) {
+    if ( _target_contract.length < 1 ) {
+      _msg =
+        "Target contract not set, auto-detecting.";
+      _msg_info(
+        _msg);
+      _target_contract_get =
+        true;
     }
+  }
+  else {
+    _msg =
+      "Target contract must have type 'string'.";
+    _msg_error(
+      _msg,
+      0);
+    throw _msg;
+  }
+  if ( _target_contract_get ) {
+    _user_defined =
+      _user_defined_check(
+        _user_defined);
     const
-      _evm_contract_deployments_dir_args = [
-        _app,
+      _deployments_dir_check_args = [
+        _deployments_dir,
+        _target_app,
         _user_defined
       ];
-    _deployments =
-      await _evm_contract_deployments_dir.apply(
+    try {
+      _deployments_dir =
+        await _deployments_dir_check.apply(
+          null,
+          _deployments_dir_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_deployments_dir_check' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _deployments_dir_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _target_networks_check_args = [
+        _networks,
+        false
+      ];
+    try {
+      _networks =
+        await _target_networks_check.apply(
+          null,
+          _target_networks_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_target_networks_check' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _target_networks_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _contract_address_check_args = [
+        _contract_address,
+        _deployments_dir,
+        _target_app,
+        _user_defined,
+        _networks
+      ];
+    try {
+      _contract_address =
+        await _contract_address_check.apply(
+          null,
+          _contract_address_check_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_contract_address_check' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _contract_address_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _address_valid =
+        await _address_check(
+          _contract_address);
+    if ( ! _address_valid ) {
+      _target_contract =
+        _contract_address;
+    }
+  }
+  return _target_contract;
+}
+
+async function
+  _target_contract_auto_detect() {
+  let
+    _contract_address,
+    _msg,
+    _target_contract;
+  _target_contract =
+    _get(
+      "target",
+      "contract");
+  const
+    _target_app =
+      _get(
+        "target",
+        "app");
+  const
+    _deployments_dir =
+      _get(
+        "deployments",
+        "dir");
+  _contract_address =
+    _get(
+      "contract",
+      "address");
+  const
+    _contract_address_check_args = [
+      _contract_address,
+      _deployments_dir,
+      _target_app
+    ];
+  try {
+    _contract_address =
+      await _contract_address_check.apply(
         null,
-        _evm_contract_deployments_dir_args);
+        _contract_address_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_contract_address_check' " +
+      "with arguments:";
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _contract_address_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _target_contract_check_args = [
+      _target_contract,
+      _contract_address,
+      _target_app,
+      _deployments_dir
+    ];
+  try {
+    _target_contract =
+      await _target_contract_check.apply(
+        null,
+        _target_contract_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_target_contract_check' " +
+      "with arguments:";
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _target_contract_check_args);
+    _echo2(
+      _error);
+    throw _error;
   }
   _override_set(
-    "deployments",
-    "dir",
-    _deployments);
+    "target",
+    "contract",
+    _target_contract);
 }
 
 async function
-  _contract_version_auto_detect() {
+  _contract_abi_auto_detect() {
   let
-    _config,
-    _config_ext,
-    _deployments,
-    _evm_contracts_deployment_versions,
-    _found,
-    _net,
-    _network,
-    _network_id,
-    _networks,
-    _version,
-    _msg;
-  _networks =
-    [];
+    _abi,
+    _abi_retrieve,
+    _contract_address,
+    _configuration_format,
+    _deployments_dir,
+    _msg,
+    _target_contract;
   const
-    _contract =
-      target_contract;
-  _found =
+    _global =
+      _global_get();
+  const
+    _quiet =
+      _global[
+        "quiet"];
+  const
+    _target_app =
+      _get(
+        "target",
+        "app");  
+  const
+    _user_defined =
+      "n";
+  _deployments_dir =
+    _get(
+      "deployments",
+      "dir");
+  _target_contract =
+    _get(
+      "target",
+      "contract");
+  _msg_info(
+    `Target app  '${_target_app}'.`);
+  _msg_info(
+    `Target contract  '${_target_contract}'.`);
+  _contract_address =
+    _get(
+      "contract",
+      "address");
+  const
+    _target_networks =
+      _get(
+        "target",
+        "networks");
+  const
+    _deployments_dir_check_args = [
+      _deployments_dir,
+      _target_app,
+      _user_defined
+    ];
+  _msg =
+    "Running '_deployments_dir_check' " +
+    `with arguments:`;
+  _msg_info(
+    _msg);
+  if ( _quiet == "n" ) {
+    _echo(
+      _deployments_dir_check_args);
+  }
+  try {
+    _deployments_dir =
+      await _deployments_dir_check.apply(
+        null,
+        _deployments_dir_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_deployments_dir_check' " +
+      `with arguments:`;
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _deployments_dir_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _target_contract_check_args = [
+      _target_contract,
+      _contract_address,
+      _target_app,
+      _deployments_dir
+    ];
+  try {
+    _target_contract =
+      await _target_contract_check.apply(
+        null,
+        _target_contract_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_target_contract_check' " +
+      "with parameters:";
+    _echo2(
+      _target_contract_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _contract_address_check_args = [
+      _contract_address,
+      _deployments_dir,
+      _target_app
+    ];
+  try {
+    _contract_address =
+      await _contract_address_check.apply(
+        null,
+        _contract_address_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_contract_address_check' " +
+      "with parameters:";
+    _echo2(
+      _contract_address_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _api_key =
+      _get(
+        "api",
+        "key");
+  const
+    _compiler_output =
+      _get(
+        "contract",
+        "compiler_output");
+  _abi =
+    _get(
+      "contract",
+      "abi");
+  const
+    _abi_type =
+      typeof(
+        _abi);
+  _abi_retrieve =
     false;
-  if ( configuration_format == "bash" ) {
-    _config_ext =
-      "sh";
+  if ( _abi_type === "undefined" ) {
+    _abi_retrieve =
+      true;
   }
-  else if ( configuration_format == "bash" ) {
-    _config_ext =
-      "json";
+  else if ( _abi_type === "string" ) {
+    if ( _abi.length < 1 ) {
+      _abi_retrieve =
+        true;
+    }
+  }
+  if ( _abi_retrieve ) {
+    if ( 1 < _target_networks.length ) {
+      _msg =
+        "You can't currently retrieve " +
+        "ABI for more than a contract.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+    else if ( 1 == _target_networks.length ) {
+      const
+        _network =
+          _target_networks[
+            0];
+      _configuration_format =
+        _configuration_format_check(
+          _configuration_format);
+      const
+        _contract_abi_check_args = [
+          _abi,
+          _network,
+          _contract_address,
+          _api_key,
+          _compiler_output,
+          _target_app,
+          _target_contract,
+          _configuration_format,
+          _deployments_dir,
+          _user_defined,
+          true                  // local
+        ];
+      _msg =
+        "Running '_contract_abi_check' with " +
+        "parameters:";
+      _msg_info(
+        _msg);
+      if ( _quiet == "n" ) {
+        _echo(
+          _contract_abi_check_args);
+      }
+      try {
+        _abi =
+          await _contract_abi_check.apply(
+            null,
+            _contract_abi_check_args);
+      }
+      catch(
+        _error) {
+        _msg =
+          "Error running '_contract_abi_check' with " +
+          "parameters:";
+        _msg_error(
+          _msg,
+          0);
+        _echo2(
+          _contract_abi_check_args);
+        _echo2(
+          _error);
+        throw _error;
+      }
+    }
+    else {
+      _msg =
+        "You must currently select a network " +
+        "to auto-detect the abi for " +
+        "a libevm application contract.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+  }
+  _override_set(
+    "contract",
+    "abi",
+    _abi);
+}
+
+async function
+  _contract_bytecode_auto_detect() {
+  let
+    _bytecode,
+    _bytecode_retrieve,
+    _contract_address,
+    _configuration_format,
+    _deployments_dir,
+    _msg,
+    _target_contract;
+  const
+    _global =
+      _global_get();
+  const
+    _quiet =
+      _global[
+        "quiet"];
+  const
+    _target_app =
+      _get(
+        "target",
+        "app");  
+  const
+    _user_defined =
+      "n";
+  _deployments_dir =
+    _get(
+      "deployments",
+      "dir");
+  _target_contract =
+    _get(
+      "target",
+      "contract");
+  _msg_info(
+    `Target app  '${_target_app}'.`);
+  _msg_info(
+    `Target contract  '${_target_contract}'.`);
+  _contract_address =
+    _get(
+      "contract",
+      "address");
+  const
+    _target_networks =
+      _get(
+        "target",
+        "networks");
+  const
+    _deployments_dir_check_args = [
+      _deployments_dir,
+      _target_app,
+      _user_defined
+    ];
+  _msg =
+    "Running '_deployments_dir_check' " +
+    `with arguments:`;
+  _msg_info(
+    _msg);
+  if ( _quiet == "n" ) {
+    _echo(
+      _deployments_dir_check_args);
+  }
+  try {
+    _deployments_dir =
+      await _deployments_dir_check.apply(
+        null,
+        _deployments_dir_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_deployments_dir_check' " +
+      `with arguments:`;
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _deployments_dir_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _target_contract_check_args = [
+      _target_contract,
+      _contract_address,
+      _target_app,
+      _deployments_dir
+    ];
+  try {
+    _target_contract =
+      await _target_contract_check.apply(
+        null,
+        _target_contract_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_target_contract_check' " +
+      "with parameters:";
+    _echo2(
+      _target_contract_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
+  const
+    _contract_address_check_args = [
+      _contract_address,
+      _deployments_dir,
+      _target_app
+    ];
+  try {
+    _contract_address =
+      await _contract_address_check.apply(
+        null,
+        _contract_address_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_contract_address_check' " +
+      "with parameters:";
+    _echo2(
+      _contract_address_check_args);
+    _echo2(
+      _error);
+    throw _error;
   }
   const
-    _contract_type =
+    _api_key =
+      _get(
+        "api",
+        "key");
+  const
+    _compiler_output =
+      _get(
+        "contract",
+        "compiler_output");
+  _bytecode =
+    _get(
+      "contract",
+      "bytecode");
+  const
+    _bytecode_type =
       typeof(
-        _contract);
-  if ( _contract != "" &&
-       _contract_type != "undefined" ) {
-    const
-      _deployments_dir_type =
-        typeof(
-          deployments_dir);
-    if ( _deployments_dir_type != "undefined" &&
-         deployments_dir != "" ) {
-      _deployments =
-        deployments_dir;
-      if ( 0 < target_networks.length ) {
+        _bytecode);
+  _bytecode_retrieve =
+    false;
+  if ( _bytecode_type === "undefined" ) {
+    _bytecode_retrieve =
+      true;
+  }
+  else if ( _bytecode_type === "string" ) {
+    if ( _bytecode.length < 1 ) {
+      _bytecode_retrieve =
+        true;
+    }
+  }
+  if ( _bytecode_retrieve ) {
+    if ( 1 < _target_networks.length ) {
+      _msg =
+        "You can't currently retrieve " +
+        "bytecode for more than a contract.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+    else if ( 1 == _target_networks.length ) {
+      const
         _network =
-          target_networks[
-            0];
-      }
-      if ( 0 < network_ids.length ) {
-        _network_id =
-          _network_ids[
+          _target_networks[
             0];
-      }
+      _configuration_format =
+        _configuration_format_check(
+          _configuration_format);
       const
-        _deployments_path =
-          _path_join( [
-            _deployments,
-            _contract ] );
-      if ( networks_all == "n" ) {
-        _networks.push(
+        _contract_bytecode_check_args = [
+          _bytecode,
           _network,
-          _network_id);
+          _contract_address,
+          _api_key,
+          _compiler_output,
+          _target_app,
+          _target_contract,
+          _configuration_format,
+          _deployments_dir,
+          _user_defined,
+          true                  // local
+        ];
+      _msg =
+        "Running '_contract_bytecode_check' with " +
+        "parameters:";
+      _msg_info(
+        _msg);
+      if ( _quiet == "n" ) {
+        _echo(
+          _contract_bytecode_check_args);
       }
-      else if ( networks_all == "y" ) {
-        const
-          _evm_contract_deployment_networks_args = [
-            _deployments_path,
-            "y",                  // Display all
-            "n",                  // Display safest
-            "n"                   // Display cheapest
-          ];
-        _networks_new =
-          await _evm_contract_deployment_networks.apply(
+      try {
+        _bytecode =
+          await _contract_bytecode_check.apply(
             null,
-            _evm_contract_deployment_networks_args);
-        _networks =
-          _networks.concat(
-            _networks_new);
-      }
-      for ( _net of _networks ) {
-        _config =
-          _path_join( [
-            _deployments_path,
-            _net,
-            `config.${_config_ext}`
-            ]);
-        if ( _file_exists(
-               _config) ) {
-          _found =
-            true;
-          _msg =
-            `Found deployment configuration ` +
-            `at location '${_config}'.`;
-          _msg_info(
-            _msg);
-          break;
-        }
+            _contract_bytecode_check_args);
       }
-      if ( ! _found ) {
+      catch(
+        _error) {
         _msg =
-          "No deployment configuration " +
-          "file found for network " +
-          `'${_network}' with ID ` +
-          `'${_network_id}'.`;
+          "Error running '_contract_bytecode_check' with " +
+          "parameters:";
         _msg_error(
           _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;
+          0);
+        _echo2(
+          _contract_bytecode_check_args);
+        _echo2(
+          _error);
+        throw _error;
       }
-      const
-        _evm_contract_deployment_versions_args = [
-          _config,
-          "y",                  // display highest
-          "n",                  // display lowest
-          configuration_format
-        ];
-      _version =
-        await _evm_contract_deployment_versions.apply(
-          null,
-          _evm_contract_deployment_versions_args);
     }
-    else if ( _deployments_dir_type == "undefined" ||
-              deployments_dir == "" ) {
-      const
-        _msg =
-          "If no target application is specified " +
-          "then the user-defined deployments " +
-          "switch must be enabled with '-u' and " +
-          "a deployments directory must be specified " +
-          "with '-d'.";
+    else {
+      _msg =
+        "You must currently select a network " +
+        "to auto-detect the bytecode for " +
+        "a libevm application contract.";
       _msg_error(
         _msg,
-        1);
+        0);
+      throw _msg;
     }
   }
   _override_set(
     "contract",
-    "version",
-    _version);
-  return true;
-}
-
-function
-  _networks_all_auto_detect() {
-  let
-    _networks_all;
-  _networks_all =
-    "n";
-  if ( target_networks.length < 1 &&
-       network_ids.length < 1 ) {
-    _networks_all =
-      "y";
-  }
-  _override_set(
-    "networks",
-    "all",
-    _networks_all);
+    "bytecode",
+    _bytecode);
 }
 
 async function
-  _target_app_auto_detect() {
+  _contract_compiler_output_auto_detect() {
   let
-    _app;
-  _app =
-    "";
+    _compiler_output,
+    _compiler_output_retrieve,
+    _contract_address,
+    _configuration_format,
+    _deployments_dir,
+    _msg,
+    _target_contract;
+  const
+    _global =
+      _global_get();
   const
-    _dir_current_name =
-      _basename(
-        _pwd());
+    _quiet =
+      _global[
+        "quiet"];
+  const
+    _target_app =
+      _get(
+        "target",
+        "app");  
   const
     _user_defined =
-      user_defined;
-
+      "n";
+  _deployments_dir =
+    _get(
+      "deployments",
+      "dir");
+  _target_contract =
+    _get(
+      "target",
+      "contract");
+  _msg_info(
+    `Target app  '${_target_app}'.`);
+  _msg_info(
+    `Target contract  '${_target_contract}'.`);
+  _contract_address =
+    _get(
+      "contract",
+      "address");
   const
-    _evm_contract_deployments_dir_args = [
-      _dir_current_name,
+    _target_networks =
+      _get(
+        "target",
+        "networks");
+  const
+    _deployments_dir_check_args = [
+      _deployments_dir,
+      _target_app,
       _user_defined
     ];
+  _msg =
+    "Running '_deployments_dir_check' " +
+    `with arguments:`;
+  _msg_info(
+    _msg);
+  if ( _quiet == "n" ) {
+    _echo(
+      _deployments_dir_check_args);
+  }
+  try {
+    _deployments_dir =
+      await _deployments_dir_check.apply(
+        null,
+        _deployments_dir_check_args);
+  }
+  catch(
+    _error) {
+    _msg =
+      "Error running '_deployments_dir_check' " +
+      `with arguments:`;
+    _msg_error(
+      _msg,
+      0);
+    _echo2(
+      _deployments_dir_check_args);
+    _echo2(
+      _error);
+    throw _error;
+  }
   const
-    _target_dir =
-      await _evm_contract_deployments_dir.apply(
+    _target_contract_check_args = [
+      _target_contract,
+      _contract_address,
+      _target_app,
+      _deployments_dir
+    ];
+  try {
+    _target_contract =
+      await _target_contract_check.apply(
         null,
-        _evm_contract_deployments_dir_args);
-  if ( _dir_exists(
-         _target_dir) ) {
-    _app =
-      _dir_current_name;
+        _target_contract_check_args);
   }
-  else {
+  catch(
+    _error) {
     _msg =
-      `Directory '${_target_dir}' ` +
-      "not found.";
-    _msg_info(
-      _msg);
+      "Error running '_target_contract_check' " +
+      "with parameters:";
+    _echo2(
+      _target_contract_check_args);
+    _echo2(
+      _error);
+    throw _error;
   }
-  _override_set(
-    "target",
-    "app",
-    _app);
-}
-
-function
-  _configuration_format_get(
-    _config_file) {
-  let
-    _configuration_format;
-  if ( _config_file.endsWith(
-         ".sh") ) {
-    _configuration_format =
-      "bash";
+  const
+    _contract_address_check_args = [
+      _contract_address,
+      _deployments_dir,
+      _target_app
+    ];
+  try {
+    _contract_address =
+      await _contract_address_check.apply(
+        null,
+        _contract_address_check_args);
   }
-  else if ( _config_file.endsWith(
-         ".json") ) {
-    _configuration_format =
-      "json";
+  catch(
+    _error) {
+    _msg =
+      "Error running '_contract_address_check' " +
+      "with parameters:";
+    _echo2(
+      _contract_address_check_args);
+    _echo2(
+      _error);
+    throw _error;
   }
-  else {
-    const
+  const
+    _api_key =
+      _get(
+        "api",
+        "key");
+  _compiler_output =
+    _get(
+      "contract",
+      "compiler_output");
+  const
+    _compiler_output_type =
+      typeof(
+        _compiler_output);
+  _compiler_output_retrieve =
+    false;
+  if ( _compiler_output_type === "undefined" ) {
+    _compiler_output_retrieve =
+      true;
+  }
+  else if ( _compiler_output_type === "string" ) {
+    if ( _compiler_output.length < 1 ) {
+      _compiler_output_retrieve =
+        true;
+    }
+  }
+  if ( _compiler_output_retrieve ) {
+    if ( 1 < _target_networks.length ) {
       _msg =
-        "Impossible determining " +
-        "configuration format from file " +
-        "extension, defaulting to 'json'.";
-    _msg_info(
-      _msg,
-      0);
-    throw _msg;
+        "You can't currently retrieve " +
+        "compiler output for more than a contract.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
+    else if ( 1 == _target_networks.length ) {
+      const
+        _network =
+          _target_networks[
+            0];
+      _configuration_format =
+        _configuration_format_check(
+          _configuration_format);
+      const
+        _contract_compiler_output_check_args = [
+          _compiler_output,
+          _network,
+          _contract_address,
+          _api_key,
+          _target_app,
+          _target_contract,
+          _configuration_format,
+          _deployments_dir,
+          _user_defined,
+          true                  // local
+        ];
+      _msg =
+        "Running '_contract_compiler_output_check' with " +
+        "parameters:";
+      _msg_info(
+        _msg);
+      if ( _quiet == "n" ) {
+        _echo(
+          _contract_compiler_output_check_args);
+      }
+      try {
+        _compiler_output =
+          await _contract_compiler_output_check.apply(
+            null,
+            _contract_compiler_output_check_args);
+      }
+      catch(
+        _error) {
+        let
+          _error_info;
+        _msg =
+          "Error running '_contract_compiler_output_check' with " +
+          "parameters:";
+        _error_info =
+          false;
+        const
+          _contract_abi =
+            _get(
+              "contract",
+              "abi");
+        const
+          _contract_bytecode =
+            _get(
+              "contract",
+              "bytecode");
+        const
+          _contract_abi_type =
+            typeof(
+              _contract_abi);
+        const
+          _contract_bytecode_type =
+            typeof(
+              _contract_bytecode);
+        if ( _contract_abi_type == "string" &&
+             _contract_bytecode_type == "string" ) {
+          if ( 0 < _contract_abi.length &&
+               0 < _contract_bytecode.length ) {
+            if ( _file_exists(
+                   _contract_abi) &&
+                 _file_exists(
+                   _contract_bytecode) ) {
+              _error_info =
+                true;
+            }
+          }
+        }
+        if ( _error_info ) {
+          _msg_info(
+            _msg);
+        }
+        else {
+          _msg_error(
+            _msg,
+            0);
+          _echo2(
+            _contract_compiler_output_check_args);
+        }
+        throw _error;
+      }
+    }
+    else {
+      _msg =
+        "You must currently select a network " +
+        "to auto-detect the compiler output for " +
+        "a libevm application contract.";
+      _msg_error(
+        _msg,
+        0);
+      throw _msg;
+    }
   }
-  return _configuration_format;
-}
-
-function
-  _configuration_format_auto_detect() {
-  const
-    _configuration_format =
-      _configuration_format_get(
-        config_file);
   _override_set(
-    "configuration",
-    "format",
-    _configuration_format);
+    "contract",
+    "compiler_output",
+    _compiler_output);
 }
 
 export {
+  _app_check,
+  _config_file_path_check,
   _configuration_format_auto_detect,
+  _configuration_format_check,
   _configuration_format_get,
+  _contract_abi_auto_detect,
+  _contract_address_auto_detect,
+  _contract_address_check,
+  _contract_bytecode_auto_detect,
+  _contract_bytecode_check,
+  _contract_compiler_output_auto_detect,
+  _contract_compiler_output_check,
   _contract_version_auto_detect,
+  _default_artifact_path_get,
   _deployments_dir_auto_detect,
+  _deployments_dir_check,
   _network_check,
   _networks_all_auto_detect,
   _target_app_auto_detect,
+  _target_contract_auto_detect,
+  _target_contract_check,
   _user_deployments_check,
+  _user_defined_check,
+  _user_level_check,
+  _version_check
 };
 
 // module.exports = {
+//   _app_check:
+//     _app_check,
+//   _config_file_path_check:
+//     _config_file_path_check,
 //   _configuration_format_auto_detect:
 //     _configuration_format_auto_detect,
+//   _configuration_format_check:
+//     _configuration_format_check,
 //   _configuration_format_get:
 //     _configuration_format_get,
+//   _contract_abi_auto_detect:
+//     _contract_abi_auto_detect,
+//   _contract_abi_check:
+//     _contract_abi_check,
+//   _contract_address_auto_detect:
+//     _contract_address_auto_detect,
+//   _contract_address_check:
+//     _contract_address_check,
+//   _contract_bytecode_check:
+//     _contract_bytecode_check,
+//   _contract_bytecode_auto_detect:
+//     _contract_bytecode_auto_detect,
+//   _contract_compiler_output_auto_detect:
+//     _contract_compiler_output_auto_detect,
+//   _contract_compiler_output_check:
+//     _contract_compiler_output_check,
 //   _contract_version_auto_detect:
 //     _contract_version_auto_detect,
+//   _default_artifact_path_get:
+//     _default_artifact_path_get,
+//   _deployments_dir_check:
+//     _deployments_dir_check,
 //   _deployments_dir_auto_detect:
 //     _deployments_dir_auto_detect,
 //   _network_check:
@@ -761,6 +4658,16 @@ export {
 //     _networks_all_auto_detect,
 //   _target_app_auto_detect:
 //     _target_app_auto_detect,
+//   _target_contract_auto_detect:
+//     _target_contract_auto_detect,
+//   _target_contract_check:
+//     _target_contract_check,
 //   _user_deployments_check:
 //     _user_deployments_check,
+//   _user_defined_check:
+//     _user_defined_check,
+//   _user_level_check:
+//     _user_level_check,
+//   _version_check:
+//     _version_check,
 // };