def test_token( deploy_client, token_proxy, private_keys, blockchain_rpc_ports, web3, ): privkey = private_keys[1] address = privatekey_to_address(privkey) address = to_canonical_address(address) other_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], privkey, web3=web3, ) other_token_proxy = Token( other_client, to_canonical_address(token_proxy.proxy.contract.address), ) # send some funds from deployer to generated address transfer_funds = 100 token_proxy.transfer(address, transfer_funds) assert transfer_funds == token_proxy.balance_of(address) allow_funds = 100 token_proxy.approve(address, allow_funds) assert allow_funds == token_proxy.proxy.contract.functions.allowance( to_checksum_address(deploy_client.sender), to_checksum_address(address), ).call() other_token_proxy.transfer(deploy_client.sender, transfer_funds) assert token_proxy.balance_of(address) == 0
def replay_wal(storage, token_network_identifier, partner_address, translator=None): all_state_changes = storage.get_statechanges_by_identifier( from_identifier=0, to_identifier='latest', ) state_manager = StateManager(state_transition=node.state_transition, current_state=None) wal = WriteAheadLog(state_manager, storage) for _, state_change in enumerate(all_state_changes): events = wal.state_manager.dispatch(state_change) chain_state = wal.state_manager.current_state channel_state = views.get_channelstate_by_token_network_and_partner( chain_state, to_canonical_address(token_network_identifier), to_canonical_address(partner_address), ) if not channel_state: continue ### # Customize this to filter things further somewhere around here. # An example would be to add `import pdb; pdb.set_trace()` # and inspect the state. ### print_state_change(state_change, translator=translator) print_events(events, translator=translator)
def test_token( deploy_client, token_proxy, private_keys, web3, contract_manager, ): privkey = private_keys[1] address = privatekey_to_address(privkey) address = to_canonical_address(address) other_client = JSONRPCClient(web3, privkey) other_token_proxy = Token( jsonrpc_client=other_client, token_address=to_canonical_address(token_proxy.proxy.contract.address), contract_manager=contract_manager, ) # send some funds from deployer to generated address transfer_funds = 100 token_proxy.transfer(address, transfer_funds) assert transfer_funds == token_proxy.balance_of(address) allow_funds = 100 token_proxy.approve(address, allow_funds) assert allow_funds == token_proxy.proxy.contract.functions.allowance( to_checksum_address(deploy_client.address), to_checksum_address(address), ).call(block_identifier='latest') other_token_proxy.transfer(deploy_client.address, transfer_funds) assert token_proxy.balance_of(address) == 0
def from_dict(cls, data: Dict[str, Any]) -> 'ContractReceiveChannelClosed': return cls( transaction_hash=deserialize_bytes(data['transaction_hash']), transaction_from=to_canonical_address(data['transaction_from']), token_network_identifier=to_canonical_address(data['token_network_identifier']), channel_identifier=ChannelID(int(data['channel_identifier'])), block_number=BlockNumber(int(data['block_number'])), )
def from_dict(cls, data: Dict[str, Any]) -> 'ContractSendChannelBatchUnlock': restored = cls( token_address=to_canonical_address(data['token_address']), token_network_identifier=to_canonical_address(data['token_network_identifier']), channel_identifier=ChannelID(int(data['channel_identifier'])), participant=to_canonical_address(data['participant']), ) return restored
def from_dict(cls, data: Dict[str, Any]) -> 'ContractSendChannelClose': restored = cls( channel_identifier=ChannelID(int(data['channel_identifier'])), token_address=to_canonical_address(data['token_address']), token_network_identifier=to_canonical_address(data['token_network_identifier']), balance_proof=data['balance_proof'], ) return restored
def from_dict(cls, data: Dict[str, Any]) -> 'ContractReceiveRouteNew': return cls( transaction_hash=deserialize_bytes(data['transaction_hash']), token_network_identifier=to_canonical_address(data['token_network_identifier']), channel_identifier=ChannelID(int(data['channel_identifier'])), participant1=to_canonical_address(data['participant1']), participant2=to_canonical_address(data['participant2']), block_number=BlockNumber(int(data['block_number'])), )
def run_smoketests(raiden_service: RaidenService, test_config: Dict, debug: bool = False): """ Test that the assembled raiden_service correctly reflects the configuration from the smoketest_genesis. """ try: chain = raiden_service.chain assert ( raiden_service.default_registry.address == to_canonical_address(test_config['contracts']['registry_address']) ) assert ( raiden_service.default_secret_registry.address == to_canonical_address(test_config['contracts']['secret_registry_address']) ) token_network_added_events = raiden_service.default_registry.filter_token_added_events() token_addresses = [event['args']['token_address'] for event in token_network_added_events] assert token_addresses == [test_config['contracts']['token_address']] if test_config.get('transport') == 'udp': assert len(chain.address_to_discovery.keys()) == 1, repr(chain.address_to_discovery) assert ( list(chain.address_to_discovery.keys())[0] == to_canonical_address(test_config['contracts']['discovery_address']) ) discovery = list(chain.address_to_discovery.values())[0] assert discovery.endpoint_by_address(raiden_service.address) != TEST_ENDPOINT token_networks = views.get_token_network_addresses_for( views.state_from_raiden(raiden_service), raiden_service.default_registry.address, ) assert len(token_networks) == 1 channel_state = views.get_channelstate_for( views.state_from_raiden(raiden_service), raiden_service.default_registry.address, token_networks[0], unhexlify(TEST_PARTNER_ADDRESS), ) distributable = channel.get_distributable( channel_state.our_state, channel_state.partner_state, ) assert distributable == TEST_DEPOSIT_AMOUNT assert distributable == channel_state.our_state.contract_balance assert channel.get_status(channel_state) == CHANNEL_STATE_OPENED # Run API test run_restapi_smoketests() except Exception: error = traceback.format_exc() if debug: import pdb pdb.post_mortem() return error
def test_serialization_participants_tuple(): participants = ( to_canonical_address('0x5522070585a1a275631ba69c444ac0451AA9Fe4C'), to_canonical_address('0xEF4f7c9962d8bAa8E268B72EC6DD4BDf09C84397'), ) data = serialization.serialize_participants_tuple(participants) restored = serialization.deserialize_participants_tuple(data) assert participants == restored
def from_dict(cls, data: Dict[str, Any]) -> 'EventPaymentSentFailed': restored = cls( payment_network_identifier=to_canonical_address(data['payment_network_identifier']), token_network_identifier=to_canonical_address(data['token_network_identifier']), identifier=int(data['identifier']), target=to_canonical_address(data['target']), reason=data['reason'], ) return restored
def from_dict(cls, data: Dict[str, Any]) -> 'EventPaymentReceivedSuccess': restored = cls( payment_network_identifier=to_canonical_address(data['payment_network_identifier']), token_network_identifier=to_canonical_address(data['token_network_identifier']), identifier=int(data['identifier']), amount=int(data['amount']), initiator=to_canonical_address(data['initiator']), ) return restored
def normalize_exec(exec_params): return { 'origin': to_canonical_address(exec_params['origin']), 'address': to_canonical_address(exec_params['address']), 'caller': to_canonical_address(exec_params['caller']), 'value': to_int(exec_params['value']), 'data': decode_hex(exec_params['data']), 'gas': to_int(exec_params['gas']), 'gasPrice': to_int(exec_params['gasPrice']), }
def from_dict(cls, data: typing.Dict[str, typing.Any]) -> 'LockedTransferUnsignedState': restored = cls( payment_identifier=int(data['payment_identifier']), token=to_canonical_address(data['token']), balance_proof=data['balance_proof'], lock=data['lock'], initiator=to_canonical_address(data['initiator']), target=to_canonical_address(data['target']), ) return restored
def from_dict(cls, data: Dict[str, Any]) -> 'ContractReceiveChannelBatchUnlock': return cls( transaction_hash=deserialize_bytes(data['transaction_hash']), token_network_identifier=to_canonical_address(data['token_network_identifier']), participant=to_canonical_address(data['participant']), partner=to_canonical_address(data['partner']), locksroot=deserialize_bytes(data['locksroot']), unlocked_amount=int(data['unlocked_amount']), returned_tokens=int(data['returned_tokens']), block_number=BlockNumber(int(data['block_number'])), )
def from_dict(cls, data: Dict[str, Any]) -> 'SendBalanceProof': restored = cls( recipient=to_canonical_address(data['recipient']), channel_identifier=ChannelID(int(data['channel_identifier'])), message_identifier=MessageID(int(data['message_identifier'])), payment_identifier=PaymentID(int(data['payment_identifier'])), token_address=to_canonical_address(data['token_address']), secret=Secret(serialization.deserialize_bytes(data['secret'])), balance_proof=data['balance_proof'], ) return restored
def from_dict(cls, data: typing.Dict[str, typing.Any]) -> 'TransferDescriptionWithSecretState': restored = cls( payment_network_identifier=to_canonical_address(data['payment_network_identifier']), payment_identifier=int(data['payment_identifier']), amount=int(data['amount']), token_network_identifier=to_canonical_address(data['token_network_identifier']), initiator=to_canonical_address(data['initiator']), target=to_canonical_address(data['target']), secret=serialization.deserialize_bytes(data['secret']), ) return restored
def test_serialization_networkx_graph(): p1 = to_canonical_address('0x5522070585a1a275631ba69c444ac0451AA9Fe4C') p2 = to_canonical_address('0x5522070585a1a275631ba69c444ac0451AA9Fe4D') p3 = to_canonical_address('0x5522070585a1a275631ba69c444ac0451AA9Fe4E') p4 = to_canonical_address('0x5522070585a1a275631ba69c444ac0451AA9Fe4F') e = [(p1, p2), (p2, p3), (p3, p4)] graph = Graph(e) data = serialization.serialize_networkx_graph(graph) restored_graph = serialization.deserialize_networkx_graph(data) assert graph.edges == restored_graph.edges
def test_encode_address(address_value, value_bit_size, data_byte_size): if value_bit_size != 20 * 8: with pytest.raises(ValueError): AddressEncoder( value_bit_size=value_bit_size, data_byte_size=data_byte_size, ) return elif value_bit_size > data_byte_size * 8: with pytest.raises(ValueError): AddressEncoder( value_bit_size=value_bit_size, data_byte_size=data_byte_size, ) return encoder = AddressEncoder( value_bit_size=value_bit_size, data_byte_size=data_byte_size, ) if not is_address(address_value): with pytest.raises(EncodingTypeError) as exception_info: encoder(address_value) assert 'AddressEncoder' in str(exception_info.value) return expected_value = zpad(to_canonical_address(address_value), data_byte_size) encoded_value = encoder(address_value) assert encoded_value == expected_value
def send_transaction( self, to: Address, value: int = 0, data: bytes = b'', startgas: int = None, gasprice: int = None, ): """ Helper to send signed messages. This method will use the `privkey` provided in the constructor to locally sign the transaction. This requires an extended server implementation that accepts the variables v, r, and s. """ if to == to_canonical_address(NULL_ADDRESS): warnings.warn('For contract creation the empty string must be used.') transaction = dict( nonce=self.nonce(), gasPrice=gasprice or self.gasprice(), gas=self.check_startgas(startgas), value=value, data=data, ) # add the to address if not deploying a contract if to != b'': transaction['to'] = to_checksum_address(to) signed_txn = self.web3.eth.account.signTransaction(transaction, self.privkey) result = self.web3.eth.sendRawTransaction(signed_txn.rawTransaction) encoded_result = encode_hex(result) return remove_0x_prefix(encoded_result)
def poll_blockchain_events(self, block_number: int = None): # When we test with geth if the contracts have already been deployed # before the filter creation we need to use `get_all_entries` to make # sure we get all the events. With tester this is not required. for event_listener in self.event_listeners: if isinstance(event_listener.filter, StatelessFilter): events = event_listener.filter.get_new_entries(block_number) elif event_listener.first_run is True: events = event_listener.filter.get_all_entries() index = self.event_listeners.index(event_listener) self.event_listeners[index] = event_listener._replace(first_run=False) else: events = event_listener.filter.get_new_entries() for log_event in events: decoded_event = dict(decode_event( event_listener.abi, log_event, )) if decoded_event is not None: decoded_event['block_number'] = log_event.get('blockNumber', 0) event = Event( to_canonical_address(log_event['address']), decoded_event, ) yield decode_event_to_internal(event)
def state_change_with_nonce(obj, nonce, channel_identifier, sender): return ( hasattr(obj, 'balance_proof') and obj.balance_proof.nonce == nonce and obj.balance_proof.channel_identifier == channel_identifier and obj.balance_proof.sender == to_canonical_address(sender) )
def from_dict(cls, data) -> 'ReceiveSecretReveal': instance = cls( secret=deserialize_bytes(data['secret']), sender=to_canonical_address(data['sender']), ) instance.secrethash = deserialize_bytes(data['secrethash']) return instance
def from_dict(cls, data: Dict[str, Any]) -> 'ContractReceiveNewTokenNetwork': return cls( transaction_hash=deserialize_bytes(data['transaction_hash']), payment_network_identifier=to_canonical_address(data['payment_network_identifier']), token_network=data['token_network'], block_number=BlockNumber(int(data['block_number'])), )
def transform_records(log_records: Iterable[Record], replacements: Dict[str, Any]): def replace(value): # Use `type(value)()` construction to preserve exact (sub-)type if isinstance(value, tuple) and hasattr(value, '_fields'): # namedtuples have a different signature, *sigh* return type(value)(*[replace(inner) for inner in value]) if isinstance(value, (list, tuple)): return type(value)(replace(inner) for inner in value) elif isinstance(value, dict): return { replace(k): replace(v) for k, v in value.items() } str_value = str(value).lower() if isinstance(value, str): keys_in_value = [key for key in replacement_keys if key in str_value] for key in keys_in_value: try: repl_start = str_value.index(key) except ValueError: # Value no longer in string due to replacement continue value = f"{value[:repl_start]}{replacements[key]}{value[repl_start + len(key):]}" str_value = value.lower() return replacements.get(str_value, value) replacements = {str(k).lower(): v for k, v in replacements.items()} for k, v in copy(replacements).items(): # Special handling for `pex()`ed eth addresses if isinstance(k, str) and k.startswith('0x') and is_address(k): replacements[pex(to_canonical_address(k))] = v replacement_keys = replacements.keys() for record in log_records: yield replace(record)
def from_dict(cls, data): assert data['type'] == cls.__name__ expired_lock = cls( chain_id=data['chain_id'], nonce=data['nonce'], message_identifier=data['message_identifier'], token_network_address=to_canonical_address(data['token_network_address']), channel_identifier=data['channel_identifier'], transferred_amount=data['transferred_amount'], secrethash=decode_hex(data['secrethash']), recipient=to_canonical_address(data['recipient']), locked_amount=data['locked_amount'], locksroot=decode_hex(data['locksroot']), ) expired_lock.signature = decode_hex(data['signature']) return expired_lock
def address_by_endpoint(self, endpoint): address = self.proxy.contract.functions.findAddressByEndpoint(endpoint).call() if address == self.not_found_address: # the 0 address means nothing found return None return to_canonical_address(address)
def normalize_block_header(header): normalized_header = { 'bloom': big_endian_to_int(decode_hex(header['bloom'])), 'coinbase': to_canonical_address(header['coinbase']), 'difficulty': to_int(header['difficulty']), 'extraData': decode_hex(header['extraData']), 'gasLimit': to_int(header['gasLimit']), 'gasUsed': to_int(header['gasUsed']), 'hash': decode_hex(header['hash']), 'mixHash': decode_hex(header['mixHash']), 'nonce': decode_hex(header['nonce']), 'number': to_int(header['number']), 'parentHash': decode_hex(header['parentHash']), 'receiptTrie': decode_hex(header['receiptTrie']), 'stateRoot': decode_hex(header['stateRoot']), 'timestamp': to_int(header['timestamp']), 'transactionsTrie': decode_hex(header['transactionsTrie']), 'uncleHash': decode_hex(header['uncleHash']), } if 'blocknumber' in header: normalized_header['blocknumber'] = to_int(header['blocknumber']) if 'chainname' in header: normalized_header['chainname'] = header['chainname'] if 'chainnetwork' in header: normalized_header['chainnetwork'] = header['chainnetwork'] return normalized_header
def from_dict(cls, data: Dict[str, Any]) -> 'ContractSendChannelSettle': restored = cls( channel_identifier=ChannelID(int(data['channel_identifier'])), token_network_identifier=to_canonical_address(data['token_network_identifier']), ) return restored
def decode_event_to_internal(event): """ Enforce the binary encoding of address for internal usage. """ data = event.event_data if data['args'].get('channel_identifier'): data['channel_identifier'] = data['args'].get('channel_identifier') # Note: All addresses inside the event_data must be decoded. if data['event'] == EVENT_TOKEN_NETWORK_CREATED: data['token_network_address'] = to_canonical_address(data['args']['token_network_address']) data['token_address'] = to_canonical_address(data['args']['token_address']) elif data['event'] == EVENT_CHANNEL_OPENED: data['participant1'] = to_canonical_address(data['args']['participant1']) data['participant2'] = to_canonical_address(data['args']['participant2']) data['settle_timeout'] = data['args']['settle_timeout'] elif data['event'] == EVENT_CHANNEL_DEPOSIT: data['deposit'] = data['args']['total_deposit'] data['participant'] = to_canonical_address(data['args']['participant']) elif data['event'] == EVENT_CHANNEL_WITHDRAW: data['withdrawn_amount'] = data['args']['withdrawn_amount'] data['participant'] = to_canonical_address(data['args']['participant']) elif data['event'] == EVENT_CHANNEL_BALANCE_PROOF_UPDATED: data['closing_participant'] = to_canonical_address(data['args']['closing_participant']) elif data['event'] == EVENT_CHANNEL_CLOSED: data['closing_participant'] = to_canonical_address(data['args']['closing_participant']) elif data['event'] == EVENT_CHANNEL_SETTLED: data['participant1_amount'] = data['args']['participant1_amount'] data['participant2_amount'] = data['args']['participant2_amount'] elif data['event'] == EVENT_CHANNEL_UNLOCKED: data['unlocked_amount'] = data['args']['unlocked_amount'] data['returned_tokens'] = data['args']['returned_tokens'] data['participant'] = to_canonical_address(data['args']['participant']) data['partner'] = to_canonical_address(data['args']['partner']) data['locksroot'] = data['args']['locksroot'] elif data['event'] == EVENT_SECRET_REVEALED: data['secrethash'] = data['args']['secrethash'] data['secret'] = data['args']['secret'] return event
def from_dict(cls, data): assert data['type'] == cls.__name__ direct_transfer = cls( chain_id=data['chain_id'], message_identifier=data['message_identifier'], payment_identifier=data['payment_identifier'], nonce=data['nonce'], token_network_address=to_canonical_address(data['token_network_address']), token=to_canonical_address(data['token']), channel_identifier=decode_hex(data['channel']), transferred_amount=data['transferred_amount'], recipient=to_canonical_address(data['recipient']), locked_amount=data['locked_amount'], locksroot=decode_hex(data['locksroot']), ) direct_transfer.signature = decode_hex(data['signature']) return direct_transfer
def chain(): """ Return a Chain object containing just the genesis block. The Chain's state includes one funded account, which can be found in the funded_address in the chain itself. This Chain will perform all validations when importing new blocks, so only valid and finalized blocks can be used with it. If you want to test importing arbitrarily constructe, not finalized blocks, use the chain_without_block_validation fixture instead. """ genesis_params = { "bloom": 0, "coinbase": to_canonical_address("8888f1f195afa192cfee860698584c030f4c9db1"), "difficulty": 131072, "extra_data": b"B", "gas_limit": 3141592, "gas_used": 0, "mix_hash": decode_hex( "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ), "nonce": decode_hex("0102030405060708"), "block_number": 0, "parent_hash": decode_hex( "0000000000000000000000000000000000000000000000000000000000000000" ), "receipt_root": decode_hex( "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ), "state_root": decode_hex( "cafd881ab193703b83816c49ff6c2bf6ba6f464a1be560c42106128c8dbc35e7" ), "timestamp": 1422494849, "transaction_root": decode_hex( "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ), "uncles_hash": decode_hex( "1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347") } funded_addr = to_canonical_address( "a94f5374fce5edbc8e2a8697c15331677e6ebf0b") initial_balance = 10000000000 genesis_state = { funded_addr: { "balance": initial_balance, "nonce": 0, "code": b"", "storage": {} } } klass = Chain.configure(name='TestChain', vm_configuration=((constants.GENESIS_BLOCK_NUMBER, FrontierVM), )) chain = klass.from_genesis(BaseChainDB(get_db_backend()), genesis_params, genesis_state) chain.funded_address = funded_addr chain.funded_address_initial_balance = initial_balance return chain
def from_dict(cls, data) -> 'ActionNewTokenNetwork': return cls( payment_network_identifier=to_canonical_address(data['payment_network_identifier']), token_network=data['token_network'], )
ROPSTEN = 'ropsten' RINKEBY = 'rinkeby' KOVAN = 'kovan' SMOKETEST = 'smoketest' ID_TO_NETWORKNAME = { 1: MAINNET, 3: ROPSTEN, 4: RINKEBY, 42: KOVAN, 627: SMOKETEST, } ID_TO_NETWORK_CONFIG = { 3: { CONTRACT_ENDPOINT_REGISTRY: to_canonical_address(ROPSTEN_DISCOVERY_ADDRESS), CONTRACT_SECRET_REGISTRY: to_canonical_address(ROPSTEN_SECRET_REGISTRY_ADDRESS), CONTRACT_TOKEN_NETWORK_REGISTRY: to_canonical_address(ROPSTEN_REGISTRY_ADDRESS), START_QUERY_BLOCK_KEY: 3604000, # 924 blocks before token network registry deployment }, } NETWORKNAME_TO_ID = { name: id for id, name in ID_TO_NETWORKNAME.items() } MIN_REQUIRED_SOLC = 'v0.4.23' NULL_ADDRESS = '0x' + '0' * 40 NULL_ADDRESS_BYTES = b'\x00' * 20
def test_token_network_proxy_basics( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): # check settlement timeouts assert token_network_proxy.settlement_timeout_min( ) == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max( ) == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(private_keys[1], c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) token_proxy.transfer(c2_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_token_balance # instantiating a new channel - test basic assumptions assert c1_token_network_proxy.channel_exists_and_not_settled( c1_client.address, c2_client.address, ) is False channel_identifier = c1_token_network_proxy._call_and_check_result( 'latest', 'getChannelIdentifier', to_checksum_address(c1_client.address), to_checksum_address(c2_client.address), ) assert c1_token_network_proxy.channel_is_opened( c1_client.address, c2_client.address, channel_identifier, ) is False assert c1_token_network_proxy.channel_is_closed( c1_client.address, c2_client.address, channel_identifier, ) is False # test timeout limits with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN - 1, ) with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MAX + 1, ) # channel to self with pytest.raises(SamePeerAddress): c1_token_network_proxy.new_netting_channel( c1_client.address, TEST_SETTLE_TIMEOUT_MIN, ) # Channel is not open yet with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.set_total_deposit( 1, 1, c2_client.address, ) assert 'does not exist' in str(exc) # Channel is not open yet with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.close( 1, c2_client.address, EMPTY_HASH, 0, EMPTY_HASH, EMPTY_HASH, ) assert 'does not exist' in str(exc) # actually create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # multiple channels with the same peer are not allowed with pytest.raises(DuplicatedChannelError): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True assert c1_token_network_proxy.channel_is_opened( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True # channel is open. # deposit with no balance with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( channel_identifier, 101, c2_client.address, ) # no negative deposit with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( channel_identifier, -1, c2_client.address, ) # actual deposit c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof.serialize_bin(), )) # close with invalid signature with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=b'\x11' * 65, ) # correct close c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert c1_token_network_proxy.channel_is_closed( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True # closing already closed channel with pytest.raises(RaidenRecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) with pytest.raises(RaidenRecoverableError) as exc: c2_token_network_proxy.set_total_deposit( channel_identifier, 20, c1_client.address, ) assert 'not in an open state' in str(exc) with pytest.raises(RaidenRecoverableError) as exc: c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert 'not in an open state' in str(exc) # update transfer wait_until_block(c1_chain, c1_chain.block_number() + TEST_SETTLE_TIMEOUT_MIN) # try to settle using incorrect data with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=1, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is False assert token_proxy.balance_of(c1_client.address) == (initial_balance_c1 - transferred_amount) assert token_proxy.balance_of(c2_client.address) == (initial_balance_c2 + transferred_amount) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) # No channel exists assert 'getChannelIdentifier returned 0' in str(exc)
def _generate_dummy_address(idx): return to_canonical_address( decode_hex('0xabbacadaba') + zpad(int_to_big_endian(idx), 15))
def mock_login(user, pw, sync=True): # pylint: disable=unused-argument recovered = recover(data=server_name.encode(), signature=decode_hex(pw)) if recovered != to_canonical_address(user): raise MatrixRequestError(403) client.user_id = f"@{user}:{server_name}"
def secret_registry_proxy(deploy_client, secret_registry_contract): return SecretRegistry( deploy_client, to_canonical_address(secret_registry_contract.contract.address), )
def withdraw_from_udc( reclamation_candidates: List[ReclamationCandidate], contract_manager: ContractManager, account: Account, web3: Web3, development_environment: ContractDevEnvironment, ): chain_id = ChainID(web3.eth.chainId) deploy = get_contracts_deployment_info( chain_id, RAIDEN_CONTRACT_VERSION, development_environment=development_environment) assert deploy planned_withdraws: Dict[ChecksumAddress, Tuple[BlockNumber, TokenAmount]] = {} log.info("Checking chain for deposits in UserDeposit contact") for node in reclamation_candidates: (userdeposit_proxy, _) = get_udc_and_corresponding_token_from_dependencies( chain_id=chain_id, proxy_manager=node.get_proxy_manager(web3, deploy), development_environment=development_environment, ) balance = userdeposit_proxy.get_total_deposit( to_canonical_address(node.address), "latest") log.debug("UDC balance", balance=balance, address=node.address) if balance > 0: drain_amount = TokenAmount(balance) existing_plan = userdeposit_proxy.get_withdraw_plan( to_canonical_address(node.address), "latest") if existing_plan.withdraw_amount == drain_amount: log.info( "Withdraw already planned", from_address=node.address, amount=drain_amount.__format__(",d"), ) ready_at_block = existing_plan.withdraw_block else: log.info( "Planning withdraw", from_address=node.address, amount=drain_amount.__format__(",d"), ) try: _, ready_at_block = userdeposit_proxy.plan_withdraw( drain_amount, "latest") except InsufficientEth: log.warning( "Not sufficient eth in node wallet to withdraw", address=node.address, ) continue planned_withdraws[node.address] = ready_at_block, drain_amount if not planned_withdraws: return log.info( "Withdraws successfully planned, waiting until withdraws are ready", planned_withdraws=planned_withdraws, ) reclaim_amount = 0 for address, (ready_at_block, amount) in planned_withdraws.items(): candidate = [ c for c in reclamation_candidates if c.address == address ][0] proxy_manager = candidate.get_proxy_manager(web3, deploy) (userdeposit_proxy, _) = get_udc_and_corresponding_token_from_dependencies( chain_id=chain_id, proxy_manager=proxy_manager, development_environment=development_environment, ) # FIXME: Something is off with the block numbers, adding 20 to work around. # See https://github.com/raiden-network/raiden/pull/6091/files#r412234516 proxy_manager.client.wait_until_block(BlockNumber(ready_at_block + 20), retry_timeout=10) log.info("Withdraw", user_address=address, amount=amount.__format__(",d")) reclaim_amount += amount userdeposit_proxy.withdraw(amount, "latest") log.info( "All UDC withdraws finished, now claim the resulting tokens!", withdraw_total=reclaim_amount.__format__(",d"), ) reclaim_erc20( reclamation_candidates, userdeposit_proxy.token_address("latest"), contract_manager, account, web3, )
def _withdraw_participant_left_capacity_from_channel( address_to_candidate: Dict[Address, ReclamationCandidate], channel: dict, token_network: TokenNetwork, current_confirmed_head: BlockIdentifier, ) -> None: """ Withdraw all tokens in channel to channel["participant1"] """ assert token_network.client.address == channel["participant1"] # Check if channel still has deposits details = token_network.detail_participants( participant1=to_canonical_address(channel["participant1"]), participant2=to_canonical_address(channel["participant2"]), block_identifier=current_confirmed_head, channel_identifier=channel["channel_identifier"], ) new_withdraw = WithdrawAmount(details.our_details.deposit - details.our_details.withdrawn + details.partner_details.deposit - details.partner_details.withdrawn) assert new_withdraw >= 0, "negative withdrawn should never happen." if new_withdraw == 0: log.info( "Participant has no left over capacity in the channel. Skipping channel.", channel=channel, ) return partner_candidate = address_to_candidate.get( details.partner_details.address) if partner_candidate is None: log.error( "Both participants must be in list of reclamation_candidates. Skipping channel.", channel=channel, ) return expiration_block = BlockExpiration(100000000000000) total_withdraw = WithdrawAmount(details.our_details.withdrawn + new_withdraw) packed_withdraw = pack_withdraw( canonical_identifier=CanonicalIdentifier( chain_identifier=token_network.chain_id(), token_network_address=token_network.address, channel_identifier=channel["channel_identifier"], ), participant=to_canonical_address(channel["participant1"]), total_withdraw=total_withdraw, expiration_block=expiration_block, ) privkey = token_network.client.privkey try: token_network.set_total_withdraw( given_block_identifier=current_confirmed_head, channel_identifier=channel["channel_identifier"], total_withdraw=total_withdraw, expiration_block=expiration_block, participant=to_canonical_address(channel["participant1"]), partner=to_canonical_address(channel["participant2"]), participant_signature=LocalSigner(privkey).sign(packed_withdraw), partner_signature=LocalSigner( partner_candidate.privkey).sign(packed_withdraw), ) except InsufficientEth: log.warning("Not enough ETH to withdraw", channel=channel) else: log.info("Withdraw successful", channel=channel, amount=new_withdraw)
def app( address, keystore_path, gas_price, eth_rpc_endpoint, registry_contract_address, secret_registry_contract_address, discovery_contract_address, listen_address, rpccorsdomain, mapped_socket, log_config, log_file, log_json, max_unresponsive_time, send_ping_time, api_address, rpc, sync_check, console, password_file, web_ui, datadir, nat, transport, matrix_server, network_id, config_file, extra_config=None, ): # pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument from raiden.app import App if transport == 'udp' and not mapped_socket: raise RuntimeError('Missing socket') address_hex = to_normalized_address(address) if address else None address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file) address = to_canonical_address(address_hex) (listen_host, listen_port) = split_endpoint(listen_address) (api_host, api_port) = split_endpoint(api_address) if datadir is None: datadir = os.path.join(os.path.expanduser('~'), '.raiden') config = deepcopy(App.DEFAULT_CONFIG) if extra_config: merge_dict(config, extra_config) config['host'] = listen_host config['port'] = listen_port config['console'] = console config['rpc'] = rpc config['web_ui'] = rpc and web_ui config['api_host'] = api_host config['api_port'] = api_port if mapped_socket: config['socket'] = mapped_socket.socket config['external_ip'] = mapped_socket.external_ip config['external_port'] = mapped_socket.external_port config['transport_type'] = transport config['matrix']['server'] = matrix_server config['transport'][ 'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES config['transport']['nat_keepalive_timeout'] = timeout privatekey_hex = hexlify(privatekey_bin) config['privatekey_hex'] = privatekey_hex rpc_host, rpc_port = eth_endpoint_to_hostport(eth_rpc_endpoint) rpc_client = JSONRPCClient( rpc_host, rpc_port, privatekey_bin, gas_price, ) blockchain_service = BlockChainService(privatekey_bin, rpc_client) net_id = blockchain_service.network_id if net_id != network_id: if network_id in constants.ID_TO_NETWORKNAME and net_id in constants.ID_TO_NETWORKNAME: print(( "The chosen ethereum network '{}' differs from the ethereum client '{}'. " 'Please update your settings.').format( constants.ID_TO_NETWORKNAME[network_id], constants.ID_TO_NETWORKNAME[net_id])) else: print(( "The chosen ethereum network id '{}' differs from the ethereum client '{}'. " 'Please update your settings.').format(network_id, net_id)) sys.exit(1) config['chain_id'] = network_id if sync_check: check_synced(blockchain_service) database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8], 'log.db') config['database_path'] = database_path print( 'You are connected to the \'{}\' network and the DB path is: {}'. format( constants.ID_TO_NETWORKNAME.get(net_id) or net_id, database_path, ), ) try: token_network_registry = blockchain_service.token_network_registry( registry_contract_address, ) except ContractVersionMismatch: print( 'Deployed registry contract version mismatch. ' 'Please update your Raiden installation.', ) sys.exit(1) try: secret_registry = blockchain_service.secret_registry( secret_registry_contract_address, ) except ContractVersionMismatch: print( 'Deployed secret registry contract version mismatch. ' 'Please update your Raiden installation.', ) sys.exit(1) discovery = None if transport == 'udp': check_discovery_registration_gas(blockchain_service, address) try: discovery = ContractDiscovery( blockchain_service.node_address, blockchain_service.discovery(discovery_contract_address), ) except ContractVersionMismatch: print('Deployed discovery contract version mismatch. ' 'Please update your Raiden installation.') sys.exit(1) throttle_policy = TokenBucket( config['transport']['throttle_capacity'], config['transport']['throttle_fill_rate'], ) transport = UDPTransport( discovery, mapped_socket.socket, throttle_policy, config['transport'], ) elif transport == 'matrix': # matrix gets spammed with the default retry-interval of 1s, wait a little more if config['transport'][ 'retry_interval'] == DEFAULT_TRANSPORT_RETRY_INTERVAL: config['transport']['retry_interval'] *= 5 try: transport = MatrixTransport(config['matrix']) except RaidenError as ex: click.secho(f'FATAL: {ex}', fg='red') sys.exit(1) else: raise RuntimeError(f'Unknown transport type "{transport}" given') try: raiden_app = App( config=config, chain=blockchain_service, query_start_block=constants.ID_TO_QUERY_BLOCK[net_id], default_registry=token_network_registry, default_secret_registry=secret_registry, transport=transport, discovery=discovery, ) except RaidenError as e: click.secho(f'FATAL: {e}', fg='red') sys.exit(1) return raiden_app
def create_view_hash(acct, authroot_hash, randomizer) -> hex: acct_bytes = to_canonical_address(acct) authroot_hash_bytes = to_bytes(hexstr=authroot_hash) randomizer_bytes = to_bytes32(randomizer) return to_hex(keccak(acct_bytes+authroot_hash_bytes+randomizer_bytes))
def _run_smoketest(): print_step('Starting Raiden') # invoke the raiden app app_ = ctx.invoke(app, **args) raiden_api = RaidenAPI(app_.raiden) rest_api = RestAPI(raiden_api) api_server = APIServer(rest_api) (api_host, api_port) = split_endpoint(args['api_address']) api_server.start(api_host, api_port) raiden_api.channel_open( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], to_canonical_address(token.contract.address), to_canonical_address(TEST_PARTNER_ADDRESS), None, None, ) raiden_api.set_total_channel_deposit( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], to_canonical_address(token.contract.address), to_canonical_address(TEST_PARTNER_ADDRESS), TEST_DEPOSIT_AMOUNT, ) smoketest_config['contracts'][ 'registry_address'] = to_checksum_address( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], ) smoketest_config['contracts'][ 'secret_registry_address'] = to_checksum_address( contract_addresses[CONTRACT_SECRET_REGISTRY], ) smoketest_config['contracts'][ 'discovery_address'] = to_checksum_address( contract_addresses[CONTRACT_ENDPOINT_REGISTRY], ) smoketest_config['contracts']['token_address'] = to_checksum_address( token.contract.address, ) success = False try: print_step('Running smoketest') error = run_smoketests(app_.raiden, smoketest_config, debug=debug) if error is not None: append_report('Smoketest assertion error', error) else: success = True finally: app_.stop() ethereum.send_signal(2) err, out = ethereum.communicate() append_report('Ethereum init stdout', ethereum_config['init_log_out'].decode('utf-8')) append_report('Ethereum init stderr', ethereum_config['init_log_err'].decode('utf-8')) append_report('Ethereum stdout', out) append_report('Ethereum stderr', err) append_report('Smoketest configuration', json.dumps(smoketest_config)) if success: print_step( f'Smoketest successful, report was written to {report_file}') else: print_step( f'Smoketest had errors, report was written to {report_file}', error=True) return success
def smoketest(ctx, debug, local_matrix, **kwargs): # pylint: disable=unused-argument """ Test, that the raiden installation is sane. """ import binascii from web3 import Web3, HTTPProvider from web3.middleware import geth_poa_middleware from raiden.api.python import RaidenAPI from raiden.tests.utils.geth import geth_wait_and_check from raiden.tests.integration.contracts.fixtures.contracts import deploy_token from raiden.tests.utils.smoketest import ( TEST_PARTNER_ADDRESS, TEST_DEPOSIT_AMOUNT, deploy_smoketest_contracts, get_private_key, load_smoketest_config, start_ethereum, run_smoketests, ) report_file = tempfile.mktemp(suffix='.log') configure_logging({'': 'DEBUG'}, log_file=report_file) def append_report(subject, data): with open(report_file, 'a', encoding='UTF-8') as handler: handler.write(f'{f" {subject.upper()} ":=^80}{os.linesep}') if data is not None: if isinstance(data, bytes): data = data.decode() handler.writelines([data + os.linesep]) append_report('Raiden version', json.dumps(get_system_spec())) append_report('Raiden log', None) step_count = 7 if ctx.parent.params['transport'] == 'matrix': step_count = 8 step = 0 def print_step(description, error=False): nonlocal step step += 1 click.echo( '{} {}'.format( click.style(f'[{step}/{step_count}]', fg='blue'), click.style(description, fg='green' if not error else 'red'), ), ) print_step('Getting smoketest configuration') smoketest_config = load_smoketest_config() if not smoketest_config: append_report( 'Smoketest configuration', 'Could not load the smoketest genesis configuration file.', ) print_step('Starting Ethereum node') ethereum, ethereum_config = start_ethereum(smoketest_config['genesis']) port = ethereum_config['rpc'] web3_client = Web3(HTTPProvider(f'http://0.0.0.0:{port}')) web3_client.middleware_stack.inject(geth_poa_middleware, layer=0) random_marker = binascii.hexlify(b'raiden').decode() privatekeys = [] geth_wait_and_check(web3_client, privatekeys, random_marker) print_step('Deploying Raiden contracts') host = '0.0.0.0' client = JSONRPCClient( host, ethereum_config['rpc'], get_private_key(), web3=web3_client, ) contract_addresses = deploy_smoketest_contracts(client, 627) token_contract = deploy_token(client) token = token_contract(1000, 0, 'TKN', 'TKN') registry = TokenNetworkRegistry( client, contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]) registry.add_token(to_canonical_address(token.contract.address)) print_step('Setting up Raiden') # setup cli arguments for starting raiden args = dict( discovery_contract_address=to_checksum_address( contract_addresses[CONTRACT_ENDPOINT_REGISTRY], ), registry_contract_address=to_checksum_address( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], ), secret_registry_contract_address=to_checksum_address( contract_addresses[CONTRACT_SECRET_REGISTRY], ), eth_rpc_endpoint='http://127.0.0.1:{}'.format(port), keystore_path=ethereum_config['keystore'], address=ethereum_config['address'], network_id='627', transport=ctx.parent.params['transport'], matrix_server='http://localhost:8008' if ctx.parent.params['matrix_server'] == 'auto' else ctx.parent.params['matrix_server'], ) smoketest_config['transport'] = args['transport'] for option_ in app.params: if option_.name in args.keys(): args[option_.name] = option_.process_value(ctx, args[option_.name]) else: args[option_.name] = option_.default password_file = os.path.join(args['keystore_path'], 'password') with open(password_file, 'w') as handler: handler.write('password') port = next(get_free_port('127.0.0.1', 5001)) args['password_file'] = click.File()(password_file) args['datadir'] = args['keystore_path'] args['api_address'] = 'localhost:' + str(port) args['sync_check'] = False def _run_smoketest(): print_step('Starting Raiden') # invoke the raiden app app_ = ctx.invoke(app, **args) raiden_api = RaidenAPI(app_.raiden) rest_api = RestAPI(raiden_api) api_server = APIServer(rest_api) (api_host, api_port) = split_endpoint(args['api_address']) api_server.start(api_host, api_port) raiden_api.channel_open( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], to_canonical_address(token.contract.address), to_canonical_address(TEST_PARTNER_ADDRESS), None, None, ) raiden_api.set_total_channel_deposit( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], to_canonical_address(token.contract.address), to_canonical_address(TEST_PARTNER_ADDRESS), TEST_DEPOSIT_AMOUNT, ) smoketest_config['contracts'][ 'registry_address'] = to_checksum_address( contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], ) smoketest_config['contracts'][ 'secret_registry_address'] = to_checksum_address( contract_addresses[CONTRACT_SECRET_REGISTRY], ) smoketest_config['contracts'][ 'discovery_address'] = to_checksum_address( contract_addresses[CONTRACT_ENDPOINT_REGISTRY], ) smoketest_config['contracts']['token_address'] = to_checksum_address( token.contract.address, ) success = False try: print_step('Running smoketest') error = run_smoketests(app_.raiden, smoketest_config, debug=debug) if error is not None: append_report('Smoketest assertion error', error) else: success = True finally: app_.stop() ethereum.send_signal(2) err, out = ethereum.communicate() append_report('Ethereum init stdout', ethereum_config['init_log_out'].decode('utf-8')) append_report('Ethereum init stderr', ethereum_config['init_log_err'].decode('utf-8')) append_report('Ethereum stdout', out) append_report('Ethereum stderr', err) append_report('Smoketest configuration', json.dumps(smoketest_config)) if success: print_step( f'Smoketest successful, report was written to {report_file}') else: print_step( f'Smoketest had errors, report was written to {report_file}', error=True) return success if args['transport'] == 'udp': with SocketFactory('127.0.0.1', port, strategy='none') as mapped_socket: args['mapped_socket'] = mapped_socket success = _run_smoketest() elif args['transport'] == 'matrix' and local_matrix.lower() != 'none': args['mapped_socket'] = None print_step('Starting Matrix transport') try: with HTTPExecutor( local_matrix, status=r'^[24]\d\d$', url=urljoin(args['matrix_server'], '/_matrix/client/versions'), shell=True, ): args['extra_config'] = { 'matrix': { 'discovery_room': { 'server': 'matrix.local.raiden' }, 'server_name': 'matrix.local.raiden', }, } success = _run_smoketest() except (PermissionError, ProcessExitedWithError): append_report('Matrix server start exception', traceback.format_exc()) print_step( f'Error during smoketest setup, report was written to {report_file}', error=True, ) success = False elif args['transport'] == 'matrix' and local_matrix.lower() == "none": args['mapped_socket'] = None success = _run_smoketest() else: # Shouldn't happen raise RuntimeError(f"Invalid transport type '{args['transport']}'") if not success: sys.exit(1)
def from_dict(cls, data) -> 'ActionChangeNodeNetworkState': return cls( node_address=to_canonical_address(data['node_address']), network_state=data['network_state'], )
def get_secret_registry_address( self, block_identifier: BlockIdentifier) -> SecretRegistryAddress: return SecretRegistryAddress( to_canonical_address( self.proxy.functions.secret_registry_address().call( block_identifier=block_identifier)))
def chain(chaindb, funded_address, funded_address_initial_balance): # noqa: F811 """ Return a Chain object containing just the genesis block. The Chain's state includes one funded account, which can be found in the funded_address in the chain itself. This Chain will perform all validations when importing new blocks, so only valid and finalized blocks can be used with it. If you want to test importing arbitrarily constructe, not finalized blocks, use the chain_without_block_validation fixture instead. """ genesis_params = { "bloom": 0, "coinbase": to_canonical_address("8888f1f195afa192cfee860698584c030f4c9db1"), "difficulty": 131072, "extra_data": b"B", "gas_limit": 3141592, "gas_used": 0, "mix_hash": decode_hex( "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ), # noqa: E501 "nonce": decode_hex("0102030405060708"), "block_number": 0, "parent_hash": decode_hex( "0000000000000000000000000000000000000000000000000000000000000000" ), # noqa: E501 "receipt_root": decode_hex( "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ), # noqa: E501 "timestamp": 1422494849, "transaction_root": decode_hex( "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ), # noqa: E501 "uncles_hash": decode_hex( "1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347" ) # noqa: E501 } genesis_state = { funded_address: { "balance": funded_address_initial_balance, "nonce": 0, "code": b"", "storage": {} } } klass = Chain.configure(__name__='TestChain', vm_configuration=((constants.GENESIS_BLOCK_NUMBER, FrontierVM), )) chain = klass.from_genesis(chaindb, genesis_params, genesis_state) return chain
def get_deprecation_executor(self, block_identifier: BlockIdentifier) -> Address: return Address( to_canonical_address( self.proxy.functions.deprecation_executor().call( block_identifier=block_identifier)))
from evm.vm.message import ( Message, ) from evm.vm.computation import ( BaseComputation, ) from evm.vm.transaction_context import ( BaseTransactionContext, ) from eth_utils import ( to_canonical_address, ) from evm.exceptions import ( ValidationError, ) NORMALIZED_ADDRESS_A = "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" NORMALIZED_ADDRESS_B = "0xcd1722f3947def4cf144679da39c4c32bdc35681" CANONICAL_ADDRESS_A = to_canonical_address( "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6") CANONICAL_ADDRESS_B = to_canonical_address( "0xcd1722f3947def4cf144679da39c4c32bdc35681") class DummyComputation(BaseComputation): def apply_message(self): pass def apply_create_message(self): pass @pytest.fixture def transaction_context(): tx_context = BaseTransactionContext(
def deploy_smoketest_contracts( client: JSONRPCClient, chain_id: ChainID, contract_manager: ContractManager, token_address: AddressHex, ) -> Dict[str, Address]: if client.eth_node is EthClient.GETH: client.web3.geth.personal.unlockAccount(client.web3.eth.accounts[0], DEFAULT_PASSPHRASE) elif client.eth_node is EthClient.PARITY: client.web3.parity.personal.unlockAccount(client.web3.eth.accounts[0], DEFAULT_PASSPHRASE) contract_proxy, _ = client.deploy_single_contract( contract_name=CONTRACT_SECRET_REGISTRY, contract=contract_manager.get_contract(CONTRACT_SECRET_REGISTRY), constructor_parameters=None, ) secret_registry_address = Address( to_canonical_address(contract_proxy.address)) secret_registry_constructor_arguments = ( to_checksum_address(secret_registry_address), chain_id, TEST_SETTLE_TIMEOUT_MIN, TEST_SETTLE_TIMEOUT_MAX, UINT256_MAX, ) contract_proxy, _ = client.deploy_single_contract( contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY, contract=contract_manager.get_contract( CONTRACT_TOKEN_NETWORK_REGISTRY), constructor_parameters=secret_registry_constructor_arguments, ) token_network_registry_address = Address( to_canonical_address(contract_proxy.address)) service_registry_constructor_arguments = ( token_address, EMPTY_ADDRESS, int(500e18), 6, 5, 180 * SECONDS_PER_DAY, 1000, 200 * SECONDS_PER_DAY, ) service_registry_contract, _ = client.deploy_single_contract( contract_name=CONTRACT_SERVICE_REGISTRY, contract=contract_manager.get_contract(CONTRACT_SERVICE_REGISTRY), constructor_parameters=service_registry_constructor_arguments, ) service_registry_address = Address( to_canonical_address(service_registry_contract.address)) user_deposit_contract, _ = client.deploy_single_contract( contract_name=CONTRACT_USER_DEPOSIT, contract=contract_manager.get_contract(CONTRACT_USER_DEPOSIT), constructor_parameters=(token_address, UINT256_MAX), ) user_deposit_address = Address( to_canonical_address(user_deposit_contract.address)) monitoring_service_contract, _ = client.deploy_single_contract( contract_name=CONTRACT_MONITORING_SERVICE, contract=contract_manager.get_contract(CONTRACT_MONITORING_SERVICE), constructor_parameters=( token_address, service_registry_address, user_deposit_address, token_network_registry_address, ), ) monitoring_service_address = Address( to_canonical_address(monitoring_service_contract.address)) one_to_n_contract, _ = client.deploy_single_contract( contract_name=CONTRACT_ONE_TO_N, contract=contract_manager.get_contract(CONTRACT_ONE_TO_N), constructor_parameters=(user_deposit_address, chain_id, service_registry_address), ) one_to_n_address = Address(to_canonical_address(one_to_n_contract.address)) proxy_manager = ProxyManager( rpc_client=client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) user_deposit_proxy = UserDeposit( jsonrpc_client=client, user_deposit_address=UserDepositAddress( to_canonical_address(user_deposit_contract.address)), contract_manager=contract_manager, proxy_manager=proxy_manager, block_identifier=BLOCK_ID_LATEST, ) transaction_hash = user_deposit_proxy.init( monitoring_service_address=MonitoringServiceAddress( monitoring_service_address), one_to_n_address=OneToNAddress(one_to_n_address), given_block_identifier=BLOCK_ID_LATEST, ) assert is_tx_hash_bytes(transaction_hash) addresses = { CONTRACT_SECRET_REGISTRY: secret_registry_address, CONTRACT_TOKEN_NETWORK_REGISTRY: token_network_registry_address, CONTRACT_SERVICE_REGISTRY: service_registry_address, CONTRACT_USER_DEPOSIT: user_deposit_address, CONTRACT_MONITORING_SERVICE: monitoring_service_address, CONTRACT_ONE_TO_N: one_to_n_address, } return addresses
def token_proxy(deploy_client, token_contract): return Token( deploy_client, to_canonical_address(token_contract.contract.address), )
def run_app( address, keystore_path, gas_price, eth_rpc_endpoint, tokennetwork_registry_contract_address, secret_registry_contract_address, endpoint_registry_contract_address, listen_address, mapped_socket, max_unresponsive_time, api_address, rpc, sync_check, console, password_file, web_ui, datadir, transport, matrix_server, network_id, environment_type, unrecoverable_error_should_crash, config=None, extra_config=None, **kwargs, ): # pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument from raiden.app import App _assert_sql_version() if transport == 'udp' and not mapped_socket: raise RuntimeError('Missing socket') if datadir is None: datadir = os.path.join(os.path.expanduser('~'), '.raiden') address_hex = to_normalized_address(address) if address else None address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file) address = to_canonical_address(address_hex) (listen_host, listen_port) = split_endpoint(listen_address) (api_host, api_port) = split_endpoint(api_address) config['transport']['udp']['host'] = listen_host config['transport']['udp']['port'] = listen_port config['console'] = console config['rpc'] = rpc config['web_ui'] = rpc and web_ui config['api_host'] = api_host config['api_port'] = api_port if mapped_socket: config['socket'] = mapped_socket.socket config['transport']['udp']['external_ip'] = mapped_socket.external_ip config['transport']['udp'][ 'external_port'] = mapped_socket.external_port config['transport_type'] = transport config['transport']['matrix']['server'] = matrix_server config['transport']['udp'][ 'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES config['transport']['udp']['nat_keepalive_timeout'] = timeout config['privatekey_hex'] = encode_hex(privatekey_bin) config[ 'unrecoverable_error_should_crash'] = unrecoverable_error_should_crash parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint) if not parsed_eth_rpc_endpoint.scheme: eth_rpc_endpoint = f'http://{eth_rpc_endpoint}' web3 = _setup_web3(eth_rpc_endpoint) rpc_client = JSONRPCClient( web3, privatekey_bin, gas_price_strategy=gas_price, block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS, uses_infura='infura.io' in eth_rpc_endpoint, ) blockchain_service = BlockChainService( privatekey_bin=privatekey_bin, jsonrpc_client=rpc_client, # Not giving the contract manager here, but injecting it later # since we first need blockchain service to calculate the network id ) if network_id == 1: # temporarily until red eyes disallow raiden on the mainnet click.secho( 'Running Raiden on the mainnet is currently not supported.', fg='red', ) sys.exit(1) given_network_id = network_id node_network_id = blockchain_service.network_id known_given_network_id = given_network_id in ID_TO_NETWORKNAME known_node_network_id = node_network_id in ID_TO_NETWORKNAME if node_network_id != given_network_id: if known_given_network_id and known_node_network_id: click.secho( f"The chosen ethereum network '{ID_TO_NETWORKNAME[given_network_id]}' " f"differs from the ethereum client '{ID_TO_NETWORKNAME[node_network_id]}'. " "Please update your settings.", fg='red', ) else: click.secho( f"The chosen ethereum network id '{given_network_id}' differs " f"from the ethereum client '{node_network_id}'. " "Please update your settings.", fg='red', ) sys.exit(1) config['chain_id'] = given_network_id # interpret the provided string argument if environment_type == Environment.PRODUCTION: # Safe configuration: restrictions for mainnet apply and matrix rooms have to be private config['environment_type'] = Environment.PRODUCTION config['transport']['matrix']['private_rooms'] = True else: config['environment_type'] = Environment.DEVELOPMENT environment_type = config['environment_type'] print(f'Raiden is running in {environment_type.value.lower()} mode') chain_config = {} contract_addresses_known = False contracts = dict() contracts_version = 'pre_limits' if environment_type == Environment.DEVELOPMENT else None config['contracts_path'] = contracts_precompiled_path(contracts_version) if node_network_id in ID_TO_NETWORKNAME and ID_TO_NETWORKNAME[ node_network_id] != 'smoketest': deployment_data = get_contracts_deployed(node_network_id, contracts_version) not_allowed = ( # for now we only disallow mainnet with test configuration network_id == 1 and environment_type == Environment.DEVELOPMENT) if not_allowed: click.secho( f'The chosen network ({ID_TO_NETWORKNAME[node_network_id]}) is not a testnet, ' 'but the "development" environment was selected.\n' 'This is not allowed. Please start again with a safe environment setting ' '(--environment production).', fg='red', ) sys.exit(1) contracts = deployment_data['contracts'] contract_addresses_known = True blockchain_service.inject_contract_manager( ContractManager(config['contracts_path'])) if sync_check: check_synced(blockchain_service, known_node_network_id) contract_addresses_given = ( tokennetwork_registry_contract_address is not None and secret_registry_contract_address is not None and endpoint_registry_contract_address is not None) if not contract_addresses_given and not contract_addresses_known: click.secho( f"There are no known contract addresses for network id '{given_network_id}'. " "Please provide them on the command line or in the configuration file.", fg='red', ) sys.exit(1) try: token_network_registry = blockchain_service.token_network_registry( tokennetwork_registry_contract_address or to_canonical_address( contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'], ), ) except ContractVersionMismatch as e: handle_contract_version_mismatch(e) except AddressWithoutCode: handle_contract_no_code('token network registry', tokennetwork_registry_contract_address) except AddressWrongContract: handle_contract_wrong_address( 'token network registry', tokennetwork_registry_contract_address, ) try: secret_registry = blockchain_service.secret_registry( secret_registry_contract_address or to_canonical_address( contracts[CONTRACT_SECRET_REGISTRY]['address'], ), ) except ContractVersionMismatch as e: handle_contract_version_mismatch(e) except AddressWithoutCode: handle_contract_no_code('secret registry', secret_registry_contract_address) except AddressWrongContract: handle_contract_wrong_address('secret registry', secret_registry_contract_address) database_path = os.path.join( datadir, f'node_{pex(address)}', f'netid_{given_network_id}', f'network_{pex(token_network_registry.address)}', f'v{RAIDEN_DB_VERSION}_log.db', ) config['database_path'] = database_path print( '\nYou are connected to the \'{}\' network and the DB path is: {}'. format( ID_TO_NETWORKNAME.get(given_network_id, given_network_id), database_path, ), ) discovery = None if transport == 'udp': transport, discovery = _setup_udp( config, blockchain_service, address, contracts, endpoint_registry_contract_address, ) elif transport == 'matrix': transport = _setup_matrix(config) else: raise RuntimeError(f'Unknown transport type "{transport}" given') raiden_event_handler = RaidenEventHandler() message_handler = MessageHandler() try: if 'contracts' in chain_config: start_block = chain_config['contracts']['TokenNetworkRegistry'][ 'block_number'] else: start_block = 0 raiden_app = App( config=config, chain=blockchain_service, query_start_block=start_block, default_registry=token_network_registry, default_secret_registry=secret_registry, transport=transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, discovery=discovery, ) except RaidenError as e: click.secho(f'FATAL: {e}', fg='red') sys.exit(1) try: raiden_app.start() except RuntimeError as e: click.secho(f'FATAL: {e}', fg='red') sys.exit(1) except filelock.Timeout: name_or_id = ID_TO_NETWORKNAME.get(given_network_id, given_network_id) click.secho( f'FATAL: Another Raiden instance already running for account {address_hex} on ' f'network id {name_or_id}', fg='red', ) sys.exit(1) return raiden_app
}]) def test_cli_wrong_rpc_endpoint(cli_args, raiden_spawner): child = raiden_spawner(cli_args) expect_cli_until_acknowledgment(child) child.expect(".*Communicating with an external service failed.") @pytest.mark.parametrize("changed_args", [{"network_id": "42"}]) def test_cli_wrong_network_id_try_kovan(cli_args, raiden_spawner): child = raiden_spawner(cli_args) expect_cli_until_acknowledgment(child) child.expect( "The configured network.*differs from the Ethereum client's network") @pytest.mark.parametrize( "changed_args", [{ "user_deposit_contract_address": to_checksum_address( to_canonical_address("0xfb6916095ca1df60bb79ce92ce3ea74c37c5d359")) }], ) def test_cli_registry_address_without_deployed_contract( cli_args, raiden_spawner): child = raiden_spawner(cli_args) expect_cli_until_acknowledgment(child) child.expect(".* does not contain code")
def test_token_network_proxy_update_transfer( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): """Tests channel lifecycle, with `update_transfer` before settling""" token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(private_keys[1], c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, 10, ) # deposit to the channel initial_balance = 100 token_proxy.transfer(c1_client.address, initial_balance) token_proxy.transfer(c2_client.address, initial_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_balance c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) c2_token_network_proxy.set_total_deposit( channel_identifier, 10, c1_client.address, ) # balance proof signed by c1 transferred_amount_c1 = 1 transferred_amount_c2 = 3 balance_proof_c1 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex( eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof_c1.serialize_bin(), )) # balance proof signed by c2 balance_proof_c2 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=2, chain_id=chain_id, transferred_amount=transferred_amount_c2, ) balance_proof_c2.signature = encode_hex( eth_sign( privkey=encode_hex(private_keys[2]), data=balance_proof_c2.serialize_bin(), )) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex( balance_proof_c1.signature) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) assert 'not in a closed state' in str(exc) # close by c1 c1_token_network_proxy.close( channel_identifier=channel_identifier, partner=c2_client.address, balance_hash=decode_hex(balance_proof_c2.balance_hash), nonce=balance_proof_c2.nonce, additional_hash=decode_hex(balance_proof_c2.additional_hash), signature=decode_hex(balance_proof_c2.signature), ) # using invalid non-closing signature # Usual mistake when calling update Transfer - balance proof signature is missing in the data non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex( balance_proof_c1.signature) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert 'cannot be settled before settlement window is over' in str(exc) wait_until_block(c1_chain, c1_chain.block_number() + 10) # settling with an invalid amount with pytest.raises(RaidenUnrecoverableError): c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=2, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) # proper settle c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert (token_proxy.balance_of( c2_client.address) == (initial_balance_c2 + transferred_amount_c1 - transferred_amount_c2)) assert (token_proxy.balance_of( c1_client.address) == (initial_balance_c1 + transferred_amount_c2 - transferred_amount_c1)) # Already settled with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.set_total_deposit( channel_identifier, 20, c1_client.address, ) assert 'getChannelIdentifier returned 0' in str(exc)
def from_dict(cls, data): return cls( token_network_identifier=to_canonical_address( data['token_network_identifier']), channel_identifier=int(data['channel_identifier']), )
CHECK_RDN_MIN_DEPOSIT_INTERVAL = 5 * 60 CHECK_GAS_RESERVE_INTERVAL = 5 * 60 CHECK_VERSION_INTERVAL = 3 * 60 * 60 CHECK_NETWORK_ID_INTERVAL = 5 * 60 DEFAULT_HTTP_REQUEST_TIMEOUT = 1.0 # seconds DISCOVERY_DEFAULT_ROOM = "discovery" MONITORING_BROADCASTING_ROOM = "monitoring" PATH_FINDING_BROADCASTING_ROOM = "path_finding" # According to the smart contracts as of 07/08: # https://github.com/raiden-network/raiden-contracts/blob/fff8646ebcf2c812f40891c2825e12ed03cc7628/raiden_contracts/contracts/TokenNetwork.sol#L213 # channel_identifier can never be 0. We make this a requirement in the client and use this fact # to signify that a channel_identifier of `0` passed to the messages adds them to the # global queue EMPTY_ADDRESS = b"\0" * 20 # Keep in sync with .circleci/config.yaml HIGHEST_SUPPORTED_GETH_VERSION = "1.9.2" LOWEST_SUPPORTED_GETH_VERSION = "1.8.21" # this is the last stable version as of this comment HIGHEST_SUPPORTED_PARITY_VERSION = "2.5.5" LOWEST_SUPPORTED_PARITY_VERSION = "1.7.6" WETH_TOKEN_ADDRESS = TokenAddress( to_canonical_address("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")) DAI_TOKEN_ADDRESS = TokenAddress( to_canonical_address("0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359"))
def token_network_proxy(deploy_client, token_network_contract): return TokenNetwork( deploy_client, to_canonical_address(token_network_contract.contract.address), )
def normalize_to_address(value: AnyStr) -> Address: if value: return to_canonical_address(value) else: return CREATE_CONTRACT_ADDRESS
def from_dict(cls, data: typing.Dict[str, typing.Any]) -> 'ReceiveProcessed': return cls( sender=to_canonical_address(data['sender']), message_identifier=int(data['message_identifier']), )
def from_dict(cls, data) -> 'ReceiveProcessed': return cls( sender=to_canonical_address(data['sender']), message_identifier=data['message_identifier'], )
def app( address, keystore_path, gas_price, eth_rpc_endpoint, registry_contract_address, secret_registry_contract_address, discovery_contract_address, listen_address, rpccorsdomain, mapped_socket, log_config, log_file, log_json, max_unresponsive_time, send_ping_time, api_address, rpc, sync_check, console, password_file, web_ui, datadir, nat, transport, matrix_server, network_id, extra_config=None, ): # pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument from raiden.app import App from raiden.network.blockchain_service import BlockChainService if transport == 'udp' and not mapped_socket: raise RuntimeError('Missing socket') address_hex = to_normalized_address(address) if address else None address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file) address = to_canonical_address(address_hex) (listen_host, listen_port) = split_endpoint(listen_address) (api_host, api_port) = split_endpoint(api_address) if datadir is None: datadir = os.path.join(os.path.expanduser('~'), '.raiden') config = deepcopy(App.DEFAULT_CONFIG) if extra_config: merge_dict(config, extra_config) config['host'] = listen_host config['port'] = listen_port config['console'] = console config['rpc'] = rpc config['web_ui'] = rpc and web_ui config['api_host'] = api_host config['api_port'] = api_port if mapped_socket: config['socket'] = mapped_socket.socket config['external_ip'] = mapped_socket.external_ip config['external_port'] = mapped_socket.external_port config['transport_type'] = transport config['matrix']['server'] = matrix_server config['transport'][ 'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES config['transport']['nat_keepalive_timeout'] = timeout privatekey_hex = hexlify(privatekey_bin) config['privatekey_hex'] = privatekey_hex endpoint = eth_rpc_endpoint # Fallback to default port if only an IP address is given rpc_port = 8545 if eth_rpc_endpoint.startswith('http://'): endpoint = eth_rpc_endpoint[len('http://'):] rpc_port = 80 elif eth_rpc_endpoint.startswith('https://'): endpoint = eth_rpc_endpoint[len('https://'):] rpc_port = 443 if ':' not in endpoint: # no port was given in url rpc_host = endpoint else: rpc_host, rpc_port = split_endpoint(endpoint) rpc_client = JSONRPCClient( rpc_host, rpc_port, privatekey_bin, gas_price, ) blockchain_service = BlockChainService( privatekey_bin, rpc_client, gas_price, ) # this assumes the eth node is already online check_json_rpc(rpc_client) net_id = blockchain_service.network_id if net_id != network_id: if network_id in ID_TO_NETWORKNAME and net_id in ID_TO_NETWORKNAME: print(( "The chosen ethereum network '{}' differs from the ethereum client '{}'. " 'Please update your settings.').format( ID_TO_NETWORKNAME[network_id], ID_TO_NETWORKNAME[net_id])) else: print(( "The chosen ethereum network id '{}' differs from the ethereum client '{}'. " 'Please update your settings.').format(network_id, net_id)) sys.exit(1) if sync_check: check_synced(blockchain_service) database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8], 'log.db') config['database_path'] = database_path print( 'You are connected to the \'{}\' network and the DB path is: {}'. format( ID_TO_NETWORKNAME.get(net_id) or net_id, database_path, ), ) try: registry = blockchain_service.registry(registry_contract_address, ) except ContractVersionMismatch: print( 'Deployed registry contract version mismatch. ' 'Please update your Raiden installation.', ) sys.exit(1) try: secret_registry = blockchain_service.secret_registry( secret_registry_contract_address, ) except ContractVersionMismatch: print( 'Deployed registry contract version mismatch. ' 'Please update your Raiden installation.', ) sys.exit(1) discovery = None if transport == 'udp': check_discovery_registration_gas(blockchain_service, address) try: discovery = ContractDiscovery( blockchain_service.node_address, blockchain_service.discovery(discovery_contract_address), ) except ContractVersionMismatch: print('Deployed discovery contract version mismatch. ' 'Please update your Raiden installation.') sys.exit(1) throttle_policy = TokenBucket( config['transport']['throttle_capacity'], config['transport']['throttle_fill_rate'], ) transport = UDPTransport( discovery, mapped_socket.socket, throttle_policy, config['transport'], ) elif transport == 'matrix': transport = MatrixTransport(config['matrix']) else: raise RuntimeError(f'Unknown transport type "{transport}" given') raiden_app = App( config, blockchain_service, registry, secret_registry, transport, discovery, ) return raiden_app