def test_mediated_transfer_calls_pfs(raiden_network, token_addresses):
app0, = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address)
with patch("raiden.routing.query_paths",
return_value=([], None)) as patched:
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=10,
target=factories.HOP1,
identifier=1,
secret=b"1" * 32,
)
assert not patched.called
# Setup PFS config
app0.raiden.config["pfs_config"] = PFSConfig(
info=PFSInfo(
url="mock-address",
chain_id=app0.raiden.rpc_client.chain_id,
token_network_registry_address=token_network_registry_address,
payment_address=factories.make_address(),
message="",
operator="",
version="",
price=TokenAmount(0),
),
maximum_fee=TokenAmount(100),
iou_timeout=BlockNumber(100),
max_paths=5,
)
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=11,
target=factories.HOP2,
identifier=2,
secret=b"2" * 32,
)
assert patched.call_count == 1
# Mediator should not re-query PFS
locked_transfer = factories.create(
factories.LockedTransferProperties(
amount=TokenAmount(5),
initiator=factories.HOP1,
target=TargetAddress(factories.HOP2),
sender=factories.HOP1,
pkey=factories.HOP1_KEY,
token=token_address,
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_address),
))
app0.raiden.mediate_mediated_transfer(locked_transfer)
assert patched.call_count == 1
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(),
confirmed_block_number=dict(number=BlockNumber(1)),
message="",
operator="",
version="",
matrix_server="http://matrix.example.com",
matrix_room_id="!room-id:matrix.example.com",
),
maximum_fee=TokenAmount(100),
iou_timeout=BlockNumber(100),
max_paths=5,
)
with patch("raiden.network.pathfinding.get_pfs_info") as mocked_pfs_info:
mocked_pfs_info.return_value = PFS_CONFIG.info
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"],
pfs_wait_for_block=query_paths_args["pfs_wait_for_block"],
)
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 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_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 services_bundle_from_contracts_deployment(
config: RaidenConfig,
proxy_manager: ProxyManager,
routing_mode: RoutingMode,
deployed_addresses: DeploymentAddresses,
pathfinding_service_address: str,
enable_monitoring: bool,
) -> ServicesBundle:
"""
Initialize and setup the contract proxies.
Depending on the provided contract addresses via the CLI, the routing mode,
the environment type and the network id try to initialize the proxies.
Returns the initialized proxies or exits the application with an error if
there is a problem.
Also depending on the given arguments populate config with PFS related settings
"""
node_network_id = config.chain_id
environment_type = config.environment_type
user_deposit_address = deployed_addresses.user_deposit_address
service_registry_address = deployed_addresses.service_registry_address
token_network_registry_address = deployed_addresses.token_network_registry_address
contractname_address: List[Tuple[str, Address, Callable]] = [
("user_deposit", Address(user_deposit_address), proxy_manager.user_deposit)
]
if routing_mode == RoutingMode.PFS:
contractname_address.append(
("service_registry", Address(service_registry_address), proxy_manager.service_registry)
)
if enable_monitoring or routing_mode == RoutingMode.PFS:
contractname_address.append(
(
"monitoring_service",
Address(deployed_addresses.monitoring_service_address),
proxy_manager.monitoring_service,
)
)
contractname_address.append(
("one_to_n", Address(deployed_addresses.one_to_n_address), proxy_manager.one_to_n)
)
proxies = dict()
for contractname, address, constructor in contractname_address:
try:
proxy = constructor(address)
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code(contractname, address)
except AddressWrongContract:
handle_contract_wrong_address(contractname, address)
proxies[contractname] = proxy
if routing_mode == RoutingMode.PFS:
check_pfs_configuration(pathfinding_service_address=pathfinding_service_address)
pfs_info = configure_pfs_or_exit(
pfs_url=pathfinding_service_address,
routing_mode=routing_mode,
service_registry=proxies["service_registry"],
node_network_id=node_network_id,
token_network_registry_address=TokenNetworkRegistryAddress(
token_network_registry_address
),
pathfinding_max_fee=config.services.pathfinding_max_fee,
)
msg = "Eth address of selected pathfinding service is unknown."
assert pfs_info.payment_address is not None, msg
# Only check that PFS is registered in production mode
if environment_type == Environment.PRODUCTION:
check_pfs_for_production(
service_registry=proxies["service_registry"], pfs_info=pfs_info
)
config.pfs_config = PFSConfig(
info=pfs_info,
maximum_fee=config.services.pathfinding_max_fee,
iou_timeout=config.services.pathfinding_iou_timeout,
max_paths=config.services.pathfinding_max_paths,
)
else:
config.pfs_config = None
return ServicesBundle(
user_deposit=cast(UserDeposit, proxies.get("user_deposit")),
service_registry=cast(ServiceRegistry, proxies.get("service_registry")),
monitoring_service=cast(MonitoringService, proxies.get("monitoring_service")),
one_to_n=cast(OneToN, proxies.get("one_to_n")),
)
def test_mediated_transfer_calls_pfs(raiden_chain: List[App], token_addresses: List[TokenAddress]):
app0, app1, app2 = raiden_chain
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address
)
assert token_network_address, "Fixture token_addresses don't have correspoding token_network"
with patch("raiden.routing.query_paths", return_value=([], None)) as patched:
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=PaymentAmount(10),
target=TargetAddress(app1.raiden.address),
identifier=PaymentID(1),
secret=Secret(b"1" * 32),
)
assert not patched.called
# Setup PFS config
app0.raiden.config.pfs_config = PFSConfig(
info=PFSInfo(
url="mock-address",
chain_id=app0.raiden.rpc_client.chain_id,
token_network_registry_address=token_network_registry_address,
user_deposit_address=factories.make_address(),
payment_address=factories.make_address(),
confirmed_block_number=chain_state.block_number,
message="",
operator="",
version="",
price=TokenAmount(0),
),
maximum_fee=TokenAmount(100),
iou_timeout=BlockTimeout(100),
max_paths=5,
)
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=PaymentAmount(11),
target=TargetAddress(app2.raiden.address),
identifier=PaymentID(2),
secret=Secret(b"2" * 32),
)
assert patched.call_count == 1
# Mediator should not re-query PFS
locked_transfer = factories.create(
factories.LockedTransferProperties(
amount=TokenAmount(5),
initiator=factories.HOP1,
target=TargetAddress(app2.raiden.address),
sender=factories.HOP1,
pkey=factories.HOP1_KEY,
token=token_address,
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_address
),
)
)
app0.raiden.on_messages([locked_transfer])
assert patched.call_count == 1
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="",
confirmed_block_number=BlockNumber(10),
matrix_server="http://matrix.example.com",
matrix_room_id="!room-id:matrix.example.com",
),
maximum_fee=TokenAmount(100),
iou_timeout=BlockTimeout(100),
max_paths=5,
)
CONFIG = {"pfs_config": PFS_CONFIG}
PRIVKEY = b"privkeyprivkeyprivkeyprivkeypriv"
def get_best_routes_with_iou_request_mocked(
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(),
payment_address=factories.make_address(),
message="",
operator="",
version="",
),
maximum_fee=TokenAmount(100),
iou_timeout=BlockNumber(100),
max_paths=5,
)
CONFIG = {"pfs_config": PFS_CONFIG}
PRIVKEY = b"privkeyprivkeyprivkeyprivkeypriv"
def get_best_routes_with_iou_request_mocked(
chain_state,
token_network_state,
def setup_proxies_or_exit(
config: Dict[str, Any],
tokennetwork_registry_contract_address: TokenNetworkRegistryAddress,
secret_registry_contract_address: Address,
user_deposit_contract_address: Address,
service_registry_contract_address: Address,
proxy_manager: ProxyManager,
contracts: Dict[str, Any],
routing_mode: RoutingMode,
pathfinding_service_address: str,
) -> Proxies:
"""
Initialize and setup the contract proxies.
Depending on the provided contract addresses via the CLI, the routing mode,
the environment type and the network id try to initialize the proxies.
Returns the initialized proxies or exits the application with an error if
there is a problem.
Also depending on the given arguments populate config with PFS related settings
"""
node_network_id = config["chain_id"]
environment_type = config["environment_type"]
check_smart_contract_addresses(
environment_type=environment_type,
node_network_id=node_network_id,
tokennetwork_registry_contract_address=
tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
contracts=contracts,
)
token_network_registry = None
try:
if tokennetwork_registry_contract_address is not None:
registered_address = tokennetwork_registry_contract_address
else:
registered_address = to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])
token_network_registry = proxy_manager.token_network_registry(
registered_address)
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code(
"token network registry",
Address(tokennetwork_registry_contract_address))
except AddressWrongContract:
handle_contract_wrong_address(
"token network registry",
Address(tokennetwork_registry_contract_address))
secret_registry = None
try:
secret_registry = proxy_manager.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]["address"]))
except ContractCodeMismatch as e:
handle_contract_code_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)
# If services contracts are provided via the CLI use them instead
if user_deposit_contract_address is not None:
contracts[CONTRACT_USER_DEPOSIT] = user_deposit_contract_address
if service_registry_contract_address is not None:
contracts[
CONTRACT_SERVICE_REGISTRY] = service_registry_contract_address
user_deposit = None
should_use_user_deposit = (
environment_type == Environment.DEVELOPMENT
and ID_TO_NETWORKNAME.get(node_network_id) != "smoketest"
and CONTRACT_USER_DEPOSIT in contracts)
if should_use_user_deposit:
try:
user_deposit = proxy_manager.user_deposit(
user_deposit_contract_address or to_canonical_address(
contracts[CONTRACT_USER_DEPOSIT]["address"]))
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("user deposit",
user_deposit_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("user_deposit",
user_deposit_contract_address)
service_registry = None
if CONTRACT_SERVICE_REGISTRY in contracts or service_registry_contract_address:
try:
service_registry = proxy_manager.service_registry(
service_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SERVICE_REGISTRY]["address"]))
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("service registry",
service_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("secret registry",
service_registry_contract_address)
# By now these should be set or Raiden aborted
assert token_network_registry, "TokenNetworkRegistry needs to be set"
assert secret_registry, "SecretRegistry needs to be set"
if routing_mode == RoutingMode.PFS:
check_pfs_configuration(
service_registry=service_registry,
pathfinding_service_address=pathfinding_service_address,
)
pfs_info = configure_pfs_or_exit(
pfs_url=pathfinding_service_address,
routing_mode=routing_mode,
service_registry=service_registry,
node_network_id=node_network_id,
token_network_registry_address=token_network_registry.address,
pathfinding_max_fee=config["services"]["pathfinding_max_fee"],
)
msg = "Eth address of selected pathfinding service is unknown."
assert pfs_info.payment_address is not None, msg
# Only check that PFS is registered in production mode
if environment_type == Environment.PRODUCTION:
check_pfs_for_production(service_registry=service_registry,
pfs_info=pfs_info)
config["pfs_config"] = PFSConfig(
info=pfs_info,
maximum_fee=config["services"]["pathfinding_max_fee"],
iou_timeout=config["services"]["pathfinding_iou_timeout"],
max_paths=config["services"]["pathfinding_max_paths"],
)
else:
config["pfs_config"] = None
proxies = Proxies(
token_network_registry=token_network_registry,
secret_registry=secret_registry,
user_deposit=user_deposit,
service_registry=service_registry,
)
return proxies
