def test_connection_issues() -> None: # 641 is a port registered with IANA for this service: # # repcmd 641/tcp # repcmd 641/udp # # This is a comcast utility agent that is unlikely to be running. The numbe # was chosen with. `sum(ord(c) for c in 'random')` web3 = Web3(HTTPProvider("http://localhost:641")) with pytest.raises(RequestsConnectionError): JSONRPCClient(web3=web3, privkey=make_privatekey_bin())
def main(output_directory, network_id, eth_rpc_endpoint, contracts_version): web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint))) try: check_ethereum_client_is_supported(web3) except ConnectionError: click.secho( f"Couldn't connect to the ethereum node, double check it is running " f"on {eth_rpc_endpoint}, this option can be changed with " f"{ETH_RPC_CONFIG_OPTION}", fg="red", ) return check_ethereum_network_id(network_id, web3) # This script does not send any transactions, the privatekey is generate # just because it is a dependency for JSONRPCClient. unecessary_privatekey = factories.make_privatekey_bin() rpc_client = JSONRPCClient(web3=web3, privkey=unecessary_privatekey) check_synced(rpc_client) deployment_data = get_contracts_deployment_info(chain_id=network_id, version=contracts_version) if not deployment_data: raise RuntimeError( f"There is no deployment data available for contracts-version {contracts_version}." ) network_name = ID_TO_CHAINNAME.get(network_id) if network_name is None: raise RuntimeError(f"Network with id {network_id} is not known.") contracts = deployment_data["contracts"] token_network_registry_deployed_at = BlockNumber( contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["block_number"] ) token_network_registry_address = TokenNetworkRegistryAddress( to_canonical_address(contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"]) ) secret_registry_address = SecretRegistryAddress( to_canonical_address(contracts[CONTRACT_SECRET_REGISTRY]["address"]) ) contracts_path = contracts_precompiled_path(contracts_version) contract_manager = ContractManager(contracts_path) current_block_number = rpc_client.block_number() confirmed_block = rpc_client.get_block( BlockNumber(current_block_number - DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS) ) all_events_for_a_deployment = fetch_all_events_for_a_deployment( contract_manager=contract_manager, web3=web3, token_network_registry_address=token_network_registry_address, secret_registry_address=secret_registry_address, start_block=token_network_registry_deployed_at, target_block=confirmed_block["number"], ) target_block_formatted = to_hex(confirmed_block["hash"]) file_path = os.path.join( output_directory, ( f"{network_name}-" f"{to_checksum_address(token_network_registry_address)}-" f"{target_block_formatted}.json.gz" ), ) block_data = { "gasLimit": confirmed_block["gasLimit"], "gasUsed": confirmed_block["gasUsed"], "hash": to_hex(confirmed_block["hash"]), "number": confirmed_block["number"], } block_data_formatted = simplejson.dumps(block_data).encode("utf8") with gzip.open(file_path, mode="wb") as handler: # Format is `jsonlines` (http://jsonlines.org/), this is used because we # don't have to keep all the events in memory to start encoding the data. for event in all_events_for_a_deployment: format_event_for_serialization(event) data = simplejson.dumps(event).encode("utf8") handler.write(data + b"\n") # Write the block details at the end handler.write(block_data_formatted + b"\n")
def test_subdispatch_by_canonical_id(chain_state): our_model, _ = create_model(balance=10, num_pending_locks=1) partner_model, _ = create_model(balance=0, num_pending_locks=0) channel_state = create_channel_from_models( our_model, partner_model, factories.make_privatekey_bin() ) canonical_identifier = channel_state.canonical_identifier token_network = TokenNetworkState( address=canonical_identifier.token_network_address, token_address=factories.make_address(), network_graph=TokenNetworkGraphState( token_network_address=channel_state.token_network_address ), ) token_network.partneraddresses_to_channelidentifiers[ partner_model.participant_address ] = canonical_identifier.channel_identifier token_network.channelidentifiers_to_channels[ canonical_identifier.channel_identifier ] = channel_state token_network_registry = TokenNetworkRegistryState( address=factories.make_address(), token_network_list=[token_network] ) chain_state.identifiers_to_tokennetworkregistries[ token_network_registry.address ] = token_network_registry chain_state.tokennetworkaddresses_to_tokennetworkregistryaddresses[ canonical_identifier.token_network_address ] = token_network_registry.address # dispatching a Block will be ignored previous_state = deepcopy(chain_state) state_change = Block( block_number=chain_state.block_number, gas_limit=GAS_LIMIT, block_hash=chain_state.block_hash, ) transition_result = subdispatch_by_canonical_id( chain_state=chain_state, canonical_identifier=canonical_identifier, state_change=state_change, ) assert transition_result.new_state == previous_state assert transition_result.events == [] state_change = ActionChannelClose(canonical_identifier=canonical_identifier) # dispatching for an unknown canonical_identifier will not emit events transition_result = subdispatch_by_canonical_id( chain_state=chain_state, canonical_identifier=CanonicalIdentifier( chain_identifier=chain_state.chain_id, token_network_address=factories.make_address(), channel_identifier=factories.make_channel_identifier(), ), state_change=state_change, ) assert not transition_result.events, transition_result assert get_status(channel_state) == ChannelState.STATE_OPENED transition_result = subdispatch_by_canonical_id( chain_state=chain_state, canonical_identifier=canonical_identifier, state_change=state_change, ) assert get_status(channel_state) == ChannelState.STATE_CLOSING assert transition_result.new_state == chain_state, transition_result