def api_sut(
pathfinding_service_mock: PathfindingService,
reachability_state: SimpleReachabilityContainer,
free_port: int,
populate_token_network_case_1, # pylint: disable=unused-argument
) -> Iterator[PFSApi]:
pathfinding_service_mock.matrix_listener.user_manager = reachability_state
api = PFSApi(
pathfinding_service=pathfinding_service_mock,
one_to_n_address=Address(bytes([1] * 20)),
operator="",
)
api.run(host=DEFAULT_API_HOST, port=free_port)
yield api
api.stop()
def api_sut(
pathfinding_service_mock: PathfindingService,
reachability_state: SimpleReachabilityContainer,
free_port: int,
populate_token_network_case_1, # pylint: disable=unused-argument
) -> Iterator[PFSApi]:
pathfinding_service_mock.matrix_listener.user_manager = reachability_state
pathfinding_service_mock.web3.eth.get_block = lambda x: Mock(
timestamp=pathfinding_service_mock.blockchain_state.latest_committed_block * 15
if x == "latest"
else x * 15
)
api = PFSApi(
pathfinding_service=pathfinding_service_mock,
one_to_n_address=Address(bytes([1] * 20)),
operator="",
)
api.run(host=DEFAULT_API_HOST, port=free_port)
yield api
api.stop()
def test_get_paths_validation(
api_sut: PFSApi,
api_url: str,
addresses: List[Address],
token_network_model: TokenNetwork,
make_iou: Callable,
):
initiator_address = to_checksum_address(addresses[0])
target_address = to_checksum_address(addresses[1])
url = api_url + "/v1/" + to_checksum_address(
token_network_model.address) + "/paths"
default_params = {
"from": initiator_address,
"to": target_address,
"value": 5,
"max_paths": 3
}
def request_path_with(status_code=400, **kwargs):
params = default_params.copy()
params.update(kwargs)
response = requests.post(url, json=params)
assert response.status_code == status_code, response.json()
return response
response = requests.post(url)
assert response.status_code == 400
assert response.json()["errors"].startswith("JSON payload expected")
for address in ["notanaddress", to_normalized_address(initiator_address)]:
response = request_path_with(**{"from": address})
assert response.json(
)["error_code"] == exceptions.InvalidRequest.error_code
assert "from" in response.json()["error_details"]
response = request_path_with(to=address)
assert response.json(
)["error_code"] == exceptions.InvalidRequest.error_code
assert "to" in response.json()["error_details"]
response = request_path_with(value=-10)
assert response.json(
)["error_code"] == exceptions.InvalidRequest.error_code
assert "value" in response.json()["error_details"]
response = request_path_with(max_paths=-1)
assert response.json(
)["error_code"] == exceptions.InvalidRequest.error_code
assert "max_paths" in response.json()["error_details"]
# successful request without payment
request_path_with(status_code=200)
# Exemplary test for payment errors. Different errors are serialized the
# same way in the rest API. Checking for specific errors is tested in
# payment_tests.
api_sut.service_fee = TokenAmount(1)
response = request_path_with()
assert response.json()["error_code"] == exceptions.MissingIOU.error_code
# prepare iou for payment tests
iou = make_iou(
PrivateKey(get_random_privkey()),
api_sut.pathfinding_service.address,
one_to_n_address=api_sut.one_to_n_address,
)
good_iou_dict = iou.Schema().dump(iou)
# malformed iou
bad_iou_dict = good_iou_dict.copy()
del bad_iou_dict["amount"]
response = request_path_with(iou=bad_iou_dict)
assert response.json(
)["error_code"] == exceptions.InvalidRequest.error_code
# malformed iou
bad_iou_dict = {
"amount": {
"_hex": "0x64"
},
"chain_id": {
"_hex": "0x05"
},
"expiration_block": {
"_hex": "0x188cba"
},
"one_to_n_address":
"0x0000000000000000000000000000000000000000",
"receiver":
"0x94DEe8e391410A9ebbA791B187df2d993212c849",
"sender":
"0x2046F7341f15D0211ca1EBeFb19d029c4Bc4c4e7",
"signature":
("0x0c3066e6a954d660028695f96dfe88cabaf0bc8a385e51781ac4d21003d0b6cd7a8b2"
"a1134115845655d1a509061f48459cd401565b5df7845c913ed329cd2351b"),
}
response = request_path_with(iou=bad_iou_dict)
assert response.json(
)["error_code"] == exceptions.InvalidRequest.error_code
# bad signature
bad_iou_dict = good_iou_dict.copy()
bad_iou_dict["signature"] = "0x" + "1" * 130
response = request_path_with(iou=bad_iou_dict)
assert response.json(
)["error_code"] == exceptions.InvalidSignature.error_code
# with successful payment
request_path_with(iou=good_iou_dict, status_code=200)
def main( # pylint: disable=too-many-arguments,too-many-locals
private_key: PrivateKey,
state_db: str,
web3: Web3,
contracts: Dict[str, Contract],
start_block: BlockNumber,
confirmations: BlockTimeout,
host: str,
port: int,
service_fee: TokenAmount,
operator: str,
info_message: str,
enable_debug: bool,
matrix_server: List[str],
accept_disclaimer: bool,
enable_tracing: bool,
tracing_sampler: str,
tracing_param: str,
) -> int:
"""The Pathfinding service for the Raiden Network."""
log.info("Starting Raiden Pathfinding Service")
click.secho(PFS_DISCLAIMER, fg="yellow")
if not accept_disclaimer:
click.confirm(CONFIRMATION_OF_UNDERSTANDING, abort=True)
if not confirmations:
chain_id = ChainID(web3.eth.chain_id)
confirmations = (BlockTimeout(0) if "arbitrum" in ID_TO_CHAINNAME.get(
chain_id, "") else DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
log.info("Setting number of confirmation blocks",
confirmations=confirmations)
log.info("Using RPC endpoint", rpc_url=get_web3_provider_info(web3))
hex_addresses = {
name: to_checksum_address(contract.address)
for name, contract in contracts.items()
}
log.info("Contract information",
addresses=hex_addresses,
start_block=start_block)
if enable_tracing:
tracing_config = Config(
config={
"sampler": {
"type": tracing_sampler,
"param": tracing_param
},
"logging": True
},
service_name="pfs",
scope_manager=GeventScopeManager(),
validate=True,
)
# Tracer is stored in `opentracing.tracer`
tracing_config.initialize_tracer()
assert isinstance(web3.provider, HTTPProvider), MYPY_ANNOTATION
assert web3.provider.endpoint_uri is not None, MYPY_ANNOTATION
# Set `Web3` requests Session to use `SessionTracing`
cache_session(
web3.provider.endpoint_uri,
SessionTracing(propagate=False, span_tags={"target": "ethnode"}),
)
service = None
api = None
try:
service = PathfindingService(
web3=web3,
contracts=contracts,
sync_start_block=start_block,
required_confirmations=confirmations,
private_key=private_key,
poll_interval=DEFAULT_POLL_INTERVALL,
db_filename=state_db,
matrix_servers=matrix_server,
enable_tracing=enable_tracing,
)
service.start()
log.debug("Waiting for service to start before accepting API requests")
try:
service.startup_finished.get(timeout=PFS_START_TIMEOUT)
except gevent.Timeout:
raise Exception("PFS did not start within time.")
log.debug("Starting API")
api = PFSApi(
pathfinding_service=service,
service_fee=service_fee,
debug_mode=enable_debug,
one_to_n_address=to_canonical_address(
contracts[CONTRACT_ONE_TO_N].address),
operator=operator,
info_message=info_message,
enable_tracing=enable_tracing,
)
api.run(host=host, port=port)
service.get()
except (KeyboardInterrupt, SystemExit):
print("Exiting...")
finally:
log.info("Stopping Pathfinding Service...")
if api:
api.stop()
if service:
service.stop()
return 0
def main( # pylint: disable=too-many-arguments,too-many-locals
private_key: PrivateKey,
state_db: str,
web3: Web3,
contracts: Dict[str, Contract],
start_block: BlockNumber,
confirmations: BlockTimeout,
host: str,
port: int,
service_fee: TokenAmount,
operator: str,
info_message: str,
enable_debug: bool,
matrix_server: List[str],
accept_disclaimer: bool,
) -> int:
"""The Pathfinding service for the Raiden Network."""
log.info("Starting Raiden Pathfinding Service")
click.secho(PFS_DISCLAIMER, fg="yellow")
if not accept_disclaimer:
click.confirm(CONFIRMATION_OF_UNDERSTANDING, abort=True)
log.info("Using RPC endpoint", rpc_url=get_web3_provider_info(web3))
hex_addresses = {
name: to_checksum_address(contract.address)
for name, contract in contracts.items()
}
log.info("Contract information",
addresses=hex_addresses,
start_block=start_block)
service = None
api = None
try:
service = PathfindingService(
web3=web3,
contracts=contracts,
sync_start_block=start_block,
required_confirmations=confirmations,
private_key=private_key,
poll_interval=DEFAULT_POLL_INTERVALL,
db_filename=state_db,
matrix_servers=matrix_server,
)
service.start()
log.debug("Waiting for service to start before accepting API requests")
try:
service.startup_finished.get(timeout=PFS_START_TIMEOUT)
except gevent.Timeout:
raise Exception("PFS did not start within time.")
log.debug("Starting API")
api = PFSApi(
pathfinding_service=service,
service_fee=service_fee,
debug_mode=enable_debug,
one_to_n_address=to_canonical_address(
contracts[CONTRACT_ONE_TO_N].address),
operator=operator,
info_message=info_message,
)
api.run(host=host, port=port)
service.get()
except (KeyboardInterrupt, SystemExit):
print("Exiting...")
finally:
log.info("Stopping Pathfinding Service...")
if api:
api.stop()
if service:
service.stop()
return 0