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)