def test_two_currencies_with_different_capitalization_should_not_interfere_with_each_other(
smart_contracts_dir,
bridgebank_address,
solidity_json_path,
):
new_account_key = (
"a" + get_shell_output("uuidgen").replace("-", "").lower())[:5]
amount = amount_in_wei(9)
new_currency = create_new_currency(amount, new_account_key,
smart_contracts_dir, bridgebank_address,
solidity_json_path)
(request1,
_) = build_request_for_new_sifchain_address(new_currency, amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request1, 10)
balance_1 = get_sifchain_addr_balance(request1.sifchain_address,
request1.sifnodecli_node,
request1.sifchain_symbol)
assert (balance_1 == request1.amount)
new_currency = create_new_currency(amount, new_account_key.upper(),
smart_contracts_dir, bridgebank_address,
solidity_json_path)
(request2,
_) = build_request_for_new_sifchain_address(new_currency, amount + 70000)
burn_lock_functions.transfer_ethereum_to_sifchain(request2, 10)
balance_1_again = get_sifchain_addr_balance(request1.sifchain_address,
request1.sifnodecli_node,
request1.sifchain_symbol)
assert (balance_1 == balance_1_again)
def generate_minimal_test_account(
base_transfer_request: EthereumToSifchainTransferRequest,
target_ceth_balance: int = 10**18,
) -> (EthereumToSifchainTransferRequest, SifchaincliCredentials):
"""Creates a test account with ceth and rowan. The address for the new account is in request.sifchain_address"""
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"]
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)
logging.info(
f"created sifchain addr {new_sifaddr} with {test_utilities.display_currency_value(target_ceth_balance)} ceth"
)
return request, credentials
def test_can_create_a_new_token_and_peg_it(
token_length: int,
basic_transfer_request: EthereumToSifchainTransferRequest,
smart_contracts_dir,
bridgebank_address,
solidity_json_path,
operator_address,
ethereum_network,
source_ethereum_address,
):
new_account_key = (
"a" + get_shell_output("uuidgen").replace("-", ""))[:token_length]
token_name = new_account_key
amount = amount_in_wei(9)
new_currency = create_new_currency(amount=amount,
symbol=new_account_key,
token_name=token_name,
decimals=18,
smart_contracts_dir=smart_contracts_dir,
bridgebank_address=bridgebank_address,
solidity_json_path=solidity_json_path,
operator_address=operator_address,
ethereum_network=ethereum_network)
request = build_request_for_new_sifchain_address(basic_transfer_request,
source_ethereum_address,
new_currency, amount / 10)
burn_lock_functions.transfer_ethereum_to_sifchain(request)
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 transfer_new_currency(request, symbol, currency, amount):
logging.info(
f"transfer some of the new currency {symbol} to the test sifchain address"
)
request.ethereum_symbol = currency["newtoken_address"]
request.sifchain_symbol = symbol
request.amount = amount
burn_lock_functions.transfer_ethereum_to_sifchain(request)
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 test_can_use_a_token_with_a_dash_in_the_name(
smart_contracts_dir,
bridgebank_address,
solidity_json_path,
):
n = "a-b"
new_currency = create_new_currency(amount_in_wei(10), n,
smart_contracts_dir, bridgebank_address,
solidity_json_path)
(request, _) = build_request_for_new_sifchain_address(new_currency, 60000)
burn_lock_functions.transfer_ethereum_to_sifchain(request, 10)
def test_transfer_eth_to_ceth_using_replay_blocks(integration_dir,
smart_contracts_dir,
ensure_relayer_restart):
starting_block = test_utilities.current_ethereum_block_number(
smart_contracts_dir)
logging.info("stopping ebrelayer")
test_utilities.get_shell_output("pkill -9 ebrelayer || true")
request, credentials = build_request()
logging.info("(no transactions should happen without a relayer)")
# test_utilities.whitelist_token(request.ethereum_symbol, request.smart_contracts_dir, True)
logging.info(
f"send {request.amount / 10**18} eth ({request.amount} wei) to {request.sifchain_address}"
)
test_utilities.send_from_ethereum_to_sifchain(request)
# test_utilities.get_shell_output(f"{integration_dir}/sifchain_start_ebrelayer.sh")
logging.info("replay blocks using ebrelayer replayEthereum")
ews = test_utilities.get_required_env_var("ETHEREUM_WEBSOCKET_ADDRESS")
bra = test_utilities.get_required_env_var("BRIDGE_REGISTRY_ADDRESS")
mon = test_utilities.get_required_env_var("MONIKER")
mn = test_utilities.get_required_env_var("MNEMONIC")
cn = test_utilities.get_required_env_var("CHAINNET")
ending_block = test_utilities.current_ethereum_block_number(
smart_contracts_dir) + 1
cmd = f"""ebrelayer replayEthereum tcp://0.0.0.0:26657 {ews} {bra} {mon} '{mn}' {starting_block} {ending_block} 1 2 --chain-id {cn} --gas 5000000000000 \
--gas-prices 0.5rowan"""
test_utilities.get_shell_output(cmd)
time.sleep(15)
logging.info(
f"check the ending balance of {request.sifchain_address} after replaying blocks"
)
ending_balance = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node,
request.sifchain_symbol)
assert (ending_balance == request.amount)
# now do it again
test_utilities.get_shell_output(cmd)
time.sleep(5)
ending_balance2 = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node,
request.sifchain_symbol)
assert (ending_balance2 == request.amount)
# now start ebrelayer and do another transfer
test_utilities.advance_n_ethereum_blocks(test_utilities.n_wait_blocks + 1,
smart_contracts_dir)
test_utilities.get_shell_output(
f"{integration_dir}/sifchain_start_ebrelayer.sh")
burn_lock_functions.transfer_ethereum_to_sifchain(request, 15)
ending_balance3 = test_utilities.get_sifchain_addr_balance(
request.sifchain_address, request.sifnodecli_node,
request.sifchain_symbol)
assert (ending_balance3 == request.amount * 2)
def test_can_create_a_new_token_with_a_long_name_and_peg_it(
smart_contracts_dir,
bridgebank_address,
solidity_json_path,
):
new_account_key = "ca36e47edfeb28489d8e110fb91d351bcd"
amount = amount_in_wei(9)
new_currency = create_new_currency(amount, new_account_key,
smart_contracts_dir, bridgebank_address,
solidity_json_path)
(request1, _) = build_request(new_currency, amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request1, 10)
def test_can_create_a_new_token_with_a_one_letter_name_and_peg_it(
smart_contracts_dir,
bridgebank_address,
solidity_json_path,
):
new_account_key = "a"
amount = amount_in_wei(9)
new_currency = create_new_currency(amount, new_account_key,
smart_contracts_dir, bridgebank_address,
solidity_json_path)
(request1,
_) = build_request_for_new_sifchain_address(new_currency, amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request1, 10)
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_transfer_eth_to_ceth_without_a_validator_should_throw_exception():
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)
credentials.from_key = new_addr["name"]
request = EthereumToSifchainTransferRequest(
sifchain_address=new_addr["address"],
smart_contracts_dir=get_required_env_var("SMART_CONTRACTS_DIR"),
ethereum_address=get_required_env_var("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=90000)
logging.info(
"try to transfer, but expect a failure since there are no whitelisted validators"
)
with pytest.raises(Exception):
# use a small number for max_retries - on a local system, it shouldn't
# take more than a second or two for ebrelayer to act
burn_lock_functions.transfer_ethereum_to_sifchain(request, 3)
def test_can_use_a_token_with_a_dash_in_the_name():
n = "a-b"
new_currency = create_new_currency(amount_in_wei(10), n)
(request, _) = build_request(new_currency, 60000)
burn_lock_functions.transfer_ethereum_to_sifchain(request, 10)
import burn_lock_functions
if __name__ == "__main__":
arg_parser = burn_lock_functions.transfer_argument_parser()
args = burn_lock_functions.add_credentials_arguments(
arg_parser).parse_args()
burn_lock_functions.configure_logging(args)
logging.debug(f"command line arguments: {sys.argv} {args}")
request = burn_lock_functions.EthereumToSifchainTransferRequest.from_args(
args)
logging.info(f"transferrequestjson: {json.dumps(request.__dict__)}")
transfer_result = burn_lock_functions.transfer_ethereum_to_sifchain(
request, max_seconds=30)
final_balance = transfer_result["sifchain_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"transferresultjson: {result}")
print(result)
new_account_key = 'user1'
credentials = sifchain_cli_credentials_for_test(new_account_key)
new_addr = burn_lock_functions.create_new_sifaddr(credentials=credentials,
keyname=new_account_key)
credentials.from_key = new_addr["name"]
request = EthereumToSifchainTransferRequest(
sifchain_address=new_addr["address"],
smart_contracts_dir=smart_contracts_dir,
ethereum_address=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=9 * 10**18,
ceth_amount=2 * (10**16))
return request, credentials
# if there's an existing user1 key, just remove it. Otherwise, adding a duplicate key will just hang
try:
test_utilities.get_shell_output(
f"sifnoded keys delete user1 --home /home/vagrant/.sifnoded --keyring-backend test -o json"
)
except:
logging.debug("no key to delete, this is normal in a fresh environment")
request, credentials = build_request()
# test_utilities.set_lock_burn_limit(smart_contracts_dir, request.ethereum_symbol, request.amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request)
test_utilities.get_sifchain_addr_balance(request.sifchain_address,
request.sifnoded_node, "ceth")
logging.info(f"created account for key {credentials.from_key}")
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_can_create_a_new_token_with_a_7_char_name_and_peg_it():
new_account_key = ("a" + get_shell_output("uuidgen").replace("-", ""))[:7]
amount = amount_in_wei(9)
new_currency = create_new_currency(amount, new_account_key)
(request1, _) = build_request(new_currency, amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request1, 10)
def test_can_create_a_new_token_with_a_long_name_and_peg_it():
new_account_key = "ca36e47edfeb28489d8e110fb91d351bcd"
amount = amount_in_wei(9)
new_currency = create_new_currency(amount, new_account_key)
(request1, _) = build_request(new_currency, amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request1, 10)
def test_can_create_a_new_token_with_a_one_letter_name_and_peg_it():
new_account_key = "a"
amount = amount_in_wei(9)
new_currency = create_new_currency(amount, new_account_key)
(request1, _) = build_request(new_currency, amount)
burn_lock_functions.transfer_ethereum_to_sifchain(request1, 10)
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_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, "")
