evm-deployer 0.0.1

package/lib/deployer

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+
+const
+  { ethers } =
+    require(
+      "ethers");
+_ethers =
+  ethers;
+_contract_factory =
+  _ethers.ContractFactory;
+const
+  _libcrash =
+    require(
+      "crash-js");
+_cmdline_check =
+  _libcrash._cmdline_check;
+_dirname =
+  _libcrash._dirname;
+_error_display =
+  _libcrash._error_display;
+_file_read =
+  _libcrash._file_read;
+_file_write =
+  _libcrash._file_write;
+_json_read =
+  _libcrash._json_read;
+_json_display =
+  _libcrash._json_display;
+_msg_info =
+  _libcrash._msg_info;
+_msg_error =
+  _libcrash._msg_error;
+_path_join =
+  _libcrash._path_join;
+const
+  _evm_wallet_module =
+    require(
+      "evm-wallet.js");
+const
+  _wallet_get =
+    _evm_wallet_module._wallet_get;
+const
+  _provider_get =
+    _evm_wallet_module._provider_get;
+
+function
+  _global_variables() {
+  app_name =
+    "deployer";
+  retries_max =
+    "";
+  call_timeout =
+    "";
+  wallet_seed =
+    "";
+  contract_abi_path =
+    "";
+  contract_bytecode_path =
+    "";
+  contract_compiler_output_path =
+    "";
+  target_network =
+    "";
+  api_key_path =
+    "";
+  contract_output_file =
+    "";
+  tx_deployment_output_file =
+    "";
+  quiet =
+    "";
+}
+
+function
+  _msg_info_provider_generated(
+    _provider) {
+  let
+    _msg,
+    _template;
+  _template =
+    "Provider '{_provider}' generated.";
+  _msg =
+    _template.replaceAll(
+      "{_provider}",
+      _provider);
+  _msg_info(
+    _msg);
+}
+
+function
+  _msg_info_contract_deployed(
+    _contract) {
+  let
+    _msg,
+    _template;
+  _template =
+    "Deployed contract '{_contract}'.";
+  _msg =
+    _template.replaceAll(
+      "{_contract}",
+      _contract);
+  _msg_info(
+    _msg);
+}
+
+function
+  _msg_error_deployment_undefined(
+    _attempt) {
+  let
+    _msg,
+    _template;
+  _template =
+    "Deployment transaction undefined at attempt '{_attempt}'.";
+  _msg =
+    _template.replaceAll(
+      "{_attempt}",
+      _attempt);
+  _msg_info(
+    _msg);
+  _msg_error(
+    _msg,
+    0);
+}
+
+async function
+  _contract_sanitize(
+    _contract) {
+  let
+    _contract_sanitized,
+    _field;
+  _contract_sanitized =
+    {};
+  for (_field in _contract) {
+    if ( _field != "runner" ) {
+      _contract_sanitized[
+        _field] =
+        _contract[
+          _field];
+    }
+  }
+  return _contract_sanitized;
+}
+
+function
+  _delay(
+    _time) {
+  return new Promise(resolve => setTimeout(resolve, _time));
+}
+
+async function
+  _evm_deployer(
+    _retries_max,
+    _call_timeout,
+    _wallet_seed,
+    _contract_abi_path,
+    _contract_bytecode_path,
+    _contract_compiler_output_path,
+    _target_network,
+    _api_key_path,
+    _contract_output_file,
+    _tx_deployment_output_file) {
+  let
+    _api_key,
+    _attempt,
+    _contract,
+    _contract_abi,
+    _contract_bytecode,
+    _contract_compiler_output,
+    _contract_json,
+    _contract_sanitized,
+    _factory,
+    _tx_deployment,
+    _tx_deployment_json,
+    _return,
+    _wallet,
+    _wallet_get_opts,
+    _wallet_password,
+    _wallet_path_list,
+    _wallet_path;
+  if ( _retries_max == "" ) {
+    _msg_info(
+      "Setting maximum call retries to '100'.");
+    _retries_max =
+      100;
+  }
+  _retries_max =
+    Number(
+      _retries_max);
+  if ( _call_timeout == "" ) {
+    _msg_info(
+      "Setting timeout to '300' seconds.");
+    _call_timeout =
+      300000;
+  }
+  _call_timeout =
+    Number(
+      _call_timeout);
+  _wallet_password =
+    "";
+  _wallet_path_list = [
+    _dirname(
+      _wallet_seed),
+    "wallet.dat"
+  ];
+  _wallet_path =
+    _path_join(
+      _wallet_path_list);
+  if ( _api_key_path != "" ) {
+    _api_key =
+      _file_read(
+        _api_key_path);
+  }
+  else if ( _api_key_path == "" ) {
+    _api_key =
+      "";
+  }
+  _provider =
+    _provider_get(
+      _target_network,
+      _api_key);
+  _msg_info_provider_generated(
+    _provider);
+  _wallet_get_opts = [
+    _wallet_path,
+    _wallet_password,
+    _wallet_seed,
+    _provider
+  ];
+  _wallet =
+    _wallet_get.apply(
+      null,
+      _wallet_get_opts);
+  if ( _contract_bytecode_path != "" ) {
+    if ( _contract_abi_path == "" ) {
+      _msg_error(
+        "Contract ABI is needed if deploying with bytecode.",
+        1);
+    }
+    _contract_bytecode =
+      _file_read(
+        _contract_bytecode_path);
+    _contract_abi =
+      _json_read(
+        _contract_abi_path);
+    _factory = new
+      _contract_factory(
+        _contract_abi,
+        _contract_bytecode);
+  }
+  else if ( _contract_compiler_output_path != "" ) {
+    _contract_compiler_output =
+      _json_read(
+        _contract_compiler_output_path);
+    _factory =
+      _contract_factory.fromSolidity(
+        _contract_compiler_output);
+  }
+  _factory =
+    _factory.connect(
+      _wallet);
+  _attempt =
+    1;
+  while ( _attempt <= _retries_max ) {
+    try {
+      _contract = await
+        _factory.deploy();
+      // It seems there is no
+      // timeout for the deployments.
+      // Probably there's a global one
+      // defined at provider's level
+      // which could be tweaked, but
+      // definitely not now.
+      _contract =
+        await _contract.waitForDeployment();
+      if ( _contract == undefined ) {
+        _msg_error_deployment_undefined(
+          _attempt);
+        throw { "error": {
+                  "message":
+                    "Contract undefined, error deploying." } };
+      }
+      else if ( _contract != undefined ) {
+        // _tx_deployment =
+        //   await _factory.getDeployTransaction();
+        _tx_deployment =
+          _contract.deploymentTransaction();
+        _contract_sanitized =
+          await _contract_sanitize(
+            _contract);
+        _msg_info_contract_deployed(
+          _contract_sanitized);
+        if ( quiet == "n" ) {
+          console.log(
+            _contract_sanitized);
+          console.log(
+            _tx_deployment);
+	}
+        if ( _contract_output_file != "" ) {
+          _contract_json =
+            _json_display(
+              _contract_sanitized);
+          _file_write(
+            _contract_output_file,
+            _contract_json);
+        }
+        if ( _tx_deployment_output_file != "" ) {
+          _tx_deployment_json =
+            _json_display(
+              _tx_deployment);
+          _file_write(
+            _tx_deployment_output_file,
+            _tx_deployment_json);
+        }
+        _msg_info(
+          "Deployment transaction sent.");
+        break;
+        }
+    } catch (
+        _error) {
+      _error_display(
+        _error);
+      _msg_info(
+        "Waiting 3 seconds before retrying.");
+      await _delay(
+        3000);
+        _attempt =
+          _attempt + 1;
+    }
+  }
+  if ( _attempt > _retries_max ) {
+    throw { "error": {
+	      "message":
+	        "Maximum number of retries reached." } };
+  }
+  _return = [
+    _contract_sanitized,
+    _tx_deployment
+  ];
+  return _return;
+}
+
+function
+  _config_show() {
+  let
+    _line,
+    _text;
+  _text =
+    [];
+  _text.push(
+    "                       Wallet seed: {wallet_seed}".replace(
+      "{wallet_seed}",
+      wallet_seed));
+  _text.push(
+    "                    Target network: {target_network}".replace(
+      "{target_network}",
+      target_network));
+  _text.push(
+    "                           API Key: {api_key}".replace(
+      "{api_key}",
+      api_key_path));
+  _text.push(
+    "                      Contract ABI: {contract_abi_path}".replace(
+      "{contract_abi_path}",
+      contract_abi_path));
+  _text.push(
+    "                 Contract bytecode: {contract_bytecode_path}".replace(
+      "{contract_bytecode_path}",
+      contract_bytecode_path));
+  _text.push(
+    "          Contract compiler output: {contract_compiler_output_path}".replace(
+      "{contract_compiler_output_path}",
+      contract_compiler_output_path));
+  _text.push(
+    "              Contract output file: {contract_output_file}".replace(
+      "{contract_output_file}",
+      contract_output_file));
+  _text.push(
+    "Deployment transaction output file: {tx_deployment_output_file}".replace(
+      "{tx_deployment_output_file}",
+      tx_deployment_output_file));
+  for ( _line of _text ) {
+    _msg_info(
+      _line);
+  }
+}
+
+function
+  _usage(
+    _exit) {
+  let
+    _line,
+    _text;
+  _text = [
+    "Usage:",
+    "  deployer",
+    "    <quiet>",
+    "    <retries_max>",
+    "    <call_timeout>",
+    "    <seed_path>",
+    "    <contract_abi_path>",
+    "    <contract_bytecode_path>",
+    "    <contract_compiler_output_path>",
+    "    (<target_network>)",
+    "    (<api_key>)",
+    "    (<contract_output_file>)",
+    "    (<tx_deployment_output_file>)",
+    "",
+    "Args:",
+    "  <quiet>                          Can be 'y' or 'n'",
+    "                                   Default: y",
+    "  <retries_max>                    Maximum number of retries before",
+    "                                   failing.",
+    "  <call_timeout>                   How many milliseconds to wait for a return",
+    "                                   before declaring the call failed.",
+    "  <wallet_seed>                    Path of the file containing",
+    "                                   the seed phrase.",
+    "  <contract_abi_path>              Contract ABI path.",
+    "  <contract_bytecode_path>         Path for the contract bytecode.",
+    "  <contract_compiler_output_path>  Path for the contract compiler",
+    "                                   output path (the hardhat artifact).",
+    "  <target_network>                 Network on which the contract",
+    "                                   resides.",
+    "  <api_key_path>                   Path of the API key for the",
+    "                                   contract ABI provider service.",
+    "  <contract_output_file>           Path for an output file in which",
+    "                                   to save the contract object generated",
+    "                                   by the deployment call. Absolutely",
+    "                                   not necessary.",
+    "  <tx_deployment_output_file>      Path for an output file in which",
+    "                                   to save the transaction object generated",
+    "                                   by the deployment call. Absolutely",
+    "                                   necessary.",
+    "",
+    "  Options:",
+    "    -h (--help)                    This help."
+  ];
+  for ( _line of _text ) {
+    _msg_info(
+      _line);
+  }
+  process.exit(
+    _exit);
+}
+
+
+function _cmdline_parse() {
+  quiet =
+    "y";
+  process.argv.forEach(
+    function (
+      _value,
+      _index,
+      _array) {
+      if ( _index == 2 ) {
+        quiet =
+          _value;
+      }
+      if ( _index == 3 ) {
+        retries_max =
+          _value;
+      }
+      if ( _index == 4 ) {
+        call_timeout =
+          _value;
+      }
+      if ( _index == 5 ) {
+        wallet_seed =
+          _value;
+      }
+      if ( _index == 6 ) {
+        contract_abi_path =
+          _value;
+      }
+      if ( _index == 7 ) {
+        contract_bytecode_path =
+          _value;
+      }
+      if ( _index == 8 ) {
+        contract_compiler_output_path =
+          _value;
+      }
+      if ( _index == 9 ) {
+        target_network =
+          _value;
+      }
+      if ( _index == 10 ) {
+        api_key_path =
+          _value;
+      }
+      if ( _index == 11 ) {
+        contract_output_file =
+          _value;
+      }
+      if ( _index == 12 ) {
+        tx_deployment_output_file =
+          _value;
+      }
+      if ( _value == "-h" ||
+           _value == "--help" ) {
+        quiet =
+          "n";
+        _usage(
+          0);
+      }
+  });
+  if ( contract_bytecode_path == "" &&
+       contract_compiler_output_path == "" ) {
+    quiet =
+      "n";
+    _usage(
+      1);
+  }
+}
+
+function 
+  _overrides_set() {
+  if ( retries_max == "" ) {
+    retries_max =
+      100;
+  }
+  if ( call_timeout == "" ) {
+    call_timeout =
+      300000;
+  }
+  if ( target_network == "" ) {
+    _msg_info(
+      "No network selected, setting Gnosis");
+    target_network =
+      "https://rpc.gnosischain.com";
+  }
+}
+
+async function 
+  _evm_deployer_cmdline(
+    _app_opts) {
+  let
+    _contract,
+    _address,
+    _tx_deployment,
+    _tx_hash;
+  try {
+    [ _contract,
+      _tx_deployment ] =
+      await _evm_deployer.apply(
+        null,
+        app_opts);
+    if ( _contract != undefined ) {
+      _address =
+        _contract[
+	  "target"];
+      _tx_hash =
+        _tx_deployment[
+          "hash"];
+      console.log(
+        "Address:",
+        _address);
+      console.log(
+        "Transaction:",
+        _tx_hash);
+    }
+    else if ( _contract == undefined ) {
+      throw { "error": {
+                "message":
+                  "Error deploying the contract." } };
+    }
+   } catch (
+       _error) {
+    _error_display(
+      _error);
+    _msg_error(
+      "Contract deployment failed.",
+      0);
+    throw _error;
+  };
+}
+
+if ( _cmdline_check(
+       "deployer") == true ) {
+  _global_variables();
+  _cmdline_parse();
+  _overrides_set();
+  _config_show();
+  app_opts = [
+    retries_max,
+    call_timeout,
+    wallet_seed,
+    contract_abi_path,
+    contract_bytecode_path,
+    contract_compiler_output_path,
+    target_network,
+    api_key_path,
+    contract_output_file,
+    tx_deployment_output_file
+  ];
+  _evm_deployer_cmdline(
+    app_opts);
+}
+
+module.exports = {
+  _evm_deployer:
+    _evm_deployer
+};