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"
