Merge branch 'develop' into feature/NDEV-698/move-workflow-from-bildkite

Dockerfile

@@ -59,9 +59,6 @@ ARG PROXY_LOG_CFG
 RUN (cp -f /opt/${PROXY_LOG_CFG} /opt/log_cfg.json || true)
 RUN sed -i 's/NEON_PROXY_REVISION_TO_BE_REPLACED/'"$PROXY_REVISION"'/g' /opt/proxy/neon_rpc_api_model/neon_rpc_api_worker.py
 
-COPY ./proxy/solana-py.patch /opt
-RUN cd /usr/local/lib/python3.8/dist-packages/ && patch -p0 </opt/solana-py.patch
-
 ENV PATH /venv/bin:/cli/bin/:/spl/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 ENV CONFIG="devnet"
 

proxy-cli/info.py

@@ -9,7 +9,7 @@
 
 import logging
 
-from proxy.common_neon.address import EthereumAddress, accountWithSeed, permAccountSeed
+from proxy.common_neon.address import NeonAddress, account_with_seed, perm_account_seed
 from proxy.common_neon.solana_interactor import SolInteractor
 from proxy.common_neon.environment_utils import get_solana_accounts
 from proxy.common_neon.config import Config
@@ -34,6 +34,9 @@ def __init__(self):
         self._storage = None
         self.print_stdout = True
 
+    def _get_solana_accounts(self):
+        return get_solana_accounts(self._config)
+
     @staticmethod
     def init_args_parser(parsers: _SubParsersAction[ArgumentParser]) -> InfoHandler:
         h = InfoHandler()
@@ -71,9 +74,9 @@ def _holder_accounts_info(self, _):
         }
 
         stop_perm_account_id = self._config.perm_account_id + self._config.perm_account_limit
-        for sol_account in get_solana_accounts():
+        for sol_account in self._get_solana_accounts():
             for rid in range(self._config.perm_account_id, stop_perm_account_id):
-                holder_address = self._generate_holder_address(sol_account.public_key(), rid)
+                holder_address = self._generate_holder_address(sol_account.public_key, rid)
                 ret_js['holder-accounts'].append(str(holder_address))
                 self._print(str(holder_address))
 
@@ -84,10 +87,10 @@ def _solana_private_key_info(self, _):
             'solana-accounts': []
         }
 
-        for sol_account in get_solana_accounts():
+        for sol_account in self._get_solana_accounts():
             acc_info_js = {
-                'address': str(sol_account.public_key()),
-                'private': list(sol_account.keypair())
+                'address': str(sol_account.public_key),
+                'private': list(sol_account.secret_key)
             }
 
             self._print(f"{acc_info_js['address']}    {acc_info_js['private']}")
@@ -101,7 +104,10 @@ def _neon_private_key_info(self, _):
             'neon-accounts': []
         }
 
-        neon_accounts = [EthereumAddress.from_private_key(operator.secret_key()) for operator in get_solana_accounts()]
+        neon_accounts = [
+            NeonAddress.from_private_key(operator.secret_key)
+            for operator in self._get_solana_accounts()
+        ]
 
         for neon_account in neon_accounts:
             acc_info_js = {
@@ -121,8 +127,8 @@ def _neon_address_info(self, _):
             'total_balance': 0
         }
 
-        operator_accounts = get_solana_accounts()
-        neon_accounts = [EthereumAddress.from_private_key(operator.secret_key()) for operator in operator_accounts]
+        operator_accounts = self._get_solana_accounts()
+        neon_accounts = [NeonAddress.from_private_key(operator.secret_key) for operator in operator_accounts]
 
         for neon_account in neon_accounts:
             acc_info_js = {
@@ -145,10 +151,10 @@ def _solana_accounts_info(self, _):
             'resource_balance': 0
         }
 
-        operator_accounts = get_solana_accounts()
+        operator_accounts = self._get_solana_accounts()
 
         for sol_account in operator_accounts:
-            acc_info_js = self._get_solana_accounts(sol_account)
+            acc_info_js = self._get_solana_account_info(sol_account)
             self._print(f"{acc_info_js['address']}    {acc_info_js['balance']:,.9f}")
 
             ret_js['total_balance'] += acc_info_js['balance']
@@ -171,12 +177,12 @@ def _all_info(self, _):
             'total_neon_balance': 0
         }
 
