344 сreate integration tests for airdropper

.dockerignore

@@ -7,7 +7,8 @@
 !setup.py
 !README.md
 !run-test-faucet.sh
-!run-test-airdropper.sh
+!run-faucet.sh
+!run-airdropper.sh
 
 # Ignore __pycache__ directory
 proxy/__pycache__

proxy/common_neon/erc20_wrapper.py

@@ -9,6 +9,8 @@
 from solana.system_program import SYS_PROGRAM_ID
 from solana.sysvar import SYSVAR_RENT_PUBKEY
 from solana.rpc.types import TxOpts, RPCResponse, Commitment
+from solana.transaction import Transaction
+import spl.token.instructions as spl_token
 from typing import Union, Dict
 from logging import getLogger
 import struct
@@ -46,26 +48,6 @@
 
 pragma solidity >=0.5.12;
 
-
-interface IERC20 {
-    function decimals() external view returns (uint8);
-    function totalSupply() external view returns (uint256);
-    function balanceOf(address who) external view returns (uint256);
-    function allowance(address owner, address spender) external view returns (uint256);
-    function transfer(address to, uint256 value) external returns (bool);
-    function approve(address spender, uint256 value) external returns (bool);
-    function transferFrom(address from, address to, uint256 value) external returns (bool);
-
-    event Transfer(address indexed from, address indexed to, uint256 value);
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-
-
-    function approveSolana(bytes32 spender, uint64 value) external returns (bool);
-    event ApprovalSolana(address indexed owner, bytes32 indexed spender, uint64 value);
-}
-
-
-
 /*abstract*/ contract NeonERC20Wrapper /*is IERC20*/ {
     address constant NeonERC20 = 0xff00000000000000000000000000000000000001;
 
@@ -158,8 +140,17 @@ def get_neon_erc20_account_address(self, neon_account_address: str):
                  neon_account_address_bytes]
         return PublicKey.find_program_address(seeds, self.evm_loader_id)[0]
 
-    def create_associated_token_account(self, owner: PublicKey):
-        return self.token.create_associated_token_account(owner)
+    def create_associated_token_account(self, owner: PublicKey, payer: SolanaAccount):
+        # Construct transaction
+        # This part of code is based on original implementation of Token.create_associated_token_account
+        # except that skip_preflight is set to True
+        txn = Transaction()
+        create_txn = spl_token.create_associated_token_account(
+            payer=payer.public_key(), owner=owner, mint=self.token.pubkey
+        )
+        txn.add(create_txn)
+        self.token._conn.send_transaction(txn, payer, opts=TxOpts(skip_preflight = True, skip_confirmation=False))
+        return create_txn.keys[1].pubkey
 
     def create_neon_erc20_account_instruction(self, payer: PublicKey, eth_address: str):
         return TransactionInstruction(
@@ -198,6 +189,9 @@ def mint_to(self, destination: Union[PublicKey, str], amount: int) -> RPCRespons
         return self.token.mint_to(destination, self.mint_authority, amount,
                                   opts=TxOpts(skip_preflight=True, skip_confirmation=False))
 
+    def erc20_interface(self):
+        return self.proxy.eth.contract(address=self.neon_contract_address, abi=self.interface['abi'])
+
     def get_balance(self, address: Union[PublicKey, str]) -> int:
         if isinstance(address, PublicKey):
             return int(self.token.get_balance(address, Commitment('confirmed'))['result']['value']['amount'])

proxy/docker-compose-test.yml

@@ -97,6 +97,7 @@ services:
       SOLANA_URL: http://solana:8899
       NEON_OPERATOR_KEYFILE: /root/.config/solana/id.json
       NEON_ETH_MAX_AMOUNT: 10
+      TEST_FAUCET_INIT_NEON_BALANCE: 10000
     hostname: faucet
     expose:
       - "3333"
@@ -131,7 +132,6 @@ services:
     container_name: airdropper
     image: neonlabsorg/proxy:${REVISION}
     environment:
-      AIRDROPPER_MODE: 'true'
       POSTGRES_DB: airdropper-db
       POSTGRES_USER: neon-airdropper
       POSTGRES_PASSWORD: neon-airdropper-pass
@@ -144,7 +144,7 @@ services:
       PRICE_UPDATE_INTERVAL: 10
       START_SLOT: LATEST
     hostname: airdropper
-    entrypoint: ./run-test-airdropper.sh
+    entrypoint: ./run-airdropper.sh
     networks:
       - net
     depends_on:

proxy/testing/test_airdropper_integration.py

@@ -19,7 +19,7 @@
 import os
 import json
 
-
+MAX_AIRDROP_WAIT_TIME = 45
 EVM_LOADER_ID = PublicKey(EVM_LOADER_ID)
 PROXY_URL = os.environ.get('PROXY_URL', 'http://localhost:9090/solana')
 FAUCET_RPC_PORT = 3333
@@ -65,7 +65,6 @@ def create_token_mint(self):
             9,
             TOKEN_PROGRAM_ID,
         )
