def get_udc_and_corresponding_token_from_dependencies( chain_id: ChainID, proxy_manager: ProxyManager, development_environment: ContractDevEnvironment, udc_address: ChecksumAddress = None, ) -> Tuple[UserDeposit, CustomToken]: """Return contract proxies for the UserDepositContract and associated token. This will return a proxy to the `UserDeposit` contract as determined by the **local** Raiden depedency. """ if udc_address is None: contracts = get_contracts_deployment_info( chain_id, version=RAIDEN_CONTRACT_VERSION, development_environment=development_environment, ) msg = (f"invalid chain_id, {chain_id} is not available " f"for version {RAIDEN_CONTRACT_VERSION}") assert contracts, msg udc_address = contracts["contracts"][CONTRACT_USER_DEPOSIT]["address"] userdeposit_proxy = proxy_manager.user_deposit( UserDepositAddress(to_canonical_address(udc_address)), "latest") token_address = userdeposit_proxy.token_address("latest") user_token_proxy = proxy_manager.custom_token(token_address, "latest") return userdeposit_proxy, user_token_proxy
def jsonrpc_services( proxy_manager: ProxyManager, private_keys: List[PrivateKey], secret_registry_address: SecretRegistryAddress, service_registry_address: ServiceRegistryAddress, token_network_registry_address: TokenNetworkRegistryAddress, web3: Web3, contract_manager: ContractManager, ) -> BlockchainServices: secret_registry = proxy_manager.secret_registry(secret_registry_address) service_registry = None if service_registry_address: service_registry = proxy_manager.service_registry(service_registry_address) deploy_registry = proxy_manager.token_network_registry(token_network_registry_address) blockchain_services = list() for privkey in private_keys: rpc_client = JSONRPCClient(web3, privkey) proxy_manager = ProxyManager( rpc_client=rpc_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) blockchain_services.append(proxy_manager) return BlockchainServices( deploy_registry=deploy_registry, secret_registry=secret_registry, service_registry=service_registry, proxy_manager=proxy_manager, blockchain_services=blockchain_services, )
def test_token_network_registry_max_token_networks( deploy_client, token_network_registry_address, contract_manager): """ get_max_token_networks() should return an integer """ proxy_manager = ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) token_network_registry_proxy = proxy_manager.token_network_registry( to_canonical_address(token_network_registry_address)) assert (token_network_registry_proxy.get_max_token_networks( block_identifier="latest") == UINT256_MAX)
def deploy_user_deposit_and_return_address( proxy_manager: ProxyManager, deploy_client: JSONRPCClient, contract_manager: ContractManager, token_proxy: Token, private_keys: List[PrivateKey], environment_type: Environment, ) -> Optional[Address]: """ Deploy UserDeposit and fund accounts with some balances """ if environment_type != Environment.DEVELOPMENT: return None constructor_arguments = [token_proxy.address, UINT256_MAX] user_deposit_address = deploy_contract_web3( contract_name=CONTRACT_USER_DEPOSIT, deploy_client=deploy_client, contract_manager=contract_manager, constructor_arguments=constructor_arguments, ) user_deposit = proxy_manager.user_deposit( UserDepositAddress(user_deposit_address)) participants = [privatekey_to_address(key) for key in private_keys] for transfer_to in participants: user_deposit.deposit( beneficiary=transfer_to, total_deposit=MONITORING_REWARD, given_block_identifier="latest", ) return user_deposit_address
def deploy_service_registry( token_deploy_result: Callable[[], Contract], deploy_client: JSONRPCClient, contract_manager: ContractManager, proxy_manager: ProxyManager, ) -> ServiceRegistry: token_contract = token_deploy_result() contract, receipt = deploy_client.deploy_single_contract( contract_name=CONTRACT_SERVICE_REGISTRY, contract=contract_manager.get_contract(CONTRACT_SERVICE_REGISTRY), constructor_parameters=( token_contract.address, EMPTY_ADDRESS, int(500e18), 6, 5, 180 * SECONDS_PER_DAY, 1000, 200 * SECONDS_PER_DAY, ), ) return proxy_manager.service_registry( ServiceRegistryAddress(to_canonical_address(contract.address)), BlockNumber(receipt["blockNumber"]), )
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 deploy_monitoring_service( token_deploy_result: Callable[[], Contract], user_deposit_deploy_result: Callable[[], UserDeposit], service_registry_deploy_result: Callable[[], ServiceRegistry], token_network_registry_deploy_result: Callable[[], TokenNetworkRegistry], deploy_client: JSONRPCClient, contract_manager: ContractManager, proxy_manager: ProxyManager, ) -> MonitoringService: token_contract = token_deploy_result() token_network_registry_proxy = token_network_registry_deploy_result() user_deposit_proxy = user_deposit_deploy_result() service_registry_proxy = service_registry_deploy_result() contract, receipt = deploy_client.deploy_single_contract( contract_name=CONTRACT_MONITORING_SERVICE, contract=contract_manager.get_contract(CONTRACT_MONITORING_SERVICE), constructor_parameters=[ token_contract.address, service_registry_proxy.address, user_deposit_proxy.address, token_network_registry_proxy.address, ], ) return proxy_manager.monitoring_service( MonitoringServiceAddress(to_canonical_address(contract.address)), BlockNumber(receipt["blockNumber"]), )
def test_token_network_deposit_race( token_network_proxy, private_keys, token_proxy, web3, contract_manager ): assert token_network_proxy.settlement_timeout_min() == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max() == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address(token_network_proxy.proxy.address) c1_client = JSONRPCClient(web3, private_keys[1]) c2_client = JSONRPCClient(web3, private_keys[2]) proxy_manager = ProxyManager( rpc_client=c1_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) c1_token_network_proxy = proxy_manager.token_network( address=token_network_address, block_identifier=BLOCK_ID_LATEST ) token_proxy.transfer(c1_client.address, 10) channel_details = c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier=BLOCK_ID_LATEST, ) assert is_tx_hash_bytes(channel_details.transaction_hash) channel_identifier = channel_details.channel_identifier assert channel_identifier is not None c1_token_network_proxy.approve_and_set_total_deposit( given_block_identifier=BLOCK_ID_LATEST, channel_identifier=channel_identifier, total_deposit=2, partner=c2_client.address, ) with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.approve_and_set_total_deposit( given_block_identifier=BLOCK_ID_LATEST, channel_identifier=channel_identifier, total_deposit=1, partner=c2_client.address, )
def test_register_secret_batch_with_pruned_block(secret_registry_proxy, web3, private_keys, contract_manager): """Test secret registration with a pruned given block.""" c1_client = JSONRPCClient(web3, private_keys[1]) c1_proxy_manager = ProxyManager( rpc_client=c1_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) # Now wait until this block becomes pruned pruned_number = c1_proxy_manager.client.block_number() c1_proxy_manager.wait_until_block(target_block_number=pruned_number + STATE_PRUNING_AFTER_BLOCKS) secret_registry_batch_happy_path(secret_registry_proxy)
def proxy_manager(deploy_key, deploy_client, contract_manager): return ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), )
def test_query_pruned_state(token_network_proxy, private_keys, web3, contract_manager): """A test for https://github.com/raiden-network/raiden/issues/3566 If pruning limit blocks pass make sure that can_query_state_for_block returns False. """ token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_proxy_manager = ProxyManager( rpc_client=c1_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = c1_proxy_manager.token_network( token_network_address) # create a channel and query the state at the current block hash channel_identifier = c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=10, given_block_identifier="latest") block = c1_client.web3.eth.getBlock("latest") block_number = int(block["number"]) block_hash = bytes(block["hash"]) channel_id = c1_token_network_proxy.get_channel_identifier( participant1=c1_client.address, participant2=c2_client.address, block_identifier=block_hash) assert channel_id == channel_identifier assert c1_client.can_query_state_for_block(block_hash) # wait until state pruning kicks in target_block = block_number + STATE_PRUNING_AFTER_BLOCKS + 1 c1_proxy_manager.wait_until_block(target_block_number=target_block) # and now query again for the old block identifier and see we can't query assert not c1_client.can_query_state_for_block(block_hash)
def test_token_network_registry_with_zero_token_address( deploy_client, token_network_registry_address, contract_manager): """ Try to register a token at 0x0000..00 """ proxy_manager = ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) token_network_registry_proxy = proxy_manager.token_network_registry( token_network_registry_address) with pytest.raises(InvalidTokenAddress, match="0x00..00 will fail"): token_network_registry_proxy.add_token( token_address=NULL_ADDRESS_BYTES, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), block_identifier=deploy_client.get_confirmed_blockhash(), )
def fund_node( token_result: Callable[[], Contract], proxy_manager: ProxyManager, to_address: Address, amount: TokenAmount, ) -> None: token_contract = token_result() token_proxy = proxy_manager.token( TokenAddress(to_canonical_address(token_contract.address)), BLOCK_ID_LATEST) token_proxy.transfer(to_address=to_address, amount=amount)
def register_token_and_return_the_network_proxy( contract_manager: ContractManager, deploy_client: JSONRPCClient, token_proxy: Token, token_network_registry_address: TokenNetworkRegistryAddress, ) -> TokenNetwork: blockchain_service = ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) token_network_registry_proxy = blockchain_service.token_network_registry( token_network_registry_address) token_network_address = token_network_registry_proxy.add_token( token_address=token_proxy.address, channel_participant_deposit_limit= RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT, token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT, block_identifier=deploy_client.get_confirmed_blockhash(), ) blockchain_service = ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) return blockchain_service.token_network(token_network_address)
def load_deployment_addresses_from_udc( proxy_manager: ProxyManager, user_deposit_address: UserDepositAddress, block_identifier: BlockIdentifier, ) -> DeploymentAddresses: """Given a user deposit address, this function returns the list of contract addresses which are used as services which are bound to the user deposit contract deployed. """ block_identifier = BLOCK_ID_LATEST user_deposit = proxy_manager.user_deposit( UserDepositAddress(to_canonical_address(user_deposit_address)), block_identifier=block_identifier, ) monitoring_service_address = user_deposit.monitoring_service_address( block_identifier) one_to_n_address = user_deposit.one_to_n_address( block_identifier=block_identifier) monitoring_service_proxy = proxy_manager.monitoring_service( address=monitoring_service_address, block_identifier=block_identifier) token_network_registry_address = monitoring_service_proxy.token_network_registry_address( block_identifier=block_identifier) token_network_registry_proxy = proxy_manager.token_network_registry( token_network_registry_address, block_identifier=block_identifier) secret_registry_address = token_network_registry_proxy.get_secret_registry_address( block_identifier=block_identifier) service_registry_address = monitoring_service_proxy.service_registry_address( block_identifier=block_identifier) return DeploymentAddresses( token_network_registry_address=token_network_registry_address, secret_registry_address=secret_registry_address, user_deposit_address=user_deposit_address, service_registry_address=service_registry_address, monitoring_service_address=monitoring_service_address, one_to_n_address=one_to_n_address, )
def deploy_secret_registry(deploy_client: JSONRPCClient, contract_manager: ContractManager, proxy_manager: ProxyManager) -> SecretRegistry: contract, receipt = deploy_client.deploy_single_contract( contract_name=CONTRACT_SECRET_REGISTRY, contract=contract_manager.get_contract(CONTRACT_SECRET_REGISTRY), constructor_parameters=None, ) return proxy_manager.secret_registry( SecretRegistryAddress(to_canonical_address(contract.address)), BlockNumber(receipt["blockNumber"]), )
def setup_token_contract_for_token_network( self, proxy_manager: ProxyManager) -> CustomToken: """Ensure there is a deployed token contract and return a `CustomToken` proxy to it. This token will be used for the scenario's token network. This will either: - Use the token from the address provided in the scenario configuration. - Use a previously deployed token, with the details loaded from the disk. - Deploy a new token if neither of the above options is used. """ token_definition = self.definition.token reuse_token_from_file = token_definition.can_reuse_token if token_definition.address: token_address = to_canonical_address(token_definition.address) elif reuse_token_from_file: token_details = load_token_configuration_from_file( token_definition.token_file) token_address = to_canonical_address(token_details["address"]) else: contract_data = proxy_manager.contract_manager.get_contract( CONTRACT_CUSTOM_TOKEN) contract, receipt = self.client.deploy_single_contract( contract_name=CONTRACT_CUSTOM_TOKEN, contract=contract_data, constructor_parameters=( ORCHESTRATION_MAXIMUM_BALANCE, token_definition.decimals, token_definition.name, token_definition.symbol, ), ) token_address = to_canonical_address(contract.address) if token_definition.should_reuse_token: details = TokenDetails({ "name": token_definition.name, "address": to_checksum_address(token_address), "block": receipt["blockNumber"], }) save_token_configuration_to_file(token_definition.token_file, details) return proxy_manager.custom_token(TokenAddress(token_address), "latest")
def deploy_tokens_and_fund_accounts( token_amount: TokenAmount, number_of_tokens: int, proxy_manager: ProxyManager, participants: List[Address], contract_manager: ContractManager, token_contract_name: str, ) -> List[TokenAddress]: """ Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and distributed among `blockchain_services`. Optionally the instances will be registered with the raiden registry. Args: token_amount: number of units that will be created per token number_of_tokens: number of token instances that will be created proxy_manager: the proxy manager used to create the token proxy participants: participant addresses that will receive tokens """ result = list() for _ in range(number_of_tokens): token_address = TokenAddress( deploy_contract_web3( contract_name=token_contract_name, deploy_client=proxy_manager.client, contract_manager=contract_manager, constructor_arguments=(token_amount, 2, "raiden", "Rd"), )) result.append(token_address) # only the creator of the token starts with a balance (deploy_service), # transfer from the creator to the other nodes for transfer_to in participants: proxy_manager.token(token_address).transfer( to_address=transfer_to, amount=TokenAmount(token_amount // len(participants))) return result
def deploy_user_deposit( token_deploy_result: Callable[[], Contract], deploy_client: JSONRPCClient, contract_manager: ContractManager, proxy_manager: ProxyManager, ) -> UserDeposit: token_contract = token_deploy_result() contract, receipt = deploy_client.deploy_single_contract( contract_name=CONTRACT_USER_DEPOSIT, contract=contract_manager.get_contract(CONTRACT_USER_DEPOSIT), constructor_parameters=[token_contract.address, UINT256_MAX], ) return proxy_manager.user_deposit( UserDepositAddress(to_canonical_address(contract.address)), BlockNumber(receipt["blockNumber"]), )
def deploy_all_tokens_register_and_return_their_addresses( token_amount: TokenAmount, number_of_tokens: int, private_keys: List[PrivateKey], proxy_manager: ProxyManager, token_network_registry_address: TokenNetworkRegistryAddress, register_tokens: bool, contract_manager: ContractManager, token_contract_name: str, ) -> List[TokenAddress]: """ Fixture that yields `number_of_tokens` ERC20 token addresses, where the `token_amount` (per token) is distributed among the addresses behind `deploy_client` and potentially pre-registered with the Raiden Registry. The following arguments can control the behavior: Args: token_amount: the overall number of units minted per token number_of_tokens: the number of token instances register_tokens: controls if tokens will be registered with raiden Registry """ participants = [privatekey_to_address(key) for key in private_keys] token_addresses = deploy_tokens_and_fund_accounts( token_amount=token_amount, number_of_tokens=number_of_tokens, proxy_manager=proxy_manager, participants=participants, contract_manager=contract_manager, token_contract_name=token_contract_name, ) if register_tokens: for token in token_addresses: registry = proxy_manager.token_network_registry( token_network_registry_address) registry.add_token( token_address=token, channel_participant_deposit_limit= RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT, token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT, block_identifier=proxy_manager.client. blockhash_from_blocknumber("latest"), ) return token_addresses
def get_proxy_manager(client: JSONRPCClient, deploy: DeployedContracts) -> ProxyManager: contract_manager = ContractManager( contracts_precompiled_path(RAIDEN_CONTRACT_VERSION)) assert "contracts" in deploy, deploy token_network_deployment_details = deploy["contracts"][ CONTRACT_TOKEN_NETWORK_REGISTRY] deployed_at = token_network_deployment_details["block_number"] token_network_registry_deployed_at = BlockNumber(deployed_at) return ProxyManager( client, contract_manager, ProxyManagerMetadata( token_network_registry_deployed_at= token_network_registry_deployed_at, filters_start_at=token_network_registry_deployed_at, ), )
def deploy_one_to_n( user_deposit_deploy_result: Callable[[], UserDeposit], service_registry_deploy_result: Callable[[], ServiceRegistry], deploy_client: JSONRPCClient, contract_manager: ContractManager, proxy_manager: ProxyManager, chain_id: ChainID, ) -> OneToN: user_deposit_proxy = user_deposit_deploy_result() service_registry_proxy = service_registry_deploy_result() contract, receipt = deploy_client.deploy_single_contract( contract_name=CONTRACT_ONE_TO_N, contract=contract_manager.get_contract(CONTRACT_ONE_TO_N), constructor_parameters=[ user_deposit_proxy.address, chain_id, service_registry_proxy.address, ], ) return proxy_manager.one_to_n( OneToNAddress(to_canonical_address(contract.address)), BlockNumber(receipt["blockNumber"]))
def test_register_secret_happy_path(web3: Web3, secret_registry_proxy: SecretRegistry, contract_manager: ContractManager) -> None: """Test happy path of SecretRegistry with a single secret. Test that `register_secret` changes the smart contract state by registering the secret, this can be verified by the block height and the existence of the SecretRegistered event. """ secret = make_secret() secrethash = sha256_secrethash(secret) secret_unregistered = make_secret() secrethash_unregistered = sha256_secrethash(secret_unregistered) secret_registered_filter = secret_registry_proxy.secret_registered_filter( GENESIS_BLOCK_NUMBER) assert not secret_registry_proxy.is_secret_registered( secrethash=secrethash, block_identifier="latest" ), "Test setup is invalid, secret must be unknown" assert not secret_registry_proxy.is_secret_registered( secrethash=secrethash_unregistered, block_identifier="latest" ), "Test setup is invalid, secret must be unknown" proxy_manager = ProxyManager( rpc_client=secret_registry_proxy.client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) proxy_manager.wait_until_block(BlockNumber(STATE_PRUNING_AFTER_BLOCKS + 1)) with pytest.raises(NoStateForBlockIdentifier): secret_registry_proxy.is_secret_registered( secrethash=secrethash_unregistered, block_identifier=0) secret_registry_proxy.register_secret(secret=secret) logs = [ secret_registry_proxy.proxy.decode_event(encoded_log) for encoded_log in secret_registered_filter.get_new_entries(web3.eth.blockNumber) ] secret_registered = must_have_event(logs, { "event": "SecretRevealed", "args": { "secrethash": secrethash } }) msg = "SecretRegistry.register_secret returned but the SecretRevealed event was not emitted." assert secret_registered, msg registered_block = secret_registry_proxy.get_secret_registration_block_by_secrethash( secrethash=secrethash, block_identifier="latest") msg = ( "Block height returned by the SecretRegistry.get_secret_registration_block_by_secrethash " "does not match the block from the SecretRevealed event.") assert secret_registered["blockNumber"] == registered_block, msg block = secret_registry_proxy.get_secret_registration_block_by_secrethash( secrethash=secrethash_unregistered, block_identifier="latest") assert block is None, "The secret that was not registered must not change block height!"
def run_app( address: Address, keystore_path: str, gas_price: Callable, eth_rpc_endpoint: str, user_deposit_contract_address: Optional[UserDepositAddress], api_address: Endpoint, rpc: bool, rpccorsdomain: str, sync_check: bool, console: bool, password_file: TextIO, web_ui: bool, datadir: Optional[str], matrix_server: str, network_id: ChainID, environment_type: Environment, unrecoverable_error_should_crash: bool, pathfinding_service_address: str, pathfinding_max_paths: int, enable_monitoring: bool, resolver_endpoint: str, default_reveal_timeout: BlockTimeout, default_settle_timeout: BlockTimeout, routing_mode: RoutingMode, flat_fee: Tuple[Tuple[TokenAddress, FeeAmount], ...], proportional_fee: Tuple[Tuple[TokenAddress, ProportionalFeeAmount], ...], proportional_imbalance_fee: Tuple[Tuple[TokenAddress, ProportionalFeeAmount], ...], blockchain_query_interval: float, cap_mediation_fees: bool, ** kwargs: Any, # FIXME: not used here, but still receives stuff in smoketest ) -> App: # pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument token_network_registry_deployed_at: Optional[BlockNumber] smart_contracts_start_at: BlockNumber if datadir is None: datadir = os.path.join(os.path.expanduser("~"), ".raiden") account_manager = AccountManager(keystore_path) web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint))) check_sql_version() check_ethereum_has_accounts(account_manager) check_ethereum_client_is_supported(web3) check_ethereum_network_id(network_id, web3) address, privatekey = get_account_and_private_key(account_manager, address, password_file) api_host, api_port = split_endpoint(api_address) if not api_port: api_port = DEFAULT_HTTP_SERVER_PORT domain_list = [] if rpccorsdomain: if "," in rpccorsdomain: for domain in rpccorsdomain.split(","): domain_list.append(str(domain)) else: domain_list.append(str(rpccorsdomain)) # Set up config fee_config = prepare_mediation_fee_config( cli_token_to_flat_fee=flat_fee, cli_token_to_proportional_fee=proportional_fee, cli_token_to_proportional_imbalance_fee=proportional_imbalance_fee, cli_cap_mediation_fees=cap_mediation_fees, ) rest_api_config = RestApiConfig( rest_api_enabled=rpc, web_ui_enabled=rpc and web_ui, cors_domain_list=domain_list, eth_rpc_endpoint=eth_rpc_endpoint, host=api_host, port=api_port, ) config = RaidenConfig( chain_id=network_id, environment_type=environment_type, reveal_timeout=default_reveal_timeout, settle_timeout=default_settle_timeout, console=console, mediation_fees=fee_config, unrecoverable_error_should_crash=unrecoverable_error_should_crash, resolver_endpoint=resolver_endpoint, rest_api=rest_api_config, ) config.blockchain.query_interval = blockchain_query_interval config.services.monitoring_enabled = enable_monitoring config.services.pathfinding_max_paths = pathfinding_max_paths config.transport.server = matrix_server contracts = load_deployed_contracts_data(config, network_id) rpc_client = JSONRPCClient( web3=web3, privkey=privatekey, gas_price_strategy=gas_price, block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS, ) token_network_registry_deployed_at = None if "TokenNetworkRegistry" in contracts: token_network_registry_deployed_at = BlockNumber( contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["block_number"]) if token_network_registry_deployed_at is None: smart_contracts_start_at = get_smart_contracts_start_at(network_id) else: smart_contracts_start_at = token_network_registry_deployed_at proxy_manager = ProxyManager( rpc_client=rpc_client, contract_manager=ContractManager(config.contracts_path), metadata=ProxyManagerMetadata( token_network_registry_deployed_at= token_network_registry_deployed_at, filters_start_at=smart_contracts_start_at, ), ) api_server: Optional[APIServer] = None if config.rest_api.rest_api_enabled: api_server = start_api_server(rpc_client=rpc_client, config=config.rest_api, eth_rpc_endpoint=eth_rpc_endpoint) if sync_check: check_synced(rpc_client) # The user has the option to launch Raiden with a custom # user deposit contract address. This can be used to load # the addresses for the rest of the deployed contracts. # The steps done here make sure that if a UDC address is provided, # the address has to be valid and all the connected contracts # are configured properly. # If a UDC address was not provided, Raiden would fall back # to using the ones deployed and provided by the raiden-contracts package. if user_deposit_contract_address is not None: if not is_address(user_deposit_contract_address): raise RaidenError("The user deposit address is invalid") deployed_addresses = load_deployment_addresses_from_udc( proxy_manager=proxy_manager, user_deposit_address=user_deposit_contract_address, block_identifier=BLOCK_ID_LATEST, ) else: deployed_addresses = load_deployment_addresses_from_contracts( contracts=contracts) # Load the available matrix servers when no matrix server is given # The list is used in a PFS check if config.transport.server == MATRIX_AUTO_SELECT_SERVER: fetch_available_matrix_servers(config.transport, environment_type) raiden_bundle = raiden_bundle_from_contracts_deployment( proxy_manager=proxy_manager, token_network_registry_address=deployed_addresses. token_network_registry_address, secret_registry_address=deployed_addresses.secret_registry_address, ) services_bundle = services_bundle_from_contracts_deployment( config=config, deployed_addresses=deployed_addresses, proxy_manager=proxy_manager, routing_mode=routing_mode, pathfinding_service_address=pathfinding_service_address, enable_monitoring=enable_monitoring, ) check_ethereum_confirmed_block_is_not_pruned( jsonrpc_client=rpc_client, secret_registry=raiden_bundle.secret_registry, confirmation_blocks=config.blockchain.confirmation_blocks, ) database_path = Path( os.path.join( datadir, f"node_{pex(address)}", f"netid_{network_id}", f"network_{pex(raiden_bundle.token_network_registry.address)}", f"v{RAIDEN_DB_VERSION}_log.db", )) config.database_path = database_path print(f"Raiden is running in {environment_type.value.lower()} mode") print("\nYou are connected to the '{}' network and the DB path is: {}". format(ID_TO_CHAINNAME.get(network_id, network_id), database_path)) matrix_transport = setup_matrix(config.transport, config.services, environment_type, routing_mode) event_handler: EventHandler = RaidenEventHandler() # User should be told how to set fees, if using default fee settings log.debug("Fee Settings", fee_settings=fee_config) has_default_fees = (len(fee_config.token_to_flat_fee) == 0 and len(fee_config.token_to_proportional_fee) == 0 and len(fee_config.token_to_proportional_imbalance_fee) == 0) if has_default_fees: click.secho( "Default fee settings are used. " "If you want use Raiden with mediation fees - flat, proportional and imbalance fees - " "see https://raiden-network.readthedocs.io/en/latest/overview_and_guide.html#firing-it-up", # noqa: E501 fg="yellow", ) # Only send feedback when PFS is used if routing_mode == RoutingMode.PFS: event_handler = PFSFeedbackEventHandler(event_handler) message_handler = MessageHandler() one_to_n_address = (services_bundle.one_to_n.address if services_bundle.one_to_n is not None else None) monitoring_service_address = (services_bundle.monitoring_service.address if services_bundle.monitoring_service is not None else None) raiden_app = App( config=config, rpc_client=rpc_client, proxy_manager=proxy_manager, query_start_block=smart_contracts_start_at, default_registry=raiden_bundle.token_network_registry, default_secret_registry=raiden_bundle.secret_registry, default_service_registry=services_bundle.service_registry, default_user_deposit=services_bundle.user_deposit, default_one_to_n_address=one_to_n_address, default_msc_address=monitoring_service_address, transport=matrix_transport, raiden_event_handler=event_handler, message_handler=message_handler, routing_mode=routing_mode, api_server=api_server, ) raiden_app.start() return raiden_app
def test_token_network_registry( deploy_client: JSONRPCClient, contract_manager: ContractManager, token_network_registry_address: TokenNetworkRegistryAddress, token_contract_name: str, ) -> None: proxy_manager = ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) confirmed_block_identifier = deploy_client.get_confirmed_blockhash() token_network_registry_proxy = proxy_manager.token_network_registry( token_network_registry_address, block_identifier=confirmed_block_identifier) assert (token_network_registry_proxy.settlement_timeout_min( BLOCK_ID_LATEST) == TEST_SETTLE_TIMEOUT_MIN) assert (token_network_registry_proxy.settlement_timeout_max( BLOCK_ID_LATEST) == TEST_SETTLE_TIMEOUT_MAX) assert (token_network_registry_proxy.get_token_network_created( block_identifier=BLOCK_ID_LATEST) == 0) bad_token_address = make_token_address() # Registering a non-existing token network should fail with pytest.raises(AddressWithoutCode): token_network_registry_proxy.add_token( token_address=bad_token_address, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), given_block_identifier=confirmed_block_identifier, ) test_token = deploy_token( deploy_client=deploy_client, contract_manager=contract_manager, initial_amount=TokenAmount(1000), decimals=0, token_name="TKN", token_symbol="TKN", token_contract_name=token_contract_name, ) test_token_address = TokenAddress(to_canonical_address(test_token.address)) # Check the proper exception is raised if the token does not comply to the # ERC20 interface. In this case the token does not have the totalSupply() # function implemented #3697 which is validated in the smart contract. with patch.object(Token, "total_supply", return_value=None): with pytest.raises(InvalidToken): token_network_registry_proxy.add_token( token_address=test_token_address, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), given_block_identifier=deploy_client.get_confirmed_blockhash(), ) # Register a valid token preblockhash = deploy_client.get_confirmed_blockhash() token_network_address = token_network_registry_proxy.add_token( token_address=test_token_address, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), given_block_identifier=preblockhash, ) assert token_network_address is not None assert (token_network_registry_proxy.get_token_network_created( block_identifier=BLOCK_ID_LATEST) == 1) # Re-registering the same token should fail with a recoverable error # because it is a race condition. with pytest.raises(RaidenRecoverableError): token_network_registry_proxy.add_token( token_address=test_token_address, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), given_block_identifier=preblockhash, ) logs = token_network_registry_proxy.filter_token_added_events() assert is_same_address(logs[0]["args"]["token_address"], test_token.address) assert is_same_address(logs[0]["args"]["token_network_address"], token_network_address) assert (token_network_registry_proxy.get_token_network( bad_token_address, BLOCK_ID_LATEST) is None) result_address = token_network_registry_proxy.get_token_network( test_token_address, BLOCK_ID_LATEST) assert result_address assert to_normalized_address(result_address) == to_normalized_address( token_network_address) with pytest.raises(ValueError): assert token_network_registry_proxy.get_token_network( None, BLOCK_ID_LATEST # type: ignore ) # These are not registered token addresses assert (token_network_registry_proxy.get_token_network( bad_token_address, BLOCK_ID_LATEST) is None) assert (token_network_registry_proxy.get_token_network( test_token_address, BLOCK_ID_LATEST) is not None) address = token_network_registry_proxy.get_token_network( TokenAddress(token_network_address), BLOCK_ID_LATEST) assert address is None
def test_token_network_registry_allows_the_last_slot_to_be_used( deploy_client, token_network_registry_address, contract_manager, token_contract_name): proxy_manager = ProxyManager( rpc_client=deploy_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) confirmed_block_identifier = deploy_client.get_confirmed_blockhash() token_network_registry_proxy = proxy_manager.token_network_registry( token_network_registry_address, block_identifier=confirmed_block_identifier) assert (token_network_registry_proxy.get_token_network_created( block_identifier=BLOCK_ID_LATEST) == 0) test_token = deploy_token( deploy_client=deploy_client, contract_manager=contract_manager, initial_amount=TokenAmount(1000), decimals=0, token_name="TKN", token_symbol="TKN", token_contract_name=token_contract_name, ) first_token_address = TokenAddress(to_canonical_address( test_token.address)) preblockhash = deploy_client.get_confirmed_blockhash() # Register a valid token, this is the last slot and should succeeded token_network_registry_proxy.add_token( token_address=first_token_address, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), given_block_identifier=preblockhash, ) test_token = deploy_token( deploy_client=deploy_client, contract_manager=contract_manager, initial_amount=TokenAmount(1000), decimals=0, token_name="TKN", token_symbol="TKN", token_contract_name=token_contract_name, ) second_token_address = TokenAddress( to_canonical_address(test_token.address)) preblockhash = deploy_client.get_confirmed_blockhash() # Tries to register a new valid token after all slots have been used. This # has to fail. with pytest.raises(MaxTokenNetworkNumberReached): token_network_registry_proxy.add_token( token_address=second_token_address, channel_participant_deposit_limit=TokenAmount(UINT256_MAX), token_network_deposit_limit=TokenAmount(UINT256_MAX), given_block_identifier=preblockhash, )
def test_payment_channel_proxy_basics( token_network_registry_address: TokenNetworkRegistryAddress, token_network_proxy: TokenNetwork, token_proxy: Token, chain_id: ChainID, private_keys: List[PrivateKey], web3: Web3, contract_manager: ContractManager, reveal_timeout: BlockTimeout, ) -> None: token_network_address = token_network_proxy.address partner = privatekey_to_address(private_keys[0]) rpc_client = JSONRPCClient(web3, private_keys[1]) proxy_manager = ProxyManager( rpc_client=rpc_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) token_network_proxy = proxy_manager.token_network( address=token_network_address, block_identifier=BLOCK_ID_LATEST ) start_block = web3.eth.blockNumber channel_details = token_network_proxy.new_netting_channel( partner=partner, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier=BLOCK_ID_LATEST, ) channel_identifier = channel_details.channel_identifier assert channel_identifier is not None channel_state = NettingChannelState( canonical_identifier=CanonicalIdentifier( chain_identifier=chain_id, token_network_address=token_network_address, channel_identifier=channel_identifier, ), token_address=token_network_proxy.token_address(), token_network_registry_address=token_network_registry_address, reveal_timeout=reveal_timeout, settle_timeout=BlockTimeout(TEST_SETTLE_TIMEOUT_MIN), fee_schedule=FeeScheduleState(), our_state=NettingChannelEndState( address=token_network_proxy.client.address, contract_balance=Balance(0) ), partner_state=NettingChannelEndState(address=partner, contract_balance=Balance(0)), open_transaction=SuccessfulTransactionState(finished_block_number=BlockNumber(0)), ) channel_proxy_1 = proxy_manager.payment_channel( channel_state=channel_state, block_identifier=BLOCK_ID_LATEST ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_1.opened(BLOCK_ID_LATEST) is True # Test deposit initial_token_balance = 100 token_proxy.transfer(rpc_client.address, TokenAmount(initial_token_balance)) assert token_proxy.balance_of(rpc_client.address) == initial_token_balance assert token_proxy.balance_of(partner) == 0 channel_proxy_1.approve_and_set_total_deposit( total_deposit=TokenAmount(10), block_identifier=BLOCK_ID_LATEST ) # ChannelOpened, ChannelNewDeposit channel_events = get_all_netting_channel_events( proxy_manager=proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_proxy_1.channel_identifier, contract_manager=contract_manager, from_block=start_block, to_block=web3.eth.blockNumber, ) assert len(channel_events) == 2 block_before_close = web3.eth.blockNumber empty_balance_proof = BalanceProof( channel_identifier=channel_proxy_1.channel_identifier, token_network_address=token_network_address, balance_hash=EMPTY_BALANCE_HASH, nonce=0, chain_id=chain_id, transferred_amount=TokenAmount(0), ) closing_data = ( empty_balance_proof.serialize_bin(msg_type=MessageTypeId.BALANCE_PROOF) + EMPTY_SIGNATURE ) channel_proxy_1.close( nonce=Nonce(0), balance_hash=EMPTY_BALANCE_HASH, additional_hash=EMPTY_MESSAGE_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data), block_identifier=BLOCK_ID_LATEST, ) assert channel_proxy_1.closed(BLOCK_ID_LATEST) is True # ChannelOpened, ChannelNewDeposit, ChannelClosed channel_events = get_all_netting_channel_events( proxy_manager=proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_proxy_1.channel_identifier, contract_manager=contract_manager, from_block=start_block, to_block=web3.eth.blockNumber, ) assert len(channel_events) == 3 # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer -- we need to wait on +1 since we use the latest block on parity for # estimate gas and at the time the latest block is the settle timeout block. # More info: https://github.com/raiden-network/raiden/pull/3699#discussion_r270477227 rpc_client.wait_until_block( target_block_number=BlockNumber(rpc_client.block_number() + TEST_SETTLE_TIMEOUT_MIN + 1) ) transaction_hash = channel_proxy_1.settle( transferred_amount=TokenAmount(0), locked_amount=LockedAmount(0), locksroot=LOCKSROOT_OF_NO_LOCKS, partner_transferred_amount=TokenAmount(0), partner_locked_amount=LockedAmount(0), partner_locksroot=LOCKSROOT_OF_NO_LOCKS, block_identifier=BLOCK_ID_LATEST, ) assert is_tx_hash_bytes(transaction_hash) assert channel_proxy_1.settled(BLOCK_ID_LATEST) is True # ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled channel_events = get_all_netting_channel_events( proxy_manager=proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_proxy_1.channel_identifier, contract_manager=contract_manager, from_block=start_block, to_block=web3.eth.blockNumber, ) assert len(channel_events) == 4 channel_details = token_network_proxy.new_netting_channel( partner=partner, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier=BLOCK_ID_LATEST, ) new_channel_identifier = channel_details.channel_identifier assert new_channel_identifier is not None channel_state = NettingChannelState( canonical_identifier=CanonicalIdentifier( chain_identifier=chain_id, token_network_address=token_network_address, channel_identifier=new_channel_identifier, ), token_address=token_network_proxy.token_address(), token_network_registry_address=token_network_registry_address, reveal_timeout=reveal_timeout, settle_timeout=BlockTimeout(TEST_SETTLE_TIMEOUT_MIN), fee_schedule=FeeScheduleState(), our_state=NettingChannelEndState( address=token_network_proxy.client.address, contract_balance=Balance(0) ), partner_state=NettingChannelEndState(address=partner, contract_balance=Balance(0)), open_transaction=SuccessfulTransactionState(finished_block_number=BlockNumber(0)), ) channel_proxy_2 = proxy_manager.payment_channel( channel_state=channel_state, block_identifier=BLOCK_ID_LATEST ) assert channel_proxy_2.channel_identifier == new_channel_identifier assert channel_proxy_2.opened(BLOCK_ID_LATEST) is True msg = "The channel was already closed, the second call must fail" with pytest.raises(RaidenRecoverableError): channel_proxy_1.close( nonce=Nonce(0), balance_hash=EMPTY_BALANCE_HASH, additional_hash=EMPTY_MESSAGE_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data), block_identifier=block_before_close, ) pytest.fail(msg) msg = "The channel is not open at latest, this must raise" with pytest.raises(RaidenUnrecoverableError): channel_proxy_1.close( nonce=Nonce(0), balance_hash=EMPTY_BALANCE_HASH, additional_hash=EMPTY_MESSAGE_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data), block_identifier=BLOCK_ID_LATEST, ) pytest.fail(msg) msg = ( "The channel was not opened at the provided block (latest). " "This call should never have been attempted." ) with pytest.raises(BrokenPreconditionError): channel_proxy_1.approve_and_set_total_deposit( total_deposit=TokenAmount(20), block_identifier=BLOCK_ID_LATEST ) pytest.fail(msg)
def test_token_network_proxy(token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager): assert token_network_proxy.settlement_timeout_min( ) == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max( ) == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_signer = LocalSigner(private_keys[1]) c1_client = JSONRPCClient(web3, private_keys[1]) c1_proxy_manager = ProxyManager( rpc_client=c1_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) c2_client = JSONRPCClient(web3, private_keys[2]) c2_proxy_manager = ProxyManager( rpc_client=c2_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) c2_signer = LocalSigner(private_keys[2]) c1_token_network_proxy = c1_proxy_manager.token_network( token_network_address) c2_token_network_proxy = c2_proxy_manager.token_network( token_network_address) initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) token_proxy.transfer(c2_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_token_balance # instantiating a new channel - test basic assumptions assert (c1_token_network_proxy.get_channel_identifier_or_none( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", ) is None) msg = "Hex encoded addresses are not supported, an assertion must be raised" with pytest.raises(AssertionError): c1_token_network_proxy.get_channel_identifier( participant1=to_checksum_address(c1_client.address), participant2=to_checksum_address(c2_client.address), block_identifier="latest", ) pytest.fail(msg) msg = "Zero is not a valid channel_identifier identifier, an exception must be raised." with pytest.raises(InvalidChannelID): assert c1_token_network_proxy.channel_is_opened( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", channel_identifier=0, ) pytest.fail(msg) msg = "Zero is not a valid channel_identifier identifier. an exception must be raised." with pytest.raises(InvalidChannelID): assert c1_token_network_proxy.channel_is_closed( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", channel_identifier=0, ) pytest.fail(msg) msg = ("Opening a channel with a settle_timeout lower then token " "network's minimum will fail. This must be validated and the " "transaction must not be sent.") with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=TEST_SETTLE_TIMEOUT_MIN - 1, given_block_identifier="latest", ) pytest.fail(msg) # Using exactly the minimal timeout must succeed c1_token_network_proxy.new_netting_channel( partner=make_address(), settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier="latest", ) msg = ("Opening a channel with a settle_timeout larger then token " "network's maximum will fail. This must be validated and the " "transaction must not be sent.") with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=TEST_SETTLE_TIMEOUT_MAX + 1, given_block_identifier="latest", ) pytest.fail(msg) # Using exactly the maximal timeout must succeed c1_token_network_proxy.new_netting_channel( partner=make_address(), settle_timeout=TEST_SETTLE_TIMEOUT_MAX, given_block_identifier="latest", ) msg = ( "Opening a channel with itself is not allow. This must be validated and " "the transaction must not be sent.") with pytest.raises(SamePeerAddress): c1_token_network_proxy.new_netting_channel( partner=c1_client.address, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier="latest", ) pytest.fail(msg) msg = "Trying a deposit to an inexisting channel must fail." with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.set_total_deposit( given_block_identifier="latest", channel_identifier=100, total_deposit=1, partner=c2_client.address, ) pytest.fail(msg) empty_balance_proof = BalanceProof( channel_identifier=100, token_network_address=c1_token_network_proxy.address, balance_hash=encode_hex(EMPTY_BALANCE_HASH), nonce=0, chain_id=chain_id, transferred_amount=0, ) closing_data = (empty_balance_proof.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF) + EMPTY_SIGNATURE) msg = "Trying to close an inexisting channel must fail." match = "The channel was not open at the provided block" with pytest.raises(RaidenUnrecoverableError, match=match): c1_token_network_proxy.close( channel_identifier=100, partner=c2_client.address, balance_hash=EMPTY_HASH, nonce=0, additional_hash=EMPTY_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=c1_signer.sign(data=closing_data), given_block_identifier="latest", ) pytest.fail(msg) channel_identifier = c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier="latest", ) msg = "new_netting_channel did not return a valid channel id" assert isinstance(channel_identifier, T_ChannelID), msg msg = "multiple channels with the same peer are not allowed" with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier="latest", ) pytest.fail(msg) assert (c1_token_network_proxy.get_channel_identifier_or_none( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", ) is not None) assert (c1_token_network_proxy.channel_is_opened( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", channel_identifier=channel_identifier, ) is True) msg = "set_total_deposit must fail if the amount exceed the account's balance" with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.set_total_deposit( given_block_identifier="latest", channel_identifier=channel_identifier, total_deposit=initial_token_balance + 1, partner=c2_client.address, ) pytest.fail(msg) msg = "set_total_deposit must fail with a negative amount" with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.set_total_deposit( given_block_identifier="latest", channel_identifier=channel_identifier, total_deposit=-1, partner=c2_client.address, ) pytest.fail(msg) msg = "set_total_deposit must fail with a zero amount" with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.set_total_deposit( given_block_identifier="latest", channel_identifier=channel_identifier, total_deposit=0, partner=c2_client.address, ) pytest.fail(msg) c1_token_network_proxy.set_total_deposit( given_block_identifier="latest", channel_identifier=channel_identifier, total_deposit=10, partner=c2_client.address, ) transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) signature = c1_signer.sign(data=balance_proof.serialize_bin()) balance_proof.signature = encode_hex(signature) signature_number = int.from_bytes(signature, "big") bit_to_change = random.randint(0, SIGNATURE_SIZE_IN_BITS - 1) signature_number_bit_flipped = signature_number ^ (2**bit_to_change) invalid_signatures = [ EMPTY_SIGNATURE, b"\x11" * 65, signature_number_bit_flipped.to_bytes(len(signature), "big"), ] msg = "close must fail if the closing_signature is invalid" for invalid_signature in invalid_signatures: closing_data = ( balance_proof.serialize_bin(msg_type=MessageTypeId.BALANCE_PROOF) + invalid_signature) with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), non_closing_signature=invalid_signature, closing_signature=c2_signer.sign(data=closing_data), given_block_identifier="latest", ) pytest.fail(msg) blocknumber_prior_to_close = c2_client.block_number() closing_data = balance_proof.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF) + decode_hex( balance_proof.signature) c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), non_closing_signature=decode_hex(balance_proof.signature), closing_signature=c2_signer.sign(data=closing_data), given_block_identifier="latest", ) assert (c1_token_network_proxy.channel_is_closed( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", channel_identifier=channel_identifier, ) is True) assert (c1_token_network_proxy.get_channel_identifier_or_none( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", ) is not None) msg = ( "given_block_identifier is the block at which the transaction is being " "sent. If the channel is already closed at that block the client code " "has a programming error. An exception is raised for that.") with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), non_closing_signature=decode_hex(balance_proof.signature), closing_signature=c2_signer.sign(data=closing_data), given_block_identifier="latest", ) pytest.fail(msg) msg = ("The channel cannot be closed two times. If it was not closed at " "given_block_identifier but it is closed at the time the proxy is " "called an exception must be raised.") with pytest.raises(RaidenRecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), non_closing_signature=decode_hex(balance_proof.signature), closing_signature=c2_signer.sign(data=closing_data), given_block_identifier=blocknumber_prior_to_close, ) pytest.fail(msg) msg = "depositing to a closed channel must fail" match = "closed" with pytest.raises(RaidenRecoverableError, match=match): c2_token_network_proxy.set_total_deposit( given_block_identifier=blocknumber_prior_to_close, channel_identifier=channel_identifier, total_deposit=20, partner=c1_client.address, ) pytest.fail(msg) c1_proxy_manager.wait_until_block( target_block_number=c1_proxy_manager.client.block_number() + TEST_SETTLE_TIMEOUT_MIN) invalid_transferred_amount = 1 msg = "settle with invalid transferred_amount data must fail" with pytest.raises(BrokenPreconditionError): c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=invalid_transferred_amount, locked_amount=0, locksroot=LOCKSROOT_OF_NO_LOCKS, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=LOCKSROOT_OF_NO_LOCKS, given_block_identifier="latest", ) pytest.fail(msg) c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=LOCKSROOT_OF_NO_LOCKS, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=LOCKSROOT_OF_NO_LOCKS, given_block_identifier="latest", ) assert (c1_token_network_proxy.get_channel_identifier_or_none( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", ) is None) assert token_proxy.balance_of(c1_client.address) == (initial_balance_c1 - transferred_amount) assert token_proxy.balance_of(c2_client.address) == (initial_balance_c2 + transferred_amount) msg = "depositing to a settled channel must fail" with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.set_total_deposit( given_block_identifier="latest", channel_identifier=channel_identifier, total_deposit=10, partner=c2_client.address, ) pytest.fail(msg)
def test_token_network_actions_at_pruned_blocks(token_network_proxy, private_keys, token_proxy, web3, chain_id, contract_manager): token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_proxy_manager = ProxyManager( rpc_client=c1_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) c1_token_network_proxy = c1_proxy_manager.token_network( token_network_address) c2_client = JSONRPCClient(web3, private_keys[2]) c2_proxy_manager = ProxyManager( rpc_client=c2_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) c2_token_network_proxy = c2_proxy_manager.token_network( token_network_address) initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) token_proxy.transfer(c2_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_token_balance # create a channel settle_timeout = STATE_PRUNING_AFTER_BLOCKS + 10 channel_identifier = c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=settle_timeout, given_block_identifier="latest") # Now wait until this block becomes pruned pruned_number = c1_proxy_manager.client.block_number() c1_proxy_manager.wait_until_block(target_block_number=pruned_number + STATE_PRUNING_AFTER_BLOCKS) # deposit with given block being pruned c1_token_network_proxy.set_total_deposit( given_block_identifier=pruned_number, channel_identifier=channel_identifier, total_deposit=2, partner=c2_client.address, ) # balance proof signed by c1 transferred_amount_c1 = 1 balance_proof_c1 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex( LocalSigner( private_keys[1]).sign(data=balance_proof_c1.serialize_bin())) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) + decode_hex( balance_proof_c1.signature) non_closing_signature = LocalSigner( c2_client.privkey).sign(data=non_closing_data) # close channel with given block being pruned empty_balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=c1_token_network_proxy.address, balance_hash=encode_hex(EMPTY_BALANCE_HASH), nonce=0, chain_id=chain_id, transferred_amount=0, ) closing_data = (empty_balance_proof.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF) + EMPTY_SIGNATURE) c1_token_network_proxy.close( channel_identifier=channel_identifier, partner=c2_client.address, balance_hash=EMPTY_HASH, nonce=0, additional_hash=EMPTY_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner( c1_client.privkey).sign(data=closing_data), given_block_identifier=pruned_number, ) close_pruned_number = c1_proxy_manager.client.block_number() assert (c1_token_network_proxy.channel_is_closed( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", channel_identifier=channel_identifier, ) is True) assert (c1_token_network_proxy.get_channel_identifier_or_none( participant1=c1_client.address, participant2=c2_client.address, block_identifier="latest", ) is not None) c1_proxy_manager.wait_until_block(target_block_number=close_pruned_number + STATE_PRUNING_AFTER_BLOCKS) # update transfer with given block being pruned c2_token_network_proxy.update_transfer( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof_c1.balance_hash), nonce=balance_proof_c1.nonce, additional_hash=decode_hex(balance_proof_c1.additional_hash), closing_signature=decode_hex(balance_proof_c1.signature), non_closing_signature=non_closing_signature, given_block_identifier=close_pruned_number, ) # update transfer c1_proxy_manager.wait_until_block(target_block_number=close_pruned_number + settle_timeout) # Test that settling will fail because at closed_pruned_number # the settlement period isn't over. with pytest.raises(BrokenPreconditionError): c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=LOCKSROOT_OF_NO_LOCKS, partner=c2_client.address, partner_transferred_amount=0, partner_locked_amount=0, partner_locksroot=LOCKSROOT_OF_NO_LOCKS, given_block_identifier=close_pruned_number, ) settle_block_number = close_pruned_number + settle_timeout # Wait until the settle block is pruned c1_proxy_manager.wait_until_block(target_block_number=settle_block_number + STATE_PRUNING_AFTER_BLOCKS + 1) c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=LOCKSROOT_OF_NO_LOCKS, partner=c2_client.address, partner_transferred_amount=0, partner_locked_amount=0, partner_locksroot=LOCKSROOT_OF_NO_LOCKS, # Settle is block number is pruned, we should not fail at pre-conditions. given_block_identifier=settle_block_number, ) assert token_proxy.balance_of( c2_client.address) == (initial_balance_c2 + transferred_amount_c1 - 0) assert token_proxy.balance_of( c1_client.address) == (initial_balance_c1 + 0 - transferred_amount_c1)