-        operator_accounts = get_solana_accounts()
-        neon_accounts = [EthereumAddress.from_private_key(operator.secret_key()) for operator in operator_accounts]
+        operator_accounts = self._get_solana_accounts()
+        neon_accounts = [NeonAddress.from_private_key(operator.secret_key) for operator in operator_accounts]
 
         for sol_account, neon_account in zip(operator_accounts, neon_accounts):
-            acc_info_js = self._get_solana_accounts(sol_account)
-            acc_info_js['private'] = list(sol_account.keypair())
+            acc_info_js = self._get_solana_account_info(sol_account)
+            acc_info_js['private'] = list(sol_account.secret_key)
 
             ret_js['total_balance'] += acc_info_js['balance']
 
@@ -194,39 +200,35 @@ def _all_info(self, _):
         return ret_js
 
     def _generate_holder_address(self, base_address: PublicKey, rid: int) -> PublicKey:
-        return self._generate_resource_address(base_address, b'holder', rid)
+        return self._generate_resource_address(base_address, b'holder-', rid)
 
     @staticmethod
     def _generate_resource_address(base_address: PublicKey, prefix: bytes, rid: int) -> PublicKey:
-        seed = permAccountSeed(prefix, rid)
-        return accountWithSeed(base_address, seed)
+        seed = perm_account_seed(prefix, rid)
+        return account_with_seed(base_address, seed)
 
-    def _get_neon_balance(self, neon_address: EthereumAddress):
+    def _get_neon_balance(self, neon_address: NeonAddress):
         neon_layout = self._solana.get_neon_account_info(neon_address)
         return Decimal(neon_layout.balance) / 1_000_000_000 / 1_000_000_000 if neon_layout else 0
 
-    def _get_solana_accounts(self, sol_account):
+    def _get_solana_account_info(self, sol_account):
         resource_tags = {
             0: 'EMPTY',
-            1: 'ACCOUNT_V1',
-            10: 'ACCOUNT',
-            2: 'CONTRACT',
-            3: 'STORAGE_V1',
-            30: 'ACTIVE_STORAGE',
+            11: 'NEON_ACCOUNT',
+            21: 'ACTIVE_HOLDER_ACCOUNT',
+            31: 'FINALIZED_HOLDER_ACCOUNT'
             4: 'ERC20_ALLOWANCE',
-            5: 'FINALIZED_STORAGE',
-            6: 'HOLDER'
         }
 
         acc_info_js = {
-            'address': str(sol_account.public_key()),
-            'balance': Decimal(self._solana.get_sol_balance(sol_account.public_key())) / 1_000_000_000,
+            'address': str(sol_account.public_key),
+            'balance': Decimal(self._solana.get_sol_balance(sol_account.public_key)) / 1_000_000_000,
             'holder': []
         }
 
         stop_perm_account_id = self._config.perm_account_id + self._config.perm_account_limit
         for rid in range(self._config.perm_account_id, stop_perm_account_id):
-            holder_address = self._generate_holder_address(sol_account.public_key(), rid)
+            holder_address = self._generate_holder_address(sol_account.public_key, rid)
             holder_info = self._solana.get_account_info(holder_address)
 
             if holder_info:

proxy/airdropper/airdropper.py

@@ -10,7 +10,7 @@
 from ..common_neon.constants import ACCOUNT_SEED_VERSION
 from ..common_neon.solana_interactor import SolInteractor
 from ..common_neon.eth_proto import NeonTx
-from ..common_neon.solana_transaction import SolPubKey
+from ..common_neon.solana_tx import SolPubKey
 
 from ..indexer.indexer_base import IndexerBase
 from ..indexer.solana_tx_meta_collector import SolTxMetaDict, FinalizedSolTxMetaCollector
