Ndev 2981 trace call overrides params

contracts/common/StorageSoliditySource.sol

@@ -6,38 +6,68 @@ pragma solidity >=0.4.0;
  */
 contract Storage {
     uint256 number;
+    uint256 numberTwo;
+    uint256 time;
+    uint256[] public values;
 
-    /**
-     * @dev Stores value in variable
-     * @param num value to store
-     */
     function store(uint256 num) public {
         number = num;
+        values = [number];
     }
 
-    /**
-     * @dev Returns value
-     * @return value of 'number'
-     */
     function retrieve() public view returns (uint256) {
         return number;
     }
 
-    /**
-     * @dev Returns code for given address
-     * @return value of '_addr.code'
-     */
+    function retrieveSenderBalance() public view returns (uint256) {
+        return msg.sender.balance;
+    }
+
+   function storeSumOfNumbers(uint256 num1, uint256 num2) public view returns (uint256) {
+        if (number == 101) {
+            num1 = 0;
+        }
+        if (numberTwo == 103) {
+            num2 = 5;
+        }
+        return num1 + num2;
+    }
+
     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];
+    }
+
+    function returnDoubledNumber(uint256 num) public view returns (uint256) {
+        if (number == 102) {
+            num = 10;
+        }
+        return num * 2;
+    }
 }
 
 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/conftest.py

@@ -4,6 +4,7 @@
 from _pytest.config import Config
 
 from utils.tracer_client import TracerClient
+from utils.storage_contract import StorageContract
 
 
 @pytest.fixture(scope="session")
@@ -16,3 +17,8 @@ def tracer_api(tracer_json_rpc_client_session, request):
     if inspect.isclass(request.cls):
         request.cls.tracer_api = tracer_json_rpc_client_session
     yield tracer_json_rpc_client_session
+
+
+@pytest.fixture(scope="class")
+def storage_object(web3_client, storage_contract):
+    return StorageContract(web3_client, storage_contract)

integration/tests/tracer/test_tracer_debug_methods.py

@@ -14,11 +14,13 @@
 from utils.web3client import NeonChainWeb3Client
 from utils.accounts import EthAccounts
 from utils.tracer_client import TracerClient
-from integration.tests.tracer.test_tracer_historical_methods import call_storage
+from utils.helpers import padhex
+
 
 SCHEMAS = "./integration/tests/tracer/schemas/"
 GOOD_CALLDATA = ["0x60fe60005360016000f3"]
 
+
 @allure.feature("Tracer API")
 @allure.story("Tracer API RPC calls debug methods check")
 @pytest.mark.usefixtures("accounts", "web3_client", "tracer_api")
@@ -37,43 +39,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_object):
         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 = storage_object.call_storage(sender_account, 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 +85,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_object):
         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 = storage_object.call_storage(sender_account, store_value, "blockNumber")
+
+        tx_info = self.web3_client.wait_get_transaction_by_hash(receipt["transactionHash"].hex())
 
         params = [
             {
@@ -119,7 +106,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 +119,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_object):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
-        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", web3_client)
+        _, _, receipt = storage_object.call_storage(sender_account, store_value, "blockNumber")
 
         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_object):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
-        _, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", web3_client)
+        _, _, receipt = storage_object.call_storage(sender_account, store_value, "blockNumber")
 
         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_debug_trace_transactions_callTracer.py

@@ -1,15 +1,13 @@
 import random
-
 import allure
 import pytest
-import json
 
 from deepdiff import DeepDiff
 from integration.tests.basic.helpers.basic import AccountData
 from utils.web3client import NeonChainWeb3Client
 from utils.accounts import EthAccounts
 from utils.tracer_client import TracerClient
-from integration.tests.tracer.test_tracer_historical_methods import call_storage
+
 
 @allure.feature("Tracer API")
 @allure.story("Tracer API RPC calls debug method trace_transaction callTracer check")
@@ -123,11 +121,11 @@ def test_callTracer_type_create2(self, tracer_caller_contract):
         expected_response = self.fill_expected_response(instruction_tx, receipt, calls_value="0x0", calls_type="CREATE2")
         self.assert_response_contains_expected(expected_response, response)
 
-    def test_callTracer_type_call(self, storage_contract):
+    def test_callTracer_type_call(self, storage_object):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
 
-        tx_obj, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", self.web3_client)
+        tx_obj, _, receipt = storage_object.call_storage(sender_account, store_value, "blockNumber")
 
         tracer_params = { "tracer": "callTracer", "tracerConfig": { "onlyTopCall": True } }
         params = [receipt["transactionHash"].hex(), tracer_params]
@@ -389,11 +387,11 @@ def test_callTracer_call_to_precompiled_contract(self, eip1052_checker):
         self.assert_response_contains_expected(expected_response, response)
 
     @pytest.mark.skip(reason="NDEV-2934")
-    def test_callTracer_without_tracerConfig(self, storage_contract):
+    def test_callTracer_without_tracerConfig(self, storage_object):
         sender_account = self.accounts[0]
         store_value = random.randint(1, 100)
 
-        tx_obj, _, receipt = call_storage(sender_account, storage_contract, store_value, "blockNumber", self.web3_client)
+        tx_obj, _, receipt = storage_object.call_storage(sender_account, store_value, "blockNumber")
 
         tracer_params = { "tracer": "callTracer" }
         params = [receipt["transactionHash"].hex(), tracer_params]