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, manager_address, poll_timeout=DEFAULT_POLL_TIMEOUT, ): # pylint: disable=too-many-arguments contract = jsonrpc_client.new_contract( CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER), to_normalized_address(manager_address), ) self.proxy = ContractProxy(jsonrpc_client, contract) if not is_binary_address(manager_address): raise ValueError('manager_address must be a valid address') check_address_has_code(jsonrpc_client, manager_address, 'Channel Manager') CONTRACT_MANAGER.check_contract_version( self.version(), CONTRACT_CHANNEL_MANAGER, ) self.address = manager_address self.client = jsonrpc_client self.poll_timeout = poll_timeout self.open_channel_transactions = dict()
def test_deploy_contract(raiden_network, deploy_client, tmpdir): """Test deploying contract with different version than the one we have set in Registry.sol. This test makes sense only for geth backend, tester uses mocked Registry class. """ contract_path = get_contract_path('Registry.sol') # Create temporary directory to put all files required to compile the changed contract to. # Why? Solidity uses first 40 characters of the file path as a library symbol. # It would be nice to just do a copy of 'Registry.sol', replace version and include statements # and then by path substitution argument of solc set the path to something like # raiden-contracts=/path/to/your/raiden/source/contracts. But then if the path is too long, # Python solidity compiler will fail because of duplicate library symbol. temp_dir = TempSolidityDir(os.path.dirname(contract_path), tmpdir) replaced_registry_path = os.path.join(temp_dir.name, 'Registry.sol') CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER) replace_contract_version(replaced_registry_path, '0.0.31415') contracts = compile_files_cwd([replaced_registry_path]) contract_proxy = deploy_client.deploy_solidity_contract( 'Registry', contracts, dict(), None, contract_path=replaced_registry_path, ) contract_address = contract_proxy.contract_address app0 = raiden_network[0] with pytest.raises(ContractVersionMismatch): app0.raiden.chain.registry(contract_address)
def __init__( self, jsonrpc_client, discovery_address, poll_timeout=DEFAULT_POLL_TIMEOUT, ): contract = jsonrpc_client.new_contract( CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY), to_normalized_address(discovery_address), ) self.proxy = ContractProxy(jsonrpc_client, contract) if not is_binary_address(discovery_address): raise ValueError('discovery_address must be a valid address') check_address_has_code(jsonrpc_client, discovery_address, 'Discovery') CONTRACT_MANAGER.check_contract_version( self.version(), CONTRACT_ENDPOINT_REGISTRY, ) self.address = discovery_address self.client = jsonrpc_client self.poll_timeout = poll_timeout self.not_found_address = NULL_ADDRESS
def __init__( self, jsonrpc_client, manager_address, 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_contract_abi(CONTRACT_CHANNEL_MANAGER), address_encoder(manager_address), ) CONTRACT_MANAGER.check_contract_version( proxy.call('contract_version').decode(), CONTRACT_CHANNEL_MANAGER ) self.address = manager_address self.proxy = proxy self.client = jsonrpc_client self.poll_timeout = poll_timeout self.open_channel_transactions = dict()
def __init__( self, jsonrpc_client, registry_address, poll_timeout=DEFAULT_POLL_TIMEOUT, ): # pylint: disable=too-many-arguments contract = jsonrpc_client.new_contract( CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY), address_encoder(registry_address), ) self.proxy = ContractProxy(jsonrpc_client, contract) if not is_binary_address(registry_address): raise ValueError('registry_address must be a valid address') check_address_has_code(jsonrpc_client, registry_address, 'Registry') CONTRACT_MANAGER.check_contract_version( self.proxy.contract.functions.contract_version().call(), CONTRACT_REGISTRY ) self.address = registry_address self.client = jsonrpc_client self.poll_timeout = poll_timeout self.node_address = privatekey_to_address(self.client.privkey) self.address_to_channelmanager = dict() self.token_to_channelmanager = dict()
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 __init__( self, jsonrpc_client, channel_address, poll_timeout=DEFAULT_POLL_TIMEOUT, ): contract = jsonrpc_client.new_contract( CONTRACT_MANAGER.get_contract_abi(CONTRACT_NETTING_CHANNEL), to_normalized_address(channel_address), ) self.proxy = ContractProxy(jsonrpc_client, contract) 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) CONTRACT_MANAGER.check_contract_version( self.proxy.contract.functions.contract_version().call(), CONTRACT_NETTING_CHANNEL, ) # check we are a participant of the given channel self.detail() self._check_exists()
def test_nettingchannel_settle_timeout_inrange(private_keys, tester_channelmanager, tester_state): """ 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] log_listener = None 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_state, CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL), netting_channel_address0_hex, log_listener=log_listener, default_key=INVALID_KEY, ) # pylint: disable=no-member assert netting_channel.settleTimeout(sender=pkey0) == minimum_settle_timeout netting_channel2 = tester.ABIContract( tester_state, CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL), netting_channel_address1_hex, log_listener=log_listener, default_key=INVALID_KEY, ) assert netting_channel2.settleTimeout(sender=pkey0) == max_settle_timeout
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 __init__( self, jsonrpc_client, discovery_address, ): contract = jsonrpc_client.new_contract( CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY), to_normalized_address(discovery_address), ) proxy = ContractProxy(jsonrpc_client, contract) if not is_binary_address(discovery_address): raise ValueError('discovery_address must be a valid address') check_address_has_code(jsonrpc_client, discovery_address, 'Discovery') is_valid_version = compare_versions( proxy.contract.functions.contract_version().call(), EXPECTED_CONTRACTS_VERSION, ) if not is_valid_version: raise ContractVersionMismatch('Incompatible ABI for Discovery') self.address = discovery_address self.client = jsonrpc_client self.not_found_address = NULL_ADDRESS self.proxy = proxy
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) 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, 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 channelnew_filter(self, from_block: Union[str, int] = 0, to_block: Union[str, int] = 'latest') -> Filter: """ Install a new filter for ChannelNew events. Args: start_block:Create filter starting from this block number (default: 0). end_block: Create filter stopping at this block number (default: 'latest'). Return: The filter instance. """ topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW)] channel_manager_address_bin = self.proxy.contract_address filter_id_raw = new_filter(self.client, channel_manager_address_bin, topics, from_block=from_block, to_block=to_block) return Filter( self.client, filter_id_raw, )
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 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, 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, 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 tokenadded_filter(self, **kwargs): """May also receive from_block, to_block but they are not used here""" topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)] filter_ = FilterTesterMock(self.tester_chain, self.address, topics, next(FILTER_ID_GENERATOR)) self.tester_chain.head_state.log_listeners.append(filter_.event) return filter_
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, 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=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 channelnew_filter(self, from_block: Union[str, int] = 0, to_block: Union[str, int] = 'latest'): topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW)] filter_ = FilterTesterMock(self.tester_chain, self.address, topics, next(FILTER_ID_GENERATOR)) self.tester_chain.head_state.log_listeners.append(filter_.event) return filter_
def add_netting_channel_listener(self, netting_channel_proxy): channel_address = netting_channel_proxy.address netting_channel_events = netting_channel_proxy.all_events_filter() self.add_event_listener( 'NettingChannel Event {}'.format(pex(channel_address)), netting_channel_events, CONTRACT_MANAGER.get_translator('netting_channel'), )
def add_channel_manager_listener(self, channel_manager_proxy): channelnew = channel_manager_proxy.channelnew_filter() manager_address = channel_manager_proxy.address self.add_event_listener( 'ChannelManager {}'.format(pex(manager_address)), channelnew, CONTRACT_MANAGER.get_translator('channel_manager'), )
def add_registry_listener(self, registry_proxy): tokenadded = registry_proxy.tokenadded_filter() registry_address = registry_proxy.address self.add_event_listener( 'Registry {}'.format(pex(registry_address)), tokenadded, CONTRACT_MANAGER.get_translator(CONTRACT_REGISTRY), )
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 secret_registered_filter(self, from_block=None, to_block=None) -> Filter: topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SECRET_REVEALED)] return self.client.new_filter( self.address, topics=topics, from_block=from_block, to_block=to_block, )
def add_registry_listener(self, registry_proxy): tokenadded = registry_proxy.tokenadded_filter() registry_address = registry_proxy.address self.add_event_listener( 'Registry {}'.format(pex(registry_address)), tokenadded, CONTRACT_MANAGER.get_translator(CONTRACT_REGISTRY), registry_proxy.tokenadded_filter, )
def add_channel_manager_listener(self, channel_manager_proxy): channelnew = channel_manager_proxy.channelnew_filter() manager_address = channel_manager_proxy.address self.add_event_listener( 'ChannelManager {}'.format(pex(manager_address)), channelnew, CONTRACT_MANAGER.get_translator('channel_manager'), channel_manager_proxy.channelnew_filter, )
def add_netting_channel_listener(self, netting_channel_proxy): netting_channel_events = netting_channel_proxy.all_events_filter() channel_address = netting_channel_proxy.address self.add_event_listener( 'NettingChannel Event {}'.format(pex(channel_address)), netting_channel_events, CONTRACT_MANAGER.get_translator('netting_channel'), netting_channel_proxy.all_events_filter, )
def tokenadded_filter(self, from_block=None, to_block=None) -> Filter: topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)] registry_address_bin = self.proxy.contract_address return self.client.new_filter( registry_address_bin, topics=topics, from_block=from_block, to_block=to_block, )
def channelnew_filter(self): topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW)] filter_ = FilterTesterMock( self.tester_chain, self.address, topics, next(FILTER_ID_GENERATOR) ) self.tester_chain.head_state.log_listeners.append(filter_.event) return filter_
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_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 tokenadded_filter(self, **kwargs): """May also receive from_block, to_block but they are not used here""" topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)] filter_ = FilterTesterMock( self.tester_chain, self.address, topics, next(FILTER_ID_GENERATOR) ) self.tester_chain.head_state.log_listeners.append(filter_.event) return filter_
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 __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_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 tokenadded_filter(self, from_block=None, to_block=None): topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)] registry_address_bin = self.proxy.contract_address filter_id_raw = new_filter( self.client, registry_address_bin, topics, from_block=from_block, to_block=to_block, ) return Filter( self.client, filter_id_raw, )
def netting_channel_events( rpc: JSONRPCClient, netting_channel: NettingChannel, end_block: Union[str, int] = 'latest') -> List[Dict]: """Get all events for a netting_channel starting from its `opened()` block. Args: rpc: client instance. netting_channel: the NettingChannel instance. end_block: read event-logs up to this block number (default: 'latest'). """ return all_contract_events( rpc, netting_channel.address, CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL), start_block=netting_channel.opened(), end_block=end_block )
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 get_all_registry_events( chain, registry_address, events=ALL_EVENTS, from_block=0, to_block='latest'): """ Helper to get all events of the Registry contract at `registry_address`. """ return get_contract_events( chain, CONTRACT_MANAGER.get_translator(CONTRACT_REGISTRY), registry_address, events, from_block, to_block, )
def get_all_netting_channel_events( chain, netting_channel_address, events=ALL_EVENTS, from_block=0, to_block='latest'): """ Helper to get all events of a NettingChannelContract at `netting_channel_address`. """ return get_contract_events( chain, CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL), netting_channel_address, events, from_block, to_block, )
def get_all_channel_manager_events( chain, channel_manager_address, events=ALL_EVENTS, from_block=0, to_block='latest'): """ Helper to get all events of the ChannelManagerContract at `token_address`. """ return get_contract_events( chain, CONTRACT_MANAGER.get_translator(CONTRACT_CHANNEL_MANAGER), channel_manager_address, events, from_block, to_block, )
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 registry_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY)
def netting_channel_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL)
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 token_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
def channel_manager_abi(): return CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER)
def run(self): os.environ['STORE_PRECOMPILED'] = 'yes' from raiden.blockchain.abi import CONTRACT_MANAGER CONTRACT_MANAGER.instantiate()
def test_query_events(raiden_chain, deposit, settle_timeout, events_poll_timeout): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking token_address = app0.raiden.default_registry.token_addresses()[0] assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 0 assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 0 token0 = app0.raiden.chain.token(token_address) manager0 = app0.raiden.default_registry.manager_by_token(token_address) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert event_dicts_are_equal(events[0], { '_event_type': b'TokenAdded', 'channel_manager_address': address_encoder(manager0.address), 'token_address': address_encoder(token_address), 'block_number': 'ignore', }) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events netcontract_address = manager0.new_netting_channel( app1.raiden.address, settle_timeout, ) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert event_dicts_are_equal(events[0], { '_event_type': b'ChannelNew', 'settle_timeout': settle_timeout, 'netting_channel': address_encoder(netcontract_address), 'participant1': address_encoder(app0.raiden.address), 'participant2': address_encoder(app1.raiden.address), 'block_number': 'ignore', }) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events netting_channel0 = app0.raiden.chain.netting_channel(netcontract_address) gevent.sleep(events_poll_timeout * 2) # channel is created but not opened and without funds assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 1 assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 1 channel0 = list(app0.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501 channel1 = list(app1.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501 assert_synched_channels( channel0, 0, [], channel1, 0, [], ) token0.approve(netcontract_address, deposit) netting_channel0.deposit(deposit) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)], ) assert len(all_netting_channel_events) == 1 assert len(events) == 1 new_balance_event = { '_event_type': b'ChannelNewBalance', 'token_address': address_encoder(token_address), 'participant': address_encoder(app0.raiden.address), 'balance': deposit, 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], new_balance_event) assert event_dicts_are_equal(events[0], new_balance_event) channel0.external_state.close(None) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)], ) assert len(all_netting_channel_events) == 2 assert len(events) == 1 closed_event = { '_event_type': b'ChannelClosed', 'closing_address': address_encoder(app0.raiden.address), 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], closed_event) assert event_dicts_are_equal(events[0], closed_event) settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 1 wait_until_block(app0.raiden.chain, settle_expiration) channel1.external_state.settle() all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)], ) assert len(all_netting_channel_events) == 3 assert len(events) == 1 settled_event = { '_event_type': b'ChannelSettled', 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], settled_event) assert event_dicts_are_equal(events[0], settled_event)