Merge pull request #362 from neonlabsorg/develop->master_0.5.0

v0.5.0

Author: vasiliy-zaznobin

.buildkite/steps/build-image.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 REVISION=$(git rev-parse HEAD)
 
-set ${SOLANA_REVISION:=v1.7.9-resources}
+set ${SOLANA_REVISION:=v1.7.9-testnet}
 set ${EVM_LOADER_REVISION:=stable}
 
 # Refreshing neonlabsorg/solana:latest image is required to run .buildkite/steps/build-image.sh locally
@@ -15,4 +15,5 @@ docker pull neonlabsorg/evm_loader:${EVM_LOADER_REVISION}
 docker build -t neonlabsorg/proxy:${REVISION} \
     --build-arg SOLANA_REVISION=${SOLANA_REVISION} \
     --build-arg EVM_LOADER_REVISION=${EVM_LOADER_REVISION} \
+    --build-arg PROXY_REVISION=${REVISION} \
     .

.buildkite/steps/deploy-test.sh

@@ -78,6 +78,11 @@ docker run --rm -ti --network=container:proxy \
      -e EVM_LOADER \
      -e SOLANA_URL \
      -e EXTRA_GAS=100000 \
+     -e NEW_USER_AIRDROP_AMOUNT=100 \
+     -e POSTGRES_DB=neon-db \
+     -e POSTGRES_USER=neon-proxy \
+     -e POSTGRES_PASSWORD=neon-proxy-pass \
+     -e POSTGRES_HOST=postgres \
      --entrypoint ./proxy/deploy-test.sh \
      ${EXTRA_ARGS:-} \
      $PROXY_IMAGE \

Dockerfile

@@ -1,11 +1,12 @@
-ARG SOLANA_REVISION=v1.7.9-resources
+ARG SOLANA_REVISION=v1.7.9-testnet
 ARG EVM_LOADER_REVISION=stable
 
 FROM neonlabsorg/solana:${SOLANA_REVISION} AS cli
 
 FROM neonlabsorg/evm_loader:${EVM_LOADER_REVISION} AS spl
 
 FROM ubuntu:20.04
+ARG PROXY_REVISION
 
 RUN apt update && \
     DEBIAN_FRONTEND=noninteractive apt -y install \
@@ -41,6 +42,7 @@ COPY --from=spl /opt/solana_utils.py \
 COPY --from=spl /opt/neon-cli /spl/bin/emulator
 
 COPY . /opt
+RUN sed -i 's/NEON_PROXY_REVISION_TO_BE_REPLACED/'"$PROXY_REVISION"'/g' /opt/proxy/plugin/solana_rest_api.py
 COPY proxy/operator-keypair.json /root/.config/solana/id.json
 RUN cd /usr/local/lib/python3.8/dist-packages/ && patch -p0 </opt/solana-py.patch
 

proxy/__main__.py

