Merge remote-tracking branch 'origin/develop' into 291_proxy_refactoring

proxy/common_neon/costs.py

@@ -51,12 +51,16 @@ def __new__(cls):
         return cls.instance
 
 
-def update_transaction_cost(receipt, eth_trx, reason=None, extra_sol_trx=False, ):
+def update_transaction_cost(receipt, eth_trx, extra_sol_trx=False, reason=None):
     cost = receipt['result']['meta']['preBalances'][0] - receipt['result']['meta']['postBalances'][0]
-
-    hash = eth_trx.hash_signed().hex()
-    sender = eth_trx.sender()
-    to_address = eth_trx.toAddress.hex() if eth_trx.toAddress else "None"
+    if eth_trx:
+        hash = eth_trx.hash_signed().hex()
+        sender = eth_trx.sender()
+        to_address = eth_trx.toAddress.hex() if eth_trx.toAddress else "None"
+    else:
+        hash = None
+        sender = None
+        to_address = None
 
     sig = receipt['result']['transaction']['signatures'][0]
     used_gas=None

proxy/common_neon/emulator_interactor.py

@@ -1,24 +1,13 @@
 import json
 import logging
 from proxy.environment import neon_cli
+from .errors import EthereumError
 
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
 
-class EthereumError(Exception):
-    def __init__(self, code, message, data=None):
-        self.code = code
-        self.message = message
-        self.data = data
-
-    def getError(self):
-        error = {'code': self.code, 'message': self.message}
-        if self.data: error['data'] = self.data
-        return error
-
-
 def call_emulated(contract_id, caller_id, data=None, value=None):
     output = emulator(contract_id, caller_id, data, value)
     logger.debug("call_emulated %s %s %s %s return %s", contract_id, caller_id, data, value, output)

proxy/common_neon/errors.py

@@ -1,6 +1,17 @@
 from enum import Enum
 
 
+class EthereumError(Exception):
+    def __init__(self, code, message, data=None):
+        self.code = code
+        self.message = message
+        self.data = data
+
+    def getError(self):
+        error = {'code': self.code, 'message': self.message}
+        if self.data: error['data'] = self.data
+        return error
+
 class SolanaErrors(Enum):
     AccountNotFound = "Invalid param: could not find account"
 

proxy/common_neon/neon_instruction.py

@@ -1,5 +1,6 @@
 import logging
 import struct
+import eth_utils
 from construct import Bytes, Int8ul, Int64ul
 from construct import Struct as cStruct
 from solana._layouts.system_instructions import SYSTEM_INSTRUCTIONS_LAYOUT, InstructionType
@@ -8,9 +9,10 @@
 from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY
 from solana.transaction import AccountMeta, TransactionInstruction, Transaction
 from spl.token.constants import ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID
+from spl.token.instructions import transfer2, Transfer2Params
 from sha3 import keccak_256
 
-from proxy.environment import evm_loader_id as EVM_LOADER_ID, ETH_TOKEN_MINT_ID , COLLATERAL_POOL_BASE
+from proxy.environment import evm_loader_id as EVM_LOADER_ID, ETH_TOKEN_MINT_ID , COLLATERAL_POOL_BASE, NEW_USER_AIRDROP_AMOUNT
 from .constants import SYSVAR_INSTRUCTION_PUBKEY, INCINERATOR_PUBKEY, KECCAK_PROGRAM, COLLATERALL_POOL_MAX
 from .address import accountWithSeed, ether2program, getTokenAddr
 
@@ -148,25 +150,21 @@ def create_account_with_seed_trx(self, seed, lamports, space):
         )
 
 
-    def createEtherAccountTrx(self, ether, code_acc=None):
-        if isinstance(ether, str):
-            if ether.startswith('0x'): ether = ether[2:]
-        else: ether = ether.hex()
-        (sol, nonce) = ether2program(ether)
-        associated_token = getTokenAddr(PublicKey(sol))
-        logger.debug('createEtherAccount: {} {} => {}'.format(ether, nonce, sol))
-        logger.debug('associatedTokenAccount: {}'.format(associated_token))
+    def make_create_eth_account_trx(self, eth_address, code_acc=None):
+        solana_address, nonce = ether2program(eth_address)
+        token_acc_address = getTokenAddr(PublicKey(solana_address))
+        logger.debug(f'Create eth account: {eth_address}, sol account: {solana_address}, token_acc_address: {token_acc_address}, nonce: {nonce}')
         base = self.operator
