Ndev 3380 compasability for iterative trx

contracts/precompiled/CallSolanaCaller.sol

@@ -2,11 +2,18 @@ pragma solidity >=0.7.0 <0.9.0;
 pragma abicoder v2;
 
 import "../external/neon-evm/call_solana.sol";
+import "../common/StorageSoliditySource.sol";
 
 
 contract CallSolanaCaller {
 
     CallSolana constant _callSolana = CallSolana(0xFF00000000000000000000000000000000000006);
+    struct Data {
+        uint256 value1;
+        uint256 value2;
+    }
+    mapping(uint256 => Data) public dataMap;
+
     struct ExecuteArgs {
         uint64 lamports;
         bytes instruction;
@@ -17,7 +24,6 @@ contract CallSolanaCaller {
         bytes instruction;
     }
 
-
     event LogBytes(bytes32 value);
     event LogStr(string value);
     event LogData(bytes32 program, bytes value);
@@ -28,9 +34,48 @@ contract CallSolanaCaller {
     }
 
     function execute(uint64 lamports, bytes calldata instruction) public {
-        bytes32 returnData = bytes32(_callSolana.execute(lamports, instruction));
-        emit LogBytes(returnData);
+       bytes32 returnData = bytes32(_callSolana.execute(lamports, instruction));
+       emit LogBytes(returnData);
+    }
+
+    function executeInIterativeMode(uint256 iterations, uint64 lamports, bytes calldata instruction) public {
+        doIterativeActions(iterations);
+        execute(lamports, instruction);
+    }
+
+    function executeAndDoSomeIterativeActions(uint256 iterations, uint64 lamports, bytes calldata instruction) public {
+        execute(lamports, instruction);
+        doIterativeActions(iterations);
+    }
+
+    function executeMultipleCallsAndDoIterativeActions(uint256 calls, uint256 iterations, uint64 lamports, bytes calldata instruction) public {
+        for (uint256 i = 0; i < calls; i++) {
+            execute(lamports, instruction);
+        }
+
+        doIterativeActions(iterations);
+    }
+
+    function doSomeIterativeActions(uint256 iterations) public {
+        doIterativeActions(iterations);
+        emit LogStr("iterative actions status: done");
+    }
+
+    function doIterativeActions(uint iterations) public {
+        // some actions to make the call iterative
+        for (uint256 i = 0; i < iterations; i++) {
+            Data memory newData = Data({
+                value1: 1,
+                value2: 2
+            });
+            dataMap[i] = newData;
+        }
+    }
 
+    function deployStorageAndCallSolana(string memory message, uint64 lamports, bytes calldata instruction) public {
+        Storage storageContract = new Storage();
+        execute(lamports, instruction);
+        emit LogStr(message);
     }
 
     function execute_with_get_return_data(uint64 lamports, bytes calldata instruction) public {

integration/tests/basic/evm/test_solana_interoperability.py

@@ -1,4 +1,5 @@
 import typing as tp
+import web3.exceptions
 
 import pytest
 import spl
@@ -290,7 +291,7 @@ def test_limit_of_simple_instr_in_one_trx(self, call_solana_caller, counter_reso
 
         for _ in range(24):
             instruction = Instruction(
-                program_id=COUNTER_ID,
+                program_id=COUNTER_ID, 
                 accounts=[
                     AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
                 ],
@@ -303,3 +304,185 @@ def test_limit_of_simple_instr_in_one_trx(self, call_solana_caller, counter_reso
         instruction_tx = call_solana_caller.functions.batchExecute(call_params).build_transaction(tx)
         resp = self.web3_client.send_transaction(sender, instruction_tx)
         assert resp["status"] == 0
+
+    @pytest.mark.parametrize("iterations_number", [29, 52])
+    def test_solana_call_after_iterative_actions(self, iterations_number, counter_resource_address, call_solana_caller, get_counter_value):
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+        instruction_tx = call_solana_caller.functions.executeInIterativeMode(iterations_number, lamports, serialized).build_transaction(tx)
+        resp = self.web3_client.send_transaction(sender, instruction_tx)
+        assert resp["status"] == 1
+        event_logs = call_solana_caller.events.LogBytes().process_receipt(resp)
+        assert int.from_bytes(event_logs[0].args.value, byteorder="little") == next(get_counter_value)
+
+    def test_solana_call_after_iterative_actions_exceed_accounts_limit(self, counter_resource_address, call_solana_caller):
+        iterations = 53
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+
+        with pytest.raises(
+            web3.exceptions.ContractLogicError,
+            match="too many accounts: 65 > 64",
+        ):
+            call_solana_caller.functions.executeInIterativeMode(iterations, lamports, serialized).build_transaction(tx)
+
+    @pytest.mark.parametrize("iterations_number", [40, 55])
+    def test_iterative_actions_no_solana_call(self, iterations_number, call_solana_caller):
+        sender = self.accounts[0]
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+        instruction_tx = call_solana_caller.functions.doSomeIterativeActions(iterations_number).build_transaction(tx)
+
+        resp = self.web3_client.send_transaction(sender, instruction_tx)
+        assert resp["status"] == 1
+
+        event_logs = call_solana_caller.events.LogStr().process_receipt(resp)
+        assert event_logs[0].args.value == "iterative actions status: done"
+
+    def test_iterative_actions_no_solana_call_exceed_accounts_limit(self, call_solana_caller):
+        sender = self.accounts[0]
+        tx = self.web3_client.make_raw_tx(sender.address)
+
+        with pytest.raises(
+            web3.exceptions.ContractLogicError,
+            match="too many accounts: 65 > 64",
+        ):
+            call_solana_caller.functions.doSomeIterativeActions(56).build_transaction(tx)
+
+    @pytest.mark.parametrize("iterations_number", [29, 52])
+    def test_iterative_actions_after_solana_call(self, iterations_number, counter_resource_address, call_solana_caller, get_counter_value):
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+        instruction_tx = call_solana_caller.functions.executeAndDoSomeIterativeActions(iterations_number, 
+                                                                                       lamports, 
+                                                                                       serialized).build_transaction(tx)
+        resp = self.web3_client.send_transaction(sender, instruction_tx)
+        assert resp["status"] == 1
+        event_logs = call_solana_caller.events.LogBytes().process_receipt(resp)
+        assert int.from_bytes(event_logs[0].args.value, byteorder="little") == next(get_counter_value)
+
+    def test_iterative_actions_after_solana_call_exceed_accounts_limit(self, counter_resource_address, call_solana_caller, get_counter_value):
+        iterations = 53
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+
+        with pytest.raises(
+            web3.exceptions.ContractLogicError,
+            match="too many accounts: 65 > 64",
+        ):
+            call_solana_caller.functions.executeAndDoSomeIterativeActions(iterations, lamports, serialized).build_transaction(tx)
+
+    def test_multiple_solana_calls_and_iterative_actions(self, counter_resource_address, call_solana_caller, get_counter_value):
+        solana_calls = 5
+        iterations = 20
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+        instruction_tx = call_solana_caller.functions.executeMultipleCallsAndDoIterativeActions(solana_calls, 
+                                                                                                iterations, 
+                                                                                                lamports, 
+                                                                                                serialized).build_transaction(tx)
+        resp = self.web3_client.send_transaction(sender, instruction_tx)
+        assert resp["status"] == 1
+        event_logs = call_solana_caller.events.LogBytes().process_receipt(resp)
+        assert int.from_bytes(event_logs[0].args.value, byteorder="little") == next(get_counter_value)
+
+    def test_multiple_solana_calls_and_iterative_actions_instructions_limit(self, counter_resource_address, call_solana_caller, get_counter_value):
+        solana_calls = 15
+        iterations = 40
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+        instruction_tx = call_solana_caller.functions.executeMultipleCallsAndDoIterativeActions(solana_calls, 
+                                                                                                iterations, 
+                                                                                                lamports, 
+                                                                                                serialized).build_transaction(tx)
+        resp = self.web3_client.send_transaction(sender, instruction_tx)
+        assert resp["status"] == 0
+
+    def test_deploy_contract_and_call_solana(self, counter_resource_address, call_solana_caller):
+        sender = self.accounts[0]
+        lamports = 0
+
+        instruction = Instruction(
+            program_id=COUNTER_ID,
+            accounts=[
+                AccountMeta(Pubkey(counter_resource_address), is_signer=False, is_writable=True),
+            ],
+            data=bytes([0x1]),
+        )
+        serialized = serialize_instruction(COUNTER_ID, instruction)
+
+        tx = self.web3_client.make_raw_tx(sender.address)
+        instruction_tx = call_solana_caller.functions.deployStorageAndCallSolana("deploy contracts status: done",
+                                                                                     lamports,
+                                                                                     serialized).build_transaction(tx)
+        resp = self.web3_client.send_transaction(sender, instruction_tx)
+        assert resp["status"] == 1
+
+        event_logs = call_solana_caller.events.LogStr().process_receipt(resp)
+        assert event_logs[0].args.value == "deploy contracts status: done"