-        sleep(20)
 
     def deploy_erc20_wrapper_contract(self):
         self.wrapper = ERC20Wrapper(proxy, NAME, SYMBOL,
@@ -98,7 +97,7 @@ def create_sol_account(self):
         return account
 
     def create_token_account(self, owner: PublicKey, mint_amount: int):
-        new_token_account = self.wrapper.create_associated_token_account(owner)
+        new_token_account = self.wrapper.create_associated_token_account(owner, self.mint_authority)
         self.wrapper.mint_to(new_token_account, mint_amount)
         return new_token_account
 
@@ -113,24 +112,36 @@ def test_success_airdrop_simple_case(self):
         mint_amount = 1000_000_000_000
         from_spl_token_acc = self.create_token_account(from_owner.public_key(), mint_amount)
         to_neon_acc = self.create_eth_account().address
-        sleep(15)
+
         self.assertEqual(self.wrapper.get_balance(from_spl_token_acc), mint_amount)
         self.assertEqual(self.wrapper.get_balance(to_neon_acc), 0)
 
+        TRANSFER_AMOUNT = 123456
         trx = Transaction()
         trx.add(self.create_account_instruction(to_neon_acc, from_owner.public_key()))
         trx.add(self.wrapper.create_neon_erc20_account_instruction(from_owner.public_key(), to_neon_acc))
         trx.add(self.wrapper.create_input_liquidity_instruction(from_owner.public_key(),
                                                                 from_spl_token_acc,
                                                                 to_neon_acc,
-                                                                123456))
+                                                                TRANSFER_AMOUNT))
 
         opts = TxOpts(skip_preflight=True, skip_confirmation=False)
         print(self.solana_client.send_transaction(trx, from_owner, opts=opts))
 
-        sleep(15)
-        self.assertEqual(self.wrapper.get_balance(from_spl_token_acc), mint_amount - 123456)
-        self.assertEqual(self.wrapper.get_balance(to_neon_acc), 123456)
+        self.assertEqual(self.wrapper.get_balance(from_spl_token_acc), mint_amount - TRANSFER_AMOUNT)
+        self.assertEqual(self.wrapper.get_balance(to_neon_acc), TRANSFER_AMOUNT)
+
+        wait_time = 0
+        eth_balance = 0
+        while wait_time < MAX_AIRDROP_WAIT_TIME:
+            eth_balance = proxy.eth.get_balance(to_neon_acc)
+            balance_ready = eth_balance > 0 and eth_balance < 10 * pow(10, 18)
+            if balance_ready:
+                break
+            sleep(1)
+            wait_time += 1
+        print(f"Wait time for simple transaction (1 airdrop): {wait_time}")
+
         eth_balance = proxy.eth.get_balance(to_neon_acc)
         print("NEON balance is: ", eth_balance)
         self.assertTrue(eth_balance > 0 and eth_balance < 10 * pow(10, 18))  # 10 NEON is a max airdrop amount
@@ -141,12 +152,13 @@ def test_success_airdrop_complex_case(self):
         from_spl_token_acc = self.create_token_account(from_owner.public_key(), mint_amount)
         to_neon_acc1 = self.create_eth_account().address
         to_neon_acc2 = self.create_eth_account().address
-        sleep(15)
 
         self.assertEqual(self.wrapper.get_balance(from_spl_token_acc), mint_amount)
         self.assertEqual(self.wrapper.get_balance(to_neon_acc1), 0)
         self.assertEqual(self.wrapper.get_balance(to_neon_acc2), 0)
 
+        TRANSFER_AMOUNT1 = 123456
+        TRANSFER_AMOUNT2 = 654321
         trx = Transaction()
         trx.add(self.create_account_instruction(to_neon_acc1, from_owner.public_key()))
         trx.add(self.create_account_instruction(to_neon_acc2, from_owner.public_key()))
