def test_rowan_to_erowan(
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request: EthereumToSifchainTransferRequest,
ethereum_network,
bridgetoken_address,
smart_contracts_dir
):
basic_transfer_request.ethereum_address = source_ethereum_address
basic_transfer_request.check_wait_blocks = True
target_rowan_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=10 ** 18,
target_rowan_balance=target_rowan_balance
)
logging.info(f"send erowan to ethereum from test account")
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network
)
request.sifchain_symbol = "rowan"
request.ethereum_symbol = bridgetoken_address
request.amount = int(target_rowan_balance / 2)
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
def test_transfer_eth_to_ceth_and_back(ropsten_wait_time, rowan_source,
sifnodecli_node,
source_ethereum_address, chain_id):
eth_transfer, credentials = build_request(sifnodecli_node,
source_ethereum_address,
chain_id)
# first we have to give the sif address some rowan so it can pay sifchain gas
rowan_transfer = deepcopy(eth_transfer)
logging.info(f"rowan_source is {rowan_source}")
rowan_transfer.sifchain_address = rowan_source
rowan_transfer.sifchain_destination_address = eth_transfer.sifchain_address
rowan_transfer.amount = 2000000
rowan_transfer.sifchain_symbol = "rowan"
test_utilities.send_from_sifchain_to_sifchain(rowan_transfer, credentials)
burn_lock_functions.transfer_ethereum_to_sifchain(eth_transfer,
ropsten_wait_time)
logging.info(f"send ceth back to {eth_transfer.ethereum_address}")
return_request = deepcopy(eth_transfer)
# don't transfer ceth => eth to the BridgeBank address since BridgeBank is responsible for paying gas.
# That means you can't just see if the exact transfer went through.
return_request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
return_request.amount = amount
burn_lock_functions.transfer_sifchain_to_ethereum(return_request,
credentials,
ropsten_wait_time)
def test_eth_to_ceth_and_back_to_eth(
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest,
ethereum_network,
smart_contracts_dir,
rowan_amount,
ceth_amount,
bridgetoken_address,
):
# logging.info("shark")
# x = 4.9908339925e+18
# s = "{:d}".format(int(x))
# logging.info(f"xiss: {s}")
# logging.info(f"xiss: {x}")
# assert False
basic_transfer_request.ethereum_address = source_ethereum_address
basic_transfer_request.check_wait_blocks = True
logging.info(f"rq: {basic_transfer_request}")
request, credentials = generate_test_account(
basic_transfer_request,
rowan_source_integrationtest_env_transfer_request,
rowan_source_integrationtest_env_credentials,
target_ceth_balance=ceth_amount,
target_rowan_balance=rowan_amount)
# send some test account ceth back to a new ethereum address
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
logging.info(f"get balance of test account")
test_utilities.get_sifchain_addr_balance(
request.sifchain_address,
sifnodecli_node=request.sifnodecli_node,
denom="ceth")
logging.info(
"send erowan back to ethereum chain, saving 100k for ceth transfer fees"
)
request.sifchain_symbol = "rowan"
request.ethereum_symbol = bridgetoken_address
request.amount = rowan_amount - 200000
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
test_utilities.get_eth_balance(request)
logging.info("send eth back to ethereum chain")
logging.info("get ceth balance to decide how much to return")
request.sifchain_symbol = "ceth"
request.ethereum_symbol = "eth"
ceth_balance = test_utilities.get_sifchain_addr_balance(
request.sifchain_address,
sifnodecli_node=request.sifnodecli_node,
denom="ceth")
request.amount = ceth_balance - request.ceth_amount
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
logging.info("get final eth balance")
test_utilities.get_eth_balance(request)
test_utilities.get_sifchain_addr_balance(
request.sifchain_address,
sifnodecli_node=request.sifnodecli_node,
denom="ceth")
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 do_currency_test(
new_currency_symbol,
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest,
ethereum_network,
solidity_json_path,
):
amount = amount_in_wei(9)
logging.info(f"create new currency")
new_currency = test_utilities.create_new_currency(
amount,
new_currency_symbol,
new_currency_symbol,
18,
smart_contracts_dir=smart_contracts_dir,
bridgebank_address=bridgebank_address,
solidity_json_path=solidity_json_path)
logging.info(
f"create test account to use with new currency {new_currency_symbol}")
basic_transfer_request.ethereum_address = source_ethereum_address
request, credentials = generate_test_account(
basic_transfer_request,
rowan_source_integrationtest_env_transfer_request,
rowan_source_integrationtest_env_credentials,
target_ceth_balance=10**17,
target_rowan_balance=10**18)
test_amount = 39000
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 = ("c" + new_currency["newtoken_symbol"]).lower()
request.amount = test_amount
burn_lock_functions.transfer_ethereum_to_sifchain(request)
logging.info("send some new currency to ethereum")
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
request.amount = test_amount - 1
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
def test_eth_to_ceth_and_back_to_eth(
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest, ethereum_network, smart_contracts_dir):
basic_transfer_request.ethereum_address = source_ethereum_address
basic_transfer_request.check_wait_blocks = True
request, credentials = generate_test_account(
basic_transfer_request,
rowan_source_integrationtest_env_transfer_request,
rowan_source_integrationtest_env_credentials,
target_ceth_balance=10**17,
target_rowan_balance=10**18)
# send some test account ceth back to a new ethereum address
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
request.amount = int(request.amount / 2)
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
def test_do_not_transfer_if_fee_allowed_is_too_low(
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest,
ethereum_network,
smart_contracts_dir,
bridgetoken_address,
):
basic_transfer_request.ethereum_address = source_ethereum_address
target_ceth_balance = 10**18
target_rowan_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)
# send some test account ceth back to a new ethereum address
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
request.sifchain_symbol = "rowan"
request.ethereum_symbol = bridgetoken_address
request.amount = 31500
logging.info(
"try to transfer rowan to erowan with a ceth_amount that's too low")
with pytest.raises(Exception):
request.ceth_amount = test_utilities.lock_gas_cost - 1
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
ending_ceth_balance = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node, "ceth")
assert ending_ceth_balance == target_ceth_balance
logging.info("try with not owning enough ceth to cover the offer")
with pytest.raises(Exception):
request.ceth_amount = target_ceth_balance + 1
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
ending_ceth_balance = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node, "ceth")
assert ending_ceth_balance == target_ceth_balance
def test_eth_to_ceth_and_back_to_eth(
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest,
ethereum_network,
smart_contracts_dir,
bridgetoken_address,
sifchain_fees_int,
):
basic_transfer_request.ethereum_address = source_ethereum_address
basic_transfer_request.check_wait_blocks = True
small_amount = 100
logging.info(
"the test account needs enough rowan and ceth for one burn and one lock, make sure it has that"
)
request, credentials = generate_test_account(
basic_transfer_request,
rowan_source_integrationtest_env_transfer_request,
rowan_source_integrationtest_env_credentials,
target_ceth_balance=test_utilities.burn_gas_cost +
test_utilities.lock_gas_cost + small_amount,
target_rowan_balance=sifchain_fees_int * 2 + small_amount)
# send some test account ceth back to a new ethereum address
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
request.sifchain_symbol = "rowan"
request.ethereum_symbol = bridgetoken_address
request.amount = small_amount
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
test_utilities.get_eth_balance(request)
logging.info("send eth back to ethereum chain")
request.sifchain_symbol = "ceth"
request.ethereum_symbol = "eth"
request.amount = small_amount
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
def test_fee_charged_to_transfer_rowan_to_erowan(
basic_transfer_request: EthereumToSifchainTransferRequest,
source_ethereum_address: str,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest,
ethereum_network,
smart_contracts_dir,
bridgetoken_address,
):
basic_transfer_request.ethereum_address = source_ethereum_address
logging.info(
f"credentials: {rowan_source_integrationtest_env_credentials}")
request, credentials = generate_test_account(
basic_transfer_request,
rowan_source_integrationtest_env_transfer_request,
rowan_source_integrationtest_env_credentials,
target_ceth_balance=10**18,
target_rowan_balance=10**18)
# send some test account ceth back to a new ethereum address
request.ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
logging.info(
f"sending rowan to erowan and checking that a ceth fee was charged")
request.sifchain_symbol = "rowan"
request.ethereum_symbol = bridgetoken_address
request.amount = 31500
# get the starting ceth balance, transfer some rowan to erowan, get the ending ceth
# balance. The difference is the fee charged and should be equal to request.ceth_amount
starting_ceth_balance = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node, "ceth")
burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
ending_ceth_balance = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node, "ceth")
fee = starting_ceth_balance - ending_ceth_balance
assert fee == test_utilities.lock_gas_cost
def test_transfer_rowan_to_erowan_and_back(
ropsten_wait_time,
rowan_source,
sifnodecli_node,
source_ethereum_address,
chain_id,
smart_contracts_dir,
basic_transfer_request: EthereumToSifchainTransferRequest,
ceth_fee,
bridgetoken_address,
):
rq: EthereumToSifchainTransferRequest = deepcopy(basic_transfer_request)
rq.ethereum_address = "0xa584E4Fd44425937649A52846bF95A783564fCda"
rq.ethereum_symbol = bridgetoken_address
bx = test_utilities.get_eth_balance(rq)
logging.info(f"bx is {bx}")
raise Exception("stop test")
logging.info(
f"transfer rowan from {rowan_source} to a newly created account")
sifaddr, credentials = create_new_sifaddr_and_credentials()
rowan_transfer_from_source = deepcopy(basic_transfer_request)
rowan_transfer_from_source.sifchain_address = rowan_source
rowan_transfer_from_source.sifchain_destination_address = sifaddr
amt = 20000000
rowan_transfer_from_source.amount = amt
rowan_transfer_from_source.sifchain_symbol = "rowan"
test_utilities.send_from_sifchain_to_sifchain(rowan_transfer_from_source,
credentials)
logging.info(f"add ceth to new sif account to pay lock fees")
eth_transfer: EthereumToSifchainTransferRequest = deepcopy(
basic_transfer_request)
eth_transfer.ethereum_address = source_ethereum_address
eth_transfer.sifchain_address = sifaddr
eth_transfer.amount = ceth_fee * 2
logging.info("get balances just to have those commands in the history")
try:
test_utilities.get_sifchain_addr_balance(
sifaddr, basic_transfer_request.sifnodecli_node, "ceth")
except Exception as e:
logging.info(f"got exception while checking balance: {e}")
test_utilities.get_eth_balance(eth_transfer)
logging.info("execute transfer of eth => ceth to enable fee payment")
burn_lock_functions.transfer_ethereum_to_sifchain(eth_transfer,
ropsten_wait_time)
ethereum_address, _ = test_utilities.create_ethereum_address(
smart_contracts_dir, ethereum_network)
logging.info(
f"lock rowan from {rowan_transfer_from_source.sifchain_destination_address} to {ethereum_address}"
)
rowan_lock: EthereumToSifchainTransferRequest = deepcopy(
rowan_transfer_from_source)
rowan_lock.sifchain_address = sifaddr
rowan_lock.ethereum_address = ethereum_address
burn_lock_functions.transfer_sifchain_to_ethereum(rowan_lock, credentials,
ropsten_wait_time)
logging.info(
f"send erowan back to {sifaddr} from ethereum {ethereum_address}")
return_request = deepcopy(rowan_lock)
return_request.amount = amt / 2
burn_lock_functions.transfer_sifchain_to_ethereum(return_request,
credentials,
ropsten_wait_time)
def test_nothing():
return True
if __name__ == "__main__":
rc = burn_lock_functions.process_args(sys.argv, __file__)
request = rc.transfer_request
logging.info(f"transfer_request_json: {json.dumps(request.__dict__)}")
credentials = rc.credentials
transfer_result = burn_lock_functions.transfer_sifchain_to_ethereum(request, credentials)
final_balance = transfer_result["ethereum_ending_balance"]
result = json.dumps({
"final_balance": final_balance,
"final_balance_10_18": float(final_balance) / (10 ** 18),
"transfer_request": request.__dict__,
"logfile": args.logfile[0],
"steps": transfer_result
})
logging.info(f"transfer_result_json: {result}")
print(result)
