Last changes from devnet tests

pretty_log_cfg.json

@@ -24,7 +24,7 @@
     },
     "formatters": {
         "standard": {
-            "format": "%(asctime)s.%(msecs)03d [%(levelname)-.1s] P:%(process)d %(class)s:%(lineno)d %(context)s %(message)s",
+            "format": "%(asctime)s.%(msecs)03d [%(levelname)-.1s] P:%(process)d %(name)s:%(class)s:%(funcName)s:%(lineno)d %(context)s %(message)s",
             "style": "%",
             "datefmt": "%Y-%m-%d %H:%M:%S"
         },

proxy/__init__.py

@@ -11,7 +11,6 @@
 from .proxy import entry_point
 from .proxy import main, start
 from .proxy import Proxy
-from .testing.test_case import TestCase
 
 __all__ = [
     # PyPi package entry_point. See
@@ -20,8 +19,5 @@
     # Embed proxy.py. See
     # https://github.com/abhinavsingh/proxy.py#embed-proxypy
     'main', 'start',
-    # Unit testing with proxy.py. See
-    # https://github.com/abhinavsingh/proxy.py#unit-testing-with-proxypy
-    'TestCase',
     'Proxy',
 ]

proxy/common_neon/address.py

@@ -65,4 +65,4 @@ class AccountInfo(NamedTuple):
     @staticmethod
     def frombytes(data):
         cont = ACCOUNT_INFO_LAYOUT.parse(data)
-        return AccountInfo(cont.ether, cont.trx_count, PublicKey(cont.code_account))
+        return AccountInfo(cont.ether, int.from_bytes(cont.trx_count, 'little'), PublicKey(cont.code_account))

proxy/common_neon/errors.py

@@ -21,3 +21,7 @@ class SolanaAccountNotFoundError(Exception):
     """Provides special error processing"""
     def __init__(self):
         super().__init__(SolanaErrors.AccountNotFound.value)
+
+
+class PendingTxError(Exception):
+    pass

proxy/common_neon/eth_proto.py

@@ -1,6 +1,4 @@
-from ecdsa import SigningKey, SECP256k1, VerifyingKey
 from sha3 import keccak_256
-import json
 import rlp
 from eth_keys import keys
 
@@ -21,6 +19,9 @@
 '''
 
 
+class InvalidTrx(Exception):
+    pass
+
 
 class Trx(rlp.Serializable):
     fields = (
@@ -35,6 +36,9 @@ class Trx(rlp.Serializable):
         ('s', rlp.codec.big_endian_int)
     )
 
+    secpk1n = 115792089237316195423570985008687907852837564279074904382605163141518161494337
+    null_address = b'\xff' * 20
+
     def __init__(self, *args, **kwargs):
         rlp.Serializable.__init__(self, *args, **kwargs)
         self._msg = None
@@ -44,29 +48,60 @@ def fromString(cls, s):
         return rlp.decode(s, Trx)
 
     def chainId(self):
-        # chainid*2 + 35  xxxxx0 + 100011   xxxx0 + 100010 +1
-        # chainid*2 + 36  xxxxx0 + 100100   xxxx0 + 100011 +1
-        return (self.v-1)//2 - 17
+        if self.v in (27, 28):
+            return None
+        elif self.v >= 37:
+            # chainid*2 + 35  xxxxx0 + 100011   xxxx0 + 100010 +1
+            # chainid*2 + 36  xxxxx0 + 100100   xxxx0 + 100011 +1
+            return ((self.v - 1) // 2) - 17
+        else:
+            raise InvalidTrx("Invalid V value")
+
+    def _unsigned_msg(self):
+        chain_id = self.chainId()
+        if chain_id is None:
+            return rlp.encode((self.nonce, self.gasPrice, self.gasLimit, self.toAddress, self.value, self.callData))
+        else:
+            return rlp.encode((self.nonce, self.gasPrice, self.gasLimit, self.toAddress, self.value, self.callData,
+                               chain_id, 0, 0), Trx)
 
     def unsigned_msg(self):
         if self._msg is None:
-            self._msg = rlp.encode((self.nonce, self.gasPrice, self.gasLimit, self.toAddress, self.value, self.callData, self.chainId(), b"", b""))
+            self._msg = self._unsigned_msg()
         return self._msg
 
+    def _signature(self):
+        return keys.Signature(vrs=[1 if self.v % 2 == 0 else 0, self.r, self.s])
+
     def signature(self):
-        return keys.Signature(vrs=[1 if self.v % 2 == 0 else 0, self.r, self.s]).to_bytes()
+        return self._signature().to_bytes()
 
     def _sender(self):
-        hash = keccak_256(self.unsigned_msg()).digest()
-        sig = keys.Signature(vrs=[1 if self.v % 2 == 0 else 0, self.r, self.s])
-        pub = sig.recover_public_key_from_msg_hash(hash)
+        if self.r == 0 and self.s == 0:
+            return self.null_address
+        elif self.v in (27, 28):
+            pass
+        elif self.v >= 37:
+            vee = self.v - self.chainId() * 2 - 8
+            assert vee in (27, 28)
+        else:
+            raise InvalidTrx("Invalid V value")
+
+        if self.r >= self.secpk1n or self.s >= self.secpk1n or self.r == 0 or self.s == 0:
+            raise InvalidTrx("Invalid signature values!")
+
+        sighash = keccak_256(self._unsigned_msg()).digest()
+        sig = self._signature()
+        pub = sig.recover_public_key_from_msg_hash(sighash)
+
         return pub.to_canonical_address()
 
     def sender(self):
         return self._sender().hex()
 
     def hash_signed(self):
-        return keccak_256(rlp.encode((self.nonce, self.gasPrice, self.gasLimit, self.toAddress, self.value, self.callData,
+        return keccak_256(rlp.encode((self.nonce, self.gasPrice, self.gasLimit,
+                                      self.toAddress, self.value, self.callData,
                                       self.v, self.r, self.s))).digest()
 
     def contract(self):
@@ -75,6 +110,7 @@ def contract(self):
         contract_addr = rlp.encode((self._sender(), self.nonce))
         return keccak_256(contract_addr).digest()[-20:].hex()
 
+
 #class JsonEncoder(json.JSONEncoder):
 #    def default(self, obj):
 #        if isinstance(obj, bytes):

proxy/common_neon/solana_interactor.py

@@ -4,6 +4,8 @@
 import re
 import time
 
+from typing import Optional
+
 from solana.blockhash import Blockhash
 from solana.publickey import PublicKey
 from solana.rpc.api import Client as SolanaClient
@@ -16,7 +18,7 @@
 
 from .costs import update_transaction_cost
 from .utils import get_from_dict, SolanaBlockInfo
-from ..environment import EVM_LOADER_ID, CONFIRMATION_CHECK_DELAY, WRITE_TRANSACTION_COST_IN_DB
+from ..environment import EVM_LOADER_ID, CONFIRMATION_CHECK_DELAY, WRITE_TRANSACTION_COST_IN_DB, SKIP_PREFLIGHT
 from ..environment import LOG_SENDING_SOLANA_TRANSACTION, FUZZING_BLOCKHASH, CONFIRM_TIMEOUT, FINALIZED
 
 from ..common_neon.layouts import ACCOUNT_INFO_LAYOUT
@@ -77,7 +79,7 @@ def _send_rpc_batch_request(self, method: str, params_list: List[Any]) -> List[R
 
         return full_response_data
 
-    def get_account_info(self, storage_account) -> AccountInfo:
+    def get_account_info(self, storage_account) -> Optional[AccountInfo]:
         opts = {
             "encoding": "base64",
             "commitment": "confirmed",
@@ -133,7 +135,7 @@ def get_multiple_accounts_info(self, accounts: [PublicKey]) -> [AccountInfo]:
     def get_sol_balance(self, account):
         return self.client.get_balance(account, commitment=Confirmed)['result']['value']
 
-    def get_neon_account_info(self, eth_account: EthereumAddress) -> NeonAccountInfo:
+    def get_neon_account_info(self, eth_account: EthereumAddress) -> Optional[NeonAccountInfo]:
         account_sol, nonce = ether2program(eth_account)
         info = self.get_account_info(account_sol)
         if info is None:
@@ -179,7 +181,7 @@ def get_block_info_list(self, block_slot_list: [int], commitment='confirmed') ->
             net_block = response['result']
             block = SolanaBlockInfo(
                 slot=slot,
-                finalized=(commitment==FINALIZED),
+                finalized=(commitment == FINALIZED),
                 hash='0x' + base58.b58decode(net_block['blockhash']).hex(),
                 height=net_block['blockHeight'],
                 parent_hash='0x' + base58.b58decode(net_block['previousBlockhash']).hex(),
@@ -189,14 +191,14 @@ def get_block_info_list(self, block_slot_list: [int], commitment='confirmed') ->
             block_list.append(block)
         return block_list
 
-    def get_recent_blockslot(self) -> int:
-        blockhash_resp = self.client.get_recent_blockhash(commitment=Confirmed)
+    def get_recent_blockslot(self, commitment=Confirmed) -> int:
+        blockhash_resp = self.client.get_recent_blockhash(commitment=commitment)
         if not blockhash_resp["result"]:
             raise RuntimeError("failed to get recent blockhash")
         return blockhash_resp['result']['context']['slot']
 
-    def get_recent_blockhash(self) -> Blockhash:
-        blockhash_resp = self.client.get_recent_blockhash(commitment=Confirmed)
+    def get_recent_blockhash(self, commitment=Confirmed) -> Blockhash:
+        blockhash_resp = self.client.get_recent_blockhash(commitment=commitment)
         if not blockhash_resp["result"]:
             raise RuntimeError("failed to get recent blockhash")
         blockhash = blockhash_resp["result"]["value"]["blockhash"]
@@ -239,7 +241,7 @@ def _fuzzing_transactions(self, signer: SolanaAccount, tx_list, tx_opts, request
 
     def _send_multiple_transactions_unconfirmed(self, signer: SolanaAccount, tx_list: [Transaction]) -> [str]:
         opts = {
-            "skipPreflight": False,
+            "skipPreflight": SKIP_PREFLIGHT,
             "encoding": "base64",
             "preflightCommitment": "confirmed"
         }
@@ -290,7 +292,7 @@ def get_measurements(self, reason, eth_tx, receipt):
             return
 
         try:
-            self.debug(f"send multiple transactions for reason {reason}: {eth_tx.__dict__}")
+            self.debug(f"send multiple transactions for reason {reason}")
 
             measurements = self._extract_measurements_from_receipt(receipt)
             for m in measurements:
@@ -454,9 +456,10 @@ def check_if_storage_is_empty_error(receipt):
     if error_arr is not None and isinstance(error_arr, list):
         error_dict = error_arr[1]
         if isinstance(error_dict, dict) and 'Custom' in error_dict:
-            if error_dict['Custom'] == 1 or error_dict['Custom'] == 4:
-                return True
-    return False
+            custom = error_dict['Custom']
+            if custom in (1, 4):
+                return custom
+    return 0
 
 
 def get_logs_from_receipt(receipt):
@@ -480,7 +483,7 @@ def get_logs_from_receipt(receipt):
     if log_from_prepared_receipt is not None:
         return log_from_prepared_receipt
 
-    return None
+    return []
 
 
 @logged_group("neon.Proxy")
@@ -489,6 +492,7 @@ def check_if_accounts_blocked(receipt, *, logger):
     if logs is None:
         logger.error("Can't get logs")
         logger.info("Failed result: %s"%json.dumps(receipt, indent=3))
+        return False
 
     ro_blocked = "trying to execute transaction on ro locked account"
     rw_blocked = "trying to execute transaction on rw locked account"