@@ -155,19 +167,34 @@ def test_success_airdrop_complex_case(self):
         trx.add(self.wrapper.create_input_liquidity_instruction(from_owner.public_key(),
                                                                 from_spl_token_acc,
                                                                 to_neon_acc1,
-                                                                123456))
+                                                                TRANSFER_AMOUNT1))
         trx.add(self.wrapper.create_input_liquidity_instruction(from_owner.public_key(),
                                                                 from_spl_token_acc,
                                                                 to_neon_acc2,
-                                                                654321))
+                                                                TRANSFER_AMOUNT2))
 
         opts = TxOpts(skip_preflight=True, skip_confirmation=False)
         print(self.solana_client.send_transaction(trx, from_owner, opts=opts))
 
-        sleep(45)
-        self.assertEqual(self.wrapper.get_balance(from_spl_token_acc), mint_amount - 123456 - 654321)
-        self.assertEqual(self.wrapper.get_balance(to_neon_acc1), 123456)
-        self.assertEqual(self.wrapper.get_balance(to_neon_acc2), 654321)
+        self.assertEqual(self.wrapper.get_balance(from_spl_token_acc), mint_amount - TRANSFER_AMOUNT1 - TRANSFER_AMOUNT2)
+        self.assertEqual(self.wrapper.get_balance(to_neon_acc1), TRANSFER_AMOUNT1)
+        self.assertEqual(self.wrapper.get_balance(to_neon_acc2), TRANSFER_AMOUNT2)
+
+
+        wait_time = 0
+        eth_balance1 = 0
+        eth_balance2 = 0
+        while wait_time < MAX_AIRDROP_WAIT_TIME:
+            eth_balance1 = proxy.eth.get_balance(to_neon_acc1)
+            eth_balance2 = proxy.eth.get_balance(to_neon_acc2)
+            balance1_ready = eth_balance1 > 0 and eth_balance1 < 10 * pow(10, 18)
+            balance2_ready = eth_balance2 > 0 and eth_balance2 < 10 * pow(10, 18)
+            if balance1_ready and balance2_ready:
+                break
+            sleep(1)
+            wait_time += 1
+        print(f"Wait time for complex transaction (2 airdrops): {wait_time}")
+
         eth_balance1 = proxy.eth.get_balance(to_neon_acc1)
         eth_balance2 = proxy.eth.get_balance(to_neon_acc2)
         print("NEON balance 1 is: ", eth_balance1)

proxy/testing/test_erc20_wrapper_contract.py

@@ -16,6 +16,7 @@
 from proxy.environment import EVM_LOADER_ID
 from proxy.common_neon.erc20_wrapper import ERC20Wrapper
 from proxy.common_neon.neon_instruction import NeonInstruction
+from solana.rpc.types import TokenAccountOpts
 
 proxy_url = os.environ.get('PROXY_URL', 'http://127.0.0.1:9090/solana')
 solana_url = os.environ.get("SOLANA_URL", "http://127.0.0.1:8899")
@@ -94,24 +95,29 @@ def test_erc20_symbol(self):
         self.assertEqual(sym, SYMBOL)
 
     def test_erc20_decimals(self):
