Ndev 2981 trace call overrides params

contracts/common/StorageSoliditySource.sol

@@ -6,13 +6,16 @@ pragma solidity >=0.4.0;
  */
 contract Storage {
     uint256 number;
+    uint256 time;
+    uint256[] public values;
 
     /**
      * @dev Stores value in variable
      * @param num value to store
      */
     function store(uint256 num) public {
         number = num;
+        values = [number];
     }
 
     /**
@@ -30,14 +33,31 @@ contract Storage {
     function at(address _addr) public view returns (bytes memory) {
         return _addr.code;
     }
+
+    function storeBlock() public {
+        number = block.number;
+        values = [number];
+    }
+
+    function storeBlockTimestamp() public returns (uint256) {
+        number = block.timestamp;
+        values = [number];
+        return block.timestamp;
+    }
+
+    function storeBlockInfo() public {
+        number = block.number;
+        time = block.timestamp;
+        values = [number, time];
+    }
 }
 
 contract StorageMultipleVars {
     string public data = "test";
-    uint256 constant public number = 1;
+    uint256 public constant number = 1;
     uint256 public notSet;
 
-    function setData(string memory _data) public  {
+    function setData(string memory _data) public {
         data = _data;
     }
-}
+}

integration/tests/tracer/test_tracer_debug_methods.py

@@ -14,6 +14,7 @@
 from utils.web3client import NeonChainWeb3Client
 from utils.accounts import EthAccounts
 from utils.tracer_client import TracerClient
+from utils.helpers import padhex
 from integration.tests.tracer.test_tracer_historical_methods import call_storage
 
 SCHEMAS = "./integration/tests/tracer/schemas/"
@@ -37,43 +38,33 @@ def validate_response_result(self, response):
         validator = Draft4Validator(schema)
         assert validator.is_valid(response["result"])
 
+   # NDEV-3009
     def test_debug_trace_call_invalid_params(self):
         response = self.tracer_api.send_rpc(method="debug_traceCall", params=[{}, "0x0"])
         assert "error" in response, "No errors in response"
         assert response["error"]["code"] == -32603, "Invalid error code"
         assert response["error"]["message"] == "neon_api::trace failed"
 
-    def test_debug_trace_call_empty_params_valid_block(self):
+    @pytest.mark.skip("NDEV-2998")
+    def test_debug_trace_call_empty_params_valid_block(self, storage_contract):
         sender_account = self.accounts[0]
-        recipient_account = self.accounts[1]
-        receipt = self.web3_client.send_neon(sender_account, recipient_account, 0.1)
-        assert receipt["status"] == 1
-        tx_hash = receipt["transactionHash"].hex()
-
-        wait_condition(
-            lambda: self.web3_client.get_transaction_by_hash(tx_hash) is not None,
-            timeout_sec=10,
-        )
-        tx_info = self.web3_client.get_transaction_by_hash(tx_hash)
+        store_value = random.randint(1, 100)
+        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", self.web3_client)
+        tx_info = self.web3_client.wait_get_transaction_by_hash(receipt["transactionHash"].hex())
 
         response = self.tracer_api.send_rpc(method="debug_traceCall", params=[{}, hex(tx_info["blockNumber"])])
 
-        assert "error" in response, "No errors in response"
-        assert response["error"]["code"] == -32603, "Invalid error code"
-        assert response["error"]["message"] == "neon_api::trace failed"
+        assert "error" not in response, "Error in response"
+        assert response["result"]["returnValue"] == ""
+        self.validate_response_result(response)
 
     def test_debug_trace_call_zero_eth_call(self):
         sender_account = self.accounts[0]
         recipient_account = self.accounts[1]
         receipt = self.web3_client.send_neon(sender_account, recipient_account, 0.1)
         assert receipt["status"] == 1
-        tx_hash = receipt["transactionHash"].hex()
 
-        wait_condition(
-            lambda: self.web3_client.get_transaction_by_hash(tx_hash) is not None,
-            timeout_sec=10,
-        )
-        tx_info = self.web3_client.get_transaction_by_hash(tx_hash)
+        tx_info = self.web3_client.wait_get_transaction_by_hash(receipt["transactionHash"].hex())
 
         params = [
             {
@@ -93,17 +84,12 @@ def test_debug_trace_call_zero_eth_call(self):
         assert response["result"]["returnValue"] == ""
         self.validate_response_result(response)
 
-    def test_debug_trace_call_non_zero_eth_call(self, storage_contract, web3_client):
+    def test_debug_trace_call_non_zero_eth_call(self, storage_contract):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
-        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", web3_client)
-        tx_hash = receipt["transactionHash"].hex()
-
-        wait_condition(
-            lambda: self.web3_client.get_transaction_by_hash(tx_hash) is not None,
-            timeout_sec=10,
-        )
-        tx_info = self.web3_client.get_transaction_by_hash(tx_hash)
+        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", self.web3_client)
+
+        tx_info = self.web3_client.wait_get_transaction_by_hash(receipt["transactionHash"].hex())
 
         params = [
             {
@@ -119,7 +105,7 @@ def test_debug_trace_call_non_zero_eth_call(self, storage_contract, web3_client)
         response = self.tracer_api.send_rpc_and_wait_response("debug_traceCall", params)
 
         assert "error" not in response, "Error in response"
-        assert 1 <= int(response["result"]["returnValue"], 16) <= 100
+        assert response["result"]["returnValue"] == padhex(hex(store_value), 64)[2:]
         self.validate_response_result(response)
 
     def test_debug_trace_transaction(self):
@@ -132,24 +118,26 @@ def test_debug_trace_transaction(self):
         assert "error" not in response, "Error in response"
         self.validate_response_result(response)
 
-    def test_debug_trace_transaction_non_zero_trace(self, web3_client, storage_contract):
+    def test_debug_trace_transaction_non_zero_trace(self, storage_contract):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
-        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", web3_client)
+        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", self.web3_client)
 
         response = self.tracer_api.send_rpc_and_wait_response("debug_traceTransaction", [receipt["transactionHash"].hex()])
+
         assert "error" not in response, "Error in response"
-        assert 1 <= int(response["result"]["returnValue"], 16) <= 100
+        assert response["result"]["returnValue"] == padhex(hex(store_value), 64)[2:]
         self.validate_response_result(response)
 
-    def test_debug_trace_transaction_hash_without_prefix(self, storage_contract, web3_client):
+    def test_debug_trace_transaction_hash_without_prefix(self, storage_contract):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
-        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", web3_client)
+        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", self.web3_client)
 
         response = self.tracer_api.send_rpc_and_wait_response("debug_traceTransaction", [receipt["transactionHash"].hex()[2:]])
+
         assert "error" not in response, "Error in response"
-        assert 1 <= int(response["result"]["returnValue"], 16) <= 100
+        assert response["result"]["returnValue"] == padhex(hex(store_value), 64)[2:]
         self.validate_response_result(response)
 
     @pytest.mark.parametrize("hash", [6, "0x0", "", "f23e554"])

integration/tests/tracer/test_tracer_historical_methods.py

@@ -21,6 +21,7 @@ def store_value(sender_account, value, storage_contract, web3_client):
     )
     receipt = web3_client.send_transaction(sender_account, instruction_tx)
     assert receipt["status"] == 1
+    return receipt
 
 
 def retrieve_value(sender_account, storage_contract, web3_client):

utils/helpers.py

@@ -183,4 +183,7 @@ def serialize_instruction(program_id, instruction) -> bytes:
         serialized += key.is_writable.to_bytes(1, "little")
 
     serialized += len(instruction.data).to_bytes(8, "little") + instruction.data
-    return serialized
+    return serialized
+
+def padhex(s, size):
+    return '0x' + s[2:].zfill(size)

utils/tracer_client.py

@@ -6,9 +6,9 @@ def __init__(self, url):
         self.url = url
         self.tracer_api = JsonRPCSession(url)
 
-    def send_rpc_and_wait_response(self, method_name, params):
+    def send_rpc_and_wait_response(self, method_name, params, req_type=None):
         wait_condition(
-            lambda: self.tracer_api.send_rpc(method=method_name, params=params)["result"]
+            lambda: self.tracer_api.send_rpc(method=method_name, params=params, req_type=req_type)["result"]
             is not None,
             timeout_sec=120,
         )

utils/web3client.py

@@ -16,6 +16,7 @@
 from utils import helpers
 from utils.consts import InputTestConstants, Unit
 from utils.helpers import decode_function_signature
+from utils.helpers import wait_condition
 
 LOG = logging.getLogger(__name__)
 
@@ -109,6 +110,17 @@ def get_transaction_by_hash(self, transaction_hash):
             return self._web3.eth.get_transaction(transaction_hash)
         except TransactionNotFound:
             return None
+
+    @allure.step("Get transaction by hash with wait for result is available")
+    def wait_get_transaction_by_hash(self, transaction_hash, timeout=10):
+        try:
+            wait_condition(
+                lambda: self._web3.eth.get_transaction(transaction_hash) is not None,
+                timeout_sec=timeout,
+            )
+            return self._web3.eth.get_transaction(transaction_hash)
+        except TransactionNotFound:
+            return None
 
     @allure.step("Get gas price")
     def gas_price(self):