def register_token(
self,
registry_address_hex: AddressHex,
token_address_hex: AddressHex,
retry_timeout: NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> TokenNetwork:
""" Register a token with the raiden token manager.
Args:
registry_address_hex: a hex encoded registry address.
token_address_hex: a hex encoded token address.
retry_timeout: the retry timeout
Returns:
The token network proxy.
"""
registry_address = TokenNetworkRegistryAddress(
to_canonical_address(registry_address_hex))
token_address = TokenAddress(to_canonical_address(token_address_hex))
registry = self._raiden.proxy_manager.token_network_registry(
registry_address, BLOCK_ID_LATEST)
token_network_address = registry.add_token(
token_address=token_address,
channel_participant_deposit_limit=TokenAmount(UINT256_MAX),
token_network_deposit_limit=TokenAmount(UINT256_MAX),
given_block_identifier=BLOCK_ID_LATEST,
)
waiting.wait_for_token_network(self._raiden, registry.address,
token_address, retry_timeout)
return self._raiden.proxy_manager.token_network(
token_network_address, BLOCK_ID_LATEST)
def get_pfs_info(url: str) -> PFSInfo:
try:
response = session.get(f"{url}/api/v1/info")
infos = get_response_json(response)
matrix_server_info = urlparse(infos["matrix_server"])
return PFSInfo(
url=url,
price=infos["price_info"],
chain_id=infos["network_info"]["chain_id"],
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(infos["network_info"]["token_network_registry_address"])
),
user_deposit_address=Address(
to_canonical_address(infos["network_info"]["user_deposit_address"])
),
payment_address=to_canonical_address(infos["payment_address"]),
message=infos["message"],
operator=infos["operator"],
version=infos["version"],
confirmed_block_number=infos["network_info"]["confirmed_block"]["number"],
matrix_server=matrix_server_info.netloc,
matrix_room_id=infos.get("matrix_room_id"),
)
except RequestException as e:
msg = "Selected Pathfinding Service did not respond"
raise ServiceRequestFailed(msg) from e
except (json.JSONDecodeError, KeyError, ValueError) as e:
msg = "Selected Pathfinding Service returned unexpected reply"
raise ServiceRequestFailed(msg) from e
def open_channel_with_funding(
self,
registry_address_hex: AddressHex,
token_address_hex: AddressHex,
peer_address_hex: AddressHex,
total_deposit: TokenAmount,
settle_timeout: BlockTimeout = None,
) -> None:
""" Convenience method to open a channel.
Args:
registry_address_hex: hex encoded address of the registry for the channel.
token_address_hex: hex encoded address of the token for the channel.
peer_address_hex: hex encoded address of the channel peer.
total_deposit: amount of total funding for the channel.
settle_timeout: amount of blocks for the settle time (if None use app defaults).
Return:
netting_channel: the (newly opened) netting channel object.
"""
# Check, if peer is discoverable
registry_address = TokenNetworkRegistryAddress(
to_canonical_address(registry_address_hex))
peer_address = to_canonical_address(peer_address_hex)
token_address = TokenAddress(to_canonical_address(token_address_hex))
self._api.channel_open(registry_address,
token_address,
peer_address,
settle_timeout=settle_timeout)
self._api.set_total_channel_deposit(registry_address, token_address,
peer_address, total_deposit)
def deploy_token_network_registry(
secret_registry_deploy_result: Callable[[], SecretRegistry],
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
proxy_manager: ProxyManager,
chain_id: ChainID,
settle_timeout_min: int,
settle_timeout_max: int,
max_token_networks: int,
) -> TokenNetworkRegistry:
secret_registry_proxy = secret_registry_deploy_result()
contract, receipt = deploy_client.deploy_single_contract(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
contract=contract_manager.get_contract(
CONTRACT_TOKEN_NETWORK_REGISTRY),
constructor_parameters=[
secret_registry_proxy.address,
chain_id,
settle_timeout_min,
settle_timeout_max,
max_token_networks,
],
)
return proxy_manager.token_network_registry(
TokenNetworkRegistryAddress(to_canonical_address(contract.address)),
BlockNumber(receipt["blockNumber"]),
)
def get_token_network_registry_from_dependencies(
settings: SettingsConfig,
proxy_manager: ProxyManager,
development_environment: ContractDevEnvironment,
smoketest_deployment_data: DeployedContracts = None,
) -> TokenNetworkRegistry:
"""Return contract proxies for the UserDepositContract and associated token.
This will return a proxy to the `UserDeposit` contract as determined by the
**local** Raiden dependency.
"""
chain_id = settings.chain_id
assert chain_id, "Missing configuration, either set udc_address or the chain_id"
if chain_id != CHAINNAME_TO_ID["smoketest"]:
contracts = get_contracts_deployment_info(
chain_id,
version=RAIDEN_CONTRACT_VERSION,
development_environment=development_environment,
)
else:
contracts = smoketest_deployment_data
msg = f"invalid chain_id, {chain_id} is not available for version {RAIDEN_CONTRACT_VERSION}"
assert contracts, msg
token_network_address = contracts["contracts"][CONTRACT_TOKEN_NETWORK_REGISTRY]["address"]
token_network_proxy = proxy_manager.token_network_registry(
TokenNetworkRegistryAddress(to_canonical_address(token_network_address)),
"latest",
)
return token_network_proxy
def token_network_registry_address(
self, block_identifier: BlockSpecification
) -> TokenNetworkRegistryAddress:
return TokenNetworkRegistryAddress(
to_canonical_address(
self.proxy.contract.functions.token_network_registry().call(
block_identifier=block_identifier)))
def contractreceivenewtokennetwork_from_event(
event: DecodedEvent,
pendingtokenregistration: Dict[TokenNetworkAddress,
Tuple[TokenNetworkRegistryAddress,
TokenAddress]],
) -> ContractReceiveNewTokenNetwork:
data = event.event_data
args = data["args"]
token_network_address = args["token_network_address"]
token_address = TokenAddress(args["token_address"])
token_network_registry_address = TokenNetworkRegistryAddress(
event.originating_contract)
pendingtokenregistration[token_network_address] = (
token_network_registry_address,
token_address,
)
return ContractReceiveNewTokenNetwork(
token_network_registry_address=token_network_registry_address,
token_network=TokenNetworkState(
address=token_network_address,
token_address=token_address,
network_graph=TokenNetworkGraphState(token_network_address),
),
transaction_hash=event.transaction_hash,
block_number=event.block_number,
block_hash=event.block_hash,
)
def deploy_token_network_registry_and_return_address(
deploy_client: JSONRPCClient,
secret_registry_address: SecretRegistryAddress,
chain_id: ChainID,
settle_timeout_min: int,
settle_timeout_max: int,
max_token_networks: int,
contract_manager: ContractManager,
) -> TokenNetworkRegistryAddress:
constructor_arguments = [
to_checksum_address(secret_registry_address),
chain_id,
settle_timeout_min,
settle_timeout_max,
max_token_networks,
]
address = deploy_contract_web3(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
return TokenNetworkRegistryAddress(to_canonical_address(address))
def get_pfs_info(url: str) -> PFSInfo:
try:
response = requests.get(f"{url}/api/v1/info",
timeout=DEFAULT_HTTP_REQUEST_TIMEOUT)
infos = get_response_json(response)
return PFSInfo(
url=url,
price=infos["price_info"],
chain_id=infos["network_info"]["chain_id"],
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(
infos["network_info"]["token_network_registry_address"])),
user_deposit_address=Address(
to_canonical_address(
infos["network_info"]["user_deposit_address"])),
payment_address=to_canonical_address(infos["payment_address"]),
message=infos["message"],
operator=infos["operator"],
version=infos["version"],
)
except requests.exceptions.RequestException as e:
msg = "Selected Pathfinding Service did not respond"
raise ServiceRequestFailed(msg) from e
except (json.JSONDecodeError, requests.exceptions.RequestException,
KeyError) as e:
msg = "Selected Pathfinding Service returned unexpected reply"
raise ServiceRequestFailed(msg) from e
def __init__(
self,
rpc_client: JSONRPCClient,
metadata: SmartContractMetadata,
proxy_manager: "ProxyManager",
block_identifier: BlockIdentifier,
) -> None:
check_address_has_code_handle_pruned_block(
client=rpc_client,
address=Address(metadata.address),
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
expected_code=metadata.runtime_bytecode,
given_block_identifier=block_identifier,
)
proxy = rpc_client.new_contract_proxy(abi=metadata.abi,
contract_address=Address(
metadata.address))
self.address = TokenNetworkRegistryAddress(metadata.address)
self.proxy_manager = proxy_manager
self.rpc_client = rpc_client
self.gas_measurements = metadata.gas_measurements
self.metadata = metadata
self.node_address = self.rpc_client.address
self.proxy = proxy
def handle_contract_receive_new_token_network_registry(
chain_state: ChainState, state_change: ContractReceiveNewTokenNetworkRegistry
) -> TransitionResult[ChainState]:
events: List[Event] = list()
token_network_registry = state_change.token_network_registry
token_network_registry_address = TokenNetworkRegistryAddress(token_network_registry.address)
if token_network_registry_address not in chain_state.identifiers_to_tokennetworkregistries:
chain_state.identifiers_to_tokennetworkregistries[
token_network_registry_address
] = token_network_registry
return TransitionResult(chain_state, events)
def test_setup_proxies_no_service_registry_but_pfs() -> None:
"""
Test that if no service registry is provided but a manual pfs address is given then startup
still works
Regression test for https://github.com/raiden-network/raiden/issues/3740
"""
chain_id = ChainID(5)
config = RaidenConfig(
chain_id=chain_id,
environment_type=Environment.DEVELOPMENT,
services=ServiceConfig(
pathfinding_max_fee=TokenAmount(100),
pathfinding_iou_timeout=BlockTimeout(500),
pathfinding_max_paths=5,
),
)
config.transport.available_servers = ["http://matrix.example.com"]
contracts = load_deployed_contracts_data(config, chain_id)
proxy_manager = MockProxyManager(node_address=make_address())
PFS_INFO = PFSInfo(
url="my-pfs",
price=TokenAmount(12),
chain_id=ChainID(5),
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])
),
user_deposit_address=user_deposit_address_test_default,
confirmed_block_number=BlockNumber(1),
payment_address=pfs_payment_address_default,
message="This is your favorite pathfinding service",
operator="John Doe",
version="0.0.3",
matrix_server="http://matrix.example.com",
matrix_room_id="!room-id:matrix.example.com",
)
deployed_addresses = load_deployment_addresses_from_contracts(contracts)
with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO):
services_bundle = services_bundle_from_contracts_deployment(
config=config,
proxy_manager=proxy_manager, # type: ignore
deployed_addresses=deployed_addresses,
routing_mode=RoutingMode.PFS,
pathfinding_service_address="my-pfs",
enable_monitoring=True,
)
assert services_bundle
def contractreceivenewtokennetwork_from_event(
event: DecodedEvent
) -> ContractReceiveNewTokenNetwork:
data = event.event_data
args = data["args"]
token_network_address = args["token_network_address"]
return ContractReceiveNewTokenNetwork(
token_network_registry_address=TokenNetworkRegistryAddress(event.originating_contract),
token_network=TokenNetworkState(
address=token_network_address,
token_address=args["token_address"],
network_graph=TokenNetworkGraphState(token_network_address),
),
transaction_hash=event.transaction_hash,
block_number=event.block_number,
block_hash=event.block_hash,
)
def _get_token_network_address(
token_address: TokenAddress,
web3: Web3,
privkey: PrivateKey,
deploy: DeployedContracts,
) -> TokenNetworkAddress:
client = JSONRPCClient(web3, privkey, faster_gas_price_strategy)
proxy_manager = get_proxy_manager(client, deploy)
token_network_registry_address = TokenNetworkRegistryAddress(
to_canonical_address(
deploy["contracts"][CONTRACT_TOKEN_NETWORK_REGISTRY]["address"]))
confirmed_block_hash = client.get_confirmed_blockhash()
token_network_registry = proxy_manager.token_network_registry(
token_network_registry_address, confirmed_block_hash)
token_network_address = token_network_registry.get_token_network(
token_address, confirmed_block_hash)
assert token_network_address
return token_network_address
def load_deployment_addresses_from_contracts(
contracts: Dict[str, Any]) -> DeploymentAddresses:
return DeploymentAddresses(
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])),
secret_registry_address=SecretRegistryAddress(
to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]["address"])),
user_deposit_address=UserDepositAddress(
to_canonical_address(contracts[CONTRACT_USER_DEPOSIT]["address"])),
service_registry_address=ServiceRegistryAddress(
to_canonical_address(
contracts[CONTRACT_SERVICE_REGISTRY]["address"])),
monitoring_service_address=MonitoringServiceAddress(
to_canonical_address(
contracts[CONTRACT_MONITORING_SERVICE]["address"])),
one_to_n_address=OneToNAddress(
to_canonical_address(contracts[CONTRACT_ONE_TO_N]["address"])),
)
def get_pfs_info(url: str) -> PFSInfo:
try:
response = requests.get(f"{url}/api/v1/info",
timeout=DEFAULT_HTTP_REQUEST_TIMEOUT)
infos = get_response_json(response)
return PFSInfo(
url=url,
price=infos["price_info"],
chain_id=infos["network_info"]["chain_id"],
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(
infos["network_info"]["registry_address"])),
payment_address=to_canonical_address(infos["payment_address"]),
message=infos["message"],
operator=infos["operator"],
version=infos["version"],
)
except (json.JSONDecodeError, requests.exceptions.RequestException,
KeyError) as e:
raise ServiceRequestFailed(str(e)) from e
def main(output_directory, network_id, eth_rpc_endpoint, contracts_version):
web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint)))
try:
check_ethereum_client_is_supported(web3)
except ConnectionError:
click.secho(
f"Couldn't connect to the ethereum node, double check it is running "
f"on {eth_rpc_endpoint}, this option can be changed with "
f"{ETH_RPC_CONFIG_OPTION}",
fg="red",
)
return
check_ethereum_network_id(network_id, web3)
# This script does not send any transactions, the privatekey is generate
# just because it is a dependency for JSONRPCClient.
unecessary_privatekey = factories.make_privatekey_bin()
rpc_client = JSONRPCClient(web3=web3, privkey=unecessary_privatekey)
check_synced(rpc_client)
deployment_data = get_contracts_deployment_info(chain_id=network_id, version=contracts_version)
if not deployment_data:
raise RuntimeError(
f"There is no deployment data available for contracts-version {contracts_version}."
)
network_name = ID_TO_CHAINNAME.get(network_id)
if network_name is None:
raise RuntimeError(f"Network with id {network_id} is not known.")
contracts = deployment_data["contracts"]
token_network_registry_deployed_at = BlockNumber(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["block_number"]
)
token_network_registry_address = TokenNetworkRegistryAddress(
to_canonical_address(contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])
)
secret_registry_address = SecretRegistryAddress(
to_canonical_address(contracts[CONTRACT_SECRET_REGISTRY]["address"])
)
contracts_path = contracts_precompiled_path(contracts_version)
contract_manager = ContractManager(contracts_path)
current_block_number = rpc_client.block_number()
confirmed_block = rpc_client.get_block(
BlockNumber(current_block_number - DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
)
all_events_for_a_deployment = fetch_all_events_for_a_deployment(
contract_manager=contract_manager,
web3=web3,
token_network_registry_address=token_network_registry_address,
secret_registry_address=secret_registry_address,
start_block=token_network_registry_deployed_at,
target_block=confirmed_block["number"],
)
target_block_formatted = to_hex(confirmed_block["hash"])
file_path = os.path.join(
output_directory,
(
f"{network_name}-"
f"{to_checksum_address(token_network_registry_address)}-"
f"{target_block_formatted}.json.gz"
),
)
block_data = {
"gasLimit": confirmed_block["gasLimit"],
"gasUsed": confirmed_block["gasUsed"],
"hash": to_hex(confirmed_block["hash"]),
"number": confirmed_block["number"],
}
block_data_formatted = simplejson.dumps(block_data).encode("utf8")
with gzip.open(file_path, mode="wb") as handler:
# Format is `jsonlines` (http://jsonlines.org/), this is used because we
# don't have to keep all the events in memory to start encoding the data.
for event in all_events_for_a_deployment:
format_event_for_serialization(event)
data = simplejson.dumps(event).encode("utf8")
handler.write(data + b"\n")
# Write the block details at the end
handler.write(block_data_formatted + b"\n")
def run_smoketest(
print_step: Callable,
args: Dict[str, Any],
contract_addresses: Dict[str, Address],
token: ContractProxy,
):
print_step("Starting Raiden")
app = None
api_server = None
try:
app = run_app(**args)
raiden_api = RaidenAPI(app.raiden)
rest_api = RestAPI(raiden_api)
(api_host, api_port) = split_endpoint(args["api_address"])
api_server = APIServer(rest_api, config={"host": api_host, "port": api_port})
api_server.start()
block = BlockNumber(app.raiden.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
# Proxies now use the confirmed block hash to query the chain for
# prerequisite checks. Wait a bit here to make sure that the confirmed
# block hash contains the deployed token network or else things break
wait_for_block(raiden=app.raiden, block_number=block, retry_timeout=1.0)
raiden_api.channel_open(
registry_address=TokenNetworkRegistryAddress(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]
),
token_address=TokenAddress(to_canonical_address(token.contract.address)),
partner_address=ConnectionManager.BOOTSTRAP_ADDR,
)
raiden_api.set_total_channel_deposit(
registry_address=TokenNetworkRegistryAddress(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]
),
token_address=TokenAddress(to_canonical_address(token.contract.address)),
partner_address=ConnectionManager.BOOTSTRAP_ADDR,
total_deposit=TEST_DEPOSIT_AMOUNT,
)
token_addresses = [to_checksum_address(token.contract.address)]
print_step("Running smoketest")
raiden_service = app.raiden
token_network_added_events = raiden_service.default_registry.filter_token_added_events()
events_token_addresses = [
event["args"]["token_address"] for event in token_network_added_events
]
assert events_token_addresses == token_addresses
token_networks = views.get_token_identifiers(
views.state_from_raiden(raiden_service), raiden_service.default_registry.address
)
assert len(token_networks) == 1
channel_state = views.get_channelstate_for(
chain_state=views.state_from_raiden(raiden_service),
token_network_registry_address=raiden_service.default_registry.address,
token_address=token_networks[0],
partner_address=ConnectionManager.BOOTSTRAP_ADDR,
)
assert channel_state
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) == ChannelState.STATE_OPENED
port_number = raiden_service.config.api_port
response = requests.get(f"http://localhost:{port_number}/api/v1/channels")
assert response.status_code == HTTPStatus.OK
response_json = json.loads(response.content)
assert response_json[0]["partner_address"] == to_checksum_address(
ConnectionManager.BOOTSTRAP_ADDR
)
assert response_json[0]["state"] == "opened"
assert int(response_json[0]["balance"]) > 0
finally:
if api_server is not None:
api_server.stop()
api_server.greenlet.get()
if app is not None:
app.stop()
app.raiden.greenlet.get()
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")),
)
is_canonical_address,
is_same_address,
to_canonical_address,
to_checksum_address,
)
from raiden.constants import MATRIX_AUTO_SELECT_SERVER, RoutingMode
from raiden.exceptions import RaidenError
from raiden.network.pathfinding import PFSInfo, check_pfs_for_production, configure_pfs_or_exit
from raiden.settings import DEFAULT_PATHFINDING_MAX_FEE
from raiden.tests.utils.mocks import mocked_json_response
from raiden.tests.utils.smartcontracts import deploy_service_registry_and_set_urls
from raiden.utils.keys import privatekey_to_address
from raiden.utils.typing import ChainID, TokenAmount, TokenNetworkRegistryAddress
token_network_registry_address_test_default = TokenNetworkRegistryAddress(
to_canonical_address("0xB9633dd9a9a71F22C933bF121d7a22008f66B908"))
def test_configure_pfs(service_registry_address, private_keys, web3,
contract_manager):
chain_id = ChainID(int(web3.net.version))
service_registry, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
json_data = {
"price_info":
0,
"network_info": {
def setup_raiden(
matrix_server: str,
print_step: StepPrinter,
contracts_version,
eth_rpc_endpoint: str,
web3: Web3,
base_datadir: Path,
keystore: Path,
) -> RaidenTestSetup:
print_step("Deploying Raiden contracts")
client = JSONRPCClient(web3, get_private_key(keystore))
contract_manager = ContractManager(
contracts_precompiled_path(contracts_version))
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,
),
)
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=TokenAmount(1000),
decimals=0,
token_name="TKN",
token_symbol="TKN",
token_contract_name=CONTRACT_CUSTOM_TOKEN,
)
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=CHAINNAME_TO_ID["smoketest"],
contract_manager=contract_manager,
token_address=token.address,
)
confirmed_block_identifier = client.get_confirmed_blockhash()
registry = proxy_manager.token_network_registry(
TokenNetworkRegistryAddress(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]),
block_identifier=confirmed_block_identifier,
)
registry.add_token(
token_address=TokenAddress(to_canonical_address(token.address)),
channel_participant_deposit_limit=TokenAmount(UINT256_MAX),
token_network_deposit_limit=TokenAmount(UINT256_MAX),
given_block_identifier=confirmed_block_identifier,
)
print_step("Setting up Raiden")
user_deposit_contract_address = to_checksum_address(
contract_addresses[CONTRACT_USER_DEPOSIT])
args = {
"address": to_checksum_address(TEST_ACCOUNT_ADDRESS),
"datadir": keystore,
"eth_rpc_endpoint": eth_rpc_endpoint,
"gas_price": "fast",
"keystore_path": keystore,
"matrix_server": matrix_server,
"chain_id": str(CHAINNAME_TO_ID["smoketest"]),
"password_file": click.File()(os.path.join(base_datadir, "pw")),
"user_deposit_contract_address": user_deposit_contract_address,
"sync_check": False,
"environment_type": Environment.DEVELOPMENT,
}
# Wait until the secret registry is confirmed, otherwise the RaidenService
# inialization will fail, needed for the check
# `check_ethereum_confirmed_block_is_not_pruned`.
current_block = client.block_number()
target_block_number = current_block + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS
while current_block < target_block_number:
current_block = client.block_number()
sleep(0.5)
return RaidenTestSetup(args=args,
token=token,
contract_addresses=contract_addresses)
def run_smoketest(print_step: StepPrinter, setup: RaidenTestSetup) -> None:
print_step("Starting Raiden")
app = None
try:
app = run_raiden_service(**setup.args)
raiden_api = app.raiden_api
assert raiden_api is not None # for mypy
partner_address = Address(b"1" * 20)
block = BlockNumber(app.get_block_number() +
DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
# Proxies now use the confirmed block hash to query the chain for
# prerequisite checks. Wait a bit here to make sure that the confirmed
# block hash contains the deployed token network or else things break
wait_for_block(raiden=app, block_number=block, retry_timeout=1.0)
raiden_api.channel_open(
registry_address=TokenNetworkRegistryAddress(
setup.contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]),
token_address=TokenAddress(
to_canonical_address(setup.token.address)),
partner_address=partner_address,
)
raiden_api.set_total_channel_deposit(
registry_address=TokenNetworkRegistryAddress(
setup.contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]),
token_address=TokenAddress(
to_canonical_address(setup.token.address)),
partner_address=partner_address,
total_deposit=TEST_DEPOSIT_AMOUNT,
)
token_addresses = [to_checksum_address(setup.token.address)
] # type: ignore
print_step("Running smoketest")
raiden_service = app
token_network_added_events = raiden_service.default_registry.filter_token_added_events(
)
events_token_addresses = [
event["args"]["token_address"]
for event in token_network_added_events
]
assert events_token_addresses == token_addresses
token_networks = views.get_token_identifiers(
views.state_from_raiden(raiden_service),
raiden_service.default_registry.address)
assert len(token_networks) == 1
channel_state = views.get_channelstate_for(
chain_state=views.state_from_raiden(raiden_service),
token_network_registry_address=raiden_service.default_registry.
address,
token_address=token_networks[0],
partner_address=partner_address,
)
assert channel_state
distributable = channel.get_distributable(channel_state.our_state,
channel_state.partner_state)
assert distributable == TEST_DEPOSIT_AMOUNT
assert Balance(
distributable) == channel_state.our_state.contract_balance
assert channel.get_status(channel_state) == ChannelState.STATE_OPENED
port_number = raiden_service.config.rest_api.port
response = requests.get(
f"http://localhost:{port_number}/api/v1/channels")
assert response.status_code == HTTPStatus.OK
response_json = json.loads(response.content)
assert response_json[0]["partner_address"] == to_checksum_address(
partner_address)
assert response_json[0]["state"] == "opened"
assert int(response_json[0]["balance"]) > 0
finally:
if app is not None:
app.stop()
app.greenlet.get()
def test_configure_pfs(service_registry_address, private_keys, web3,
contract_manager):
chain_id = ChainID(int(web3.net.version))
service_registry, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
json_data = {
"price_info":
0,
"network_info": {
"chain_id":
chain_id,
"token_network_registry_address":
to_checksum_address(token_network_registry_address_test_default),
"user_deposit_address":
to_checksum_address(privatekey_to_address(private_keys[1])),
"confirmed_block": {
"number": 10
},
},
"message":
"This is your favorite pathfinding service",
"operator":
"John Doe",
"version":
"0.0.1",
"payment_address":
to_checksum_address(privatekey_to_address(private_keys[0])),
}
response = mocked_json_response(response_data=json_data)
# With local routing configure_pfs should raise assertion
with pytest.raises(AssertionError):
_ = configure_pfs_or_exit(
pfs_url="",
routing_mode=RoutingMode.LOCAL,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# With private routing configure_pfs should raise assertion
with pytest.raises(AssertionError):
_ = configure_pfs_or_exit(
pfs_url="",
routing_mode=RoutingMode.PRIVATE,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# Asking for auto address
# To make this deterministic we need to patch the random selection function
patch_random = patch("raiden.network.pathfinding.get_random_pfs",
return_value="http://foo")
with patch.object(requests, "get", return_value=response), patch_random:
config = configure_pfs_or_exit(
pfs_url=MATRIX_AUTO_SELECT_SERVER,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
assert config.url in urls
assert is_canonical_address(config.payment_address)
# Configuring a valid given address
given_address = "http://foo"
with patch.object(requests, "get", return_value=response):
config = configure_pfs_or_exit(
pfs_url=given_address,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
assert config.url == given_address
assert is_same_address(config.payment_address,
json_data["payment_address"])
assert config.price == json_data["price_info"]
# Bad address, should exit the program
bad_address = "http://badaddress"
with pytest.raises(RaidenError):
with patch.object(requests,
"get",
side_effect=requests.RequestException()):
# Configuring a given address
_ = configure_pfs_or_exit(
pfs_url=bad_address,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# Addresses of token network registries of pfs and client conflict, should exit the client
response = mocked_json_response(response_data=json_data)
with pytest.raises(RaidenError):
with patch.object(requests, "get", return_value=response):
_ = configure_pfs_or_exit(
pfs_url="http://foo",
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(
"0x2222222222222222222222222222222222222221")),
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# ChainIDs of pfs and client conflict, should exit the client
response = mocked_json_response(response_data=json_data)
with pytest.raises(RaidenError):
with patch.object(requests, "get", return_value=response):
configure_pfs_or_exit(
pfs_url="http://foo",
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=ChainID(chain_id + 1),
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
def setup_raiden(
transport,
matrix_server,
print_step,
contracts_version,
eth_client,
eth_rpc_endpoint,
web3,
base_datadir,
keystore,
):
print_step("Deploying Raiden contracts")
if eth_client is EthClient.PARITY:
client = JSONRPCClient(
web3, get_private_key(keystore), gas_estimate_correction=lambda gas: gas * 2
)
else:
client = JSONRPCClient(web3, get_private_key(keystore))
contract_manager = ContractManager(contracts_precompiled_path(contracts_version))
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,
),
)
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=TokenAmount(1000),
decimals=0,
token_name="TKN",
token_symbol="TKN",
token_contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
)
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=NETWORKNAME_TO_ID["smoketest"],
contract_manager=contract_manager,
token_address=to_checksum_address(token.contract.address),
)
registry = proxy_manager.token_network_registry(
TokenNetworkRegistryAddress(contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY])
)
registry.add_token(
token_address=TokenAddress(to_canonical_address(token.contract.address)),
channel_participant_deposit_limit=TokenAmount(UINT256_MAX),
token_network_deposit_limit=TokenAmount(UINT256_MAX),
block_identifier=client.get_confirmed_blockhash(),
)
print_step("Setting up Raiden")
tokennetwork_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY]
)
secret_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY]
)
args = {
"address": to_checksum_address(TEST_ACCOUNT_ADDRESS),
"datadir": keystore,
"eth_rpc_endpoint": eth_rpc_endpoint,
"gas_price": "fast",
"keystore_path": keystore,
"matrix_server": matrix_server,
"network_id": str(NETWORKNAME_TO_ID["smoketest"]),
"password_file": click.File()(os.path.join(base_datadir, "pw")),
"tokennetwork_registry_contract_address": tokennetwork_registry_contract_address,
"secret_registry_contract_address": secret_registry_contract_address,
"sync_check": False,
"transport": transport,
}
service_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SERVICE_REGISTRY]
)
args["service_registry_contract_address"] = service_registry_contract_address
monitoring_service_contract_address = to_checksum_address(
contract_addresses[CONTRACT_MONITORING_SERVICE]
)
args["monitoring_service_contract_address"] = monitoring_service_contract_address
one_to_n_contract_address = to_checksum_address(contract_addresses[CONTRACT_ONE_TO_N])
args["one_to_n_contract_address"] = one_to_n_contract_address
# Wait until the secret registry is confirmed, otherwise the App
# inialization will fail, needed for the check
# `check_ethereum_confirmed_block_is_not_pruned`.
current_block = client.block_number()
target_block_number = current_block + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS
while current_block < target_block_number:
current_block = client.block_number()
sleep(0.5)
return {"args": args, "contract_addresses": contract_addresses, "token": token}
