def transfer_sifchain_to_sifchain( transfer_request: EthereumToSifchainTransferRequest, credentials: SifchaincliCredentials, max_seconds: int = 30): logging.debug( f"transfer_sifchain_to_sifchain: {transfer_request.as_json()}") try: sifchain_starting_balance = get_sifchain_addr_balance( transfer_request.sifchain_destination_address, transfer_request.sifnodecli_node, transfer_request.sifchain_symbol) except Exception as e: # this is a new account, so the balance is 0 sifchain_starting_balance = 0 status = { "action": "transfer_sifchain_to_sifchain", "sifchain_starting_balance": sifchain_starting_balance, } logging.info(status) send_from_sifchain_to_sifchain(transfer_request, credentials) target_balance = transfer_request.amount + sifchain_starting_balance wait_for_sifchain_addr_balance( sifchain_address=transfer_request.sifchain_destination_address, symbol=transfer_request.sifchain_symbol, target_balance=target_balance, sifchaincli_node=transfer_request.sifnodecli_node, max_seconds=max_seconds, debug_prefix=f"transfer_sifchain_to_sifchain {transfer_request}") return { **status, "sifchain_ending_balance": target_balance, }
def transfer_sifchain_to_sifchain( transfer_request: EthereumToSifchainTransferRequest, credentials: SifchaincliCredentials, ): logging.debug( f"transfer_sifchain_to_sifchain: {transfer_request.as_json()}") sifchain_starting_balance = get_sifchain_addr_balance( transfer_request.sifchain_destination_address, transfer_request.sifnodecli_node, transfer_request.sifchain_symbol) status = { "action": "transfer_sifchain_to_sifchain", "sifchain_starting_balance": sifchain_starting_balance, } logging.info(status) send_from_sifchain_to_sifchain( from_address=transfer_request.sifchain_address, to_address=transfer_request.sifchain_destination_address, amount=transfer_request.amount, currency=transfer_request.sifchain_symbol, yes_password=credentials.keyring_passphrase) target_balance = transfer_request.amount + sifchain_starting_balance wait_for_sifchain_addr_balance( transfer_request.sifchain_destination_address, transfer_request.sifchain_symbol, transfer_request.sifnodecli_node, target_balance, 30, f"transfer_sifchain_to_sifchain {transfer_request}") return { **status, "sifchain_ending_balance": target_balance, }
def test_create_pools( basic_transfer_request: EthereumToSifchainTransferRequest, source_ethereum_address: str, rowan_source_integrationtest_env_credentials: SifchaincliCredentials, rowan_source_integrationtest_env_transfer_request: EthereumToSifchainTransferRequest): basic_transfer_request.ethereum_address = source_ethereum_address basic_transfer_request.check_wait_blocks = True target_rowan_balance = 10**19 target_ceth_balance = 10**19 request, credentials = generate_test_account( basic_transfer_request, rowan_source_integrationtest_env_transfer_request, rowan_source_integrationtest_env_credentials, target_ceth_balance=target_ceth_balance, target_rowan_balance=target_rowan_balance) sifaddress = request.sifchain_address # wait for balance test_utilities.wait_for_sifchain_addr_balance( sifaddress, "rowan", target_rowan_balance, basic_transfer_request.sifnodecli_node) test_utilities.wait_for_sifchain_addr_balance( sifaddress, "ceth", target_ceth_balance, basic_transfer_request.sifnodecli_node) pools = get_pools(basic_transfer_request.sifnodecli_node) change_amount = 10**18 sifchain_fees = 100000 # Should probably make this a constant basic_transfer_request.amount = change_amount basic_transfer_request.sifchain_symbol = "ceth" basic_transfer_request.sifchain_address = sifaddress current_ceth_balance = target_ceth_balance current_rowan_balance = target_rowan_balance # Only works the first time, fails later. Make this flexible for manual and private net testing for now. if pools is None: create_pool(basic_transfer_request, credentials) get_pools(basic_transfer_request.sifnodecli_node) current_ceth_balance = current_ceth_balance - change_amount current_rowan_balance = current_rowan_balance - change_amount - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "ceth") == current_ceth_balance) # check for failure if we try to create a pool twice txn = create_pool(basic_transfer_request, credentials) assert (txn["code"] == 14) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "ceth") == current_ceth_balance)
def test_rescue_ceth( basic_transfer_request: EthereumToSifchainTransferRequest, source_ethereum_address: str, rowan_source_integrationtest_env_credentials: SifchaincliCredentials, rowan_source_integrationtest_env_transfer_request: EthereumToSifchainTransferRequest, sifchain_fees_int, ethbridge_module_address, sifchain_admin_account ): """ does a lock of rowan (using another test) that should result in ceth being sent to a place it can be rescued from """ basic_transfer_request.ethereum_address = source_ethereum_address admin_user_credentials = SifchaincliCredentials( from_key=sifchain_admin_account ) small_amount = 100 test_account_request, test_account_credentials = generate_test_account( basic_transfer_request, rowan_source_integrationtest_env_transfer_request=rowan_source_integrationtest_env_transfer_request, rowan_source_integrationtest_env_credentials=rowan_source_integrationtest_env_credentials, target_ceth_balance=test_utilities.burn_gas_cost + small_amount, target_rowan_balance=sifchain_fees_int ) logging.info("get the starting balance for the ethbridge module - that's where fees should be going") ethbridge_module_balance = test_utilities.get_sifchain_addr_balance( ethbridge_module_address, basic_transfer_request.sifnodecli_node, "ceth" ) test_account_request.amount = small_amount burn_lock_functions.transfer_sifchain_to_ethereum(test_account_request, test_account_credentials) logging.info( f"test account {test_account_request.sifchain_address} should now have no ceth") logging.info("ethbridge should have the fee that was paid") test_utilities.wait_for_sifchain_addr_balance( ethbridge_module_address, "ceth", ethbridge_module_balance + test_utilities.burn_gas_cost, test_account_request.sifnodecli_node ) logging.info(f"rescue ceth into {test_account_request.sifchain_address}") test_utilities.rescue_ceth( receiver_account=test_account_request.sifchain_address, admin_account=sifchain_admin_account, amount=test_utilities.burn_gas_cost, transfer_request=basic_transfer_request, credentials=admin_user_credentials ) test_utilities.wait_for_sifchain_addr_balance( test_account_request.sifchain_address, "ceth", test_utilities.burn_gas_cost, test_account_request.sifnodecli_node, max_seconds=10, debug_prefix="wait for rescue ceth" )
def test_ethereum_transactions_with_offline_relayer( basic_transfer_request: EthereumToSifchainTransferRequest, smart_contracts_dir, source_ethereum_address, bridgebank_address, integration_dir, ): logging.debug( "need one transaction to make sure ebrelayer writes out relaydb") basic_transfer_request.ethereum_address = source_ethereum_address generate_minimal_test_account(base_transfer_request=basic_transfer_request, target_ceth_balance=100) logging.info("shut down ebrelayer") time.sleep(10) test_utilities.get_shell_output(f"pkill -9 ebrelayer || true") logging.info("prepare transactions to be sent while ebrelayer is offline") amount = 9000 new_addresses = list(map(lambda x: create_new_sifaddr(), range(3))) logging.debug(f"new_addresses: {new_addresses}") request: EthereumToSifchainTransferRequest = copy.deepcopy( basic_transfer_request) requests = list( map( lambda addr: { "amount": amount, "symbol": test_utilities.NULL_ADDRESS, "sifchain_address": addr }, new_addresses)) json_requests = json.dumps(requests) logging.info("send ethereum transactions while ebrelayer is offline") yarn_result = test_utilities.run_yarn_command(" ".join([ f"yarn --cwd {smart_contracts_dir}", "integrationtest:sendBulkLockTx", f"--amount {amount}", f"--symbol eth", f"--json_path {request.solidity_json_path}", f"--sifchain_address {new_addresses[0]}", f"--transactions \'{json_requests}\'", f"--ethereum_address {source_ethereum_address}", f"--bridgebank_address {bridgebank_address}" ])) logging.debug(f"bulk result: {yarn_result}") logging.info( "restart ebrelayer with outstanding locks on the ethereum side") test_utilities.get_shell_output( f"{integration_dir}/sifchain_start_ebrelayer.sh") time.sleep(5) for _ in new_addresses: # ebrelayer only reads blocks if there are new blocks generated test_utilities.advance_n_ethereum_blocks(test_utilities.n_wait_blocks, request.smart_contracts_dir) for a in new_addresses: test_utilities.wait_for_sif_account( a, basic_transfer_request.sifnoded_node, 90) test_utilities.wait_for_sifchain_addr_balance( a, "ceth", amount, basic_transfer_request.sifnoded_node, 90)
def test_bulk_transfers( basic_transfer_request: EthereumToSifchainTransferRequest, smart_contracts_dir, source_ethereum_address, bridgebank_address, integration_dir, ): logging.info("shut down ebrelayer") test_utilities.get_shell_output(f"pkill -9 ebrelayer || true") logging.info("prepare transactions to be sent while ebrelayer is offline") amount = 9000 new_addresses = list(map(lambda x: create_new_sifaddr(), range(3))) logging.debug(f"new_addresses: {new_addresses}") request: EthereumToSifchainTransferRequest = copy.deepcopy( basic_transfer_request) requests = list( map( lambda addr: { "amount": amount, "symbol": test_utilities.NULL_ADDRESS, "sifchain_address": addr }, new_addresses)) json_requests = json.dumps(requests) logging.info("send ethereum transactions while ebrelayer is offline") yarn_result = test_utilities.run_yarn_command(" ".join([ f"yarn --cwd {smart_contracts_dir}", "integrationtest:sendBulkLockTx", f"--amount {amount}", f"--symbol eth", f"--sifchain_address {new_addresses[0]}", f"--transactions \'{json_requests}\'", f"--ethereum_address {source_ethereum_address}", f"--bridgebank_address {bridgebank_address}" ])) logging.info(f"bulk result: {yarn_result}") logging.info("restart ebrelayer") test_utilities.get_shell_output( f"{integration_dir}/sifchain_start_ebrelayer.sh") test_utilities.advance_n_ethereum_blocks(test_utilities.n_wait_blocks, request.smart_contracts_dir) for a in new_addresses: test_utilities.wait_for_sif_account( a, basic_transfer_request.sifnodecli_node, 90) test_utilities.wait_for_sifchain_addr_balance( a, "ceth", amount, basic_transfer_request.sifnodecli_node, 90)
def test_bulk_transfers( basic_transfer_request: EthereumToSifchainTransferRequest, smart_contracts_dir, source_ethereum_address, bridgebank_address, integration_dir, ganache_timed_blocks, ): n_transfers = int(test_utilities.get_optional_env_var("NTRANSFERS", 1)) ganache_delay = test_utilities.get_optional_env_var("GANACHE_DELAY", 1) # test_utilities.get_shell_output(f"{integration_dir}/ganache_start.sh {ganache_delay}") amount = 9000 new_addresses = list( map(lambda x: create_new_sifaddr(), range(n_transfers))) logging.debug(f"new_addresses: {new_addresses}") request: EthereumToSifchainTransferRequest = copy.deepcopy( basic_transfer_request) requests = list( map( lambda addr: { "amount": amount, "symbol": test_utilities.NULL_ADDRESS, "sifchain_address": addr }, new_addresses)) json_requests = json.dumps(requests) yarn_result = test_utilities.run_yarn_command(" ".join([ f"yarn --cwd {smart_contracts_dir}", "integrationtest:sendBulkLockTx", f"--amount {amount}", f"--symbol eth", f"--sifchain_address {new_addresses[0]}", f"--transactions \'{json_requests}\'", f"--ethereum_address {source_ethereum_address}", f"--bridgebank_address {bridgebank_address}" ])) logging.info(f"bulk result: {yarn_result}") test_utilities.wait_for_ethereum_block_number( yarn_result["blockNumber"] + test_utilities.n_wait_blocks, basic_transfer_request) for a in new_addresses: test_utilities.wait_for_sif_account( a, basic_transfer_request.sifnodecli_node, 90) test_utilities.wait_for_sifchain_addr_balance( a, "ceth", amount, basic_transfer_request.sifnodecli_node, 90)
def transfer_ethereum_to_sifchain( transfer_request: EthereumToSifchainTransferRequest, max_seconds: int = default_timeout_for_ganache): logging.debug( f"transfer_ethereum_to_sifchain {transfer_request.as_json()}") assert transfer_request.ethereum_address assert transfer_request.sifchain_address # it's possible that this is the first transfer to the address, so there's # no balance to retrieve. Catch that exception. original_log_level = decrease_log_level() try: sifchain_starting_balance = get_sifchain_addr_balance( transfer_request.sifchain_address, transfer_request.sifnodecli_node, transfer_request.sifchain_symbol) except: logging.debug( f"transfer_ethereum_to_sifchain failed to get starting balance, this is probably a new account" ) sifchain_starting_balance = 0 status = { "action": "transfer_ethereum_to_sifchain", "sifchain_starting_balance": sifchain_starting_balance, "transfer_request": transfer_request.__dict__, } logging.debug( f"transfer_ethereum_to_sifchain_json: {json.dumps(status)}", ) force_log_level(original_log_level) starting_block = send_from_ethereum_to_sifchain(transfer_request) logging.debug( f"send_from_ethereum_to_sifchain ethereum block number: {starting_block}" ) original_log_level = decrease_log_level() half_n_wait_blocks = n_wait_blocks / 2 logging.debug("wait half the blocks, transfer should not complete") if transfer_request.manual_block_advance: advance_n_ethereum_blocks(half_n_wait_blocks, transfer_request.smart_contracts_dir) time.sleep(5) else: wait_for_ethereum_block_number(block_number=starting_block + half_n_wait_blocks, transfer_request=transfer_request) # we still may not have an account try: sifchain_balance_before_required_elapsed_blocks = get_sifchain_addr_balance( transfer_request.sifchain_address, transfer_request.sifnodecli_node, transfer_request.sifchain_symbol) except: sifchain_balance_before_required_elapsed_blocks = 0 if transfer_request.check_wait_blocks and sifchain_balance_before_required_elapsed_blocks != sifchain_starting_balance: print_error_message( f"balance should not have changed yet. Starting balance {sifchain_starting_balance}," f" current balance {sifchain_balance_before_required_elapsed_blocks}" ) if transfer_request.manual_block_advance: advance_n_ethereum_blocks(half_n_wait_blocks, transfer_request.smart_contracts_dir) else: wait_for_ethereum_block_number(block_number=starting_block + n_wait_blocks, transfer_request=transfer_request) target_balance = sifchain_starting_balance + transfer_request.amount # You can't get the balance of an account that doesn't exist yet, # so wait for the account to be there before asking for the balance logging.debug(f"wait for account {transfer_request.sifchain_address}") wait_for_sif_account(sif_addr=transfer_request.sifchain_address, sifchaincli_node=transfer_request.sifnodecli_node, max_seconds=max_seconds) wait_for_sifchain_addr_balance( sifchain_address=transfer_request.sifchain_address, symbol=transfer_request.sifchain_symbol, sifchaincli_node=transfer_request.sifnodecli_node, target_balance=target_balance, max_seconds=max_seconds, debug_prefix= f"transfer_ethereum_to_sifchain waiting for balance {transfer_request}" ) force_log_level(original_log_level) result = { **status, "sifchain_ending_balance": target_balance, } logging.debug(f"transfer_ethereum_to_sifchain completed {result}") return result
def test_pools( basic_transfer_request: EthereumToSifchainTransferRequest, source_ethereum_address: str, rowan_source_integrationtest_env_credentials: SifchaincliCredentials, rowan_source_integrationtest_env_transfer_request: EthereumToSifchainTransferRequest, solidity_json_path): # max symbol length in clp is 10 new_currency_symbol = ("a" + get_shell_output("uuidgen").replace("-", ""))[:8] target_new_currency_balance = 5 * 10**18 logging.info(f"create new currency") new_currency = test_utilities.create_new_currency( 1000 * target_new_currency_balance, new_currency_symbol, smart_contracts_dir=smart_contracts_dir, bridgebank_address=bridgebank_address, solidity_json_path=solidity_json_path) sifchain_symbol = ("c" + new_currency["newtoken_symbol"]).lower() basic_transfer_request.ethereum_address = source_ethereum_address basic_transfer_request.check_wait_blocks = True target_rowan_balance = 5 * 10**18 target_ceth_balance = 10**18 request, credentials = generate_test_account( basic_transfer_request, rowan_source_integrationtest_env_transfer_request, rowan_source_integrationtest_env_credentials, target_ceth_balance=target_ceth_balance, target_rowan_balance=target_rowan_balance) logging.info( f"transfer some of the new currency {new_currency_symbol} to the test sifchain address" ) request.ethereum_symbol = new_currency["newtoken_address"] request.sifchain_symbol = sifchain_symbol request.amount = target_new_currency_balance burn_lock_functions.transfer_ethereum_to_sifchain(request) sifaddress = request.sifchain_address sifchain_fees = 100000 # Should probably make this a constant #from_key = credentials.from_key # wait for balance test_utilities.wait_for_sifchain_addr_balance( sifaddress, "rowan", target_rowan_balance, basic_transfer_request.sifnodecli_node) test_utilities.wait_for_sifchain_addr_balance( sifaddress, sifchain_symbol, target_new_currency_balance, basic_transfer_request.sifnodecli_node) pools = get_pools(basic_transfer_request.sifnodecli_node) basic_transfer_request.sifchain_symbol = sifchain_symbol basic_transfer_request.sifchain_address = sifaddress current_coin_balance = target_new_currency_balance current_rowan_balance = target_rowan_balance change_amount = 10**19 basic_transfer_request.amount = change_amount # Fail if amount is greater than user has txn = create_pool(basic_transfer_request, credentials) assert (txn["code"] == 12) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) change_amount = 10**17 basic_transfer_request.amount = change_amount # Fail if amount is less than or equal to minimum txn = create_pool(basic_transfer_request, credentials) assert (txn["code"] == 7) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) change_amount = 10**18 basic_transfer_request.amount = change_amount # Only works the first time, fails later. txn = create_pool(basic_transfer_request, credentials) assert (txn.get("code", 0) == 0) get_pools(basic_transfer_request.sifnodecli_node) current_coin_balance = current_coin_balance - change_amount current_rowan_balance = current_rowan_balance - change_amount - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # check for failure if we try to create a pool twice txn = create_pool(basic_transfer_request, credentials) assert (txn["code"] == 14) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # ensure we can add liquidity, money gets transferred txn = add_pool_liquidity(basic_transfer_request, credentials) assert (txn.get("code", 0) == 0) get_pools(basic_transfer_request.sifnodecli_node) current_coin_balance = current_coin_balance - change_amount current_rowan_balance = current_rowan_balance - change_amount - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # check for failure if we try to remove all liquidity txn = remove_pool_liquidity(basic_transfer_request, credentials, 10000) assert (txn["code"] == 26) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # ensure we can remove liquidity, money gets transferred txn = remove_pool_liquidity(basic_transfer_request, credentials, 5000) assert (txn.get("code", 0) == 0) get_pools(basic_transfer_request.sifnodecli_node) current_coin_balance = current_coin_balance + change_amount current_rowan_balance = current_rowan_balance + change_amount - sifchain_fees #assert(test_utilities.get_sifchain_addr_balance(sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) #assert(test_utilities.get_sifchain_addr_balance(sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_ceth_balance) # no slippage if pool is perfectly balanced. # TODO: compute this precisely? slip_pct = 0.01 balance = test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") slip_cost = (slip_pct * current_rowan_balance) assert (balance >= current_rowan_balance - slip_cost and balance <= current_rowan_balance + slip_cost) current_rowan_balance = balance balance = test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) slip_cost = (slip_pct * current_coin_balance) assert (balance >= current_coin_balance - slip_cost and balance <= current_coin_balance + slip_cost) current_coin_balance = balance # check for failure if we try to add too much liquidity basic_transfer_request.amount = 10**19 txn = add_pool_liquidity(basic_transfer_request, credentials) assert (txn["code"] == 25) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # check for failure if we try to remove too much liquidity, only occurs now if not 100% liquidity provider """ txn = remove_pool_liquidity(basic_transfer_request, credentials, 10000) assert(txn["code"] == 3) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert(test_utilities.get_sifchain_addr_balance(sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert(test_utilities.get_sifchain_addr_balance(sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) """ # check for failure if we try to swap too much for user txn = swap_pool(basic_transfer_request, "rowan", sifchain_symbol, credentials) assert (txn["code"] == 27) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # check for failure if we try to swap too much for pool basic_transfer_request.amount = 5 * 10**17 txn = swap_pool(basic_transfer_request, "rowan", sifchain_symbol, credentials) assert (txn["code"] == 31) get_pools(basic_transfer_request.sifnodecli_node) current_rowan_balance = current_rowan_balance - sifchain_fees assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") == current_rowan_balance) assert (test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) == current_coin_balance) # now try to do a swap that works change_amount = 10**15 basic_transfer_request.amount = change_amount txn = swap_pool(basic_transfer_request, "rowan", sifchain_symbol, credentials) # TODO: compute this precisely? slip_pct = 0.01 balance = test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, "rowan") assert (balance < current_rowan_balance) current_rowan_balance = balance balance = test_utilities.get_sifchain_addr_balance( sifaddress, basic_transfer_request.sifnodecli_node, sifchain_symbol) assert (balance > current_coin_balance) current_coin_balance = balance
def test_bulk_transfers_from_sifchain( basic_transfer_request: EthereumToSifchainTransferRequest, rowan_source_integrationtest_env_credentials: SifchaincliCredentials, rowan_source_integrationtest_env_transfer_request: EthereumToSifchainTransferRequest, smart_contracts_dir, source_ethereum_address, rowan_source, rowan_source_key, bridgebank_address, bridgetoken_address, ethereum_network, ): basic_transfer_request.ethereum_address = source_ethereum_address logging.info(f"transfer_request: {basic_transfer_request}") # account_with_ceth, credentials_for_account_with_ceth = generate_test_account( # base_transfer_request=basic_transfer_request, # rowan_source_integrationtest_env_transfer_request=rowan_source_integrationtest_env_transfer_request, # rowan_source_integrationtest_env_credentials=rowan_source_integrationtest_env_credentials, # target_ceth_balance=5 * 10 ** 18, # target_rowan_balance=50 * 10 ** 18 # ) n_transfers = int(test_utilities.get_optional_env_var("NTRANSFERS", 2)) amount = "{:d}".format(5 * test_utilities.highest_gas_cost) new_addresses_and_keys = list(map(lambda x: create_new_sifaddr_and_key(), range(n_transfers))) logging.info(f"aandk: {new_addresses_and_keys}") new_addresses = list(map(lambda a: a[0], new_addresses_and_keys)) logging.debug(f"new_addresses: {new_addresses}") new_eth_addrs = test_utilities.create_ethereum_addresses(smart_contracts_dir, basic_transfer_request.ethereum_network, len(new_addresses)) logging.info(f"new eth addrs: {new_eth_addrs}") request: EthereumToSifchainTransferRequest = copy.deepcopy(basic_transfer_request) requests = list(map(lambda addr: { "amount": amount, "symbol": test_utilities.NULL_ADDRESS, "sifchain_address": addr }, new_addresses)) request.amount = 5 * test_utilities.highest_gas_cost credentials_for_account_with_ceth = SifchaincliCredentials(from_key=rowan_source_key) for r in requests: request.ethereum_address = source_ethereum_address request.sifchain_address = rowan_source request.sifchain_destination_address = r["sifchain_address"] request.sifchain_symbol = "ceth" request.ethereum_symbol = "eth" logging.warning(f"requestis: {request}") test_utilities.send_from_sifchain_to_sifchain(request, credentials_for_account_with_ceth) time.sleep(3) request.sifchain_symbol = "rowan" request.ethereum_symbol = bridgetoken_address test_utilities.send_from_sifchain_to_sifchain(request, credentials_for_account_with_ceth) time.sleep(3) for a in new_addresses: test_utilities.wait_for_sif_account(a, basic_transfer_request.sifnodecli_node, 90) test_utilities.wait_for_sifchain_addr_balance(a, "ceth", amount, basic_transfer_request.sifnodecli_node, 180) test_utilities.wait_for_sifchain_addr_balance(a, "rowan", amount, basic_transfer_request.sifnodecli_node, 180) text_file = open("pfile.cmds", "w") simple_credentials = SifchaincliCredentials( keyring_passphrase=None, keyring_backend="test", from_key=None, sifnodecli_homedir=None ) logging.info(f"all accounts are on sifchain and have the correct balance") for sifaddr, ethaddr in zip(new_addresses_and_keys, new_eth_addrs): r = copy.deepcopy(basic_transfer_request) r.sifchain_address = sifaddr[0] r.ethereum_address = ethaddr["address"] r.amount = 100 simple_credentials.from_key = sifaddr[1] c = test_utilities.send_from_sifchain_to_ethereum_cmd(r, simple_credentials) text_file.write(f"{c}\n") text_file.close() test_utilities.get_shell_output("cat pfile.cmds | parallel --trim lr -v {}") test_utilities.advance_n_ethereum_blocks(test_utilities.n_wait_blocks, smart_contracts_dir) # test_utilities.get_shell_output("bash -x pfile.cmds") for sifaddr, ethaddr in zip(new_addresses_and_keys, new_eth_addrs): r = copy.deepcopy(basic_transfer_request) r.ethereum_address = ethaddr["address"] r.amount = 100 test_utilities.wait_for_eth_balance(r, 100, 6000 * (n_transfers + 1))
def test_rollback_chain(source_ethereum_address): new_account_key = get_shell_output("uuidgen") credentials = sifchain_cli_credentials_for_test(new_account_key) new_account = burn_lock_functions.create_new_sifaddr( credentials=credentials, keyname=new_account_key) credentials.from_key = new_account["name"] # Any amount will work amount = 11000 request = EthereumToSifchainTransferRequest( sifchain_address=new_account["address"], smart_contracts_dir=get_required_env_var("SMART_CONTRACTS_DIR"), ethereum_address=source_ethereum_address, ethereum_private_key_env_var="ETHEREUM_PRIVATE_KEY", bridgebank_address=get_required_env_var("BRIDGE_BANK_ADDRESS"), ethereum_network=(os.environ.get("ETHEREUM_NETWORK") or ""), amount=amount) logging.info(f"create account with a balance of {request.amount}") burn_lock_functions.transfer_ethereum_to_sifchain(request, 50) new_addr = new_account["address"] snapshot = get_shell_output( f"{test_integration_dir}/snapshot_ganache_chain.sh") logging.info(f"created new account, took ganache snapshot {snapshot}") initial_user_balance = get_sifchain_addr_balance(new_addr, "", request.sifchain_symbol) logging.info(f"initial_user_balance {initial_user_balance}") transfer_1 = send_from_ethereum_to_sifchain(transfer_request=request) logging.info(f"transfer started but it will never complete (by design)") logging.info("advance less than wait blocks") advance_n_ethereum_blocks(n_wait_blocks / 2, request.smart_contracts_dir) # the transaction should not have happened on the sifchain side yet # since we haven't waited for the right number of blocks. # roll back ganache to the snapshot and try another transfer that # should succeed. logging.info( f"apply snapshot {snapshot} - this eliminates transfer_1 (block {transfer_1})" ) get_shell_output( f"{test_integration_dir}/apply_ganache_snapshot.sh {snapshot} 2>&1") logging.info("advance past block wait") advance_n_ethereum_blocks(n_wait_blocks * 2, request.smart_contracts_dir) time.sleep(5) second_user_balance = get_sifchain_addr_balance(new_addr, "", request.sifchain_symbol) if second_user_balance == initial_user_balance: logging.info( f"got expected outcome of no balance change @ {initial_user_balance}" ) else: raise Exception( f"balance should be the same after applying snapshot and rolling forward n_wait_blocks * 2. initial_user_balance: {initial_user_balance} second_user_balance: {second_user_balance}" ) request.amount = 10000 logging.info(f"sending more eth: {request.amount} to {new_addr}") burn_lock_functions.transfer_ethereum_to_sifchain(request) # We want to know that ebrelayer will never do a second transaction. # We can't know that, so just delay a reasonable amount of time. logging.info("delay to give ebrelayer time to make a mistake") time.sleep(10) balance_after_sleep = get_sifchain_addr_balance(new_addr, "", request.sifchain_symbol) logging.info( f"get_sifchain_addr_balance after sleep is {balance_after_sleep} for {new_addr}" ) expected_balance = initial_user_balance + request.amount logging.info(f"look for a balance of {expected_balance}") wait_for_sifchain_addr_balance(new_addr, request.sifchain_symbol, expected_balance, "")
def test_bulk_transfers( basic_transfer_request: EthereumToSifchainTransferRequest, smart_contracts_dir, source_ethereum_address, bridgebank_address, bridgetoken_address, ethereum_network, ): n_transfers = int(test_utilities.get_optional_env_var("NTRANSFERS", 2)) ganache_delay = test_utilities.get_optional_env_var("GANACHE_DELAY", 1) # test_utilities.get_shell_output(f"{integration_dir}/ganache_start.sh {ganache_delay}") amount = "{:d}".format(5 * test_utilities.highest_gas_cost) new_addresses_and_keys = list( map(lambda x: create_new_sifaddr_and_key(), range(n_transfers))) logging.info(f"aandk: {new_addresses_and_keys}") new_addresses = list(map(lambda a: a[0], new_addresses_and_keys)) logging.debug(f"new_addresses: {new_addresses}") new_eth_addrs = test_utilities.create_ethereum_addresses( smart_contracts_dir, basic_transfer_request.ethereum_network, len(new_addresses)) logging.info(f"new eth addrs: {new_eth_addrs}") request: EthereumToSifchainTransferRequest = copy.deepcopy( basic_transfer_request) requests = list( map( lambda addr: { "amount": amount, "symbol": test_utilities.NULL_ADDRESS, "sifchain_address": addr }, new_addresses)) json_requests = json.dumps(requests) test_utilities.run_yarn_command(" ".join([ f"yarn --cwd {smart_contracts_dir}", "integrationtest:sendBulkLockTx", f"--amount {amount}", f"--symbol eth", f"--json_path {request.solidity_json_path}", f"--sifchain_address {new_addresses[0]}", f"--transactions \'{json_requests}\'", f"--ethereum_address {source_ethereum_address}", f"--bridgebank_address {bridgebank_address}", f"--ethereum_network {ethereum_network}", ])) requests = list( map( lambda addr: { "amount": amount, "symbol": bridgetoken_address, "sifchain_address": addr }, new_addresses)) json_requests = json.dumps(requests) yarn_result = test_utilities.run_yarn_command(" ".join([ f"yarn --cwd {smart_contracts_dir}", "integrationtest:sendBulkLockTx", f"--amount {amount}", "--lock_or_burn burn", f"--symbol {bridgetoken_address}", f"--json_path {request.solidity_json_path}", f"--sifchain_address {new_addresses[0]}", f"--transactions \'{json_requests}\'", f"--ethereum_address {source_ethereum_address}", f"--bridgebank_address {bridgebank_address}", f"--ethereum_network {ethereum_network}", ])) logging.info(f"bulk result: {yarn_result}") manual_advance = False if manual_advance: test_utilities.advance_n_ethereum_blocks(test_utilities.n_wait_blocks, smart_contracts_dir) test_utilities.wait_for_ethereum_block_number( yarn_result["blockNumber"] + test_utilities.n_wait_blocks, basic_transfer_request) for a in new_addresses: test_utilities.wait_for_sif_account( a, basic_transfer_request.sifnodecli_node, 90) test_utilities.wait_for_sifchain_addr_balance( a, "ceth", amount, basic_transfer_request.sifnodecli_node, 180) test_utilities.wait_for_sifchain_addr_balance( a, "rowan", amount, basic_transfer_request.sifnodecli_node, 180) text_file = open("pfile.cmds", "w") simple_credentials = SifchaincliCredentials(keyring_passphrase=None, keyring_backend="test", from_key=None, sifnodecli_homedir=None) logging.info(f"all accounts are on sifchain and have the correct balance") for sifaddr, ethaddr in zip(new_addresses_and_keys, new_eth_addrs): r = copy.deepcopy(basic_transfer_request) r.sifchain_address = sifaddr[0] r.ethereum_address = ethaddr["address"] r.amount = 100 simple_credentials.from_key = sifaddr[1] c = test_utilities.send_from_sifchain_to_ethereum_cmd( r, simple_credentials) text_file.write(f"{c}\n") text_file.close() # test_utilities.get_shell_output("cat pfile.cmds | parallel --trim lr -v {}") test_utilities.get_shell_output("bash -x pfile.cmds") for sifaddr, ethaddr in zip(new_addresses_and_keys, new_eth_addrs): r = copy.deepcopy(basic_transfer_request) r.ethereum_address = ethaddr["address"] r.amount = 100 test_utilities.wait_for_eth_balance(r, 100, 300)