@@ -8,7 +8,26 @@
     :copyright: (c) 2013-present by Abhinav Singh and contributors.
     :license: BSD, see LICENSE for more details.
 """
+
 from .proxy import entry_point
+import os
+from .indexer.airdropper import run_airdropper
 
 if __name__ == '__main__':
-    entry_point()
+    airdropper_mode = os.environ.get('AIRDROPPER_MODE', 'False').lower() in [1, 'true', 'True']
+    if airdropper_mode:
+        print("Will run in airdropper mode")
+        solana_url = os.environ['SOLANA_URL']
+        evm_loader_id = os.environ['EVM_LOADER']
+        faucet_url = os.environ['FAUCET_URL']
+        wrapper_whitelist = os.environ['INDEXER_ERC20_WRAPPER_WHITELIST'].split(',')
+        airdrop_amount = int(os.environ['AIRDROP_AMOUNT'])
+        log_level = os.environ['LOG_LEVEL']
+        run_airdropper(solana_url,
+                       evm_loader_id,
+                       faucet_url,
+                       wrapper_whitelist,
+                       airdrop_amount,
+                       log_level)
+    else:
+        entry_point()

proxy/common_neon/__init__.py

@@ -0,0 +1,70 @@
+import logging
+import random
+
+from eth_keys import keys as eth_keys
+from hashlib import sha256
+from solana.publickey import PublicKey
+from spl.token.instructions import get_associated_token_address
+from typing import NamedTuple
+
+from .layouts import ACCOUNT_INFO_LAYOUT
+from ..environment import neon_cli, ETH_TOKEN_MINT_ID, EVM_LOADER_ID
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+
+class EthereumAddress:
+    def __init__(self, data, private=None):
+        if isinstance(data, str):
+            data = bytes(bytearray.fromhex(data[2:]))
+        self.data = data
+        self.private = private
+
+    @staticmethod
+    def random():
+        letters = '0123456789abcdef'
+        data = bytearray.fromhex(''.join([random.choice(letters) for k in range(64)]))
+        pk = eth_keys.PrivateKey(data)
+        return EthereumAddress(pk.public_key.to_canonical_address(), pk)
+
+    def __str__(self):
+        return '0x'+self.data.hex()
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __bytes__(self): return self.data
+
+
+def accountWithSeed(base, seed):
+    result = PublicKey(sha256(bytes(base) + bytes(seed) + bytes(PublicKey(EVM_LOADER_ID))).digest())
+    return result
+
+
+def ether2program(ether):
+    if isinstance(ether, str):
+        pass
+    elif isinstance(ether, EthereumAddress):
+        ether = str(ether)
+    else:
+        ether = ether.hex()
+    output = neon_cli().call("create-program-address", ether)
+    items = output.rstrip().split(' ')
+    return items[0], int(items[1])
+
+
+def getTokenAddr(account):
+    return get_associated_token_address(PublicKey(account), ETH_TOKEN_MINT_ID)
+
+
+class AccountInfo(NamedTuple):
+    ether: eth_keys.PublicKey
+    trx_count: int
+    code_account: PublicKey
+
+    @staticmethod
+    def frombytes(data):
+        cont = ACCOUNT_INFO_LAYOUT.parse(data)
+        return AccountInfo(cont.ether, cont.trx_count, PublicKey(cont.code_account))

proxy/common_neon/address.py

@@ -0,0 +1,12 @@
+KECCAK_PROGRAM = "KeccakSecp256k11111111111111111111111111111"
+INCINERATOR_PUBKEY = "1nc1nerator11111111111111111111111111111111"
+SYSVAR_INSTRUCTION_PUBKEY = "Sysvar1nstructions1111111111111111111111111"
+
+STORAGE_SIZE = 128*1024
+
+ACCOUNT_SEED_VERSION=b'\1'
+
+COLLATERALL_POOL_MAX=10
+
+EMPTY_STORAGE_TAG=0
+FINALIZED_STORAGE_TAG=5

proxy/common_neon/constants.py

@@ -0,0 +1,93 @@
+import base58
+import psycopg2
+
+from ..environment import EVM_LOADER_ID
+from ..indexer.sql_dict import POSTGRES_USER, POSTGRES_HOST, POSTGRES_DB, POSTGRES_PASSWORD
+
+class SQLCost():
+    def __init__(self):
+
+        self.conn = psycopg2.connect(
+            dbname=POSTGRES_DB,
+            user=POSTGRES_USER,
+            password=POSTGRES_PASSWORD,
+            host=POSTGRES_HOST
+        )
+
+        self.conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
+        cur = self.conn.cursor()
+        cur.execute('''
+                CREATE TABLE IF NOT EXISTS OPERATOR_COST
+                (
+                    hash char(64),
+                    cost bigint,
+                    used_gas bigint,
+                    sender char(40),
+                    to_address char(40) ,
+                    sig char(100),
+                    status varchar(100),
+                    reason varchar(100)
+                )'''
+                    )
+
+    def close(self):
+        self.conn.close()
+
+    def insert(self, hash, cost, used_gas, sender, to_address, sig, status, reason):
+        cur = self.conn.cursor()
+        cur.execute('''
+                INSERT INTO OPERATOR_COST (hash, cost, used_gas, sender, to_address, sig, status, reason)
+                VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
+            ''',
+            (hash, cost, used_gas, sender, to_address, sig, status, reason)
+        )
+
+
+class CostSingleton(object):
+    def __new__(cls):
+        if not hasattr(cls, 'instance'):
+            cls.instance = super(CostSingleton, cls).__new__(cls)
+            cls.instance.operator_cost = SQLCost()
+        return cls.instance
+
+
+def update_transaction_cost(receipt, eth_trx, extra_sol_trx=False, reason=None):
+    cost = receipt['result']['meta']['preBalances'][0] - receipt['result']['meta']['postBalances'][0]
+    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
+
+    tx_info = receipt['result']
+    accounts = tx_info["transaction"]["message"]["accountKeys"]
+    evm_loader_instructions = []
+
+    for idx, instruction in enumerate(tx_info["transaction"]["message"]["instructions"]):
+        if accounts[instruction["programIdIndex"]] == EVM_LOADER_ID:
+            evm_loader_instructions.append(idx)
+
+    for inner in (tx_info['meta']['innerInstructions']):
+        if inner["index"] in evm_loader_instructions:
+            for event in inner['instructions']:
+                if accounts[event['programIdIndex']] == EVM_LOADER_ID:
+                    used_gas = base58.b58decode(event['data'])[2:10]
+                    used_gas = int().from_bytes(used_gas, "little")
+
+    table = CostSingleton().operator_cost
+    table.insert(
+        hash,
+        cost,
+        used_gas if used_gas else 0,
+        sender,
+        to_address,
+        sig,
+        'extra' if extra_sol_trx else 'ok',
+        reason if reason else ''
+    )

proxy/common_neon/costs.py

@@ -0,0 +1,34 @@
+import json
+import logging
+
+from .errors import EthereumError
+from ..environment import neon_cli
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+
+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)
+    result = json.loads(output)
+    exit_status = result['exit_status']
+    if exit_status == 'revert':
+        result_value = result['result']
+        if len(result_value) < 8 or result_value[:8] != '08c379a0':
+            raise EthereumError(code=3, message='execution reverted')
+
+        offset = int(result_value[8:8+64], 16)
+        length = int(result_value[8+64:8+64+64], 16)
+        message = str(bytes.fromhex(result_value[8+offset*2+64:8+offset*2+64+length*2]), 'utf8')
+        raise EthereumError(code=3, message='execution reverted: '+message, data='0x'+result_value)
+    if result["exit_status"] != "succeed":
+        raise Exception("evm emulator error ", result)
+    return result
+
+
+def emulator(contract, sender, data, value):
+    data = data or "none"
+    value = value or ""
+    return neon_cli().call("emulate", sender, contract, data, value)

proxy/common_neon/emulator_interactor.py

@@ -0,0 +1,23 @@
+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"
+
+
+class SolanaAccountNotFoundError(Exception):
+    """Provides special error processing"""
+    def __init__(self):
+        super().__init__(SolanaErrors.AccountNotFound.value)