evm-contracts-tools 0.0.62 → 0.0.64

package/lib/evm-contract-call-static

@@ -63,6 +63,11 @@ const
 const
   _echo =
     _libcrash._echo;
+/* global
+     _echo2 */
+const
+  _echo2 =
+    _libcrash._echo2;
 /* global
      _error_display */
 const
@@ -238,6 +243,285 @@ function
     _msg);
 }
 
+async function
+  _contract_object_check(
+    _contract_object,
+    _wallet_seed,
+    _wallet_password,
+    _contract_address,
+    _contract_abi_path,
+    _contract_bytecode_path,
+    _contract_compiler_output_path,
+    _target_network,
+    _api_key_path) {
+  let
+    _contract_object_get,
+    _msg;
+  const
+    _contract_object_type =
+      typeof(
+        _contract_object);
+  _contract_object_get =
+    false;
+  if ( _contract_object_type === "undefined" ) {
+    _msg =
+      "Ethers contract object is " +
+      "undefined, generating " +
+      "ethers contract object.";
+    _msg_info(
+      _msg);
+    _contract_object_get =
+      true;
+  }
+  else if ( _contract_object_type === "string" ) {
+    if ( _contract_object.length < 1 )  {
+      _msg =
+        "Ethers contract object is an empty " +
+        "string, generating " +
+        "ethers contract object.";
+      _msg_info(
+        _msg);
+      _contract_object_get =
+        true;
+    }
+  }
+  else if ( _contract_object_type === "object" ) {
+    const
+      _contract_object_keys =
+        Object.keys(
+          _contract_object);
+    if ( _contract_object_keys.length < 1 )  {
+      _msg =
+        "Ethers contract object is an empty " +
+        "object, generating " +
+        "ethers contract object.";
+      _msg_info(
+        _msg);
+      _contract_object_get =
+        true;
+    }
+  }
+  if ( _contract_object_get ) {
+    const
+      _contract_get_args = [
+        _wallet_seed,
+        _wallet_password,
+        _contract_address,
+        _contract_abi_path,
+        _contract_bytecode_path,
+        _contract_compiler_output_path,
+        _target_network,
+        _api_key_path
+      ];
+    try {
+      _contract_object =
+        await _contract_get.apply(
+          null,
+          _contract_get_args);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_contract_get' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _contract_get_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    _msg_info_contract_obtained(
+      _contract_object);
+  }
+  return _contract_object;
+}
+
+async function
+  _method_object_check(
+    _method_object,
+    _contract_object,
+    _contract_method,
+    _wallet_seed,
+    _wallet_password,
+    _contract_address,
+    _contract_abi_path,
+    _contract_bytecode_path,
+    _contract_compiler_output_path,
+    _target_network,
+    _api_key_path) {
+  let
+    _method_object_get,
+    _msg;
+  const
+    _method_object_type =
+      typeof(
+        _method_object);
+  _method_object_get =
+    false;
+  if ( _method_object_type === "undefined" ) {
+    _msg =
+      "Ethers contract method object is " +
+      "undefined, generating " +
+      "ethers contract method object.";
+    _msg_info(
+      _msg);
+    _method_object_get =
+      true;
+  }
+  else if ( _method_object_type === "string" ) {
+    if ( _method_object.length < 1 )  {
+      _msg =
+        "Ethers contract method object is an empty " +
+        "string, generating " +
+        "ethers contract method object.";
+      _msg_info(
+        _msg);
+      _method_object_get =
+        true;
+    }
+  }
+  else if ( _method_object_type === "object" ) {
+    const
+      _method_object_keys =
+        Object.keys(
+          _method_object);
+    if ( _method_object_keys.length < 1 )  {
+      _msg =
+        "Ethers contract method object is an empty " +
+        "object, generating.";
+      _msg_info(
+        _msg);
+      _method_object_get =
+        true;
+    }
+  }
+  if ( _method_object_get ) {
+    const
+      _contract_object_check_args = [
+        _contract_object,
+        _wallet_seed,
+        _wallet_password,
+        _contract_address,
+        _contract_abi_path,
+        _contract_bytecode_path,
+        _contract_compiler_output_path,
+        _target_network,
+        _api_key_path
+      ];
+    try {
+      _contract_object =
+        await _contract_object_check.apply(
+          null,
+          _contract_object_check_args);
+      _msg =
+        "Contract object to derive method " +
+        "object checked.";
+      _msg_info(
+        _msg);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_contract_object_check' " +
+        "with parameters:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _contract_object_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _contract_get_function_args = [
+        _contract_method
+      ];
+    try {
+      _method_object =
+        await _contract_object.getFunction(
+          _contract_method);
+    }
+    catch(
+      _error) {
+      const
+        _msg_no_fragment =
+          "no matching fragment";
+      if ( "shortMessage" in _error ) {
+        const
+          _msg_short =
+            _error[
+              "shortMessage"];
+        if ( _msg_no_fragment == _msg_short ) {
+          _msg =
+            `Found no '${_contract_method}' method ` +
+            `nor contract ABI '${_contract_abi_path}' ` +
+            `nor in compiler output ` +
+            `'${_contract_compiler_output_path}'.`;
+          _msg_error(
+            _msg,
+            0);
+        }
+      }
+      _msg =
+        "Error running '_contract_object.getFunction' " +
+        "with arguments:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _contract_get_function_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    _msg_info_method_obtained(
+      _method_object);
+  }
+  return _method_object;
+}
+
+function
+  _is_network_error(
+    _error) {
+  let
+    _is_error,
+    _msg;
+  _is_error =
+    false;
+  const
+    _error_type =
+      typeof(
+        _error);
+  if ( _error_type === "object" ) {
+    if ( "errno" in _error ) {
+      const
+        _errno =
+          _error[
+            "errno"];
+      if ( _errno === -3001 ) {
+        const
+          _rpc =
+            _error[
+              "hostname"];
+        _msg =
+          "Error connecting to RPC " +
+          `'${_rpc}', is the computer ` +
+          `connected to the internet?`;
+        _msg_error(
+          _msg,
+          0);
+        _is_error =
+          true;
+      }
+    }
+  }
+  return _is_error;
+}
+
 async function
   _contract_call_static(
     _wallet_seed,
@@ -250,13 +534,16 @@ async function
     _method_object,
     _contract_address,
     _contract_method,
-    _method_args) {
+    _method_args,
+    _contract_object) {
   let
-    _contract,
-    _contract_get_opts,
+    _contract_get_args,
+    _contract_object_get,
+    _exception,
     _method,
     _msg,
     _passed,
+    _retry,
     _value;
   if ( _method_object == undefined ) {
     _method_object =
@@ -267,98 +554,201 @@ async function
   const
     _wallet_password =
       "";
-  _contract_get_opts = [
-    _wallet_seed,
-    _wallet_password,
-    _contract_address,
-    _contract_abi_path,
-    _contract_bytecode_path,
-    _contract_compiler_output_path,
-    _target_network,
-    _api_key_path,
-  ];
+  const
+    _contract_object_check_args = [
+      _contract_object,
+      _wallet_seed,
+      _wallet_password,
+      _contract_address,
+      _contract_abi_path,
+      _contract_bytecode_path,
+      _contract_compiler_output_path,
+      _target_network,
+      _api_key_path
+    ];
   _passed = 
     false;
   while ( _retry <= _retries_max &&
           _passed == false ) {
     try {
-      if ( _method_object === "" ||
-           typeof(
-             _method_object) === "undefined" ) {
-        _contract =
-          await _contract_get.apply(
+      _contract_object =
+        await _contract_object_check.apply(
+          null,
+          _contract_object_check_args);
+      _msg =
+        "Checked ethers contract object.";
+      _msg_info(
+        _msg);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_contract_object_check' " +
+        "parameters:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _contract_object_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    const
+      _method_object_check_args = [
+        _method_object,
+        _contract_object,
+        _contract_method,
+        _wallet_seed,
+        _wallet_password,
+        _contract_address,
+        _contract_abi_path,
+        _contract_bytecode_path,
+        _contract_compiler_output_path,
+        _target_network,
+        _api_key_path
+      ];
+    try {
+      _method_object =
+        await _method_object_check.apply(
+          null,
+          _method_object_check_args);
+      _msg =
+        "Checked ethers contract method object.";
+      _msg_info(
+        _msg);
+    }
+    catch(
+      _error) {
+      _msg =
+        "Error running '_method_object_check' " +
+        "with parameters:";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
+        _method_object_check_args);
+      _echo2(
+        _error);
+      throw _error;
+    }
+    _method =
+      _method_object;
+    try {
+      try {
+        _msg =
+          "Running static call."
+        _msg_info(
+          _msg);
+        _value =
+          await _method.staticCall.apply(
             null,
-            _contract_get_opts);
-        _msg_info_contract_obtained(
-          _contract);
-        try {
-          _method =
-            await _contract.getFunction(
-              _contract_method);
-          _msg_info_method_obtained(
-            _method);
-	}
-        catch(
-          _error) {
-          const
-            _msg_no_fragment =
-              "no matching fragment";
-          const
-            _msg_short =
-              _error[
-                "shortMessage"];
-          if ( _msg_no_fragment == _msg_short ) {
-            _msg =
-              `Found no '${_contract_method}' method ` +
-              `nor contract ABI '${_contract_abi_path}' ` +
-              `nor in compiler output ` +
-              `'${_contract_compiler_output_path}'.`;
-            _msg_error(
-              _msg,
-              0);
-	  }
-          throw _error;
-	}
-      }
-      else if ( _method_object != "" ||
-                _method_object != undefined ) {
+            _method_args);
         _msg =
-          "Re-using contract method.";
+          "Value obtained;";
         _msg_info(
           _msg);
-        _method =
-          _method_object;
       }
-      _value =
-        await _method.staticCall.apply(
-          null,
-          _method_args);
-      if ( _value != undefined ) {
+      catch(
+        _error) {
+        const
+          _error_is_network_error =
+            _is_network_error(
+              _error);
+        if ( ! _error_is_network_error ) {
+          _msg =
+            "Unknown error type " +
+            "for (evm-contract-call).";
+          _msg_error(
+            _msg,
+            0);
+        }
+        _msg =
+          `Error running ` +
+          `'${_contract_method}.staticCall' with ` +
+          "the given parameters.";
+        _msg_error(
+          _msg,
+          0);
+        _echo2(
+          _error);
+        throw _error;
+      }
+      const
+        _value_type =
+          typeof(
+            _value);
+      if ( _value_type !== "undefined" ) {
+        _msg =
+          "Call value obtained";
+        _msg_info(
+          _msg);
         _passed =
           true;
       }
-      else if ( _value == undefined ) {
-        throw { "error": {
-                  "message":
-                    "Value undefined, static call error" } };
+      else if ( _value_type === "undefined" ) {
+        _exception = {
+          "error": {
+            "message":
+              "Value undefined, static call error"
+            }
+        };
+        throw _exception;
       }
-    } catch (
-        _error) {
-      _error_display(
+    }
+    catch (
+      _error) {
+      _msg =
+        "Error running static call.";
+      _msg_error(
+        _msg,
+        0);
+      _echo2(
         _error);
+      // _error_display(
+      //   _error);
       _retry =
         _retry + 1;
+      _msg =
+        "Destroying method and contract " +
+        "objects.";
+      _contract_object.runner.provider.destroy();
+      _contract_object =
+        {};
+      _method_object =
+        {};
+      _msg_info(
+        _msg);
+      _msg =
+        "Increasing retry and waiting 3 seconds.";
       _msg_error(
-        "Increasing retry and waiting 3 seconds.",
+        _msg,
         0);
-      await _sleep(
-        3000);
+      try {
+        await _sleep(
+          3000);
+      }
+      catch(
+        _error) {
+        _msg =
+          "Problems sleeping?";
+        _msg_error(
+          _msg,
+          0);
+        _echo2(
+          _error);
+        throw _error;
+      }
     }
   }
   if ( _retry > _retries_max ) {
-    throw { "error": {
-              "message":
-                "Maximum number of retries reached." } };
+    _exception = {
+      "error": {
+        "message":
+          "Maximum number of retries reached."
+        }
+      };
+    throw _exception;
   }
   return [
     _value,