Resolve some remarks made by @a_falaleev

proxy/common_neon/data.py

@@ -1,22 +1,14 @@
 from __future__ import annotations
 from dataclasses import dataclass
 from typing import Dict, Any
-from .eth_proto import Trx as NeonTx
 
 
 @dataclass
 class NeonTxCfg:
-    is_without_chainid: bool
+    is_underpriced_tx_without_chainid: bool
     steps_executed: int
 
 
-@dataclass
-class MemPoolTxCfg:
-    neon_tx: NeonTx
-    neon_tx_cfg: NeonTxCfg
-    emulating_result: NeonEmulatingResult
-
-
 NeonEmulatingResult = Dict[str, Any]
 
 

proxy/common_neon/utils/utils.py

@@ -6,6 +6,9 @@
 
 from eth_utils import big_endian_to_int
 
+# TODO: move it out from here
+from ...environment import EVM_LOADER_ID
+
 from ..eth_proto import Trx as EthTx
 
 
@@ -126,8 +129,6 @@ def fill_block_info(self, block: SolanaBlockInfo):
             rec['blockNumber'] = hex(block.slot)
 
     def decode(self, neon_sign: str, tx: {}, ix_idx=-1) -> NeonTxResultInfo:
-        # TODO: move it out from here
-        from ...environment import EVM_LOADER_ID
         self._set_defaults()
         meta_ixs = tx['meta']['innerInstructions']
         msg = tx['transaction']['message']

proxy/mempool/__init__.py

@@ -1,6 +1,7 @@
 from .mempool_client import MemPoolClient
 from .mempool_service import MemPoolService
 from .mem_pool import MemPool
+from .mempool_api import *
 
 MEMPOOL_SERVICE_PORT = MemPoolService.MEMPOOL_SERVICE_PORT
 MEMPOOL_SERVICE_HOST = MemPoolService.MEMPOOL_SERVICE_HOST

proxy/mempool/mem_pool.py

@@ -1,9 +1,9 @@
 from logged_groups import logged_group
 from concurrent.futures import ProcessPoolExecutor
 
-from ..common_neon.data import MemPoolTxCfg
 from ..common_neon.config import IConfig
 
+from .mempool_api import MemPoolTxRequest
 from .mempool_tx_executor import MemPoolTxExecutor
 
 
@@ -16,15 +16,15 @@ def __init__(self, config: IConfig):
         self._pool = ProcessPoolExecutor(self.POOL_PROC_COUNT)
         self._tx_executor = MemPoolTxExecutor(config)
 
-    def send_raw_transaction(self, mempool_tx_cfg: MemPoolTxCfg) -> bool:
+    def send_raw_transaction(self, mempool_tx_request: MemPoolTxRequest) -> bool:
         try:
-           self._pool.submit(MemPool._send_raw_transaction_impl, mempool_tx_cfg)
+           self._pool.submit(MemPool._send_raw_transaction_impl, mempool_tx_request)
         except Exception as err:
-            print(f"Failed enqueue mempool_tx_cfg into the worker pool: {err}")
+            print(f"Failed enqueue mempool_tx_request into the worker pool: {err}")
             return False
         return True
 
     @staticmethod
-    def _send_raw_transaction_impl(mempool_tx_cfg: MemPoolTxCfg) -> bool:
-        print(f"mempool_tx_cfg: {mempool_tx_cfg}")
+    def _send_raw_transaction_impl(mempool_tx_request: MemPoolTxRequest) -> bool:
+        print(f"mempool_tx_request: {mempool_tx_request}")
         return True

proxy/mempool/mempool_api.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from ..common_neon.eth_proto import Trx as NeonTx
+from ..common_neon.data import NeonTxCfg, NeonEmulatingResult
+
+
+@dataclass
+class MemPoolTxRequest:
+    neon_tx: NeonTx
+    neon_tx_cfg: NeonTxCfg
+    emulating_result: NeonEmulatingResult

proxy/mempool/mempool_client.py

@@ -1,11 +1,12 @@
-from ..common_neon.data import MemPoolTxCfg
 from ..common_neon.utils import AddrPickableDataClient
 
