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 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 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_token_distribution(
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,
):
tokens = test_utilities.get_whitelisted_tokens(basic_transfer_request)
request = basic_transfer_request
amount_in_tokens = 10000000
for t in tokens:
try:
logging.info(f"sending: {t}")
destination_symbol = "c" + t["symbol"]
if t["symbol"] == "erowan":
destination_symbol = "rowan"
request.amount = int(amount_in_tokens * (10**int(t["decimals"])))
request.ethereum_symbol = t["token"]
request.sifchain_symbol = destination_symbol
request.sifchain_address = rowan_source
request.sifchain_destination_address = test_utilities.get_required_env_var(
"DESTINATION_ACCOUNT")
test_utilities.send_from_sifchain_to_sifchain(
request, rowan_source_integrationtest_env_credentials)
except Exception as e:
logging.error(f"error: {e}")
def generate_test_account(
base_transfer_request: EthereumToSifchainTransferRequest,
rowan_source_integrationtest_env_transfer_request:
EthereumToSifchainTransferRequest,
rowan_source_integrationtest_env_credentials: SifchaincliCredentials,
target_ceth_balance: int = 10**18,
target_rowan_balance: int = 10**18
) -> (EthereumToSifchainTransferRequest, SifchaincliCredentials):
"""Creates a test account with ceth and rowan"""
new_account_key = get_shell_output("uuidgen")
credentials = sifchain_cli_credentials_for_test(new_account_key)
new_addr = burn_lock_functions.create_new_sifaddr(credentials=credentials,
keyname=new_account_key)
new_sifaddr = new_addr["address"]
credentials.from_key = new_addr["name"]
initial_rowan = test_utilities.get_sifchain_addr_balance(
rowan_source_integrationtest_env_transfer_request.sifchain_address,
rowan_source_integrationtest_env_transfer_request.sifnodecli_node,
"rowan")
if target_rowan_balance > 0:
rowan_request: EthereumToSifchainTransferRequest = copy.deepcopy(
rowan_source_integrationtest_env_transfer_request)
rowan_request.sifchain_destination_address = new_sifaddr
rowan_request.amount = target_rowan_balance
logging.debug(
f"transfer {target_rowan_balance} to {new_sifaddr} from {rowan_request.sifchain_address}"
)
test_utilities.send_from_sifchain_to_sifchain(
rowan_request, rowan_source_integrationtest_env_credentials)
request: EthereumToSifchainTransferRequest = copy.deepcopy(
base_transfer_request)
request.sifchain_address = new_sifaddr
request.amount = target_ceth_balance
request.sifchain_symbol = "ceth"
request.ethereum_symbol = "eth"
logging.debug(
f"transfer {target_ceth_balance} eth to {new_sifaddr} from {base_transfer_request.ethereum_address}"
)
burn_lock_functions.transfer_ethereum_to_sifchain(request)
ending_rowan = test_utilities.get_sifchain_addr_balance(
rowan_source_integrationtest_env_transfer_request.sifchain_address,
rowan_source_integrationtest_env_transfer_request.sifnodecli_node,
"rowan")
rowan_used = initial_rowan - ending_rowan
rowan_fees = rowan_used - target_rowan_balance
# logging.info(f"rowan fees from source is {rowan_fees}")
logging.info(
f"created sifchain addr {new_sifaddr} with {test_utilities.display_currency_value(target_ceth_balance)} ceth and {test_utilities.display_currency_value(target_rowan_balance)} rowan"
)
return request, credentials
def setup_currencies():
owner_addr = get_required_env_var("OWNER_ADDR")
user1_addr = get_required_env_var("USER1ADDR")
print(f"adding eth to {owner_addr}")
transact_ethereum_to_sifchain(owner_addr, "eth", amount_in_wei(10))
print(f"adding eth to {user1_addr}")
transact_ethereum_to_sifchain(user1_addr, "eth", amount_in_wei(13))
time.sleep(15)
send_from_sifchain_to_sifchain(owner_addr, user1_addr, amount_in_wei(23),
"rowan",
get_required_env_var("OWNER_PASSWORD"))
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_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))