-        erc20 = proxy.eth.contract(address=self.wrapper.neon_contract_address, abi=self.wrapper.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
         decs = erc20.functions.decimals().call()
         self.assertEqual(decs, 9)
 
     def test_erc20_totalSupply(self):
-        erc20 = proxy.eth.contract(address=self.wrapper.neon_contract_address, abi=self.wrapper.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
         ts = erc20.functions.totalSupply().call()
         self.assertGreater(ts, 0)
 
     def test_erc20_balanceOf(self):
-        erc20 = proxy.eth.contract(address=self.wrapper.neon_contract_address, abi=self.wrapper.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
         b = erc20.functions.balanceOf(admin.address).call()
         self.assertGreater(b, 0)
         b = erc20.functions.balanceOf(user.address).call()
         self.assertEqual(b, 0)
 
     def test_erc20_transfer(self):
-        erc20 = proxy.eth.contract(address=self.wrapper.neon_contract_address, abi=self.wrapper.interface['abi'])
+        transfer_value = 1000
+        erc20 = self.wrapper.erc20_interface()
+
+        admin_balance_before = erc20.functions.balanceOf(admin.address).call()
+        user_balance_before = erc20.functions.balanceOf(user.address).call()
+
         nonce = proxy.eth.get_transaction_count(proxy.eth.default_account)
         tx = {'nonce': nonce}
         tx = erc20.functions.transfer(user.address, transfer_value).buildTransaction(tx)
@@ -129,7 +135,7 @@ def test_erc20_transfer(self):
 
     def test_erc20_transfer_not_enough_funds(self):
         transfer_value = 100_000_000_000_000
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         admin_balance_before = erc20.functions.balanceOf(admin.address).call()
         user_balance_before = erc20.functions.balanceOf(user.address).call()
@@ -145,14 +151,14 @@ def test_erc20_transfer_not_enough_funds(self):
 
     def test_erc20_transfer_out_of_bounds(self):
         transfer_value = 0xFFFF_FFFF_FFFF_FFFF + 1
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         with self.assertRaisesRegex(Exception, "ERC20 transfer failed"):
             erc20.functions.transfer(user.address, transfer_value).buildTransaction()
 
     def test_erc20_approve(self):
         approve_value = 1000
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         allowance_before = erc20.functions.allowance(admin.address, user.address).call()
 
@@ -171,7 +177,7 @@ def test_erc20_approve(self):
     def test_erc20_transferFrom(self):
         approve_value = 1000
         transfer_value = 100        
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         nonce = proxy.eth.get_transaction_count(admin.address)
         tx = erc20.functions.approve(user.address, approve_value).buildTransaction({'nonce': nonce})
@@ -205,7 +211,7 @@ def test_erc20_transferFrom(self):
 
     def test_erc20_transferFrom_beyond_approve(self):
         transfer_value = 10_000_000
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         with self.assertRaisesRegex(Exception, "ERC20 transferFrom failed"):
             erc20.functions.transferFrom(admin.address, user.address, transfer_value).buildTransaction(
@@ -214,7 +220,7 @@ def test_erc20_transferFrom_beyond_approve(self):
 
     def test_erc20_transferFrom_out_of_bounds(self):
         transfer_value = 0xFFFF_FFFF_FFFF_FFFF + 1
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         with self.assertRaisesRegex(Exception, "ERC20 transferFrom failed"):
             erc20.functions.transferFrom(admin.address, user.address, transfer_value).buildTransaction(
@@ -224,7 +230,7 @@ def test_erc20_transferFrom_out_of_bounds(self):
     def test_erc20_approveSolana(self):
         delegate = SolanaAccount()
         approve_value = 1000
-        erc20 = proxy.eth.contract(address=self.contract_address, abi=self.interface['abi'])
+        erc20 = self.wrapper.erc20_interface()
 
         nonce = proxy.eth.get_transaction_count(admin.address)
         tx = erc20.functions.approveSolana(bytes(delegate.public_key()), approve_value).buildTransaction({'nonce': nonce})
@@ -234,16 +240,10 @@ def test_erc20_approveSolana(self):
         self.assertEqual(tx_receipt.status, 1)
 
         self.assertIsNotNone(tx_receipt)
-
-        contract_address_bytes = bytes.fromhex(self.contract_address[2:])
-        admin_address_bytes = bytes.fromhex(admin.address[2:])
-        admin_token_seeds = [ b"\1", b"ERC20Balance", bytes(self.token.pubkey), contract_address_bytes, admin_address_bytes ]
-        admin_solana_token = PublicKey.find_program_address(admin_token_seeds, evm_loader_id)[0]
-
         accounts = self.solana_client.get_token_accounts_by_delegate(delegate.public_key(), TokenAccountOpts(mint=self.token.pubkey), commitment=Recent)
         accounts = list(map(lambda a: PublicKey(a['pubkey']), accounts['result']['value']))
 
-        self.assertIn(admin_solana_token, accounts)
+        self.assertIn(self.wrapper.get_neon_erc20_account_address(admin.address), accounts)
 
 
 if __name__ == '__main__':

run-airdropper.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+if [ -z "$EVM_LOADER" ]; then
+    echo "Extracting EVM_LOADER address from keypair file..."
+    export EVM_LOADER=$(solana address -k /spl/bin/evm_loader-keypair.json)
+    echo "EVM_LOADER=$EVM_LOADER"
+fi
+export AIRDROPPER_MODE='true'
+
+python3 -m proxy

run-faucet.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+if [ -z "$SOLANA_URL" ]; then
+  echo "SOLANA_URL is not set"
+  exit 1
+fi
+
+echo "Extracting NEON-EVM's ELF parameters"
+export EVM_LOADER=$(solana address -k /spl/bin/evm_loader-keypair.json)
+export $(/spl/bin/neon-cli --commitment confirmed --url $SOLANA_URL --evm_loader="$EVM_LOADER" neon-elf-params)
+
+BALANCE=$(solana balance | tr '.' '\t'| tr '[:space:]' '\t' | cut -f1)
+if [ "$BALANCE" -eq 0 ]; then
+    echo "SOL balance is 0"
+    exit 1
+fi
+
+if [ "$(spl-token balance "$NEON_TOKEN_MINT" || echo 0)" -eq 0 ]; then
+    echo "NEON balance is 0"
+    exit 1
+fi
+
+faucet run --workers 1