+from .mempool_api import MemPoolTxRequest
+
 
 class MemPoolClient:
 
     def __init__(self, host: str, port: int):
         self._pickable_data_client = AddrPickableDataClient((host, port))
 
-    def send_raw_transaction(self, mempool_tx_cfg: MemPoolTxCfg):
-        self._pickable_data_client.send_data(mempool_tx_cfg)
+    def send_raw_transaction(self, mempool_tx_request: MemPoolTxRequest):
+        self._pickable_data_client.send_data(mempool_tx_request)

proxy/mempool/mempool_tx_executor.py

@@ -2,12 +2,12 @@
 
 from ..common_neon.solana_interactor import SolanaInteractor
 from ..common_neon.config import IConfig
-from ..common_neon.data import MemPoolTxCfg
 from ..memdb.memdb import MemDB
 
 # TODO: NeonTxSender should be moved out from there
 from .transaction_sender import NeonTxSender
 from .operator_resource_list import OperatorResourceList
+from .mempool_api import MemPoolTxRequest
 
 
 @logged_group("neon.MemPool")
@@ -19,10 +19,10 @@ def __init__(self, config: IConfig):
         self._db = MemDB(self._solana)
         self._config = config
 
-    def execute_neon_tx(self, mempool_tx_cfg: MemPoolTxCfg):
-        neon_tx = mempool_tx_cfg.neon_tx
-        neon_tx_cfg = mempool_tx_cfg.neon_tx_cfg
-        emulating_result = mempool_tx_cfg.emulating_result
+    def execute_neon_tx(self, mempool_tx_request: MemPoolTxRequest):
+        neon_tx = mempool_tx_request.neon_tx
+        neon_tx_cfg = mempool_tx_request.neon_tx_cfg
+        emulating_result = mempool_tx_request.emulating_result
         emv_step_count = self._config.get_evm_count()
         tx_sender = NeonTxSender(self._db, self._solana, neon_tx, steps=emv_step_count)
         with OperatorResourceList(tx_sender):

proxy/mempool/transaction_sender.py

@@ -11,7 +11,7 @@
 from solana.blockhash import Blockhash
 
 from ..mempool.neon_tx_stages import NeonCreateAccountTxStage, NeonCreateERC20TxStage, NeonCreateContractTxStage, \
-                                         NeonResizeContractTxStage
+                                     NeonResizeContractTxStage
 
 from ..common_neon.compute_budget import TransactionWithComputeBudget
 from ..common_neon.neon_instruction import NeonInstruction as NeonIxBuilder
@@ -252,7 +252,7 @@ def _validate_txsize(self) -> bool:
             raise
 
     def _validate_gas_limit(self):
-        if not self._neon_tx_exec_cfg.is_without_chainid:
+        if not self._neon_tx_exec_cfg.is_underpriced_tx_without_chainid:
             return True
 
         self.error = "Underpriced transaction without chain-id"
@@ -539,7 +539,7 @@ def __init__(self, *args, **kwargs):
         HolderNeonTxStrategy.__init__(self, *args, **kwargs)
 
     def _validate(self) -> bool:
-        if not self._neon_tx_exec_cfg.is_without_chainid:
+        if not self._neon_tx_exec_cfg.is_underpriced_tx_without_chainid:
             self.error = 'Normal transaction'
             return False
 

proxy/neon_rpc_api_model/neon_rpc_api_model.py

@@ -1,7 +1,7 @@
 import json
 import multiprocessing
 import traceback
-from typing import Optional, Union
+from typing import Optional, Union, Tuple
 
 import sha3
 from logged_groups import logged_group
@@ -15,15 +15,15 @@
 from ..common_neon.keys_storage import KeyStorage
 from ..common_neon.solana_interactor import SolanaInteractor
 from ..common_neon.utils import SolanaBlockInfo
-from ..common_neon.data import MemPoolTxCfg, NeonTxCfg, NeonEmulatingResult
+from ..common_neon.data import NeonTxCfg, NeonEmulatingResult
 from ..common_neon.gas_price_calculator import GasPriceCalculator
 
 from ..environment import SOLANA_URL, PP_SOLANA_URL, PYTH_MAPPING_ACCOUNT, NEON_EVM_VERSION, NEON_EVM_REVISION, \
                           CHAIN_ID, neon_cli
 
 from ..memdb.memdb import MemDB
 from ..statistics_exporter.proxy_metrics_interface import StatisticsExporter
