261 restrict write instruction

proxy/plugin/solana_rest_api.py

@@ -21,7 +21,7 @@
 from ..http.server import HttpWebServerBasePlugin, httpProtocolTypes
 from .eth_proto import Trx as EthTrx
 from solana.rpc.api import Client as SolanaClient
-from sha3 import keccak_256, shake_256
+from sha3 import keccak_256
 import base58
 import traceback
 import threading
@@ -49,15 +49,15 @@ class PermanentAccounts:
     def __init__(self, client, signer, proxy_id):
         self.operator = signer.public_key()
         self.operator_token = getTokenAddr(self.operator)
+        self.proxy_id = proxy_id
 
         proxy_id_bytes = proxy_id.to_bytes((proxy_id.bit_length() + 7) // 8, 'big')
-        signer_public_key_bytes = bytes(signer.public_key())
 
-        storage_seed = shake_256(b"storage" + proxy_id_bytes + signer_public_key_bytes).hexdigest(16)
+        storage_seed = keccak_256(b"storage" + proxy_id_bytes).hexdigest()[:32]
         storage_seed = bytes(storage_seed, 'utf8')
         self.storage = create_account_with_seed(client, funding=signer, base=signer, seed=storage_seed, storage_size=STORAGE_SIZE)
 
-        holder_seed = shake_256(b"holder" + proxy_id_bytes + signer_public_key_bytes).hexdigest(16)
+        holder_seed = keccak_256(b"holder" + proxy_id_bytes).hexdigest()[:32]
         holder_seed = bytes(holder_seed, 'utf8')
         self.holder = create_account_with_seed(client, funding=signer, base=signer, seed=holder_seed, storage_size=STORAGE_SIZE)
 

proxy/plugin/solana_rest_api_tools.py

@@ -94,7 +94,6 @@
     AccountMeta(pubkey=sysvarclock, is_signer=False, is_writable=False),
 ]
 
-
 class TransactionAccounts:
     def __init__(self, caller_token, eth_accounts):
         self.caller_token = caller_token
@@ -118,10 +117,11 @@ def create_account_layout(lamports, space, ether, nonce):
         nonce=nonce
     ))
 
-def write_layout(offset, data):
-    return (bytes.fromhex("00000000")+
-            offset.to_bytes(4, byteorder="little")+
-            len(data).to_bytes(8, byteorder="little")+
+def write_holder_layout(nonce, offset, data):
+    return (bytes.fromhex('12')+
+            nonce.to_bytes(8, byteorder='little')+
+            offset.to_bytes(4, byteorder='little')+
+            len(data).to_bytes(8, byteorder='little')+
             data)
 
 def accountWithSeed(base, seed, program):
@@ -1059,7 +1059,7 @@ def call_signed_noniterative(signer, client, ethTrx, perm_accs, trx_accs, msg, c
 
 def call_signed_with_holder_acc(signer, client, ethTrx, perm_accs, trx_accs, steps, create_acc_trx):
 
-    write_trx_to_holder_account(signer, client, perm_accs.holder, ethTrx)
+    write_trx_to_holder_account(signer, client, perm_accs.holder, perm_accs.proxy_id, ethTrx)
 
     if len(create_acc_trx.instructions):
         precall_txs = Transaction()
@@ -1142,7 +1142,7 @@ def createERC20TokenAccountTrx(signer, token_info):
 
 
 
-def write_trx_to_holder_account(signer, client, holder, ethTrx):
+def write_trx_to_holder_account(signer, client, holder, proxy_id, ethTrx):
     msg = ethTrx.signature() + len(ethTrx.unsigned_msg()).to_bytes(8, byteorder="little") + ethTrx.unsigned_msg()
 
     # Write transaction to transaction holder account
@@ -1154,7 +1154,7 @@ def write_trx_to_holder_account(signer, client, holder, ethTrx):
         trx = Transaction()
         # logger.debug("sender_sol %s %s %s", sender_sol, holder, acc.public_key())
         trx.add(TransactionInstruction(program_id=evm_loader_id,
-                                       data=write_layout(offset, part),
+                                       data=write_holder_layout(proxy_id, offset, part),
                                        keys=[
                                            AccountMeta(pubkey=holder, is_signer=False, is_writable=True),
                                            AccountMeta(pubkey=signer.public_key(), is_signer=True, is_writable=False),
@@ -1168,6 +1168,81 @@ 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, perm_accs.proxy_id, 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: