def test_nettingchannel_settle_timeout_inrange(private_keys, tester_channelmanager, tester_chain): """ The netting channel constructor must enforce that settle timeout is in the valid range. Also asserts that the constants.py and the netting channel contract values are synched. """ pkey0 = private_keys[0] pkey1 = private_keys[1] pkey2 = private_keys[2] with pytest.raises(TransactionFailed): small_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MIN - 1 tester_channelmanager.newChannel( privatekey_to_address(pkey1), small_settle_timeout, sender=pkey0, ) with pytest.raises(TransactionFailed): big_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MAX + 1 tester_channelmanager.newChannel( privatekey_to_address(pkey1), big_settle_timeout, sender=pkey0, ) minimum_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MIN netting_channel_address0_hex = tester_channelmanager.newChannel( privatekey_to_address(pkey1), minimum_settle_timeout, sender=pkey0, ) max_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MAX netting_channel_address1_hex = tester_channelmanager.newChannel( privatekey_to_address(pkey2), max_settle_timeout, sender=pkey0, ) netting_channel = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), netting_channel_address0_hex) # pylint: disable=no-member assert netting_channel.settleTimeout( sender=pkey0) == minimum_settle_timeout netting_channel2 = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), netting_channel_address1_hex) assert netting_channel2.settleTimeout(sender=pkey0) == max_settle_timeout
def __init__(self, jsonrpc_client, manager_address, startgas=GAS_LIMIT, gasprice=GAS_PRICE, poll_timeout=DEFAULT_POLL_TIMEOUT): # pylint: disable=too-many-arguments if not isaddress(manager_address): raise ValueError('manager_address must be a valid address') result = jsonrpc_client.call( 'eth_getCode', address_encoder(manager_address), 'latest', ) if result == '0x': raise AddressWithoutCode( 'Channel manager address {} does not contain code'.format( address_encoder(manager_address), )) proxy = jsonrpc_client.new_abi_contract( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), address_encoder(manager_address), ) self.address = manager_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def __init__( self, jsonrpc_client, discovery_address, startgas, gasprice, poll_timeout=DEFAULT_POLL_TIMEOUT): if not isaddress(discovery_address): raise ValueError('discovery_address must be a valid address') check_address_has_code(jsonrpc_client, discovery_address, 'Discovery') proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY), address_encoder(discovery_address), ) self.address = discovery_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout self.not_found_address = '0x' + '0' * 40
def __init__( self, jsonrpc_client, registry_address, startgas, gasprice, poll_timeout=DEFAULT_POLL_TIMEOUT): # pylint: disable=too-many-arguments if not isaddress(registry_address): raise ValueError('registry_address must be a valid address') check_address_has_code(jsonrpc_client, registry_address, 'Registry') proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY), address_encoder(registry_address), ) self.address = registry_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout self.address_to_channelmanager = dict() self.token_to_channelmanager = dict()
def __init__(self, jsonrpc_client, discovery_address, startgas, gasprice, poll_timeout=DEFAULT_POLL_TIMEOUT): if not isaddress(discovery_address): raise ValueError('discovery_address must be a valid address') result = jsonrpc_client.call( 'eth_getCode', address_encoder(discovery_address), 'latest', ) if result == '0x': raise AddressWithoutCode( 'Discovery address {} does not contain code'.format( address_encoder(discovery_address), )) proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY), address_encoder(discovery_address), ) self.address = discovery_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def __init__(self, jsonrpc_client, registry_address, startgas, gasprice, poll_timeout=DEFAULT_POLL_TIMEOUT): # pylint: disable=too-many-arguments if not isaddress(registry_address): raise ValueError('registry_address must be a valid address') check_address_has_code(jsonrpc_client, registry_address) proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY), address_encoder(registry_address), ) self.address = registry_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout self.address_to_channelmanager = dict() self.token_to_channelmanager = dict()
def __init__(self, jsonrpc_client, discovery_address, startgas=GAS_LIMIT, gasprice=GAS_PRICE, poll_timeout=DEFAULT_POLL_TIMEOUT): result = jsonrpc_client.call( 'eth_getCode', address_encoder(discovery_address), 'latest', ) if result == '0x': raise AddressWithoutCode( 'Discovery address {} does not contain code'.format( address_encoder(discovery_address), )) proxy = jsonrpc_client.new_abi_contract( CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY), address_encoder(discovery_address), ) self.address = discovery_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def new_nettingcontract(our_key, partner_key, tester_state, log_listener, channelmanager, settle_timeout): if settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN: raise ValueError('settle_timeout must be larger-or-equal to {}'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN )) netting_channel_address0_hex = channelmanager.newChannel( privatekey_to_address(partner_key), settle_timeout, sender=our_key, ) tester_state.mine(number_of_blocks=1) nettingchannel_translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL) ) nettingchannel = tester.ABIContract( tester_state, nettingchannel_translator, netting_channel_address0_hex, log_listener=log_listener, default_key=INVALID_KEY, ) return nettingchannel
def __init__( self, jsonrpc_client, registry_address, poll_timeout=DEFAULT_POLL_TIMEOUT, ): # pylint: disable=too-many-arguments if not isaddress(registry_address): raise InvalidAddress( 'Expected binary address format for token network registry') check_address_has_code(jsonrpc_client, registry_address, CONTRACT_TOKEN_NETWORK_REGISTRY) proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_TOKEN_NETWORK_REGISTRY), address_encoder(registry_address), ) CONTRACT_MANAGER.check_contract_version( proxy.functions.contract_version().call(), CONTRACT_TOKEN_NETWORK_REGISTRY) self.address = registry_address self.proxy = proxy self.client = jsonrpc_client self.poll_timeout = poll_timeout self.node_address = privatekey_to_address(self.client.privkey) self.address_to_tokennetwork = dict() self.token_to_tokennetwork = dict()
def __init__(self, jsonrpc_client, token_address, startgas=GAS_LIMIT, gasprice=GAS_PRICE, poll_timeout=DEFAULT_POLL_TIMEOUT): if not isaddress(token_address): raise ValueError('token_address must be a valid address') result = jsonrpc_client.call( 'eth_getCode', address_encoder(token_address), 'latest', ) if result == '0x': raise AddressWithoutCode( 'Token address {} does not contain code'.format( address_encoder(token_address), )) proxy = jsonrpc_client.new_abi_contract( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN), address_encoder(token_address), ) self.address = token_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def __init__(self, jsonrpc_client, registry_address, startgas=GAS_LIMIT, gasprice=GAS_PRICE, poll_timeout=DEFAULT_POLL_TIMEOUT): # pylint: disable=too-many-arguments result = jsonrpc_client.call( 'eth_getCode', address_encoder(registry_address), 'latest', ) if result == '0x': raise ValueError( 'Registry address {} does not contain code'.format( address_encoder(registry_address), )) proxy = jsonrpc_client.new_abi_contract( CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY), address_encoder(registry_address), ) self.address = registry_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def __init__(self, jsonrpc_client, channel_address, startgas=GAS_LIMIT, gasprice=GAS_PRICE, poll_timeout=DEFAULT_POLL_TIMEOUT): # pylint: disable=too-many-arguments result = jsonrpc_client.call( 'eth_getCode', address_encoder(channel_address), 'latest', ) if result == '0x': raise AddressWithoutCode( 'Netting channel address {} does not contain code'.format( address_encoder(channel_address), )) proxy = jsonrpc_client.new_abi_contract( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), address_encoder(channel_address), ) self.address = channel_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout # check we are a participant of the given channel self.node_address = privatekey_to_address(self.client.privkey) self.detail(self.node_address)
def __init__(self, jsonrpc_client, manager_address, startgas, gasprice, poll_timeout=DEFAULT_POLL_TIMEOUT): # pylint: disable=too-many-arguments if not isaddress(manager_address): raise ValueError('manager_address must be a valid address') check_address_has_code(jsonrpc_client, manager_address, 'Channel Manager') proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), address_encoder(manager_address), ) self.address = manager_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def __init__( self, jsonrpc_client, manager_address, poll_timeout=DEFAULT_POLL_TIMEOUT, ): # pylint: disable=too-many-arguments if not isaddress(manager_address): raise InvalidAddress( 'Expected binary address format for token nework') check_address_has_code(jsonrpc_client, manager_address, 'Channel Manager') proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_TOKEN_NETWORK), address_encoder(manager_address), ) CONTRACT_MANAGER.check_contract_version( proxy.functions.contract_version().call(), CONTRACT_TOKEN_NETWORK) self.address = manager_address self.proxy = proxy self.client = jsonrpc_client self.node_address = privatekey_to_address(self.client.privkey) self.poll_timeout = poll_timeout # Prevents concurrent deposit, withdraw, close, or settle operations on the same channel self.channel_operations_lock = dict() self.open_channel_transactions = dict()
def create_registryproxy(tester_chain, tester_registry_address, log_listener): translator = tester.ContractTranslator(CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY)) tester_chain.head_state.log_listeners.append(log_listener) registry_abi = tester.ABIContract( tester_chain, translator, tester_registry_address, ) return registry_abi
def create_registryproxy(tester_state, tester_registry_address, log_listener): translator = tester.ContractTranslator(CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY)) registry_abi = tester.ABIContract( tester_state, translator, tester_registry_address, log_listener=log_listener, default_key=INVALID_KEY, ) return registry_abi
def create_tokenproxy(tester_chain, tester_token_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)) tester_chain.head_state.log_listeners.append(log_listener) token_abi = tester.ABIContract( tester_chain, translator, tester_token_address, ) return token_abi
def create_nettingchannel_proxy(tester_chain, tester_nettingchannel_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL) ) tester_chain.head_state.log_listeners.append(log_listener) netting_channel_abi = tester.ABIContract( tester_chain, translator, tester_nettingchannel_address, ) return netting_channel_abi
def create_tokenproxy(tester_state, tester_token_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)) token_abi = tester.ABIContract( tester_state, translator, tester_token_address, log_listener=log_listener, default_key=INVALID_KEY, ) return token_abi
def create_channelmanager_proxy(tester_chain, tester_channelmanager_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER) ) channel_manager_abi = tester.ABIContract( tester_chain, translator, tester_channelmanager_address, ) tester_chain.head_state.log_listeners.append(log_listener) return channel_manager_abi
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN), address)
def create_tokenproxy(tester_chain, tester_token_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN) ) tester_chain.head_state.log_listeners.append(log_listener) token_abi = tester.ABIContract( tester_chain, translator, tester_token_address, ) return token_abi
def create_channelmanager_proxy(tester_state, tester_channelmanager_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER)) channel_manager_abi = tester.ABIContract( tester_state, translator, tester_channelmanager_address, log_listener=log_listener, default_key=INVALID_KEY, ) return channel_manager_abi
def create_nettingchannel_proxy(tester_state, tester_nettingchannel_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL)) netting_channel_abi = tester.ABIContract( tester_state, translator, tester_nettingchannel_address, log_listener=log_listener, default_key=INVALID_KEY, ) return netting_channel_abi
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), address) self.participant_filter = defaultdict(list) self.address_filter = defaultdict(list)
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN), address )
def __init__(self, tester_state, private_key, address): if len(tester_state.block.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_state = tester_state self.private_key = private_key self.proxy = tester.ABIContract( tester_state, CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY), address, default_key=private_key, )
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.registry_proxy = tester.ABIContract( self.tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY), self.address) self.tokenadded_filters = list() self.address_to_channelmanager = dict() self.token_to_channelmanager = dict()
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), address ) self.participant_filter = defaultdict(list) self.address_filter = defaultdict(list)
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.registry_proxy = tester.ABIContract( self.tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY), self.address ) self.tokenadded_filters = list() self.address_to_channelmanager = dict() self.token_to_channelmanager = dict()
def __init__(self, jsonrpc_client, channel_address, poll_timeout=DEFAULT_POLL_TIMEOUT): self.address = channel_address self.client = jsonrpc_client self.poll_timeout = poll_timeout self.client = jsonrpc_client self.node_address = privatekey_to_address(self.client.privkey) self.proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), address_encoder(channel_address), ) # check we are a participant of the given channel self.detail() self._check_exists()
def __init__(self, jsonrpc_client, token_address, poll_timeout=DEFAULT_POLL_TIMEOUT): if not isaddress(token_address): raise ValueError('token_address must be a valid address') check_address_has_code(jsonrpc_client, token_address, 'Token') proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN), address_encoder(token_address), ) self.address = token_address self.proxy = proxy self.client = jsonrpc_client self.poll_timeout = poll_timeout
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), address) self.newbalance_filters = list() self.secretrevealed_filters = list() self.channelclose_filters = list() self.channelsettle_filters = list() # check we are a participant of the channel self.detail()
def __init__(self, jsonrpc_client, channel_address, poll_timeout=DEFAULT_POLL_TIMEOUT): self.address = channel_address self.client = jsonrpc_client self.poll_timeout = poll_timeout # Prevents concurrent deposit, close, or settle operations on the same channel self.channel_operations_lock = RLock() self.client = jsonrpc_client self.node_address = privatekey_to_address(self.client.privkey) self.proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), address_encoder(channel_address), ) # check we are a participant of the given channel self.detail() self._check_exists()
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL), address ) self.newbalance_filters = list() self.secretrevealed_filters = list() self.channelclose_filters = list() self.channelsettle_filters = list() # check we are a participant of the channel self.detail()
def __init__( self, jsonrpc_client, token_address, startgas, gasprice, poll_timeout=DEFAULT_POLL_TIMEOUT): if not isaddress(token_address): raise ValueError('token_address must be a valid address') check_address_has_code(jsonrpc_client, token_address, 'Token') proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN), address_encoder(token_address), ) self.address = token_address self.proxy = proxy self.client = jsonrpc_client self.startgas = startgas self.gasprice = gasprice self.poll_timeout = poll_timeout
def test_blockchain( blockchain_backend, # required to start the geth backend pylint: disable=unused-argument blockchain_rpc_ports, private_keys, poll_timeout): # pylint: disable=too-many-locals addresses = [ privatekey_to_address(priv) for priv in private_keys ] privatekey = private_keys[0] address = privatekey_to_address(privatekey) total_token = 100 host = '127.0.0.1' jsonrpc_client = JSONRPCClient( host, blockchain_rpc_ports[0], privatekey, ) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, list(), (total_token, 'raiden', 2, 'Rd'), contract_path=humantoken_path, gasprice=GAS_PRICE, timeout=poll_timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, list(), tuple(), contract_path=registry_path, gasprice=GAS_PRICE, timeout=poll_timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert not log_list assert token_proxy.call('balanceOf', address) == total_token transaction_hash = registry_proxy.transact( 'addToken', token_proxy.contract_address, gasprice=denoms.wei, ) jsonrpc_client.poll(unhexlify(transaction_hash), timeout=poll_timeout) assert len(registry_proxy.call('tokenAddresses')) == 1 log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_proxy.call( 'channelManagerByToken', token_proxy.contract_address, ) channel_manager_address = normalize_address(channel_manager_address_encoded) log = log_list[0] log_topics = [ topic_decoder(topic) for topic in log['topics'] # pylint: disable=invalid-sequence-index ] log_data = log['data'] # pylint: disable=invalid-sequence-index event = registry_proxy.translator.decode_event( log_topics, unhexlify(log_data[2:]), ) assert channel_manager_address == normalize_address(event['channel_manager_address']) assert token_proxy.contract_address == normalize_address(event['token_address']) channel_manager_proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), channel_manager_address, ) transaction_hash = channel_manager_proxy.transact( 'newChannel', addresses[1], 10, gasprice=denoms.wei, ) jsonrpc_client.poll(unhexlify(transaction_hash), timeout=poll_timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2
def registry_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY)
def token_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
def channel_manager_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER)
def test_blockchain( blockchain_type, blockchain_backend, # required to start the geth backend blockchain_rpc_ports, private_keys, poll_timeout): # pylint: disable=too-many-locals # this test is for interaction with a blockchain using json-rpc, so it # doesnt make sense to execute it against tester if blockchain_type not in ('geth', ): return addresses = [privatekey_to_address(priv) for priv in private_keys] privatekey = private_keys[0] address = privatekey_to_address(privatekey) total_token = 100 jsonrpc_client = JSONRPCClient( port=blockchain_rpc_ports[0], privkey=privatekey, print_communication=False, ) patch_send_transaction(jsonrpc_client) patch_send_message(jsonrpc_client) humantoken_path = get_contract_path('HumanStandardToken.sol') humantoken_contracts = compile_file(humantoken_path, libraries=dict()) token_proxy = jsonrpc_client.deploy_solidity_contract( address, 'HumanStandardToken', humantoken_contracts, dict(), (total_token, 'raiden', 2, 'Rd'), contract_path=humantoken_path, gasprice=default_gasprice, timeout=poll_timeout, ) registry_path = get_contract_path('Registry.sol') registry_contracts = compile_file(registry_path) registry_proxy = jsonrpc_client.deploy_solidity_contract( address, 'Registry', registry_contracts, dict(), tuple(), contract_path=registry_path, gasprice=default_gasprice, timeout=poll_timeout, ) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 0 # pylint: disable=no-member assert token_proxy.balanceOf(address) == total_token transaction_hash = registry_proxy.addToken.transact( token_proxy.address, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) assert len(registry_proxy.tokenAddresses.call()) == 1 log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 1 channel_manager_address_encoded = registry_proxy.channelManagerByToken.call( token_proxy.address, ) channel_manager_address = channel_manager_address_encoded.decode('hex') log = log_list[0] log_topics = [ decode_topic(topic) for topic in log['topics'] # pylint: disable=invalid-sequence-index ] log_data = log['data'] event = registry_proxy.translator.decode_event( log_topics, log_data[2:].decode('hex'), ) assert channel_manager_address == event['channel_manager_address'].decode( 'hex') assert token_proxy.address == event['token_address'].decode('hex') channel_manager_proxy = jsonrpc_client.new_contract_proxy( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), channel_manager_address, ) transaction_hash = channel_manager_proxy.newChannel.transact( addresses[1], 10, gasprice=denoms.wei, ) jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout) log_list = jsonrpc_client.call( 'eth_getLogs', { 'fromBlock': '0x0', 'toBlock': 'latest', 'topics': [], }, ) assert len(log_list) == 2
def netting_channel_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL)