evm-contracts-tools 0.0.47 → 0.0.49

package/libevm-contract-deployment

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+
+// 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 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
+ *     along with this program.
+ *     If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/* eslint-disable
+     no-unused-vars */
+/* eslint-disable
+     no-useless-assignment */
+
+/* EVM Contracts tools global variables */
+/* global
+     call_type */
+/* global
+     call_auth:
+       writable */
+
+/* libEVM global variables */
+/* global 
+     api_key */
+/* global
+     contract_abi:
+       writable */
+/* global
+     contract_address */
+/* global
+     contract_bytecode:
+       writable */
+/* global
+     contract_compiler_output:
+       writable */
+/* global
+     target_network:
+       writable */
+/* global
+     target_networks:
+       writable */
+
+const
+  _libcrash_module =
+    require(
+      "crash-js");
+/* global
+     _basename */
+const
+  _basename =
+    _libcrash_module._basename;
+/* global
+     _chmod */
+const
+  _chmod =
+    _libcrash_module._chmod;
+/* global
+     _cp */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _cp =
+    _libcrash_module._cp;
+/* global
+     _dir_exists */
+const
+  _dir_exists =
+    _libcrash_module._dir_exists;
+/* global
+     _file_exists */
+const
+  _file_exists =
+    _libcrash_module._file_exists;
+/* global
+     _file_read */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _file_read =
+    _libcrash_module._file_read;
+/* global
+     _from_bash_ass_array */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _from_bash_ass_array =
+    _libcrash_module._from_bash_ass_array;
+/* global
+     _homedir_get */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _homedir_get =
+    _libcrash_module._homedir_get;
+/* global
+     _json_read */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _json_read =
+    _libcrash_module._json_read;
+/* global
+     _mkdir */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _mkdir =
+    _libcrash_module._mkdir;
+/* global
+     _msg_info */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _msg_info =
+    _libcrash_module._msg_info;
+/* global
+     _msg_error */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _msg_error =
+    _libcrash_module._msg_error;
+/* global
+     _override_set */
+const
+  _override_set =
+    _libcrash_module._override_set;
+/* global
+     _path_join */
+/* eslint-disable-next-line
+     no-global-assign */
+const
+  _path_join =
+    _libcrash_module._path_join;
+/* global
+     _pwd */
+const
+  _pwd =
+    _libcrash_module._pwd;
+const
+  _evm_chains_info_module =
+    require(
+      "evm-chains-info");
+/* global
+     _evm_chains_info */
+const
+  _evm_chains_info =
+    _evm_chains_info_module._evm_chains_info;
+const
+  _libevm_contract_deployments_dir_module =
+    require(
+      "./libevm-contract-deployments-dir");
+/* global
+     _evm_contract_deployments_dir */
+const
+  _evm_contract_deployments_dir =
+    _libevm_contract_deployments_dir_module._evm_contract_deployments_dir;
+const
+  _libevm_contract_deployment_networks_module =
+    require(
+      "./libevm-contract-deployment-networks");
+/* global
+     _evm_contract_deployment_networks */
+const
+  _evm_contract_deployment_networks =
+    _libevm_contract_deployment_networks_module._evm_contract_deployment_networks;
+const
+  _libevm_contract_deployment_versions_module =
+    require(
+      "./libevm-contract-deployment-versions");
+/* global
+     _evm_contract_deployment_versions */
+const
+  _evm_contract_deployment_versions =
+    _libevm_contract_deployment_versions_module._evm_contract_deployment_versions;
+
+async function
+  _network_check(
+    _deployments,
+    _contract,
+    _target_network,
+    _target_network_id) {
+  let
+    _error_flag,
+    _msg,
+    _network_id;
+  _error_flag =
+    false;
+  _deployments_path =
+    _path_join( [
+      _deployments,
+      _contract ]);
+  const
+    _evm_contract_deployment_networks_args = [
+      _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) ) {
+      _msg =
+        "The 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,
+      1);
+  }
+  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
+    ];
+    _network_id =
+      await _evm_chains_info.apply(
+        null,
+        _evm_chains_info_args);
+  }
+  else if ( _target_network == "" ) {
+    _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
+    ];
+    _target_network =
+      await _evm_chains_info(
+        _evm_chains_info_args);
+  }
+  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,
+        1);
+    }
+  }
+}
+
+async function
+  _user_deployments_init(
+    _app,
+    _deployments_dir) {
+  const
+    _user_defined =
+      "y";
+  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);
+  }
+}
+
+async function
+  _deployments_dir_auto_detect() {
+  let
+    _deployments;
+  _deployments =
+    "";
+  const
+    _app =
+      target_app;
+  const
+    _app_type =
+      typeof(
+        _app);
+  if ( _app_type != "undefined" &&
+       _app != "" ) {
+    const
+      _user_defined =
+        user_defined;
+    const
+      _evm_contract_deployments_dir_args = [
+        _app,
+        _user_defined
+      ];
+    _deployments =
+      await _evm_contract_deployments_dir.apply(
+        null,
+        _evm_contract_deployments_dir_args);
+  }
+  _override_set(
+    "deployments",
+    "dir",
+    _deployments);
+}
+
+async function
+  _contract_version_auto_detect() {
+  let
+    _config,
+    _config_ext,
+    _deployments,
+    _found,
+    _net,
+    _network,
+    _network_id,
+    _networks,
+    _version,
+    _msg;
+  _networks =
+    [];
+  const
+    _contract =
+      target_contract;
+  _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);
+      }
+      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
+  _target_app_auto_detect() {
+  let
+    _app;
+  _app =
+    "";
+  const
+    _dir_current_name =
+      _basename(
+        _pwd());
+  const
+    _user_defined =
+      user_defined;
+  const
+    _evm_contract_deployments_dir_args = [
+      _dir_current_name,
+      _user_defined
+    ];
+  const
+    _target_dir =
+      await _evm_contract_deployments_dir.apply(
+        null,
+        _evm_contract_deployments_dir_args);
+  if ( _dir_exists(
+         _target_dir) ) {
+    _app =
+      _dir_current_name;
+  }
+  else {
+    _msg =
+      `Directory '${_target_dir}' ` +
+      "not found.";
+    _msg_info(
+      _msg);
+  }
+  _override_set(
+    "target",
+    "app",
+    _app);
+}
+
+function
+  _configuration_format_get(
+    _config_file) {
+  let
+    _configuration_format;
+  if ( _config_file.endsWith(
+         ".sh") ) {
+    _configuration_format =
+      "bash";
+  }
+  else if ( _config_file.endsWith(
+         ".json") ) {
+    _configuration_format =
+      "json";
+  }
+  else {
+    const
+      _msg =
+        "Impossible determining " +
+        "configuration format from file " +
+        "extension, defaulting to 'json'.";
+    _msg_info(
+      _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);
+}
+
+module.exports = {
+  _configuration_format_auto_detect:
+    _configuration_format_auto_detect,
+  _configuration_format_get:
+    _configuration_format_get,
+  _contract_version_auto_detect:
+    _contract_version_auto_detect,
+  _deployments_dir_auto_detect:
+    _deployments_dir_auto_detect,
+  _network_check:
+    _network_check,
+  _networks_all_auto_detect:
+    _networks_all_auto_detect,
+  _target_app_auto_detect:
+    _target_app_auto_detect,
+  _user_deployments_check:
+    _user_deployments_check,
+};