-        data=create_account_layout(0, 0, bytes.fromhex(ether), nonce)
+        data = create_account_layout(0, 0, bytes(eth_address), nonce)
         trx = Transaction()
         if code_acc is None:
             trx.add(TransactionInstruction(
                 program_id=EVM_LOADER_ID,
                 data=data,
                 keys=[
                     AccountMeta(pubkey=base, is_signer=True, is_writable=True),
-                    AccountMeta(pubkey=PublicKey(sol), is_signer=False, is_writable=True),
-                    AccountMeta(pubkey=associated_token, is_signer=False, is_writable=True),
+                    AccountMeta(pubkey=PublicKey(solana_address), is_signer=False, is_writable=True),
+                    AccountMeta(pubkey=token_acc_address, is_signer=False, is_writable=True),
                     AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
                     AccountMeta(pubkey=ETH_TOKEN_MINT_ID, is_signer=False, is_writable=False),
                     AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False),
@@ -179,19 +177,19 @@ def createEtherAccountTrx(self, ether, code_acc=None):
                 data=data,
                 keys=[
                     AccountMeta(pubkey=base, is_signer=True, is_writable=True),
-                    AccountMeta(pubkey=PublicKey(sol), is_signer=False, is_writable=True),
-                    AccountMeta(pubkey=associated_token, is_signer=False, is_writable=True),
+                    AccountMeta(pubkey=PublicKey(solana_address), is_signer=False, is_writable=True),
+                    AccountMeta(pubkey=token_acc_address, is_signer=False, is_writable=True),
                     AccountMeta(pubkey=PublicKey(code_acc), is_signer=False, is_writable=True),
                     AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
                     AccountMeta(pubkey=ETH_TOKEN_MINT_ID, is_signer=False, is_writable=False),
                     AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False),
                     AccountMeta(pubkey=ASSOCIATED_TOKEN_PROGRAM_ID, is_signer=False, is_writable=False),
                     AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False),
                 ]))
-        return (trx, sol, associated_token)
+        return trx, token_acc_address
 
 
-    def createERC20TokenAccountTrx(self, token_info):
+    def createERC20TokenAccountTrx(self, token_info) -> Transaction:
         trx = Transaction()
         trx.add(TransactionInstruction(
             program_id=EVM_LOADER_ID,
@@ -211,7 +209,35 @@ def createERC20TokenAccountTrx(self, token_info):
         return trx
 
 
-    def make_write_transaction(self, offset: int, data: bytes):
+    def make_transfer_instruction(self, associated_token_account: PublicKey) -> TransactionInstruction:
+        owner_associated_token_account = getTokenAddr(self.operator)
+        transfer_instruction = transfer2(Transfer2Params(
+            source=owner_associated_token_account,
+            owner=self.operator,
+            dest=associated_token_account,
+            amount=NEW_USER_AIRDROP_AMOUNT * eth_utils.denoms.gwei,
+            decimals=9,
+            mint=ETH_TOKEN_MINT_ID,
+            program_id=TOKEN_PROGRAM_ID
+        ))
+        logger.debug(f"Token transfer from token: {owner_associated_token_account}, owned by: {self.operator}, to token: "
+                    f"{associated_token_account}, owned by: {associated_token_account} , value: {NEW_USER_AIRDROP_AMOUNT}")
+        return transfer_instruction
+
+
+    def trx_with_create_and_airdrop(self, eth_account, code_acc=None) -> Transaction:
+        trx = Transaction()
+        create_trx, associated_token_account = self.make_create_eth_account_trx(eth_account, code_acc)
+        trx.add(create_trx)
+        if NEW_USER_AIRDROP_AMOUNT <= 0:
+            return trx
+        transfer_instruction = self.make_transfer_instruction(associated_token_account)
+        trx.add(transfer_instruction)
+
+        return trx
+
+
+    def make_write_transaction(self, offset: int, data: bytes) -> Transaction:
         return Transaction().add(TransactionInstruction(
             program_id=EVM_LOADER_ID,
             data=write_holder_layout(self.perm_accs_id, offset, data),
@@ -222,7 +248,7 @@ def make_write_transaction(self, offset: int, data: bytes):
         ))
 
 
-    def make_keccak_instruction(self, check_instruction_index, msg_len, data_start):
+    def make_keccak_instruction(self, check_instruction_index, msg_len, data_start) -> TransactionInstruction:
         return TransactionInstruction(
             program_id=KECCAK_PROGRAM,
             data=make_keccak_instruction_data(check_instruction_index, msg_len, data_start),
@@ -232,7 +258,7 @@ def make_keccak_instruction(self, check_instruction_index, msg_len, data_start):
         )
 
 
-    def make_05_call_instruction(self):
+    def make_05_call_instruction(self) -> TransactionInstruction:
         return TransactionInstruction(
             program_id = EVM_LOADER_ID,
             data = bytearray.fromhex("05") + self.collateral_pool_index_buf + self.msg,
@@ -255,7 +281,7 @@ def make_noniterative_call_transaction(self, length_before: int = 0) -> Transact
         return trx
 
 
-    def make_partial_call_instruction(self):
+    def make_partial_call_instruction(self) -> TransactionInstruction:
         return TransactionInstruction(
             program_id = EVM_LOADER_ID,
             data = bytearray.fromhex("13") + self.collateral_pool_index_buf + int(0).to_bytes(8, byteorder="little") + self.msg,
@@ -304,7 +330,7 @@ def make_call_from_account_instruction(self) -> Transaction:
         ))
 
 
-    def make_continue_instruction(self, steps, index=None):
+    def make_continue_instruction(self, steps, index=None) -> Transaction:
         data = bytearray.fromhex("14") + self.collateral_pool_index_buf + steps.to_bytes(8, byteorder="little")
         if index:
             data = data + index.to_bytes(8, byteorder="little")
@@ -328,7 +354,7 @@ def make_continue_instruction(self, steps, index=None):
         ))
 
 