-from ..mempool import MemPoolClient, MEMPOOL_SERVICE_HOST, MEMPOOL_SERVICE_PORT
+from ..mempool import MemPoolTxRequest, MemPoolClient, MEMPOOL_SERVICE_HOST, MEMPOOL_SERVICE_PORT
 
 from .transaction_validator import NeonTxValidator
 
@@ -444,20 +444,19 @@ def eth_sendRawTransaction(self, rawTrx: str) -> str:
 
         self._stat_tx_begin()
         try:
-            emulating_result: NeonEmulatingResult = call_trx_emulated(trx)
-            neon_tx_cfg = self.precheck(trx, emulating_result)
+            neon_tx_cfg, emulating_result = self.precheck(trx)
 
             # tx_sender = NeonTxSender(self._db, self._solana, trx, steps=EVM_STEP_COUNT)
             # with OperatorResourceList(tx_sender):
             #     tx_sender.execute(neon_tx_cfg)
 
             self._stat_tx_success()
-            mempool_tx_cfg = MemPoolTxCfg(neon_tx=trx,
-                                          neon_tx_cfg=neon_tx_cfg,
-                                          emulating_result=emulating_result)
+            mempool_tx_request = MemPoolTxRequest(neon_tx=trx,
+                                                  neon_tx_cfg=neon_tx_cfg,
+                                                  emulating_result=emulating_result)
 
-            if not self._mempool_client.send_raw_transaction(mempool_tx_cfg):
-                raise Exception("Failed to pass tx into MemPool")
+            if not self._mempool_client.send_raw_transaction(mempool_tx_request):
+                raise Exception("Failed to pass neon_tx into MemPool")
 
             return eth_signature
 
@@ -472,14 +471,10 @@ def eth_sendRawTransaction(self, rawTrx: str) -> str:
             self._stat_tx_failed()
             raise
 
-    def precheck(self, neon_trx: EthTrx, emulating_result: NeonEmulatingResult) -> NeonTxCfg:
-
+    def precheck(self, neon_trx: EthTrx) -> Tuple[NeonTxCfg, NeonEmulatingResult]:
         min_gas_price = self.gas_price_calculator.get_min_gas_price()
         neon_validator = NeonTxValidator(self._solana, neon_trx, min_gas_price)
-
-        precheck_result = neon_validator.precheck()
-
-        return precheck_result
+        return neon_validator.precheck()
 
     def _stat_tx_begin(self):
         self._stat_exporter.stat_commit_tx_begin()

proxy/neon_rpc_api_model/transaction_validator.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-
+from typing import Tuple
 from logged_groups import logged_group
 
 from ..common_neon.eth_proto import Trx as EthTx
@@ -58,16 +58,16 @@ def is_underpriced_tx_without_chainid(self) -> bool:
             return False
         return (self._tx.gasPrice < self._min_gas_price) or (self._tx.gasLimit < self._estimated_gas)
 
-    def precheck(self) -> NeonTxCfg:
+    def precheck(self) -> Tuple[NeonTxCfg, NeonEmulatingResult]:
         try:
             self._prevalidate_tx()
             emulating_result: NeonEmulatingResult = call_trx_emulated(self._tx)
             self._prevalidate_emulator(emulating_result)
 
-            is_without_chainid = self.is_underpriced_tx_without_chainid()
-            precheck_result = NeonTxCfg(steps_executed=emulating_result["steps_executed"],
-                                        is_without_chainid=is_without_chainid)
-            return precheck_result
+            is_underpriced_tx_without_chainid = self.is_underpriced_tx_without_chainid()
+            neon_tx_cfg = NeonTxCfg(steps_executed=emulating_result["steps_executed"],
+                                    is_underpriced_tx_without_chainid=is_underpriced_tx_without_chainid)
+            return neon_tx_cfg, emulating_result
 
         except Exception as e:
             self.extract_ethereum_error(e)