def get_nodes_to_connect(self) -> Generator[Node, None, None]: from evm.chains.ropsten import RopstenChain from evm.chains.mainnet import MainnetChain if self.network_id == MainnetChain.network_id: yield Node(keys.PublicKey(decode_hex("1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082")), # noqa: E501 Address("52.74.57.123", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d")), # noqa: E501 Address("191.235.84.50", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("ddd81193df80128880232fc1deb45f72746019839589eeb642d3d44efbb8b2dda2c1a46a348349964a6066f8afb016eb2a8c0f3c66f32fadf4370a236a4b5286")), # noqa: E501 Address("52.231.202.145", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99")), # noqa: E501 Address("13.93.211.84", 30303, 30303)) elif self.network_id == RopstenChain.network_id: yield Node(keys.PublicKey(decode_hex("88c2b24429a6f7683fbfd06874ae3f1e7c8b4a5ffb846e77c705ba02e2543789d66fc032b6606a8d8888eb6239a2abe5897ce83f78dcdcfcb027d6ea69aa6fe9")), # noqa: E501 Address("163.172.157.61", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("a1ef9ba5550d5fac27f7cbd4e8d20a643ad75596f307c91cd6e7f85b548b8a6bf215cca436d6ee436d6135f9fe51398f8dd4c0bd6c6a0c332ccb41880f33ec12")), # noqa: E501 Address("51.15.218.125", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("e80276aabb7682a4a659f4341c1199de79d91a2e500a6ee9bed16ed4ce927ba8d32ba5dea357739ffdf2c5bcc848d3064bb6f149f0b4249c1f7e53f8bf02bfc8")), # noqa: E501 Address("51.15.39.57", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("584c0db89b00719e9e7b1b5c32a4a8942f379f4d5d66bb69f9c7fa97fa42f64974e7b057b35eb5a63fd7973af063f9a1d32d8c60dbb4854c64cb8ab385470258")), # noqa: E501 Address("51.15.35.2", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("d40871fc3e11b2649700978e06acd68a24af54e603d4333faecb70926ca7df93baa0b7bf4e927fcad9a7c1c07f9b325b22f6d1730e728314d0e4e6523e5cebc2")), # noqa: E501 Address("51.15.132.235", 30303, 30303)) yield Node(keys.PublicKey(decode_hex("482484b9198530ee2e00db89791823244ca41dcd372242e2e1297dd06f6d8dd357603960c5ad9cc8dc15fcdf0e4edd06b7ad7db590e67a0b54f798c26581ebd7")), # noqa: E501 Address("51.15.75.138", 30303, 30303)) else: raise ValueError("Unknown network_id: {}".format(self.network_id))
async def test_get_local_enr(manually_driven_discovery): discovery = manually_driven_discovery enr = await discovery.get_local_enr() validate_node_enr(discovery.this_node, enr, sequence_number=1) old_node = copy.copy(discovery.this_node) # If our node's details change but an ENR refresh is not due yet, we'll get the ENR for the # old node. discovery.this_node.address.udp_port += 1 assert discovery._local_enr_next_refresh > time.monotonic() enr = await discovery.get_local_enr() validate_node_enr(old_node, enr, sequence_number=1) # If a local ENR refresh is due, get_local_enr() will create a fresh ENR with a new sequence # number. discovery._local_enr_next_refresh = time.monotonic() - 1 enr = await discovery.get_local_enr() validate_node_enr(discovery.this_node, enr, sequence_number=2) # The new ENR will also be stored in our DB. our_node = Node(discovery.enr_db.get_enr(discovery.this_node.id)) assert enr == our_node.enr # And the next refresh time will be updated. assert discovery._local_enr_next_refresh > time.monotonic()
async def test_bootstrap_nodes(): private_key = PrivateKeyFactory().to_bytes() bootnode1 = ENRFactory(private_key=private_key) bootnode2 = ENRFactory() discovery = MockDiscoveryService([Node(bootnode1), Node(bootnode2)]) assert discovery.enr_db.get_enr(bootnode1.node_id) == bootnode1 assert discovery.enr_db.get_enr(bootnode2.node_id) == bootnode2 assert [node.enr for node in discovery.bootstrap_nodes] == [bootnode1, bootnode2] # If our DB gets updated with a newer ENR of one of our bootnodes, the @bootstrap_nodes # property will reflect that. new_bootnode1 = ENRFactory( private_key=private_key, sequence_number=bootnode1.sequence_number + 1) discovery.enr_db.set_enr(new_bootnode1) assert [node.enr for node in discovery.bootstrap_nodes] == [new_bootnode1, bootnode2]
async def test_shard_syncer(n_peers, connections): cancel_token = CancelToken("canceltoken") PeerTuple = collections.namedtuple("PeerTuple", ["node", "server", "syncer"]) peer_tuples = [] for i in range(n_peers): private_key = keys.PrivateKey(pad32(int_to_big_endian(i + 1))) port = get_open_port() address = Address("127.0.0.1", port, port) node = Node(private_key.public_key, address) server = ShardingServer(private_key, address, network_id=9324090483, min_peers=0, peer_class=ShardingPeer) asyncio.ensure_future(server.run()) peer_tuples.append( PeerTuple( node=node, server=server, syncer=server.syncer, )) # connect peers to each other await asyncio.gather(*[ peer_tuples[i].server.peer_pool._connect_to_nodes( [peer_tuples[j].node]) for i, j in connections ]) for i, j in connections: peer_remotes = [ peer.remote for peer in peer_tuples[i].server.peer_pool.peers ] assert peer_tuples[j].node in peer_remotes # let each node propose and check that collation appears at all other nodes for proposer in peer_tuples: collation = proposer.syncer.propose() await asyncio.wait_for(asyncio.gather(*[ peer_tuple.syncer.collations_received_event.wait() for peer_tuple in peer_tuples if peer_tuple != proposer ]), timeout=10) for peer_tuple in peer_tuples: assert peer_tuple.syncer.shard.get_collation_by_hash( collation.hash) == collation # stop everything cancel_token.trigger() await asyncio.gather( *[peer_tuple.server.cancel() for peer_tuple in peer_tuples]) await asyncio.gather( *[peer_tuple.syncer.cancel() for peer_tuple in peer_tuples])
def test_node_constructor(): privkey = PrivateKeyFactory() address = AddressFactory() enr = ENRFactory(private_key=privkey.to_bytes(), address=address) node = Node(enr) assert node.id == keccak(privkey.public_key.to_bytes()) assert node.address == address
def _extract_nodes_from_payload( sender: AddressAPI, payload: List[Tuple[str, bytes, bytes, bytes]], logger: ExtendedDebugLogger) -> Iterator[NodeAPI]: for item in payload: ip, udp_port, tcp_port, node_id = item address = Address.from_endpoint(ip, udp_port, tcp_port) if check_relayed_addr(sender, address): yield Node(keys.PublicKey(node_id), address) else: logger.debug("Skipping invalid address %s relayed by %s", address, sender)
async def receive_handshake(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None: # Use reader to read the auth_init msg until EOF msg = await reader.read(ENCRYPTED_AUTH_MSG_LEN) # Use HandshakeResponder.decode_authentication(auth_init_message) on auth init msg try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) # Try to decode as EIP8 except DecryptionError: msg_size = big_endian_to_int(msg[:2]) remaining_bytes = msg_size - ENCRYPTED_AUTH_MSG_LEN + 2 msg += await reader.read(remaining_bytes) ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) # Get remote's address: IPv4 or IPv6 ip, port, *_ = writer.get_extra_info("peername") remote_address = Address(ip, port) # Create `HandshakeResponder(remote: kademlia.Node, privkey: datatypes.PrivateKey)` instance initiator_remote = Node(initiator_pubkey, remote_address) responder = HandshakeResponder(initiator_remote, self.privkey) # Call `HandshakeResponder.create_auth_ack_message(nonce: bytes)` to create the reply responder_nonce = secrets.token_bytes(HASH_LEN) auth_ack_msg = responder.create_auth_ack_message(nonce=responder_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) # Use the `writer` to send the reply to the remote writer.write(auth_ack_ciphertext) await writer.drain() # Call `HandshakeResponder.derive_shared_secrets()` and use return values to create `Peer` aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets( initiator_nonce=initiator_nonce, responder_nonce=responder_nonce, remote_ephemeral_pubkey=ephem_pubkey, auth_init_ciphertext=msg, auth_ack_ciphertext=auth_ack_ciphertext) # Create and register peer in peer_pool eth_peer = ETHPeer(remote=initiator_remote, privkey=self.privkey, reader=reader, writer=writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, chaindb=self.chaindb, network_id=self.network_id) self.peer_pool.add_peer(eth_peer)
def _make_node_with_enr_and_forkid(genesis_hash, head, vm_config): fork_blocks = forkid.extract_fork_blocks(vm_config) node_forkid = forkid.make_forkid(genesis_hash, head, fork_blocks) ip = socket.inet_aton(IPAddressFactory.generate()) udp_port = 30304 enr = ENRFactory( custom_kv_pairs={ b'eth': sedes.List([forkid.ForkID]).serialize([node_forkid]), IP_V4_ADDRESS_ENR_KEY: ip, UDP_PORT_ENR_KEY: udp_port, TCP_PORT_ENR_KEY: udp_port, }) return Node(enr)
async def test_lookup_and_maybe_update_enr_new_node(): discovery = MockDiscoveryService([]) privkey = PrivateKeyFactory() address = AddressFactory() # When looking up the ENR for a node we haven't heard about before, we'll create a stub ENR # and add that into our DB. enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, address) assert enr.sequence_number == 0 node = Node(enr) assert node.pubkey == privkey.public_key assert node.address == address db_enr = discovery.enr_db.get_enr(node.id) assert db_enr == enr
async def test_lookup_and_maybe_update_enr_existing_node_different_address(): discovery = MockDiscoveryService([]) privkey = PrivateKeyFactory() address = AddressFactory() # If the address given is different than the one we have in our DB, though, a stub ENR would # be created and stored in our DB, replacing the existing one. enr = ENRFactory(private_key=privkey.to_bytes(), address=address) discovery.enr_db.set_enr(enr) new_address = AddressFactory() lookedup_enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, new_address) assert lookedup_enr != enr assert lookedup_enr.public_key == enr.public_key assert lookedup_enr.sequence_number == 0 assert Node(lookedup_enr).address == new_address assert lookedup_enr == discovery.enr_db.get_enr(enr.node_id)
def test_node_constructor(): privkey = PrivateKeyFactory() ip = socket.inet_aton(IPAddressFactory.generate()) udp_port = tcp_port = 30303 enr = ENRFactory(private_key=privkey.to_bytes(), custom_kv_pairs={ IP_V4_ADDRESS_ENR_KEY: ip, UDP_PORT_ENR_KEY: udp_port }) node = Node(enr) assert node.id == keccak(privkey.public_key.to_bytes()) assert node.address.ip_packed == ip assert node.address.tcp_port == tcp_port assert node.address.udp_port == udp_port
def __init__(self, privkey: datatypes.PrivateKey, address: AddressAPI, bootstrap_nodes: Sequence[NodeAPI], cancel_token: CancelToken) -> None: self.privkey = privkey self.address = address self.bootstrap_nodes = bootstrap_nodes self.this_node = Node(self.pubkey, address) self.routing = RoutingTable(self.this_node) self.topic_table = TopicTable(self.logger) self.pong_callbacks = CallbackManager() self.ping_callbacks = CallbackManager() self.neighbours_callbacks = CallbackManager() self.topic_nodes_callbacks = CallbackManager() self.parity_pong_tokens: Dict[Hash32, Hash32] = {} self.cancel_token = CancelToken('DiscoveryProtocol').chain(cancel_token)
def __init__(self, privkey: datatypes.PrivateKey, address: AddressAPI, bootstrap_nodes: Sequence[NodeAPI], event_bus: EndpointAPI, socket: trio.socket.SocketType) -> None: self.privkey = privkey self.address = address self.bootstrap_nodes = bootstrap_nodes self._event_bus = event_bus self.this_node = Node(self.pubkey, address) self.routing = RoutingTable(self.this_node) self.pong_callbacks = CallbackManager() self.ping_callbacks = CallbackManager() self.neighbours_callbacks = CallbackManager() self.parity_pong_tokens: Dict[Hash32, Hash32] = {} if socket.family != trio.socket.AF_INET: raise ValueError("Invalid socket family") elif socket.type != trio.socket.SOCK_DGRAM: raise ValueError("Invalid socket type") self.socket = socket
async def receive(self, address: AddressAPI, message: bytes) -> None: try: remote_pubkey, cmd_id, payload, message_hash = _unpack_v4(message) except DefectiveMessage as e: self.logger.error('error unpacking message (%s) from %s: %s', message, address, e) return try: cmd = CMD_ID_MAP[cmd_id] except KeyError: self.logger.warning("Ignoring uknown msg type: %s; payload=%s", cmd_id, payload) return self.logger.debug2("Received %s with payload: %s", cmd.name, payload) node = Node(remote_pubkey, address) handler = self._get_handler(cmd) await handler(node, payload, message_hash)
async def test_fetch_enrs(nursery, manually_driven_discovery_pair): alice, bob = manually_driven_discovery_pair # Pretend that bob and alice have already bonded, otherwise bob will ignore alice's ENR # request. alice.node_db.set_last_pong_time(bob.this_node.id, int(time.monotonic())) bob.node_db.set_last_pong_time(alice.this_node.id, int(time.monotonic())) # Also add bob's node to alice's DB as when scheduling an ENR retrieval we only get the node ID # and need to look it up in the DB. alice.node_db.set_enr(bob.this_node.enr) # This task will run in a loop consuming from the pending_enrs_consumer channel and requesting # ENRs. alice.manager.run_task(alice.fetch_enrs) with trio.fail_after(1): # Generate a new ENR for bob, because the old one alice already got when we manually added # bob's node to her DB above. bobs_new_enr = await bob._generate_local_enr( bob.this_node.enr.sequence_number + 1) bob.this_node = Node(bobs_new_enr) # This feeds a request to retrieve Bob's ENR to fetch_enrs(), which spawns a background # task to do it. await alice.pending_enrs_producer.send( (bob.this_node.id, bobs_new_enr.sequence_number)) # bob cosumes the ENR_REQUEST and replies with its own ENR await bob.consume_datagram() # alice consumes the ENR_RESPONSE, feeding the ENR to the background task started above. await alice.consume_datagram() # Now we need to wait a little bit here for that background task to pick it up and store # it in our DB. while True: await trio.sleep(0.1) try: bob_enr = alice.node_db.get_enr(bob.this_node.id) except KeyError: continue else: break assert bob_enr is not None assert bob_enr == await bob.get_local_enr()
def receive(self, address: AddressAPI, message: bytes) -> None: try: remote_pubkey, cmd_id, payload, message_hash = _unpack_v4(message) except DefectiveMessage as e: self.logger.error('error unpacking message (%s) from %s: %s', message, address, e) return # As of discovery version 4, expiration is the last element for all packets, so # we can validate that here, but if it changes we may have to do so on the # handler methods. expiration = rlp.sedes.big_endian_int.deserialize(payload[-1]) if time.time() > expiration: self.logger.debug('received message already expired') return cmd = CMD_ID_MAP[cmd_id] if len(payload) != cmd.elem_count: self.logger.error('invalid %s payload: %s', cmd.name, payload) return node = Node(remote_pubkey, address) handler = self._get_handler(cmd) handler(node, payload, message_hash)
def __init__( self, privkey: datatypes.PrivateKey, address: AddressAPI, bootstrap_nodes: Sequence[NodeAPI], event_bus: EndpointAPI, socket: trio.socket.SocketType, enr_field_providers: Sequence[ENR_FieldProvider] = tuple(), ) -> None: self.privkey = privkey self.address = address self.bootstrap_nodes = bootstrap_nodes self._event_bus = event_bus self.this_node = Node(self.pubkey, address) self.routing = RoutingTable(self.this_node) self.enr_response_channels = ExpectedResponseChannels[Tuple[ENR, Hash32]]() self.pong_channels = ExpectedResponseChannels[Tuple[Hash32, int]]() self.neighbours_channels = ExpectedResponseChannels[List[NodeAPI]]() self.ping_channels = ExpectedResponseChannels[None]() self.enr_field_providers = enr_field_providers # FIXME: Use a persistent EnrDb implementation. self._enr_db = MemoryEnrDb(default_identity_scheme_registry) # FIXME: Use a concurrency-safe EnrDb implementation. self._enr_db_lock = trio.Lock() self._local_enr: ENR = None self._local_enr_next_refresh: float = time.monotonic() self._local_enr_lock = trio.Lock() self.parity_pong_tokens: Dict[Hash32, Hash32] = {} if socket.family != trio.socket.AF_INET: raise ValueError("Invalid socket family") elif socket.type != trio.socket.SOCK_DGRAM: raise ValueError("Invalid socket type") self.socket = socket self.pending_enrs_producer, self.pending_enrs_consumer = trio.open_memory_channel[ Tuple[NodeAPI, int]](self._max_pending_enrs)
def get_open_port(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("", 0)) s.listen(1) port = s.getsockname()[1] s.close() return port port = get_open_port() SERVER_ADDRESS = Address('127.0.0.1', udp_port=port, tcp_port=port) INITIATOR_PUBKEY = keys.PrivateKey(eip8_values['initiator_private_key']).public_key INITIATOR_ADDRESS = Address('127.0.0.1', get_open_port() + 1) INITIATOR_REMOTE = Node(INITIATOR_PUBKEY, INITIATOR_ADDRESS) @pytest.fixture def server(): privkey = keys.PrivateKey(eip8_values['receiver_private_key']) chaindb = ChainDB(MemoryDB()) server = Server(privkey, SERVER_ADDRESS, chaindb, [], 1) return server # FIXME: Instead of starting an actual server and send data over the wire, this test should create # StreamReaders and StreamWriters and connect them directly, like in test_auth.py. That way we # don't need those "strategically" placed sleep() calls. @pytest.mark.asyncio async def test_server_authenticates_incoming_connections(server, event_loop):
async def _receive_handshake( self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None: msg = await self.wait( reader.read(ENCRYPTED_AUTH_MSG_LEN), timeout=REPLY_TIMEOUT) peername = writer.get_extra_info("peername") if peername is None: socket = writer.get_extra_info("socket") sockname = writer.get_extra_info("sockname") raise HandshakeFailure( "Received incoming connection with no remote information:" f"socket={repr(socket)} sockname={sockname}" ) ip, socket, *_ = peername remote_address = Address(ip, socket) self.logger.debug("Receiving handshake from %s", remote_address) try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) except DecryptionError as non_eip8_err: # Try to decode as EIP8 got_eip8 = True msg_size = big_endian_to_int(msg[:2]) remaining_bytes = msg_size - ENCRYPTED_AUTH_MSG_LEN + 2 msg += await self.wait( reader.read(remaining_bytes), timeout=REPLY_TIMEOUT) try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) except DecryptionError as eip8_err: raise HandshakeFailure( f"Failed to decrypt both EIP8 handshake: {eip8_err} and " f"non-EIP8 handshake: {non_eip8_err}" ) else: got_eip8 = False initiator_remote = Node(initiator_pubkey, remote_address) responder = HandshakeResponder(initiator_remote, self.privkey, got_eip8, self.cancel_token) responder_nonce = secrets.token_bytes(HASH_LEN) auth_ack_msg = responder.create_auth_ack_message(responder_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) # Use the `writer` to send the reply to the remote writer.write(auth_ack_ciphertext) await self.wait(writer.drain()) # Call `HandshakeResponder.derive_shared_secrets()` and use return values to create `Peer` aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets( initiator_nonce=initiator_nonce, responder_nonce=responder_nonce, remote_ephemeral_pubkey=ephem_pubkey, auth_init_ciphertext=msg, auth_ack_ciphertext=auth_ack_ciphertext ) transport = Transport( remote=initiator_remote, private_key=self.privkey, reader=reader, writer=writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, ) # Create and register peer in peer_pool peer = self.peer_pool.get_peer_factory().create_peer( transport=transport, inbound=True, ) if self.peer_pool.is_full: await peer.disconnect(DisconnectReason.too_many_peers) return elif not self.peer_pool.is_valid_connection_candidate(peer.remote): await peer.disconnect(DisconnectReason.useless_peer) return total_peers = len(self.peer_pool) inbound_peer_count = len([ peer for peer in self.peer_pool.connected_nodes.values() if peer.inbound ]) if total_peers > 1 and inbound_peer_count / total_peers > DIAL_IN_OUT_RATIO: # make sure to have at least 1/4 outbound connections await peer.disconnect(DisconnectReason.too_many_peers) else: # We use self.wait() here as a workaround for # https://github.com/ethereum/py-evm/issues/670. await self.wait(self.do_handshake(peer))
async def test_request_enr(nursery, manually_driven_discovery_pair): alice, bob = manually_driven_discovery_pair # Pretend that bob and alice have already bonded, otherwise bob will ignore alice's ENR # request. bob._last_pong_at[alice.this_node.id] = int(time.monotonic()) # Add a copy of Bob's node with a stub ENR to alice's RT as later we're going to check that it # gets updated with the received ENR. bobs_node_with_stub_enr = Node.from_pubkey_and_addr( bob.this_node.pubkey, bob.this_node.address) alice._last_pong_at[bob.this_node.id] = int(time.monotonic()) alice.enr_db.delete_enr(bobs_node_with_stub_enr.id) alice.enr_db.set_enr(bobs_node_with_stub_enr.enr) assert alice.enr_db.get_enr(bobs_node_with_stub_enr.id).sequence_number == 0 received_enr = None got_enr = trio.Event() async def fetch_enr(event): nonlocal received_enr received_enr = await alice.request_enr(bobs_node_with_stub_enr) event.set() # Start a task in the background that requests an ENR to bob and then waits for it. nursery.start_soon(fetch_enr, got_enr) # Bob will now consume one datagram containing the ENR_REQUEST from alice, and as part of that # will send an ENR_RESPONSE, which will then be consumed by alice, and as part of that it will # be fed into the request_enr() task we're running the background. with trio.fail_after(0.5): await bob.consume_datagram() await alice.consume_datagram() with trio.fail_after(1): await got_enr.wait() validate_node_enr(bob.this_node, received_enr, sequence_number=1) assert alice.enr_db.get_enr(bob.this_node.id) == received_enr # Now, if Bob later sends us a new ENR with no endpoint information, we'll evict him from both # our DB and RT. sequence_number = bob.this_node.enr.sequence_number + 1 new_unsigned_enr = UnsignedENR( sequence_number, kv_pairs={ IDENTITY_SCHEME_ENR_KEY: V4IdentityScheme.id, V4IdentityScheme.public_key_enr_key: bob.pubkey.to_compressed_bytes(), } ) bob.this_node = Node(new_unsigned_enr.to_signed_enr(bob.privkey.to_bytes())) received_enr = None got_new_enr = trio.Event() nursery.start_soon(fetch_enr, got_new_enr) with trio.fail_after(0.5): await bob.consume_datagram() await alice.consume_datagram() with trio.fail_after(1): await got_new_enr.wait() assert Node(received_enr).address is None assert not alice.routing._contains(bob.this_node.id, include_replacement_cache=True) with pytest.raises(KeyError): alice.enr_db.get_enr(bob.this_node.id)
def get_nodes_to_connect(self) -> Generator[Node, None, None]: from evm.chains.ropsten import RopstenChain from evm.chains.mainnet import MainnetChain if self.network_id == MainnetChain.network_id: nodes = [ Node(keys.PublicKey(decode_hex("1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082")), # noqa: E501 Address("52.74.57.123", 30303, 30303)), Node(keys.PublicKey(decode_hex("78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d")), # noqa: E501 Address("191.235.84.50", 30303, 30303)), Node(keys.PublicKey(decode_hex("ddd81193df80128880232fc1deb45f72746019839589eeb642d3d44efbb8b2dda2c1a46a348349964a6066f8afb016eb2a8c0f3c66f32fadf4370a236a4b5286")), # noqa: E501 Address("52.231.202.145", 30303, 30303)), Node(keys.PublicKey(decode_hex("3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99")), # noqa: E501 Address("13.93.211.84", 30303, 30303)), ] elif self.network_id == RopstenChain.network_id: nodes = [ Node(keys.PublicKey(decode_hex("60ce95dc5b6873e1c53897815496c28132fa50a1227935c58fbffc30a25bf9df68594f7bdc63b1d33c2911c96013b5b058dcfc9184a78082e9af5ace05fe5486")), # noqa: E501 Address("79.98.29.93", 30303, 30303)), Node(keys.PublicKey(decode_hex("a147a3adde1daddc0d86f44f1a76404914e44cee018c26d49248142d4dc8a9fb0e7dd14b5153df7e60f23b037922ae1f33b8f318844ef8d2b0453b9ab614d70d")), # noqa: E501 Address("72.36.89.11", 30303, 30303)), Node(keys.PublicKey(decode_hex("d8714127db3c10560a2463c557bbe509c99969078159c69f9ce4f71c2cd1837bcd33db3b9c3c3e88c971b4604bbffa390a0a7f53fc37f122e2e6e0022c059dfd")), # noqa: E501 Address("51.15.217.106", 30303, 30303)), Node(keys.PublicKey(decode_hex("efc75f109d91cdebc62f33be992ca86fce2637044d49a954a8bdceb439b1239afda32e642456e9dfd759af5b440ef4d8761b9bda887e2200001c5f3ab2614043")), # noqa: E501 Address("34.228.166.142", 30303, 30303)), Node(keys.PublicKey(decode_hex("c8b9ec645cd7fe570bc73740579064c528771338c31610f44d160d2ae63fd00699caa163f84359ab268d4a0aed8ead66d7295be5e9c08b0ec85b0198273bae1f")), # noqa: E501 Address("178.62.246.6", 30303, 30303)), Node(keys.PublicKey(decode_hex("7a34c02d5ef9de43475580cbb88fb492afb2858cfc45f58cf5c7088ceeded5f58e65be769b79c31c5ae1f012c99b3e9f2ea9ef11764d553544171237a691493b")), # noqa: E501 Address("35.227.38.243", 30303, 30303)), Node(keys.PublicKey(decode_hex("bbb3ad8be9684fa1d67ac057d18f7357dd236dc01a806fef6977ac9a259b352c00169d092c50475b80aed9e28eff12d2038e97971e0be3b934b366e86b59a723")), # noqa: E501 Address("81.169.153.213", 30303, 30303)), Node(keys.PublicKey(decode_hex("30b7ab30a01c124a6cceca36863ece12c4f5fa68e3ba9b0b51407ccc002eeed3b3102d20a88f1c1d3c3154e2449317b8ef95090e77b312d5cc39354f86d5d606")), # noqa: E501 Address("52.176.7.10", 30303, 30303)), Node(keys.PublicKey(decode_hex("02508da84b37a1b7f19f77268e5b69acc9e9ab6989f8e5f2f8440e025e633e4277019b91884e46821414724e790994a502892144fc1333487ceb5a6ce7866a46")), # noqa: E501 Address("54.175.255.230", 30303, 30303)), Node(keys.PublicKey(decode_hex("0eec3472a46f0b637045e41f923ce1d4a585cd83c1c7418b183c46443a0df7405d020f0a61891b2deef9de35284a0ad7d609db6d30d487dbfef72f7728d09ca9")), # noqa: E501 Address("181.168.193.197", 30303, 30303)), Node(keys.PublicKey(decode_hex("643c31104d497e3d4cd2460ff0dbb1fb9a6140c8bb0fca66159bbf177d41aefd477091c866494efd3f1f59a0652c93ab2f7bb09034ed5ab9f2c5c6841aef8d94")), # noqa: E501 Address("34.198.237.7", 30303, 30303)), ] else: raise ValueError("Unknown network_id: {}".format(self.network_id)) random.shuffle(nodes) for node in nodes: yield node
async def _receive_handshake(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None: msg = await self.wait(reader.read(ENCRYPTED_AUTH_MSG_LEN), timeout=REPLY_TIMEOUT) ip, socket, *_ = writer.get_extra_info("peername") remote_address = Address(ip, socket) self.logger.debug("Receiving handshake from %s", remote_address) got_eip8 = False try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) except DecryptionError: # Try to decode as EIP8 got_eip8 = True msg_size = big_endian_to_int(msg[:2]) remaining_bytes = msg_size - ENCRYPTED_AUTH_MSG_LEN + 2 msg += await self.wait(reader.read(remaining_bytes), timeout=REPLY_TIMEOUT) try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) except DecryptionError as e: self.logger.debug("Failed to decrypt handshake: %s", e) return initiator_remote = Node(initiator_pubkey, remote_address) responder = HandshakeResponder(initiator_remote, self.privkey, got_eip8, self.cancel_token) responder_nonce = secrets.token_bytes(HASH_LEN) auth_ack_msg = responder.create_auth_ack_message(responder_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) # Use the `writer` to send the reply to the remote writer.write(auth_ack_ciphertext) await self.wait(writer.drain()) # Call `HandshakeResponder.derive_shared_secrets()` and use return values to create `Peer` aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets( initiator_nonce=initiator_nonce, responder_nonce=responder_nonce, remote_ephemeral_pubkey=ephem_pubkey, auth_init_ciphertext=msg, auth_ack_ciphertext=auth_ack_ciphertext) # Create and register peer in peer_pool peer = self.peer_class( remote=initiator_remote, privkey=self.privkey, reader=reader, writer=writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, headerdb=self.headerdb, network_id=self.network_id, inbound=True, ) if self.peer_pool.is_full: peer.disconnect(DisconnectReason.too_many_peers) else: # We use self.wait() here as a workaround for # https://github.com/ethereum/py-evm/issues/670. await self.wait(self.do_handshake(peer))
def _test(): """ Create a Peer instance connected to a local geth instance and log messages exchanged with it. Use the following command line to run geth: ./build/bin/geth -vmodule p2p=4,p2p/discv5=0,eth/*=0 \ -nodekeyhex 45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8 \ -testnet -lightserv 90 """ import argparse import signal from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.memory import MemoryDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') # The default remoteid can be used if you pass nodekeyhex as above to geth. nodekey = keys.PrivateKey(decode_hex( "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8")) remoteid = nodekey.public_key.to_hex() parser = argparse.ArgumentParser() parser.add_argument('-remoteid', type=str, default=remoteid) parser.add_argument('-light', action='store_true', help="Connect as a light node") args = parser.parse_args() peer_class = ETHPeer # type: ignore if args.light: peer_class = LESPeer # type: ignore remote = Node( keys.PublicKey(decode_hex(args.remoteid)), Address('127.0.0.1', 30303, 30303)) chaindb = FakeAsyncChainDB(MemoryDB()) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) network_id = RopstenChain.network_id loop = asyncio.get_event_loop() peer = loop.run_until_complete( asyncio.wait_for( handshake(remote, ecies.generate_privkey(), peer_class, chaindb, network_id), HANDSHAKE_TIMEOUT)) async def request_stuff(): # Request some stuff from ropsten's block 2440319 # (https://ropsten.etherscan.io/block/2440319), just as a basic test. nonlocal peer block_hash = decode_hex( '0x59af08ab31822c992bb3dad92ddb68d820aa4c69e9560f07081fa53f1009b152') if peer_class == ETHPeer: peer = cast(ETHPeer, peer) peer.sub_proto.send_get_block_headers(block_hash, 1) peer.sub_proto.send_get_block_bodies([block_hash]) peer.sub_proto.send_get_receipts([block_hash]) else: peer = cast(LESPeer, peer) request_id = 1 peer.sub_proto.send_get_block_headers(block_hash, 1, request_id) peer.sub_proto.send_get_block_bodies([block_hash], request_id + 1) peer.sub_proto.send_get_receipts(block_hash, request_id + 2) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, peer.cancel_token.trigger) asyncio.ensure_future(request_stuff()) loop.run_until_complete(peer.run()) loop.close()
def get_nodes_to_connect(self) -> Generator[Node, None, None]: from evm.chains.ropsten import RopstenChain from evm.chains.mainnet import MainnetChain if self.network_id == MainnetChain.network_id: nodes = [ Node(keys.PublicKey(decode_hex("1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082")), # noqa: E501 Address("52.74.57.123", 30303, 30303)), Node(keys.PublicKey(decode_hex("78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d")), # noqa: E501 Address("191.235.84.50", 30303, 30303)), Node(keys.PublicKey(decode_hex("ddd81193df80128880232fc1deb45f72746019839589eeb642d3d44efbb8b2dda2c1a46a348349964a6066f8afb016eb2a8c0f3c66f32fadf4370a236a4b5286")), # noqa: E501 Address("52.231.202.145", 30303, 30303)), Node(keys.PublicKey(decode_hex("3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99")), # noqa: E501 Address("13.93.211.84", 30303, 30303)), ] elif self.network_id == RopstenChain.network_id: nodes = [ Node(keys.PublicKey(decode_hex("c8b9ec645cd7fe570bc73740579064c528771338c31610f44d160d2ae63fd00699caa163f84359ab268d4a0aed8ead66d7295be5e9c08b0ec85b0198273bae1f")), # noqa: E501 Address("178.62.246.6", 30303, 30303)), Node(keys.PublicKey(decode_hex("7a34c02d5ef9de43475580cbb88fb492afb2858cfc45f58cf5c7088ceeded5f58e65be769b79c31c5ae1f012c99b3e9f2ea9ef11764d553544171237a691493b")), # noqa: E501 Address("35.227.38.243", 30303, 30303)), Node(keys.PublicKey(decode_hex("bbb3ad8be9684fa1d67ac057d18f7357dd236dc01a806fef6977ac9a259b352c00169d092c50475b80aed9e28eff12d2038e97971e0be3b934b366e86b59a723")), # noqa: E501 Address("81.169.153.213", 30303, 30303)), Node(keys.PublicKey(decode_hex("30b7ab30a01c124a6cceca36863ece12c4f5fa68e3ba9b0b51407ccc002eeed3b3102d20a88f1c1d3c3154e2449317b8ef95090e77b312d5cc39354f86d5d606")), # noqa: E501 Address("52.176.7.10", 30303, 30303)), Node(keys.PublicKey(decode_hex("02508da84b37a1b7f19f77268e5b69acc9e9ab6989f8e5f2f8440e025e633e4277019b91884e46821414724e790994a502892144fc1333487ceb5a6ce7866a46")), # noqa: E501 Address("54.175.255.230", 30303, 30303)), Node(keys.PublicKey(decode_hex("0eec3472a46f0b637045e41f923ce1d4a585cd83c1c7418b183c46443a0df7405d020f0a61891b2deef9de35284a0ad7d609db6d30d487dbfef72f7728d09ca9")), # noqa: E501 Address("181.168.193.197", 30303, 30303)), Node(keys.PublicKey(decode_hex("643c31104d497e3d4cd2460ff0dbb1fb9a6140c8bb0fca66159bbf177d41aefd477091c866494efd3f1f59a0652c93ab2f7bb09034ed5ab9f2c5c6841aef8d94")), # noqa: E501 Address("34.198.237.7", 30303, 30303)), Node(keys.PublicKey(decode_hex("88c2b24429a6f7683fbfd06874ae3f1e7c8b4a5ffb846e77c705ba02e2543789d66fc032b6606a8d8888eb6239a2abe5897ce83f78dcdcfcb027d6ea69aa6fe9")), # noqa: E501 Address("163.172.157.61", 30303, 30303)), Node(keys.PublicKey(decode_hex("a1ef9ba5550d5fac27f7cbd4e8d20a643ad75596f307c91cd6e7f85b548b8a6bf215cca436d6ee436d6135f9fe51398f8dd4c0bd6c6a0c332ccb41880f33ec12")), # noqa: E501 Address("51.15.218.125", 30303, 30303)), Node(keys.PublicKey(decode_hex("e80276aabb7682a4a659f4341c1199de79d91a2e500a6ee9bed16ed4ce927ba8d32ba5dea357739ffdf2c5bcc848d3064bb6f149f0b4249c1f7e53f8bf02bfc8")), # noqa: E501 Address("51.15.39.57", 30303, 30303)), Node(keys.PublicKey(decode_hex("584c0db89b00719e9e7b1b5c32a4a8942f379f4d5d66bb69f9c7fa97fa42f64974e7b057b35eb5a63fd7973af063f9a1d32d8c60dbb4854c64cb8ab385470258")), # noqa: E501 Address("51.15.35.2", 30303, 30303)), Node(keys.PublicKey(decode_hex("d40871fc3e11b2649700978e06acd68a24af54e603d4333faecb70926ca7df93baa0b7bf4e927fcad9a7c1c07f9b325b22f6d1730e728314d0e4e6523e5cebc2")), # noqa: E501 Address("51.15.132.235", 30303, 30303)), Node(keys.PublicKey(decode_hex("482484b9198530ee2e00db89791823244ca41dcd372242e2e1297dd06f6d8dd357603960c5ad9cc8dc15fcdf0e4edd06b7ad7db590e67a0b54f798c26581ebd7")), # noqa: E501 Address("51.15.75.138", 30303, 30303)), ] else: raise ValueError("Unknown network_id: {}".format(self.network_id)) random.shuffle(nodes) for node in nodes: yield node
async def _receive_handshake( self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None: msg = await self.wait_first( reader.read(ENCRYPTED_AUTH_MSG_LEN), timeout=REPLY_TIMEOUT) ip, socket, *_ = writer.get_extra_info("peername") remote_address = Address(ip, socket) self.logger.debug("Receiving handshake from %s", remote_address) try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) except DecryptionError: # Try to decode as EIP8 msg_size = big_endian_to_int(msg[:2]) remaining_bytes = msg_size - ENCRYPTED_AUTH_MSG_LEN + 2 msg += await self.wait_first( reader.read(remaining_bytes), timeout=REPLY_TIMEOUT) try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, self.privkey) except DecryptionError as e: self.logger.debug("Failed to decrypt handshake: %s", e) return # Create `HandshakeResponder(remote: kademlia.Node, privkey: datatypes.PrivateKey)` instance initiator_remote = Node(initiator_pubkey, remote_address) responder = HandshakeResponder(initiator_remote, self.privkey, self.cancel_token) # Call `HandshakeResponder.create_auth_ack_message(nonce: bytes)` to create the reply responder_nonce = secrets.token_bytes(HASH_LEN) auth_ack_msg = responder.create_auth_ack_message(nonce=responder_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) # Use the `writer` to send the reply to the remote writer.write(auth_ack_ciphertext) await writer.drain() # Call `HandshakeResponder.derive_shared_secrets()` and use return values to create `Peer` aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets( initiator_nonce=initiator_nonce, responder_nonce=responder_nonce, remote_ephemeral_pubkey=ephem_pubkey, auth_init_ciphertext=msg, auth_ack_ciphertext=auth_ack_ciphertext ) # Create and register peer in peer_pool peer = self.peer_class( remote=initiator_remote, privkey=self.privkey, reader=reader, writer=writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, headerdb=self.headerdb, network_id=self.network_id, inbound=True, ) await self.do_handshake(peer)
def get_open_port(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("", 0)) s.listen(1) port = s.getsockname()[1] s.close() return port port = get_open_port() NETWORK_ID = 99 SERVER_ADDRESS = Address('127.0.0.1', udp_port=port, tcp_port=port) RECEIVER_PRIVKEY = keys.PrivateKey(eip8_values['receiver_private_key']) RECEIVER_PUBKEY = RECEIVER_PRIVKEY.public_key RECEIVER_REMOTE = Node(RECEIVER_PUBKEY, SERVER_ADDRESS) INITIATOR_PRIVKEY = keys.PrivateKey(eip8_values['initiator_private_key']) INITIATOR_PUBKEY = INITIATOR_PRIVKEY.public_key INITIATOR_ADDRESS = Address('127.0.0.1', get_open_port() + 1) INITIATOR_REMOTE = Node(INITIATOR_PUBKEY, INITIATOR_ADDRESS) class MockPeerPool: is_full = False connected_nodes = {} def __init__(self): self._new_peers = asyncio.Queue() async def start_peer(self, peer):
# Yield control to ensure we process any disconnection requests from peers. Otherwise # we could return peers that should have been disconnected already. await asyncio.sleep(0) try: peer = next(self.iter) if not peer.is_closing: return peer except StopIteration: raise StopAsyncIteration DEFAULT_PREFERRED_NODES: Dict[int, Tuple[Node, ...]] = { MAINNET_NETWORK_ID: ( Node( keys.PublicKey( decode_hex( "1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082" )), # noqa: E501 Address("52.74.57.123", 30303, 30303)), Node( keys.PublicKey( decode_hex( "78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d" )), # noqa: E501 Address("191.235.84.50", 30303, 30303)), Node( keys.PublicKey( decode_hex( "ddd81193df80128880232fc1deb45f72746019839589eeb642d3d44efbb8b2dda2c1a46a348349964a6066f8afb016eb2a8c0f3c66f32fadf4370a236a4b5286" )), # noqa: E501 Address("52.231.202.145", 30303, 30303)), Node(
async def receive_connection(cls, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, private_key: datatypes.PrivateKey, token: CancelToken) -> TransportAPI: try: msg = await token.cancellable_wait( reader.readexactly(ENCRYPTED_AUTH_MSG_LEN), timeout=REPLY_TIMEOUT, ) except asyncio.IncompleteReadError as err: raise HandshakeFailure from err try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, private_key, ) except DecryptionError as non_eip8_err: # Try to decode as EIP8 msg_size = big_endian_to_int(msg[:2]) remaining_bytes = msg_size - ENCRYPTED_AUTH_MSG_LEN + 2 try: msg += await token.cancellable_wait( reader.readexactly(remaining_bytes), timeout=REPLY_TIMEOUT, ) except asyncio.IncompleteReadError as err: raise HandshakeFailure from err try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, private_key, ) except DecryptionError as eip8_err: raise HandshakeFailure( f"Failed to decrypt both EIP8 handshake: {eip8_err} and " f"non-EIP8 handshake: {non_eip8_err}") else: got_eip8 = True else: got_eip8 = False peername = writer.get_extra_info("peername") if peername is None: socket = writer.get_extra_info("socket") sockname = writer.get_extra_info("sockname") raise HandshakeFailure( "Received incoming connection with no remote information:" f"socket={repr(socket)} sockname={sockname}") ip, socket, *_ = peername remote_address = Address(ip, socket) cls.logger.debug("Receiving handshake from %s", remote_address) initiator_remote = Node(initiator_pubkey, remote_address) responder = HandshakeResponder(initiator_remote, private_key, got_eip8, token) responder_nonce = secrets.token_bytes(HASH_LEN) auth_ack_msg = responder.create_auth_ack_message(responder_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) # Use the `writer` to send the reply to the remote writer.write(auth_ack_ciphertext) await token.cancellable_wait(writer.drain()) # Call `HandshakeResponder.derive_shared_secrets()` and use return values to create `Peer` aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets( initiator_nonce=initiator_nonce, responder_nonce=responder_nonce, remote_ephemeral_pubkey=ephem_pubkey, auth_init_ciphertext=msg, auth_ack_ciphertext=auth_ack_ciphertext) transport = cls( remote=initiator_remote, private_key=private_key, reader=reader, writer=writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, ) return transport
def get_nodes_to_connect(self) -> Generator[Node, None, None]: from evm.chains.ropsten import RopstenChain from evm.chains.mainnet import MainnetChain if self.network_id == MainnetChain.network_id: nodes = [ Node( keys.PublicKey( decode_hex( "1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082" )), # noqa: E501 Address("52.74.57.123", 30303, 30303)), Node( keys.PublicKey( decode_hex( "78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d" )), # noqa: E501 Address("191.235.84.50", 30303, 30303)), Node( keys.PublicKey( decode_hex( "ddd81193df80128880232fc1deb45f72746019839589eeb642d3d44efbb8b2dda2c1a46a348349964a6066f8afb016eb2a8c0f3c66f32fadf4370a236a4b5286" )), # noqa: E501 Address("52.231.202.145", 30303, 30303)), Node( keys.PublicKey( decode_hex( "3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99" )), # noqa: E501 Address("13.93.211.84", 30303, 30303)), ] elif self.network_id == RopstenChain.network_id: nodes = [ Node( keys.PublicKey( decode_hex( "0d7f627a9a139c1fbff6731d6e0123561738c5155908e32c3a1eea00a3e0c3b460d97c8aea1935c19bfb4e7013651488b8d328b9c142c0b820e221fde7894253" )), # noqa: E501 Address("58.250.0.61", 30303, 30303)), Node( keys.PublicKey( decode_hex( "360aeace83f0771dd671f253a023b4757e920aca3598563779d8edb2f4d4ca001b5dc2f900ec1547edcd34cfd5cf858e717647e9b5c1f88cef1934081337678b" )), # noqa: E501 Address("34.212.25.61", 30303, 30303)), Node( keys.PublicKey( decode_hex( "49f9e25549aaa9d2bbbedb32bc22029833a8ce457ce54310e44ed8097082379ac94ff5319ff57da0afa91584c271d17324bc3ea3a74e01a9684fbe9a392b239d" )), # noqa: E501 Address("34.237.139.163", 30303, 30303)), Node( keys.PublicKey( decode_hex( "5740300afd843ce51b2ca734e30ec690f1b61b163f67a289888757e8962f8046d46f8b6a8d2663246f0b81a75cbc7604619721567054309f15bc360490c8c4da" )), # noqa: E501 Address("172.104.183.123", 30303, 30303)), Node( keys.PublicKey( decode_hex( "7f3c9e7472a28904c7b5066bce561ac230801147fb6cffae10967baf058a9fcffe03e386c55e5c1397172aef36d78b9f35b6d4f0dc831707c66530194f4867fb" )), # noqa: E501 Address("114.242.249.161", 30303, 30303)), Node( keys.PublicKey( decode_hex( "8d24ff3d32b0fc70bf41cf828b98940e2ef18ab82fc37de779c206cbec88d5c11a3e3af9700953b9f5e6582f73cddd76f90fc1688992fbdf3b9216228c80654c" )), # noqa: E501 Address("202.9.6.81", 30303, 30303)), Node( keys.PublicKey( decode_hex( "bbb3ad8be9684fa1d67ac057d18f7357dd236dc01a806fef6977ac9a259b352c00169d092c50475b80aed9e28eff12d2038e97971e0be3b934b366e86b59a723" )), # noqa: E501 Address("81.169.153.213", 30303, 30303)), Node( keys.PublicKey( decode_hex( "a147a3adde1daddc0d86f44f1a76404914e44cee018c26d49248142d4dc8a9fb0e7dd14b5153df7e60f23b037922ae1f33b8f318844ef8d2b0453b9ab614d70d" )), # noqa: E501 Address("72.36.89.11", 30303, 30303)), Node( keys.PublicKey( decode_hex( "bd2867892d879b57734d571b208bb7adc04fa412fbdfe73b89b1a0ec5b7978932cc776609e4ac7bac231049975ecb22c74988da36cbc5111d116b1edf7d44802" )), # noqa: E501 Address("185.68.101.99", 30303, 30303)), Node( keys.PublicKey( decode_hex( "c2bb011038530b60b40a342705246a84e6d2d22d9f8d8d3df4ae1c7464f302396e7be7673a3971b2de16ebd66574ade262fc292b6de7715983f0f15f9c9922ea" )), # noqa: E501 Address("36.225.32.203", 30303, 30303)), Node( keys.PublicKey( decode_hex( "d8714127db3c10560a2463c557bbe509c99969078159c69f9ce4f71c2cd1837bcd33db3b9c3c3e88c971b4604bbffa390a0a7f53fc37f122e2e6e0022c059dfd" )), # noqa: E501 Address("51.15.217.106", 30303, 30303)), Node( keys.PublicKey( decode_hex( "efc75f109d91cdebc62f33be992ca86fce2637044d49a954a8bdceb439b1239afda32e642456e9dfd759af5b440ef4d8761b9bda887e2200001c5f3ab2614043" )), # noqa: E501 Address("34.228.166.142", 30303, 30303)), Node( keys.PublicKey( decode_hex( "c8b9ec645cd7fe570bc73740579064c528771338c31610f44d160d2ae63fd00699caa163f84359ab268d4a0aed8ead66d7295be5e9c08b0ec85b0198273bae1f" )), # noqa: E501 Address("178.62.246.6", 30303, 30303)), Node( keys.PublicKey( decode_hex( "7a34c02d5ef9de43475580cbb88fb492afb2858cfc45f58cf5c7088ceeded5f58e65be769b79c31c5ae1f012c99b3e9f2ea9ef11764d553544171237a691493b" )), # noqa: E501 Address("35.227.38.243", 30303, 30303)), Node( keys.PublicKey( decode_hex( "bbb3ad8be9684fa1d67ac057d18f7357dd236dc01a806fef6977ac9a259b352c00169d092c50475b80aed9e28eff12d2038e97971e0be3b934b366e86b59a723" )), # noqa: E501 Address("81.169.153.213", 30303, 30303)), Node( keys.PublicKey( decode_hex( "30b7ab30a01c124a6cceca36863ece12c4f5fa68e3ba9b0b51407ccc002eeed3b3102d20a88f1c1d3c3154e2449317b8ef95090e77b312d5cc39354f86d5d606" )), # noqa: E501 Address("52.176.7.10", 30303, 30303)), Node( keys.PublicKey( decode_hex( "02508da84b37a1b7f19f77268e5b69acc9e9ab6989f8e5f2f8440e025e633e4277019b91884e46821414724e790994a502892144fc1333487ceb5a6ce7866a46" )), # noqa: E501 Address("54.175.255.230", 30303, 30303)), Node( keys.PublicKey( decode_hex( "0eec3472a46f0b637045e41f923ce1d4a585cd83c1c7418b183c46443a0df7405d020f0a61891b2deef9de35284a0ad7d609db6d30d487dbfef72f7728d09ca9" )), # noqa: E501 Address("181.168.193.197", 30303, 30303)), Node( keys.PublicKey( decode_hex( "643c31104d497e3d4cd2460ff0dbb1fb9a6140c8bb0fca66159bbf177d41aefd477091c866494efd3f1f59a0652c93ab2f7bb09034ed5ab9f2c5c6841aef8d94" )), # noqa: E501 Address("34.198.237.7", 30303, 30303)), Node( keys.PublicKey( decode_hex( "88c2b24429a6f7683fbfd06874ae3f1e7c8b4a5ffb846e77c705ba02e2543789d66fc032b6606a8d8888eb6239a2abe5897ce83f78dcdcfcb027d6ea69aa6fe9" )), # noqa: E501 Address("163.172.157.61", 30303, 30303)), Node( keys.PublicKey( decode_hex( "a1ef9ba5550d5fac27f7cbd4e8d20a643ad75596f307c91cd6e7f85b548b8a6bf215cca436d6ee436d6135f9fe51398f8dd4c0bd6c6a0c332ccb41880f33ec12" )), # noqa: E501 Address("51.15.218.125", 30303, 30303)), Node( keys.PublicKey( decode_hex( "e80276aabb7682a4a659f4341c1199de79d91a2e500a6ee9bed16ed4ce927ba8d32ba5dea357739ffdf2c5bcc848d3064bb6f149f0b4249c1f7e53f8bf02bfc8" )), # noqa: E501 Address("51.15.39.57", 30303, 30303)), Node( keys.PublicKey( decode_hex( "584c0db89b00719e9e7b1b5c32a4a8942f379f4d5d66bb69f9c7fa97fa42f64974e7b057b35eb5a63fd7973af063f9a1d32d8c60dbb4854c64cb8ab385470258" )), # noqa: E501 Address("51.15.35.2", 30303, 30303)), Node( keys.PublicKey( decode_hex( "d40871fc3e11b2649700978e06acd68a24af54e603d4333faecb70926ca7df93baa0b7bf4e927fcad9a7c1c07f9b325b22f6d1730e728314d0e4e6523e5cebc2" )), # noqa: E501 Address("51.15.132.235", 30303, 30303)), Node( keys.PublicKey( decode_hex( "482484b9198530ee2e00db89791823244ca41dcd372242e2e1297dd06f6d8dd357603960c5ad9cc8dc15fcdf0e4edd06b7ad7db590e67a0b54f798c26581ebd7" )), # noqa: E501 Address("51.15.75.138", 30303, 30303)), ] else: raise ValueError("Unknown network_id: {}".format(self.network_id)) random.shuffle(nodes) for node in nodes: yield node