-    def make_cancel_instruction(self):
+    def make_cancel_instruction(self) -> Transaction:
         return Transaction().add(TransactionInstruction(
             program_id = EVM_LOADER_ID,
             data = bytearray.fromhex("15") + self.eth_trx.nonce.to_bytes(8, 'little'),

proxy/plugin/solana_rest_api.py

@@ -8,36 +8,36 @@
     :copyright: (c) 2013-present by Abhinav Singh and contributors.
     :license: BSD, see LICENSE for more details.
 """
-from typing import List, Tuple, Optional
 import copy
 import json
 import unittest
 import eth_utils
 import rlp
-import solana
+import os
+import logging
+from typing import List, Tuple, Optional
 from solana.account import Account as sol_Account
-from ..common.utils import socket_connection, text_, build_http_response
+from ..common.utils import build_http_response
 from ..http.codes import httpStatusCodes
 from ..http.parser import HttpParser
 from ..http.websocket import WebsocketFrame
 from ..http.server import HttpWebServerBasePlugin, httpProtocolTypes
 from .eth_proto import Trx as EthTrx
-from solana.rpc.api import Client as SolanaClient
+from solana.rpc.api import Client as SolanaClient, SendTransactionError as SolanaTrxError
 import base58
 import traceback
 import threading
-from .solana_rest_api_tools import getTokens, getAccountInfo, \
-    call_signed, neon_config_load
-from solana.rpc.commitment import Commitment, Confirmed
+from .solana_rest_api_tools import getAccountInfo, \
+    call_signed, neon_config_load, get_token_balance_or_airdrop
+from solana.rpc.commitment import Confirmed
 from web3 import Web3
-import logging
-from ..core.acceptor.pool import proxy_id_glob
-import os
+from proxy.core.acceptor.pool import proxy_id_glob
 from proxy.indexer.utils import get_trx_results, LogDB
 from proxy.indexer.sql_dict import SQLDict
-from proxy.environment import evm_loader_id, solana_cli, solana_url, MINIMAL_GAS_PRICE
-from proxy.common_neon.emulator_interactor import EthereumError, call_emulated
+from proxy.environment import neon_cli, solana_cli, solana_url, MINIMAL_GAS_PRICE
+from proxy.common_neon.emulator_interactor import call_emulated
 from proxy.common_neon.address import EthereumAddress
+from proxy.common_neon.errors import EthereumError
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)