def test_simple_transfer(
web3_home,
web3_foreign,
foreign_bridge_contract,
token_contract,
accounts,
started_bridges,
):
"""
Tests whether a simple transfer with all bridges online works
"""
sender = accounts[3]
value = 5000
foreign_balance_before = token_contract.functions.balanceOf(sender).call()
home_balance_before = web3_home.eth.getBalance(sender)
wait_for_successful_transaction_receipt(
web3_foreign,
token_contract.functions.transfer(foreign_bridge_contract.address,
value).transact({"from": sender}),
)
mine_min_blocks(web3_foreign, REORG_DEPTH)
def check_balance():
foreign_balance_after = token_contract.functions.balanceOf(
sender).call()
home_balance_after = web3_home.eth.getBalance(sender)
assert foreign_balance_before - foreign_balance_after == value
assert home_balance_before - home_balance_after == -value
assert_within_timeout(check_balance, 10)
def initialize_deposit_locker(deployed_contract, block_number,
validator_contract_address, web3):
txid = deployed_contract.functions.init(
block_number,
validator_contract_address).transact({"from": web3.eth.defaultAccount})
wait_for_successful_transaction_receipt(web3, txid)
return deployed_contract
def token_contract(deploy_contract_on_chain, web3_foreign, accounts):
"""The token contract on the foreign chain."""
constructor_args = (
"Trustlines Network Token",
"TLN",
18,
accounts[0],
BRIDGE_FUNDS,
)
token_contract = deploy_contract_on_chain(
web3_foreign,
"TrustlinesNetworkToken",
constructor_args=constructor_args)
assert token_contract.functions.balanceOf(accounts[0]).call() > 0
for account in accounts[1:]:
wait_for_successful_transaction_receipt(
web3_foreign,
token_contract.functions.transfer(account, 10**18).transact(
{"from": accounts[0]}),
)
return token_contract
def initialize_test_validator_slasher(deployed_contract, validators,
fund_contract_address, web3):
txid = deployed_contract.functions.init(
validators,
fund_contract_address).transact({"from": web3.eth.defaultAccount})
wait_for_successful_transaction_receipt(web3, txid)
return deployed_contract
def init(deposit_locker, depositors_proxy):
txid = deposit_locker.functions.init(
_releaseTimestamp=release_timestamp,
_slasher="0x0000000000000000000000000000000000000000",
_depositorsProxy=depositors_proxy,
).transact()
wait_for_successful_transaction_receipt(web3, txid)
def initialize_validator_set(test_validator_set_contract, validators,
validator_proxy_address, web3):
txid = test_validator_set_contract.functions.init(
validators,
validator_proxy_address).transact({"from": web3.eth.defaultAccount})
wait_for_successful_transaction_receipt(web3, txid)
return test_validator_set_contract
def compute_one_result(
self,
fees_paid_by,
value,
capacity_imbalance_fee_divisor,
addresses,
balances_before,
):
self.contract.functions.setCapacityImbalanceFeeDivisor(
capacity_imbalance_fee_divisor
).transact()
for a, b, balance in zip(addresses, addresses[1:], balances_before):
txid = self.contract.functions.setAccount(
a, b, 100_000_000, 100_000_000, 0, 0, False, 0, balance
).transact()
# we only wait for the last transaction to speed things up
wait_for_successful_transaction_receipt(self.contract.web3, txid)
assert fees_paid_by in ("sender", "receiver")
if fees_paid_by == "sender":
fn = self.contract.functions.testTransferSenderPays
elif fees_paid_by == "receiver":
fn = self.contract.functions.testTransferReceiverPays
txid = fn(value, value, addresses).transact()
wait_for_successful_transaction_receipt(self.contract.web3, txid)
balances = [
self.contract.functions.getAccount(a, b).call()[-1]
for a, b in zip(addresses, addresses[1:])
]
return dict(balances_after=balances)
def mine_min_blocks(web3, number_of_blocks):
"""
Mines a minimum of `number_of_blocks` blocks.
Works by sending out transactions, assumes the parity InstaSeal engine
"""
block_height = web3.eth.blockNumber
while web3.eth.blockNumber < block_height + number_of_blocks:
wait_for_successful_transaction_receipt(
web3, web3.eth.sendTransaction({"from": DEV_ACCOUNT}))
def test_validator_set_changes_transfer(
web3_home,
web3_foreign,
foreign_bridge_contract,
token_contract,
accounts,
bridges,
bridge_addresses,
validator_proxy_contract,
system_address,
):
"""
Tests that a transfer initiated when not enough validators are online to confirm it will be confirmed
when the validator set changes to have enough validators online
"""
inactive_address = accounts[2]
assert inactive_address not in bridge_addresses
initial_validators = [
bridge_addresses[0], inactive_address, bridge_addresses[2]
]
validator_proxy_contract.functions.updateValidators(
initial_validators).transact({"from": system_address})
# Only bridges[0] and bridges[2] are validators, so bridge transfers will not be complete with
# only bridges[0] and bridges[1] online
bridges[0].start()
bridges[1].start()
sender = accounts[3]
value = 5000
home_balance_before = web3_home.eth.getBalance(sender)
wait_for_successful_transaction_receipt(
web3_foreign,
token_contract.functions.transfer(foreign_bridge_contract.address,
value).transact({"from": sender}),
)
mine_min_blocks(web3_foreign, REORG_DEPTH)
# new validators include two online bridges: bridges[0] and bridges[1] and bridge transfers should be complete
validator_proxy_contract.functions.updateValidators(
bridge_addresses).transact({"from": system_address})
def check_balance_transfer_complete():
home_balance_transfer_complete = web3_home.eth.getBalance(sender)
assert home_balance_transfer_complete - home_balance_before == value
assert_within_timeout(check_balance_transfer_complete, 10)
def web3_foreign(node_foreign, accounts, account_keys):
web3 = Web3(HTTPProvider(FOREIGN_RPC_URL))
web3.middleware_onion.add(
construct_sign_and_send_raw_middleware(account_keys))
for account in accounts[1:]:
wait_for_successful_transaction_receipt(
web3,
web3.eth.sendTransaction({
"from": accounts[0],
"to": account,
"value": START_WEI_PER_ACCOUNT
}),
)
return web3
def initialize_deposit_locker(
deployed_contract,
release_timestamp,
validator_contract_address,
auction_contract_address,
web3,
):
txid = deployed_contract.functions.init(
_releaseTimestamp=release_timestamp,
_slasher=validator_contract_address,
_depositorsProxy=auction_contract_address,
).transact({"from": web3.eth.defaultAccount})
wait_for_successful_transaction_receipt(web3, txid)
return deployed_contract
def test_offline_validators_do_not_validates_complete_transfer(
web3_home,
web3_foreign,
foreign_bridge_contract,
token_contract,
accounts,
bridges,
validators,
):
"""
Tests that a transfer initiated when threshold validators are online will not be pointlessly validated when different validator turn online
"""
bridge_2_address = validators[2]
before_tx_count = web3_home.eth.getTransactionCount(bridge_2_address)
bridges[0].start()
bridges[1].start()
sender = accounts[3]
value = 5000
home_balance_before = web3_home.eth.getBalance(sender)
wait_for_successful_transaction_receipt(
web3_foreign,
token_contract.functions.transfer(foreign_bridge_contract.address,
value).transact({"from": sender}),
)
mine_min_blocks(web3_foreign, REORG_DEPTH)
def check_balance_transfer_complete():
home_balance_transfer_complete = web3_home.eth.getBalance(sender)
assert home_balance_transfer_complete - home_balance_before == value
# We need to wait for the transaction to be completed before starting bridges[2]
assert_within_timeout(check_balance_transfer_complete, 10)
bridges[2].start()
def check_no_transaction_sent():
after_tx_count = web3_home.eth.getTransactionCount(bridge_2_address)
assert after_tx_count == before_tx_count
assert_after_timout(check_no_transaction_sent, 10)
def test_openethereum_node_restarting(
web3_home,
web3_foreign,
foreign_bridge_contract,
token_contract,
accounts,
bridges,
node_home,
node_foreign,
):
"""
Tests that the openethereum node bound to the bridge can crash and restart without impacting the bridge
"""
bridges[0].start()
bridges[1].start()
node_home.terminate()
node_foreign.terminate()
assert bridges[0].is_up()
node_home.start()
node_foreign.start()
sender = accounts[3]
value = 5000
home_balance_before = web3_home.eth.getBalance(sender)
wait_for_successful_transaction_receipt(
web3_foreign,
token_contract.functions.transfer(foreign_bridge_contract.address,
value).transact({"from": sender}),
)
mine_min_blocks(web3_foreign, REORG_DEPTH)
def check_balance_transfer_complete():
home_balance_transfer_complete = web3_home.eth.getBalance(sender)
assert home_balance_transfer_complete - home_balance_before == value
assert_within_timeout(check_balance_transfer_complete, 10)
def test_offline_validators_validates_not_complete_transfer(
web3_home, web3_foreign, foreign_bridge_contract, token_contract,
accounts, bridges):
"""
Tests whether a transfer initiated when threshold validators are offline will be effective when enough validators turn online
"""
bridges[0].start()
sender = accounts[3]
value = 5000
foreign_balance_before = token_contract.functions.balanceOf(sender).call()
home_balance_before = web3_home.eth.getBalance(sender)
wait_for_successful_transaction_receipt(
web3_foreign,
token_contract.functions.transfer(foreign_bridge_contract.address,
value).transact({"from": sender}),
)
mine_min_blocks(web3_foreign, REORG_DEPTH)
def check_balances_bridge_transfer_not_complete():
foreign_balance_transfer_not_complete = token_contract.functions.balanceOf(
sender).call()
home_balance_transfer_not_complete = web3_home.eth.getBalance(sender)
assert foreign_balance_before - foreign_balance_transfer_not_complete == value
assert home_balance_before == home_balance_transfer_not_complete
assert_after_timout(check_balances_bridge_transfer_not_complete, 10)
bridges[1].start()
def check_balance_transfer_complete():
home_balance_transfer_complete = web3_home.eth.getBalance(sender)
assert home_balance_transfer_complete - home_balance_before == value
assert_within_timeout(check_balance_transfer_complete, 10)
