impl emulate deploy trx (#219)

* impl emulate deploy trx

* add debug info

* add debug info

* fix call_signed

* remove debug info

* remove deploy_contract()

* remove unused code

Author: sinev-valentine

proxy/plugin/solana_rest_api.py

@@ -27,7 +27,7 @@
 import threading
 from .solana_rest_api_tools import EthereumAddress, create_account_with_seed, evm_loader_id, getTokens, \
     getAccountInfo, solana_cli, call_signed, solana_url, call_emulated, \
-    Trx, deploy_contract, EthereumError, create_collateral_pool_address, getTokenAddr, STORAGE_SIZE, neon_config_load
+    Trx,  EthereumError, create_collateral_pool_address, getTokenAddr, STORAGE_SIZE, neon_config_load
 from solana.rpc.commitment import Commitment, Confirmed
 from web3 import Web3
 import logging
@@ -395,10 +395,7 @@ def eth_sendRawTransaction(self, rawTrx):
         logger.debug('Eth Hash: %s', eth_signature)
 
         try:
-            if (not trx.toAddress):
-                (signature, _contract_eth) = deploy_contract(self.signer, self.client, trx, self.perm_accs, steps=1000)
-            else:
-                signature = call_signed(self.signer, self.client, trx, self.perm_accs, steps=250)
+            signature = call_signed(self.signer, self.client, trx, self.perm_accs, steps=250)
 
             logger.debug('Transaction signature: %s %s', signature, eth_signature)
 

proxy/plugin/solana_rest_api_tools.py

@@ -819,41 +819,33 @@ def create_account_list_by_emulate(signer, client, ethTrx):
     add_keys_05 = []
     trx = Transaction()
 
-    output_json = call_emulated(ethTrx.toAddress.hex(), sender_ether.hex(), ethTrx.callData.hex(), hex(ethTrx.value))
+    if not ethTrx.toAddress:
+        to_address_arg = "deploy"
+        to_address = keccak_256(rlp.encode((bytes.fromhex(ethTrx.sender()), ethTrx.nonce))).digest()[-20:]
+    else:
+        to_address_arg = ethTrx.toAddress.hex()
+        to_address = ethTrx.toAddress
+
+    output_json = call_emulated(to_address_arg, sender_ether.hex(), ethTrx.callData.hex(), hex(ethTrx.value))
     logger.debug("emulator returns: %s", json.dumps(output_json, indent=3))
     for acc_desc in output_json["accounts"]:
         address = bytes.fromhex(acc_desc["address"][2:])
-        if address == ethTrx.toAddress:
-            contract_sol = PublicKey(acc_desc["account"])
-            if acc_desc["contract"] != None :
-                code_sol = PublicKey(acc_desc["contract"])
-                code_writable = acc_desc["writable"]
-            else:
-                code_sol = None
-                code_writable = None
-
-        elif address == sender_ether:
-            sender_sol = PublicKey(acc_desc["account"])
-        else:
-            add_keys_05.append(AccountMeta(pubkey=acc_desc["account"], is_signer=False, is_writable=(True if acc_desc["contract"] else acc_desc["writable"])))
-            token_account = get_associated_token_address(PublicKey(acc_desc["account"]), ETH_TOKEN_MINT_ID)
-            add_keys_05.append(AccountMeta(pubkey=token_account, is_signer=False, is_writable=True))
-            if acc_desc["contract"]:
-                add_keys_05.append(AccountMeta(pubkey=acc_desc["contract"], is_signer=False, is_writable=acc_desc["writable"]))
 
+        code_account = None
+        code_account_writable = False
         if acc_desc["new"]:
             logger.debug("Create solana accounts for %s: %s %s", acc_desc["address"], acc_desc["account"], acc_desc["contract"])
-            code_account = None
             if acc_desc["code_size"]:
-                seed = b58encode(address)
+                seed = b58encode(ACCOUNT_SEED_VERSION+address)
                 code_account = accountWithSeed(signer.public_key(), seed, PublicKey(evm_loader_id))
                 logger.debug("     with code account %s", code_account)
                 code_size = acc_desc["code_size"]
                 valids_size = (code_size // 8) + 1
                 code_account_size = CODE_INFO_LAYOUT.sizeof() + code_size + valids_size + 2048
                 code_account_balance = client.get_minimum_balance_for_rent_exemption(code_account_size)["result"]
                 trx.add(createAccountWithSeedTrx(signer.public_key(), signer.public_key(), seed, code_account_balance, code_account_size, PublicKey(evm_loader_id)))
-                add_keys_05.append(AccountMeta(pubkey=code_account, is_signer=False, is_writable=acc_desc["writable"]))
+                # add_keys_05.append(AccountMeta(pubkey=code_account, is_signer=False, is_writable=acc_desc["writable"]))
+                code_account_writable = acc_desc["writable"]
 
             (create_trx, solana_address, token_address) = createEtherAccountTrx(client, address, evm_loader_id, signer, code_account)
             trx.add(create_trx)
@@ -873,6 +865,34 @@ def create_account_list_by_emulate(signer, client, ethTrx):
                              acc_desc["address"],
                              str(NEW_USER_AIRDROP_AMOUNT))
 
+
+        if address == to_address:
+            contract_sol = PublicKey(acc_desc["account"])
+            if acc_desc["new"]:
+                code_sol = code_account
+                code_writable = code_account_writable
+            else:
+                if acc_desc["contract"] != None:
+                    code_sol = PublicKey(acc_desc["contract"])
+                    code_writable = acc_desc["writable"]
+                else:
+                    code_sol = None
+                    code_writable = None
+
+        elif address == sender_ether:
+            sender_sol = PublicKey(acc_desc["account"])
+        else:
+            add_keys_05.append(AccountMeta(pubkey=acc_desc["account"], is_signer=False, is_writable=(True if acc_desc["contract"] else acc_desc["writable"])))
+            token_account = get_associated_token_address(PublicKey(acc_desc["account"]), ETH_TOKEN_MINT_ID)
+            add_keys_05.append(AccountMeta(pubkey=token_account, is_signer=False, is_writable=True))
+            if acc_desc["new"]:
+                if code_account:
+                    add_keys_05.append(AccountMeta(pubkey=code_account, is_signer=False, is_writable=code_account_writable))
+            else:
+                if acc_desc["contract"]:
+                    add_keys_05.append(AccountMeta(pubkey=acc_desc["contract"], is_signer=False, is_writable=acc_desc["writable"]))
+
+
     for token_account in output_json["token_accounts"]:
         add_keys_05.append(AccountMeta(pubkey=PublicKey(token_account["key"]), is_signer=False, is_writable=True))
 
@@ -898,24 +918,29 @@ def create_account_list_by_emulate(signer, client, ethTrx):
 
 
 def call_signed(signer, client, ethTrx, perm_accs, steps):
+
     (trx_accs, sender_ether, create_acc_trx) = create_account_list_by_emulate(signer, client, ethTrx)
-    msg = sender_ether + ethTrx.signature() + ethTrx.unsigned_msg()
 
-    call_from_holder = False
-    call_iterative = False
-    try:
-        logger.debug("Try single trx call")
-        return call_signed_noniterative(signer, client, ethTrx, perm_accs, trx_accs, msg, create_acc_trx)
-    except Exception as err:
-        logger.debug(str(err))
-        if str(err).find("Program failed to complete") >= 0:
-            logger.debug("Program exceeded instructions")
-            call_iterative = True
-        elif str(err).startswith("transaction too large:"):
-            logger.debug("Transaction too large, call call_signed_with_holder_acc():")
-            call_from_holder = True
-        else:
-            raise
+    if not ethTrx.toAddress:
+        call_from_holder = True
+    else:
+        call_from_holder = False
+        call_iterative = False
+        msg = sender_ether + ethTrx.signature() + ethTrx.unsigned_msg()
+
+        try:
+            logger.debug("Try single trx call")
+            return call_signed_noniterative(signer, client, ethTrx, perm_accs, trx_accs, msg, create_acc_trx)
+        except Exception as err:
+            logger.debug(str(err))
+            if str(err).find("Program failed to complete") >= 0:
+                logger.debug("Program exceeded instructions")
+                call_iterative = True
+            elif str(err).startswith("transaction too large:"):
+                logger.debug("Transaction too large, call call_signed_with_holder_acc():")
+                call_from_holder = True
+            else:
+                raise
 
     if call_from_holder:
         return call_signed_with_holder_acc(signer, client, ethTrx, perm_accs, trx_accs, steps, create_acc_trx)
@@ -1085,81 +1110,6 @@ def write_trx_to_holder_account(signer, client, holder, ethTrx):
         logger.debug("confirmed: %s", rcpt)
 
 
-def deploy_contract(signer, client, ethTrx, perm_accs, steps):
-    sender_ether = bytes.fromhex(ethTrx.sender())
-    (sender_sol, _) = ether2program(sender_ether.hex(), evm_loader_id, signer.public_key())
-    logger.debug("Sender account solana: %s %s", sender_ether.hex(), sender_sol)
-
-    caller_token = get_associated_token_address(PublicKey(sender_sol), ETH_TOKEN_MINT_ID)
-
-    #info = _getAccountData(client, sender_sol, ACCOUNT_INFO_LAYOUT.sizeof())
-    #trx_count = int.from_bytes(AccountInfo.frombytes(info).trx_count, 'little')
-    #logger.debug("Sender solana trx_count: %s", trx_count)
-
-    # Create legacy contract address from (sender_eth, nonce)
-    #rlp = pack(sender_ether, ethTrx.nonce or None)
-    contract_eth = keccak_256(rlp.encode((sender_ether, ethTrx.nonce))).digest()[-20:]
-    (contract_sol, contract_nonce) = ether2program(contract_eth.hex(), evm_loader_id, signer.public_key())
-
-    # We need append ACCOUNT_SEED_VERSION to created CODE account (to avoid using previously created accounts to store the code)
-    # when calculate contract_sol variable ACCOUNT_SEED_VERSION already added in `neon-cli create-program-address`.
-    (code_sol, code_nonce, code_seed) = ether2seed(ACCOUNT_SEED_VERSION+contract_eth, evm_loader_id, signer.public_key())
-
-    logger.debug("Legacy contract address ether: %s", contract_eth.hex())
-    logger.debug("Legacy contract address solana: %s %s", contract_sol, contract_nonce)
-    logger.debug("Legacy code address solana: %s %s", code_sol, code_nonce)
-
-    write_trx_to_holder_account(signer, client, perm_accs.holder, ethTrx)
-
-    # Create contract account & execute deploy transaction
-    logger.debug("    # Create contract account & execute deploy transaction")
-    trx = Transaction()
-    sender_sol_info = client.get_account_info(sender_sol, commitment=Confirmed)
-    if sender_sol_info['result']['value'] is None:
-        trx.add(createEtherAccountTrx(client, sender_ether, evm_loader_id, signer)[0])
-        if NEW_USER_AIRDROP_AMOUNT > 0:
-            trx.add(transfer2(Transfer2Params(
-                source=getTokenAddr(signer.public_key()),
-                owner=signer.public_key(),
-                dest=caller_token,
-                amount=NEW_USER_AIRDROP_AMOUNT*1_000_000_000,
-                decimals=9,
-                mint=ETH_TOKEN_MINT_ID,
-                program_id=TOKEN_PROGRAM_ID,
-            )))
-            logger.debug("Token transfer to %s as ethereum 0x%s amount %s", caller_token, ethTrx.sender(), str(NEW_USER_AIRDROP_AMOUNT))
-
-    if client.get_balance(code_sol, commitment=Confirmed)['result']['value'] == 0:
-        msg_size = len(ethTrx.signature() + len(ethTrx.unsigned_msg()).to_bytes(8, byteorder="little") + ethTrx.unsigned_msg())
-        valids_size = (msg_size // 8) + 1
-        code_account_size = CODE_INFO_LAYOUT.sizeof() + msg_size + valids_size + 2048
-        code_account_balance = client.get_minimum_balance_for_rent_exemption(code_account_size)["result"]
-        trx.add(createAccountWithSeedTrx(signer.public_key(), signer.public_key(), code_seed, code_account_balance, code_account_size, PublicKey(evm_loader_id)))
-    if client.get_balance(contract_sol, commitment=Confirmed)['result']['value'] == 0:
-        trx.add(createEtherAccountTrx(client, contract_eth, evm_loader_id, signer, code_sol)[0])
-    if len(trx.instructions):
-        result = send_measured_transaction(client, trx, signer)
-
-    eth_accounts = [
-                AccountMeta(pubkey=contract_sol, is_signer=False, is_writable=True),
-                AccountMeta(pubkey=get_associated_token_address(PublicKey(contract_sol), ETH_TOKEN_MINT_ID), is_signer=False, is_writable=True),
-                AccountMeta(pubkey=code_sol, is_signer=False, is_writable=True),
-                AccountMeta(pubkey=sender_sol, is_signer=False, is_writable=True),
-                AccountMeta(pubkey=caller_token, is_signer=False, is_writable=True),
-                ]
-
-    trx_accs = TransactionAccounts(caller_token, eth_accounts)
-
-    precall_txs = Transaction()
-    precall_txs.add(make_call_from_account_instruction(perm_accs, trx_accs))
-
-    # ExecuteTrxFromAccountDataIterative
-    logger.debug("ExecuteTrxFromAccountDataIterative:")
-    send_measured_transaction(client, precall_txs, signer)
-
-    return (call_continue(signer, client, perm_accs, trx_accs, steps), '0x'+contract_eth.hex())
-
-
 def _getAccountData(client, account, expected_length, owner=None):
     info = client.get_account_info(account, commitment=Confirmed)['result']['value']
     if info is None: