def connect_to_blockchain( eth_rpc: URI, gas_price_strategy: Optional[Callable[[Web3, Any], Wei]], used_contracts: List[str], address_overwrites: Dict[str, Address], development_environment: ContractDevEnvironment, ) -> Tuple[Web3, Dict[str, Contract], BlockNumber]: try: provider = HTTPProvider(eth_rpc) web3 = Web3(provider) # Will throw ConnectionError on bad Ethereum client chain_id = ChainID(web3.eth.chain_id) except requests.exceptions.ConnectionError: log.error( "Can not connect to the Ethereum client. Please check that it is running and that " "your settings are correct.", eth_rpc=eth_rpc, ) sys.exit(1) # Add POA middleware for geth POA chains, no/op for other chains web3.middleware_onion.inject(geth_poa_middleware, layer=0) # Set gas price strategy # for that we also need a cache middleware, otherwise sampling is expensive web3.middleware_onion.add(simple_cache_middleware) if not gas_price_strategy: chain_id = ChainID(web3.eth.chain_id) gas_price_strategy = (rpc_gas_price_strategy if "arbitrum" in ID_TO_CHAINNAME.get( chain_id, "") else fast_gas_price_strategy) web3.eth.setGasPriceStrategy(gas_price_strategy) # give web3 some time between retries before failing # TODO: find a way to to this type safe provider.middlewares.replace( # type: ignore "http_retry_request", http_retry_with_backoff_middleware) addresses, start_block = get_contract_addresses_and_start_block( chain_id=chain_id, contracts=used_contracts, address_overwrites=address_overwrites, development_environment=development_environment, ) contracts = { c: web3.eth.contract(abi=CONTRACT_MANAGER.get_contract_abi(c), address=address) for c, address in addresses.items() } return web3, contracts, start_block
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 test_setup_proxies_raiden_addresses_are_given(): """ Test that startup for proxies works fine if only raiden addresses are given """ chain_id = ChainID(5) config = RaidenConfig(chain_id=chain_id, environment_type=Environment.DEVELOPMENT) contracts = load_deployed_contracts_data(config, chain_id) proxy_manager = MockProxyManager(node_address=make_address()) deployed_addresses = load_deployment_addresses_from_contracts(contracts) 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, proxy_manager=proxy_manager, deployed_addresses=deployed_addresses, routing_mode=RoutingMode.LOCAL, pathfinding_service_address=None, enable_monitoring=False, ) assert raiden_bundle assert services_bundle assert raiden_bundle.token_network_registry assert raiden_bundle.secret_registry assert services_bundle.user_deposit assert not services_bundle.service_registry
def test_setup_proxies_all_addresses_are_given(): """ Test that startup for proxies works fine if all addresses are given and routing is local """ chain_id = ChainID(5) config = RaidenConfig(chain_id=chain_id, environment_type=Environment.DEVELOPMENT) contracts = load_deployed_contracts_data(config, chain_id) proxy_manager = MockProxyManager(node_address=make_address()) deployed_addresses = load_deployment_addresses_from_contracts(contracts) with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO): 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, proxy_manager=proxy_manager, deployed_addresses=deployed_addresses, routing_mode=RoutingMode.LOCAL, pathfinding_service_address="my-pfs", enable_monitoring=True, ) assert raiden_bundle assert services_bundle assert raiden_bundle.token_network_registry assert raiden_bundle.secret_registry assert services_bundle.user_deposit assert not services_bundle.service_registry
def test_ecrecover_output( token_network: Contract, signature_test_contract: Contract, get_accounts: Callable, create_channel: Callable, create_balance_proof: Callable, ) -> None: """ecrecover returns the address that was used to sign a balance proof""" (A, B) = get_accounts(2) channel_identifier = create_channel(A, B)[0] balance_proof_A = create_balance_proof(channel_identifier, A, 2, 0, 3) signature = balance_proof_A.original_signature r = signature[:32] s = signature[32:64] v = signature[64:] balance_proof_hash = eth_sign_hash_message( pack_balance_proof( token_network_address=token_network.address, chain_identifier=ChainID( token_network.functions.chain_id().call()), channel_identifier=channel_identifier, balance_hash=balance_proof_A.balance_hash, nonce=balance_proof_A.nonce, additional_hash=balance_proof_A.additional_hash, msg_type=MessageTypeId.BALANCE_PROOF, )) address = signature_test_contract.functions.verifyEcrecoverOutput( balance_proof_hash, r, s, int.from_bytes(v, byteorder="big")).call() assert address == A
def f( chain_id: ChainID = ChainID(1), amount: TokenAmount = TokenAmount(50), nonce: Nonce = Nonce(1), channel_id: ChannelID = ChannelID(1), ) -> RequestMonitoring: balance_proof = HashedBalanceProof( channel_identifier=channel_id, token_network_address=TokenNetworkAddress(b"1" * 20), chain_id=chain_id, nonce=nonce, additional_hash="", balance_hash=encode_hex(bytes([amount])), priv_key=get_random_privkey(), ) request_monitoring = balance_proof.get_request_monitoring( privkey=non_closing_privkey, reward_amount=TokenAmount(55), monitoring_service_contract_address=TEST_MSC_ADDRESS, ) # usually not a property of RequestMonitoring, but added for convenience in these tests request_monitoring.non_closing_signer = to_checksum_address( # type: ignore non_closing_address) return request_monitoring
def get_network_to_broadcast_rooms( api: GMatrixHttpApi) -> Dict[str, List[RoomInfo]]: room_alias_fragments = [ DISCOVERY_DEFAULT_ROOM, PATH_FINDING_BROADCASTING_ROOM, MONITORING_BROADCASTING_ROOM, ] server = urlparse(api.base_url).netloc network_to_broadcast: Dict[str, List[RoomInfo]] = dict() for network in Networks: broadcast_room_infos: List[RoomInfo] = list() network_to_broadcast[str(network.value)] = broadcast_room_infos for room_alias_fragment in room_alias_fragments: broadcast_room_alias = make_room_alias(ChainID(network.value), room_alias_fragment) local_room_alias = f"#{broadcast_room_alias}:{server}" try: room_id = api.get_room_id(local_room_alias) broadcast_room_infos.append( RoomInfo(room_id, broadcast_room_alias, server)) except MatrixError as ex: click.secho( f"Could not find room {broadcast_room_alias} with error {ex}" ) return network_to_broadcast
def verify_deployed_service_contracts_in_filesystem( self, token_address: HexAddress, user_deposit_whole_balance_limit: int, token_network_registry_address: HexAddress, ) -> None: chain_id = ChainID(self.web3.eth.chain_id) deployment_data = get_contracts_deployment_info( chain_id=chain_id, version=self.contract_manager.contracts_version, module=DeploymentModule.SERVICES, ) deployment_file_path = contracts_deployed_path( chain_id=chain_id, version=self.contract_manager.contracts_version, services=True) if deployment_data is None: raise RuntimeError( f"Deployment data cannot be found at {deployment_file_path}") if self.verify_service_contracts_deployment_data( token_address=token_address, user_deposit_whole_balance_limit= user_deposit_whole_balance_limit, deployed_contracts_info=deployment_data, token_network_registry_address=token_network_registry_address, ): print( f"Deployment info from {deployment_file_path} has been verified " "and it is CORRECT.")
def test_setup_proxies_no_service_registry_and_no_pfs_address_but_requesting_pfs( environment_type): """ Test that if pfs routing mode is requested and no address or service registry is given then the client exits with an error message """ chain_id = ChainID(5) config = RaidenConfig( chain_id=chain_id, environment_type=environment_type, services=ServiceConfig(pathfinding_max_fee=100, pathfinding_iou_timeout=500, pathfinding_max_paths=5), ) contracts = load_deployed_contracts_data(config, chain_id) proxy_manager = MockProxyManager(node_address=make_address()) with pytest.raises(RaidenError): deployed_addresses = load_deployment_addresses_from_contracts( contracts) with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO): services_bundle_from_contracts_deployment( config=config, proxy_manager=proxy_manager, deployed_addresses=deployed_addresses, routing_mode=RoutingMode.PFS, pathfinding_service_address=None, enable_monitoring=False, )
def main( private_key: str, state_db: str, web3: Web3, contracts: Dict[str, Contract], start_block: BlockNumber, rdn_per_eth: float, expire_within: Timestamp, ) -> None: pfs_address = private_key_to_address(private_key) chain_id = ChainID(web3.eth.chain_id) database = PFSDatabase(filename=state_db, chain_id=chain_id, pfs_address=pfs_address, sync_start_block=start_block) claim_cost_rdn = calc_claim_cost_rdn(web3, rdn_per_eth) time_now = get_posix_utc_time_now() ious = list( get_claimable_ious( database, claimable_until_after=time_now, claimable_until_before=Timestamp(time_now + expire_within), claim_cost_rdn=claim_cost_rdn, )) print(f"Found {len(ious)} claimable IOUs") _, failures = claim_ious(ious, claim_cost_rdn, contracts[CONTRACT_ONE_TO_N], web3, database) if failures: sys.exit(1)
def test_verify( token_network: Contract, signature_test_contract: Contract, get_accounts: Callable, create_channel: Callable, create_balance_proof: Callable, ) -> None: """ECVerify.ecverify returns the correct address This test checks if the signature test contract returns the correct addresses on the balance hash signed by both ends of a channel""" (A, B) = get_accounts(2) channel_identifier = create_channel(A, B)[0] balance_proof_A = create_balance_proof(channel_identifier, A, 2, 0, 3) signature = balance_proof_A.original_signature balance_proof_hash = eth_sign_hash_message( pack_balance_proof( token_network_address=token_network.address, chain_identifier=ChainID( token_network.functions.chain_id().call()), channel_identifier=channel_identifier, balance_hash=balance_proof_A.balance_hash, nonce=balance_proof_A.nonce, additional_hash=balance_proof_A.additional_hash, msg_type=MessageTypeId.BALANCE_PROOF, )) address = signature_test_contract.functions.verify(balance_proof_hash, signature).call() assert address == A balance_proof_B = create_balance_proof(channel_identifier, B, 0, 0, 0) signature = balance_proof_B.original_signature balance_proof_hash = eth_sign_hash_message( pack_balance_proof( token_network_address=token_network.address, chain_identifier=ChainID( token_network.functions.chain_id().call()), channel_identifier=channel_identifier, balance_hash=balance_proof_B.balance_hash, nonce=balance_proof_B.nonce, additional_hash=balance_proof_B.additional_hash, msg_type=MessageTypeId.BALANCE_PROOF, )) address = signature_test_contract.functions.verify(balance_proof_hash, signature).call() assert address == B
def test_setup_proxies_all_addresses_are_known(): """ Test that startup for proxies works fine if all addresses are given and routing is basic """ chain_id = ChainID(5) config = RaidenConfig(chain_id=chain_id, environment_type=Environment.DEVELOPMENT) 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=to_canonical_address( contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"]), user_deposit_address=user_deposit_address_test_default, payment_address=pfs_payment_address_default, confirmed_block_number=BlockNumber(1), 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): 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, proxy_manager=proxy_manager, deployed_addresses=deployed_addresses, routing_mode=RoutingMode.PFS, pathfinding_service_address="my-pfs", enable_monitoring=False, ) assert raiden_bundle assert services_bundle assert raiden_bundle.token_network_registry assert raiden_bundle.secret_registry assert services_bundle.user_deposit assert services_bundle.service_registry
def test_can_get_contract_address(self): udc_address = get_contract_address(1, CONTRACT_USER_DEPOSIT) deployment_info = get_contracts_deployment_info(ChainID(1)) assert deployment_info expected_udc_address = to_canonical_address( deployment_info["contracts"][CONTRACT_USER_DEPOSIT]["address"] ) self.assertEqual(udc_address, expected_udc_address)
def register_token_network( self, token_registry_abi: ABI, token_registry_address: ChecksumAddress, token_address: ChecksumAddress, channel_participant_deposit_limit: int, token_network_deposit_limit: int, ) -> Dict[str, Any]: """Register token with a TokenNetworkRegistry contract.""" token_network_registry = self.web3.eth.contract( abi=token_registry_abi, address=token_registry_address) command = token_network_registry.functions.createERC20TokenNetwork( token_address, channel_participant_deposit_limit, token_network_deposit_limit) self.transact(command) LOG.debug("Collecting constructor parameters for later verification") chain_id = ChainID(self.web3.eth.chain_id) deployment_data = get_contracts_deployment_info( chain_id=chain_id, version=self.contract_manager.contracts_version, module=DeploymentModule.RAIDEN, ) assert deployment_data secret_registry = self.contract_instance_from_deployment_data( deployment_data, CONTRACT_SECRET_REGISTRY) token_network_registry = self.contract_instance_from_deployment_data( deployment_data, CONTRACT_TOKEN_NETWORK_REGISTRY) settle_timeout_min = token_network_registry.functions.settlement_timeout_min( ).call() settle_timeout_max = token_network_registry.functions.settlement_timeout_max( ).call() constructor_arguments = dict( _token_address=token_address, _secret_registry=secret_registry.address, _chain_id=chain_id, _settlement_timeout_min=settle_timeout_min, _settlement_timeout_max=settle_timeout_max, _controller=self.owner, _channel_participant_deposit_limit= channel_participant_deposit_limit, _token_network_deposit_limit=token_network_deposit_limit, ) LOG.debug("Getting address of new token network") token_network_address = "0x0" while int(token_network_address, 16) == 0: token_network_address = token_network_registry.functions.token_to_token_networks( token_address).call() time.sleep(2) LOG.debug(f"TokenNetwork address: {token_network_address}") return dict( token_network_address=token_network_address, constructor_arguments=constructor_arguments, )
def wait_for_sync(rpc_client: JSONRPCClient, tolerance: BlockTimeout, sleep: float) -> None: # print something since the actual test may take a few moments for the first # iteration print("Checking if the ethereum node is synchronized") # Only use blockcypher on mainnet if rpc_client.chain_id == ChainID(1): wait_for_sync_blockcypher(rpc_client, tolerance, sleep) wait_for_sync_rpc_api(rpc_client, tolerance, sleep)
def get_token_network_registry_contract(w3: Web3): chain_id = int(w3.net.version) manager = ContractManager(contracts_precompiled_path()) contract_data = get_contracts_deployment_info(ChainID(chain_id)) assert contract_data address = contract_data["contracts"][CONTRACT_TOKEN_NETWORK_REGISTRY]["address"] abi = manager.get_contract_abi(CONTRACT_TOKEN_NETWORK_REGISTRY) return w3.eth.contract(abi=abi, address=address)
def __init__( self, web3: Web3, privkey: Optional[PrivateKey], gas_price_strategy: Callable = rpc_gas_price_strategy, gas_estimate_correction: Callable = lambda gas: gas, block_num_confirmations: int = 0, ) -> None: if privkey is None or len(privkey) != 32: raise ValueError("Invalid private key") if block_num_confirmations < 0: raise ValueError("Number of confirmations has to be positive") monkey_patch_web3(web3, gas_price_strategy) version = web3.version.node supported, eth_node, _ = is_supported_client(version) if not supported: raise EthNodeInterfaceError( f"Unsupported Ethereum client {version}") address = privatekey_to_address(privkey) address_checksumed = to_checksum_address(address) if eth_node is EthClient.PARITY: parity_assert_rpc_interfaces(web3) available_nonce = parity_discover_next_available_nonce( web3, address_checksumed) elif eth_node is EthClient.GETH: geth_assert_rpc_interfaces(web3) available_nonce = geth_discover_next_available_nonce( web3, address_checksumed) self.eth_node = eth_node self.privkey = privkey self.address = address self.web3 = web3 self.default_block_num_confirmations = block_num_confirmations # Ask for the chain id only once and store it here self.chain_id = ChainID(int(self.web3.version.network)) self._available_nonce = available_nonce self._nonce_lock = Semaphore() self._gas_estimate_correction = gas_estimate_correction log.debug( "JSONRPCClient created", node=to_checksum_address(self.address), available_nonce=available_nonce, client=version, )
def _add_token_network_deploy_info( token_network: Dict[str, Any], deployer: ContractDeployer, contracts_version: str ) -> None: """ Add deploy info dict to the deploy_*.json file """ deployment_file_path = contracts_deployed_path( chain_id=ChainID(deployer.web3.eth.chainId), version=contracts_version ) with deployment_file_path.open() as f: deployed_contracts_info: DeployedContracts = json.load(f) deployed_contracts_info.setdefault("token_networks", []).append(token_network) deployer.store_and_verify_deployment_info_raiden( deployed_contracts_info=deployed_contracts_info )
def _store_deployment_info(self, services: bool, deployment_info: DeployedContracts) -> None: deployment_file_path = contracts_deployed_path( chain_id=ChainID(self.web3.eth.chain_id), version=self.contracts_version, services=services, ) with deployment_file_path.open(mode="w") as target_file: target_file.write(json.dumps(deployment_info, indent=2)) print( f'Deployment information for chain id = {deployment_info["chain_id"]} ' f" has been updated at {deployment_file_path}.")
def __init__( # pylint: disable=too-many-arguments self, web3: Web3, private_key: PrivateKey, db_filename: str, contracts: Dict[str, Contract], sync_start_block: BlockNumber, required_confirmations: BlockTimeout, poll_interval: float, min_reward: int = 0, get_timestamp_now: Callable = get_posix_utc_time_now, ): self.web3 = web3 self.chain_id = ChainID(web3.eth.chain_id) self.private_key = private_key self.address = private_key_to_address(private_key) self.poll_interval = poll_interval self.service_registry = contracts[CONTRACT_SERVICE_REGISTRY] self.token_network_registry = contracts[ CONTRACT_TOKEN_NETWORK_REGISTRY] self.get_timestamp_now = get_timestamp_now self.try_scheduled_events_after = get_timestamp_now() web3.middleware_onion.add( construct_sign_and_send_raw_middleware(private_key)) monitoring_contract = contracts[CONTRACT_MONITORING_SERVICE] user_deposit_contract = contracts[CONTRACT_USER_DEPOSIT] self.database = Database( filename=db_filename, chain_id=self.chain_id, registry_address=to_canonical_address( self.token_network_registry.address), receiver=self.address, msc_address=MonitoringServiceAddress( to_canonical_address(monitoring_contract.address)), sync_start_block=sync_start_block, ) ms_state = self.database.load_state() self.context = Context( ms_state=ms_state, database=self.database, web3=self.web3, monitoring_service_contract=monitoring_contract, user_deposit_contract=user_deposit_contract, min_reward=min_reward, required_confirmations=required_confirmations, )
def get_discovery_room(api: GMatrixHttpApi, network_value: int) -> Optional[RoomInfo]: server = urlparse(api.base_url).netloc discovery_room_alias = make_room_alias(ChainID(network_value), DISCOVERY_DEFAULT_ROOM) local_room_alias = f"#{discovery_room_alias}:{server}" try: room_id = api.get_room_id(local_room_alias) return RoomInfo(room_id, discovery_room_alias, server) except MatrixError as ex: click.secho( f"Could not find room {discovery_room_alias} with error {ex}") return None
def verify_deployed_contracts_in_filesystem(self) -> None: chain_id = ChainID(self.web3.eth.chain_id) deployment_data = get_contracts_deployment_info( chain_id=chain_id, version=self.contract_manager.contracts_version, module=DeploymentModule.RAIDEN, ) deployment_file_path = contracts_deployed_path( chain_id=chain_id, version=self.contract_manager.contracts_version) if deployment_data is None: raise RuntimeError( f"Deployment data cannot be found at {deployment_file_path}") if self.verify_deployment_data(deployment_data): print( f"Deployment info from {deployment_file_path} has been verified " "and it is CORRECT.")
def test_claim_by_unregistered_service( one_to_n_contract: Contract, deposit_to_udc: Callable, get_accounts: Callable, get_private_key: Callable, web3: Web3, ) -> None: """OneToN contract should not work for an unregistered service provider.""" (A, B) = get_accounts(2) deposit_to_udc(A, 30) amount = TokenAmount(10) expiration = BlockExpiration(web3.eth.block_number + 2) chain_id = web3.eth.chain_id signature = sign_one_to_n_iou( get_private_key(A), sender=A, receiver=B, amount=amount, expiration_block=expiration, one_to_n_address=one_to_n_contract.address, chain_id=ChainID(chain_id), ) # Doesn't work because B is not registered with pytest.raises(TransactionFailed, match="receiver not registered"): call_and_transact( one_to_n_contract.functions.claim( sender=A, receiver=B, amount=amount, expiration_block=expiration, one_to_n_address=one_to_n_contract.address, signature=signature, ), {"from": A}, )
def f( sender_priv_key: PrivateKey, receiver: Address, amount=1, claimable_until=1000000000 * 15 + MIN_IOU_EXPIRY, one_to_n_address: Address = one_to_n_contract_address, chain_id: ChainID = ChainID(61), ) -> IOU: receiver_hex: str = to_checksum_address(receiver) iou_dict = { "sender": to_checksum_address(private_key_to_address(sender_priv_key)), "receiver": receiver_hex, "amount": amount, "claimable_until": claimable_until, "one_to_n_address": to_checksum_address(one_to_n_address), "chain_id": chain_id, } iou_dict["signature"] = encode_hex( sign_one_to_n_iou(privatekey=sender_priv_key, **iou_dict)) iou = IOU.Schema().load(iou_dict) iou.claimed = False return iou
def test_deploy_data_not_deployed() -> None: assert ( get_contracts_deployment_info(ChainID(1), "0.8.0", module=DeploymentModule.RAIDEN) is None )
def print_gas_one_to_n( one_to_n_contract: Contract, deposit_to_udc: Callable, print_gas: Callable, make_iou: Callable, web3: Web3, get_private_key: Callable, create_service_account: Callable, create_account: Callable, ) -> None: """Abusing pytest to print gas cost of OneToN functions""" A = create_account() B = create_service_account() deposit_to_udc(A, 30) # happy case chain_id = web3.eth.chain_id amount = TokenAmount(10) expiration = BlockExpiration(web3.eth.block_number + 2) signature = sign_one_to_n_iou( get_private_key(A), sender=A, receiver=B, amount=amount, expiration_block=expiration, one_to_n_address=one_to_n_contract.address, chain_id=ChainID(chain_id), ) txn_hash = call_and_transact( one_to_n_contract.functions.claim(A, B, amount, expiration, one_to_n_contract.address, signature), {"from": A}, ) print_gas(txn_hash, CONTRACT_ONE_TO_N + ".claim") # bulk claims gas prices def concat_iou_data(ious: List[Dict], key: str) -> List: return [iou[key] for iou in ious] def concat_iou_signatures(ious: List[Dict]) -> bytes: result = b"" for iou in ious: result += iou["signature"] return result for num_ious in (1, 6): receivers = [create_service_account() for i in range(num_ious)] ious = [make_iou(A, r) for r in receivers] txn_hash = call_and_transact( one_to_n_contract.functions.bulkClaim( concat_iou_data(ious, "sender"), concat_iou_data(ious, "receiver"), concat_iou_data(ious, "amount"), concat_iou_data(ious, "expiration_block"), one_to_n_contract.address, concat_iou_signatures(ious), ), {"from": A}, ) print_gas(txn_hash, CONTRACT_ONE_TO_N + f".bulkClaim {num_ious} ious")
def test_check_network_id_raises_with_mismatching_ids(): check_ethereum_network_id(ChainID(68), MockWeb3(68)) with pytest.raises(RaidenError): check_ethereum_network_id(ChainID(61), MockWeb3(68))
CONTRACT_USER_DEPOSIT, ) from raiden_contracts.utils.type_aliases import ChainID token_network_registry_address_test_default = TokenNetworkRegistryAddress( to_canonical_address("0xB9633dd9a9a71F22C933bF121d7a22008f66B908")) user_deposit_address_test_default = Address( to_canonical_address("0x8888888888888888888888888888888888888888")) pfs_payment_address_default = to_canonical_address( "0xB9633dd9a9a71F22C933bF121d7a22008f66B907") PFS_INFO = PFSInfo( url="my-pfs", price=TokenAmount(12), chain_id=ChainID(5), token_network_registry_address=token_network_registry_address_test_default, user_deposit_address=user_deposit_address_test_default, payment_address=pfs_payment_address_default, confirmed_block_number=BlockNumber(1), message="This is your favorite pathfinding service", operator="John Doe", version="0.0.3", ) def test_check_network_id_raises_with_mismatching_ids(): check_ethereum_network_id(ChainID(68), MockWeb3(68)) with pytest.raises(RaidenError): check_ethereum_network_id(ChainID(61), MockWeb3(68))
class Networks(Enum): INTEGRATION = ChainID(4321)
def _ensure_room_for_network(self, network: Networks, alias_fragment: str) -> None: log.info(f"Ensuring {alias_fragment} room for {network.name}") room_alias_prefix = make_room_alias(ChainID(network.value), alias_fragment) room_infos: Dict[str, Optional[RoomInfo]] = { server_name: self._get_room(server_name, room_alias_prefix) for server_name in self._known_servers.keys() } first_server_room_info = room_infos[self._first_server_name] if not first_server_room_info: log.warning("First server room missing") if self._is_first_server: log.info("Creating room", server_name=self._own_server_name) first_server_room_info = self._create_room( self._own_server_name, room_alias_prefix) room_infos[self._first_server_name] = first_server_room_info else: raise EnsurerError("First server room missing.") are_all_rooms_the_same = all( room_info is not None and room_info.room_id == first_server_room_info.room_id for room_info in room_infos.values()) if not are_all_rooms_the_same: log.warning( "Room id mismatch", alias_prefix=room_alias_prefix, expected=first_server_room_info.room_id, found={ server_name: room_info.room_id if room_info else None for server_name, room_info in room_infos.items() }, ) own_server_room_info = room_infos.get(self._own_server_name) own_server_room_alias = f"#{room_alias_prefix}:{self._own_server_name}" first_server_room_alias = f"#{room_alias_prefix}:{self._first_server_name}" if not own_server_room_info: log.warning( "Room missing on own server, adding alias", server_name=self._own_server_name, room_id=first_server_room_info.room_id, new_room_alias=own_server_room_alias, ) self._join_and_alias_room(first_server_room_alias, own_server_room_alias) log.info("Room alias set", alias=own_server_room_alias) elif own_server_room_info.room_id != first_server_room_info.room_id: log.warning( "Conflicting local room, reassigning alias", server_name=self._own_server_name, expected_room_id=first_server_room_info.room_id, current_room_id=own_server_room_info.room_id, ) self._own_api.remove_room_alias(own_server_room_alias) self._join_and_alias_room(first_server_room_alias, own_server_room_alias) log.info( "Room alias updated", alias=own_server_room_alias, room_id=first_server_room_info.room_id, ) else: log.warning( "Mismatching rooms on other servers. Doing nothing.") else: log.info( "Room state ok.", network=network, server_rooms={ server_name: room_info.room_id if room_info else None for server_name, room_info in room_infos.items() }, )