@@ -142,7 +142,7 @@ def check_create_approve_call_instr(self, account_keys, create_acc, approve, cal
 
         data = base58.b58decode(call['data'])
         try:
-            tx = NeonTx.fromString(data[5:])
+            tx = NeonTx.from_string(data[5:])
         except (Exception, ):
             self.debug('bad transaction')
             return False

proxy/common_neon/account_whitelist.py

@@ -1,13 +1,14 @@
 from datetime import datetime
 from typing import Union
+
 from logged_groups import logged_group
 
-from ..common_neon.address import EthereumAddress
-from ..common_neon.permission_token import PermissionToken
-from ..common_neon.solana_transaction import SolPubKey, SolAccount
-from ..common_neon.elf_params import ElfParams
+from ..common_neon.address import NeonAddress
 from ..common_neon.config import Config
+from ..common_neon.elf_params import ElfParams
+from ..common_neon.permission_token import PermissionToken
 from ..common_neon.solana_interactor import SolInteractor
+from ..common_neon.solana_tx import SolPubKey, SolAccount
 
 
 @logged_group("neon.AccountWhitelist")
@@ -32,7 +33,7 @@ def __init__(self, config: Config, solana: SolInteractor):
         self.allowance_token = PermissionToken(config, self.solana, SolPubKey(allowance_token_addr))
         self.denial_token = PermissionToken(config, self.solana, SolPubKey(denial_token_addr))
 
-    def read_balance_diff(self, ether_addr: Union[str, EthereumAddress]) -> int:
+    def read_balance_diff(self, ether_addr: Union[str, NeonAddress]) -> int:
         token_list = [
             self.allowance_token.get_token_account_address(ether_addr),
             self.denial_token.get_token_account_address(ether_addr)
@@ -43,7 +44,7 @@ def read_balance_diff(self, ether_addr: Union[str, EthereumAddress]) -> int:
         denial_balance = balance_list[1]
         return allowance_balance - denial_balance
 
-    def grant_permissions(self, ether_addr: Union[str, EthereumAddress], min_balance: int, signer: SolAccount):
+    def grant_permissions(self, ether_addr: Union[str, NeonAddress], min_balance: int, signer: SolAccount):
         try:
             diff = self.read_balance_diff(ether_addr)
             if diff >= min_balance:
@@ -58,7 +59,7 @@ def grant_permissions(self, ether_addr: Union[str, EthereumAddress], min_balance
             self.error(f'Failed to grant permissions to {ether_addr}', exc_info=exc)
             return False
 
-    def deprive_permissions(self, ether_addr: Union[str, EthereumAddress], min_balance: int, signer: SolAccount):
+    def deprive_permissions(self, ether_addr: Union[str, NeonAddress], min_balance: int, signer: SolAccount):
         try:
             diff = self.read_balance_diff(ether_addr)
             if diff < min_balance:
@@ -73,22 +74,23 @@ def deprive_permissions(self, ether_addr: Union[str, EthereumAddress], min_balan
             self.error(f'Failed to grant permissions to {ether_addr}', exc_info=exc)
             return False
 
-    def grant_client_permissions(self, ether_addr: Union[str, EthereumAddress], signer: SolAccount):
+    def grant_client_permissions(self, ether_addr: Union[str, NeonAddress], signer: SolAccount):
         return self.grant_permissions(ether_addr, ElfParams().neon_minimal_client_allowance_balance, signer)
 
-    def grant_contract_permissions(self, ether_addr: Union[str, EthereumAddress], signer: SolAccount):
+    def grant_contract_permissions(self, ether_addr: Union[str, NeonAddress], signer: SolAccount):
         return self.grant_permissions(ether_addr, ElfParams().neon_minimal_contract_allowance_balance, signer)
 
-    def deprive_client_permissions(self, ether_addr: Union[str, EthereumAddress], signer: SolAccount):
+    def deprive_client_permissions(self, ether_addr: Union[str, NeonAddress], signer: SolAccount):
         return self.deprive_permissions(ether_addr, ElfParams().neon_minimal_client_allowance_balance, signer)
 
-    def deprive_contract_permissions(self, ether_addr: Union[str, EthereumAddress], signer: SolAccount):
+    def deprive_contract_permissions(self, ether_addr: Union[str, NeonAddress], signer: SolAccount):
         return self.deprive_permissions(ether_addr, ElfParams().neon_minimal_contract_allowance_balance, signer)
 
-    def get_current_time(self):
+    @staticmethod
+    def get_current_time():
         return datetime.now().timestamp()
 
-    def has_permission(self, ether_addr: Union[str, EthereumAddress], min_balance: int):
+    def has_permission(self, ether_addr: Union[str, NeonAddress], min_balance: int):
         if self.allowance_token is None and self.denial_token is None:
             return True
 
@@ -109,8 +111,8 @@ def has_permission(self, ether_addr: Union[str, EthereumAddress], min_balance: i
         except BaseException as exc:
             self.error(f'Failed to read permissions for {ether_addr}', exc_info=exc)
 
-    def has_client_permission(self, ether_addr: Union[str, EthereumAddress]):
+    def has_client_permission(self, ether_addr: Union[str, NeonAddress]):
         return self.has_permission(ether_addr, ElfParams().neon_minimal_client_allowance_balance)
 
-    def has_contract_permission(self, ether_addr: Union[str, EthereumAddress]):
+    def has_contract_permission(self, ether_addr: Union[str, NeonAddress]):
         return self.has_permission(ether_addr, ElfParams().neon_minimal_contract_allowance_balance)

proxy/common_neon/address.py

@@ -1,37 +1,37 @@
 from __future__ import annotations
 
-import random
-import sha3
 import math
+import random
 
 from typing import Tuple
 
-from eth_keys import keys as eth_keys
-from hashlib import sha256
+import sha3
 
-from .solana_transaction import SolPubKey
-from ..common_neon.environment_data import EVM_LOADER_ID
+from eth_keys import keys as neon_keys
+
+from ..common_neon.solana_tx import SolPubKey
 from ..common_neon.constants import ACCOUNT_SEED_VERSION
+from ..common_neon.environment_data import EVM_LOADER_ID
 
 
-class EthereumAddress:
-    def __init__(self, data, private: eth_keys.PrivateKey = None):
+class NeonAddress:
+    def __init__(self, data, private: neon_keys.PrivateKey = None):
         if isinstance(data, str):
             data = bytes(bytearray.fromhex(data[2:]))
         self.data = data
         self.private = private
 
     @staticmethod
-    def random() -> EthereumAddress:
+    def random() -> NeonAddress:
         letters = '0123456789abcdef'
-        data = bytearray.fromhex(''.join([random.choice(letters) for _ in range(64)]))
-        pk = eth_keys.PrivateKey(data)
-        return EthereumAddress(pk.public_key.to_canonical_address(), pk)
+        data = bytearray.fromhex(''.join([random.choice(letters) for _ in range(32)]))
+        pk = neon_keys.PrivateKey(data)
+        return NeonAddress(pk.public_key.to_canonical_address(), pk)
 
     @staticmethod
-    def from_private_key(pk_data: bytes) -> EthereumAddress:
-        pk = eth_keys.PrivateKey(pk_data)
-        return EthereumAddress(pk.public_key.to_canonical_address(), pk)
+    def from_private_key(pk_data: bytes) -> NeonAddress:
+        pk = neon_keys.PrivateKey(pk_data[:32])
+        return NeonAddress(pk.public_key.to_canonical_address(), pk)
 
     def __str__(self):
         return '0x'+self.data.hex()
@@ -42,26 +42,27 @@ def __repr__(self):
     def __bytes__(self): return self.data
 
 
-def accountWithSeed(base_address: SolPubKey, seed: bytes) -> SolPubKey:
-    result = SolPubKey(sha256(bytes(base_address) + bytes(seed) + bytes(SolPubKey(EVM_LOADER_ID))).digest())
+def account_with_seed(base_address: SolPubKey, seed: bytes) -> SolPubKey:
+    seed_str = str(seed, 'utf8')
+    result = SolPubKey.create_with_seed(base_address, seed_str, SolPubKey(EVM_LOADER_ID))
     return result
 
 
-def permAccountSeed(prefix: bytes, resource_id: int) -> bytes:
+def perm_account_seed(prefix: bytes, resource_id: int) -> bytes:
     aid = resource_id.to_bytes(math.ceil(resource_id.bit_length() / 8), 'big')
     seed_base = prefix + aid
     seed = sha3.keccak_256(seed_base).hexdigest()[:32]
     return bytes(seed, 'utf8')
 
 
-def ether2program(ether) -> Tuple[SolPubKey, int]:
-    if isinstance(ether, EthereumAddress):
-        ether = bytes(ether)
-    elif isinstance(ether, str):
-        if ether[0:2] == '0x':
-            ether = ether[2:]
-        ether = bytes.fromhex(ether)
+def neon_2program(neon) -> Tuple[SolPubKey, int]:
+    if isinstance(neon, NeonAddress):
+        neon = bytes(neon)
+    elif isinstance(neon, str):
+        if neon[0:2] == '0x':
+            neon = neon[2:]
+        neon = bytes.fromhex(neon)
 
-    seed = [ACCOUNT_SEED_VERSION, ether]
+    seed = [ACCOUNT_SEED_VERSION, neon]
     (pda, nonce) = SolPubKey.find_program_address(seed, SolPubKey(EVM_LOADER_ID))
     return pda, nonce