def test_setup_proxies_no_service_registry_and_no_pfs_address_but_requesting_pfs(environment_type): """ Test that if pfs routing mode is requested and no address or service registry is given then the client exits with an error message """ network_id = 42 config = { "environment_type": environment_type, "chain_id": network_id, "services": dict( pathfinding_max_fee=100, pathfinding_iou_timeout=500, pathfinding_max_paths=5 ), } contracts = {} proxy_manager = MockProxyManager(node_address=make_address()) with pytest.raises(SystemExit): with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO): setup_proxies_or_exit( config=config, tokennetwork_registry_contract_address=make_token_network_registry_address(), secret_registry_contract_address=make_address(), user_deposit_contract_address=make_address(), service_registry_contract_address=None, proxy_manager=proxy_manager, contracts=contracts, routing_mode=RoutingMode.PFS, pathfinding_service_address=None, )
def test_timestamped_event(): event = EventPaymentSentFailed(make_token_network_registry_address(), make_address(), 1, make_address(), "whatever") log_time = "2018-09-07T20:02:35.000" timestamped = TimestampedEvent(event, log_time) assert timestamped.log_time == log_time assert timestamped.reason == timestamped.wrapped_event.reason == "whatever" assert timestamped.identifier == 1
def test_timestamped_event(): event = EventPaymentSentFailed(make_token_network_registry_address(), make_address(), 1, make_address(), "whatever") log_time = datetime.fromisoformat("2018-09-07T20:02:35.000") timestamped = TimestampedEvent(event, log_time) assert timestamped.log_time == log_time assert isinstance(timestamped.event, EventPaymentSentFailed) assert timestamped.reason == timestamped.event.reason == "whatever" assert timestamped.identifier == timestamped.event.identifier == 1
def initialize_all(self, block_number, random, random_seed): self.random_seed = random_seed self.block_number = block_number self.block_hash = factories.make_block_hash() self.random = random self.token_network_address = factories.UNIT_TOKEN_NETWORK_ADDRESS self.token_id = factories.UNIT_TOKEN_ADDRESS self.token_network_state = TokenNetworkState( address=self.token_network_address, token_address=self.token_id, network_graph=TokenNetworkGraphState(self.token_network_address), ) self.token_network_registry_address = factories.make_token_network_registry_address() self.token_network_registry_state = TokenNetworkRegistryState( self.token_network_registry_address, [self.token_network_state] ) channels = [] for _ in range(self.number_of_clients): private_key, address = factories.make_privkey_address() self.address_to_privkey[address] = private_key chain_state = ChainState( pseudo_random_generator=self.random, block_number=self.block_number, block_hash=self.block_hash, our_address=address, chain_id=factories.UNIT_CHAIN_ID, ) chain_state.identifiers_to_tokennetworkregistries[ self.token_network_registry_address ] = self.token_network_registry_state chain_state.tokennetworkaddresses_to_tokennetworkregistryaddresses[ self.token_network_address ] = self.token_network_registry_address self.address_to_client[address] = Client(chain_state=chain_state) channels.extend( self.new_channel_with_transaction(client_address=address) for _ in range(self.initial_number_of_channels) ) return multiple(*channels)
def test_event_filter_for_payments(): token_network_address = factories.make_address() secret = factories.make_secret() token_network_registry_address = factories.make_token_network_registry_address( ) identifier = 1 target = factories.make_address() event = EventPaymentSentSuccess( token_network_registry_address=token_network_registry_address, token_network_address=token_network_address, identifier=identifier, amount=5, target=target, secret=secret, route=[], ) assert event_filter_for_payments(event=event, partner_address=None) assert event_filter_for_payments(event=event, partner_address=target) assert not event_filter_for_payments( event=event, partner_address=factories.make_address()) event = EventPaymentReceivedSuccess( token_network_registry_address=token_network_registry_address, token_network_address=token_network_address, identifier=identifier, amount=5, initiator=target, ) assert event_filter_for_payments(event=event, partner_address=None) assert event_filter_for_payments(event=event, partner_address=target) assert not event_filter_for_payments( event=event, partner_address=factories.make_address()) event = EventPaymentSentFailed( token_network_registry_address=factories. make_token_network_registry_address(), token_network_address=token_network_address, identifier=identifier, target=target, reason="whatever", ) assert event_filter_for_payments(event=event, partner_address=None) assert event_filter_for_payments(event=event, partner_address=target) assert not event_filter_for_payments( event=event, partner_address=factories.make_address())
def test_no_iou_when_pfs_price_0(query_paths_args): """ Test that no IOU is sent when PFS is for free """ query_paths_args["pfs_config"] = PFSConfig( info=PFSInfo( url="abc", price=TokenAmount(0), chain_id=ChainID(42), token_network_registry_address=factories.make_token_network_registry_address(), user_deposit_address=factories.make_address(), payment_address=factories.make_address(), message="", operator="", version="", ), maximum_fee=TokenAmount(100), iou_timeout=BlockNumber(100), max_paths=5, ) with patch.object( pathfinding, "post_pfs_paths", return_value=mocked_json_response() ) as post_path: query_paths( pfs_config=query_paths_args["pfs_config"], our_address=query_paths_args["our_address"], privkey=query_paths_args["privkey"], current_block_number=query_paths_args["current_block_number"], token_network_address=query_paths_args["token_network_address"], one_to_n_address=query_paths_args["one_to_n_address"], chain_id=query_paths_args["chain_id"], route_from=query_paths_args["route_from"], route_to=query_paths_args["route_to"], value=query_paths_args["value"], ) assert post_path.call_args == call( payload={ "from": to_checksum_address(query_paths_args["route_from"]), "to": to_checksum_address(query_paths_args["route_to"]), "value": query_paths_args["value"], "max_paths": query_paths_args["pfs_config"].max_paths, }, token_network_address=query_paths_args["token_network_address"], url=query_paths_args["pfs_config"].info.url, )
def iou_side_effect(*args, **kwargs): if args[0].endswith("/info"): return mocked_json_response({ "price_info": 5, "network_info": { "chain_id": 42, "token_network_registry_address": to_checksum_address( factories.make_token_network_registry_address()), "user_deposit_address": to_checksum_address(factories.make_address()), "confirmed_block": { "number": 11 }, }, "version": "0.0.3", "operator": "John Doe", "message": "This is your favorite pathfinding service", "payment_address": to_checksum_address(factories.make_address()), "matrix_server": "http://matrix.example.com", }) else: assert "params" in kwargs body = kwargs["params"] assert is_hex_address(body["sender"]) assert is_hex_address(body["receiver"]) assert "timestamp" in body assert is_hex(body["signature"]) assert len(body["signature"] ) == 65 * 2 + 2 # 65 hex encoded bytes with 0x prefix return mocked_json_response(response_data=iou_json_data)
def test_write_read_events(): wal = new_wal(state_transition_noop) event = EventPaymentSentFailed(make_token_network_registry_address(), make_address(), 1, make_address(), "whatever") with pytest.raises(sqlite3.IntegrityError): unexisting_state_change_id = random.getrandbits(16 * 8).to_bytes( 16, "big") wal.storage.write_events([(unexisting_state_change_id, event)]) previous_events = wal.storage.get_events_with_timestamps() state_change_ids = wal.storage.write_state_changes([StateChange()]) wal.storage.write_events([(state_change_ids[0], event)]) new_events = wal.storage.get_events_with_timestamps() assert len(previous_events) + 1 == len(new_events) latest_event = new_events[-1] assert isinstance(latest_event, TimestampedEvent) assert isinstance(latest_event.wrapped_event, EventPaymentSentFailed)
def setup_pfs_handler_test( set_feedback_token: bool, ) -> Tuple[RaidenService, PFSFeedbackEventHandler, TokenNetworkRegistryAddress, TokenNetworkAddress, List[Address], Optional[UUID], ]: channel_identifier = make_channel_identifier() token_network_registry_address = make_token_network_registry_address() token_network_address = make_token_network_address() participant = make_address() raiden = make_raiden_service_mock( token_network_registry_address=token_network_registry_address, token_network_address=token_network_address, channel_identifier=channel_identifier, partner=participant, ) default_handler = RaidenEventHandler() pfs_handler = PFSFeedbackEventHandler(default_handler) route = [make_address(), make_address(), make_address()] # Set PFS config and feedback token pfs_config = True # just a truthy value raiden.config.pfs_config = pfs_config feedback_uuid = None if set_feedback_token: feedback_uuid = uuid4() raiden.route_to_feedback_token[tuple(route)] = feedback_uuid return ( raiden, pfs_handler, token_network_registry_address, token_network_address, route, feedback_uuid, )
def test_handle_contract_send_channelunlock_already_unlocked(): """This is a test for the scenario where the onchain unlock has already happened when we get to handle our own send unlock transaction. Regression test for https://github.com/raiden-network/raiden/issues/3152 """ channel_identifier = ChannelID(1) token_network_registry_address = make_token_network_registry_address() token_network_address = make_token_network_address() participant = make_address() raiden = make_raiden_service_mock( token_network_registry_address=token_network_registry_address, token_network_address=token_network_address, channel_identifier=channel_identifier, partner=participant, ) channel_state = get_channelstate_by_token_network_and_partner( chain_state=state_from_raiden(raiden), token_network_address=token_network_address, partner_address=participant, ) assert channel_state channel_state.our_state.onchain_locksroot = LOCKSROOT_OF_NO_LOCKS channel_state.partner_state.onchain_locksroot = LOCKSROOT_OF_NO_LOCKS def detail_participants(_participant1, _participant2, _block_identifier, _channel_identifier): transferred_amount = TokenAmount(1) locked_amount = LockedAmount(1) locksroot = make_locksroot() balance_hash = hash_balance_data(transferred_amount, locked_amount, locksroot) our_details = ParticipantDetails( address=raiden.address, deposit=TokenAmount(5), withdrawn=WithdrawAmount(0), is_closer=False, balance_hash=balance_hash, nonce=Nonce(1), locksroot=locksroot, locked_amount=locked_amount, ) transferred_amount = TokenAmount(1) locked_amount = LockedAmount(1) # Let's mock here that partner locksroot is 0x0 balance_hash = hash_balance_data(transferred_amount, locked_amount, locksroot) partner_details = ParticipantDetails( address=participant, deposit=TokenAmount(5), withdrawn=WithdrawAmount(0), is_closer=True, balance_hash=balance_hash, nonce=Nonce(1), locksroot=LOCKSROOT_OF_NO_LOCKS, locked_amount=locked_amount, ) return ParticipantsDetails(our_details, partner_details) # make sure detail_participants returns partner data with a locksroot of 0x0 raiden.proxy_manager.token_network.detail_participants = detail_participants event = ContractSendChannelBatchUnlock( canonical_identifier=make_canonical_identifier( token_network_address=token_network_address, channel_identifier=channel_identifier), sender=participant, triggered_by_block_hash=make_block_hash(), ) # This should not throw an unrecoverable error RaidenEventHandler().on_raiden_events( raiden=raiden, chain_state=raiden.wal.state_manager.current_state, events=[event])
new_state, channels = factories.create_network( token_network_state=token_network_state, our_address=our_address, routes=routes, block_number=factories.make_block_number(), ) return new_state, [address1, address2, address3, address4], channels PFS_CONFIG = PFSConfig( info=PFSInfo( url="abc", price=TokenAmount(12), chain_id=ChainID(42), token_network_registry_address=factories.make_token_network_registry_address(), user_deposit_address=factories.make_address(), payment_address=factories.make_address(), message="", operator="", version="", ), maximum_fee=TokenAmount(100), iou_timeout=BlockTimeout(100), max_paths=5, ) CONFIG = {"pfs_config": PFS_CONFIG} PRIVKEY = b"privkeyprivkeyprivkeyprivkeypriv"