async def test_file_db_saves_enrs(file_db_dir, file_db):
enr = ENRFactory()
await file_db.insert(enr)
filename = get_enr_filename(enr)
assert (file_db_dir / filename).exists()
assert (file_db_dir / filename).is_file()
assert ENR.from_repr((file_db_dir / filename).read_text()) == enr
def test_extract_forkid():
enr = ENR.from_repr(
"enr:-Jq4QO5zEyIBU5lSa9iaen0A2xUB5_IVrCi1DbyASTTnLV5RJan6aGPr8kU0p0MYKU5YezZgdSUE"
"-GOBEio6Ultyf1Aog2V0aMrJhGN2AZCDGfCggmlkgnY0gmlwhF4_wLuJc2VjcDI1NmsxoQOt7cA_B_Kg"
"nQ5RmwyA6ji8M1Y0jfINItRGbOOwy7XgbIN0Y3CCdl-DdWRwgnZf")
assert extract_forkid(enr) == ForkID(hash=to_bytes(hexstr='0x63760190'),
next=1700000)
def test_real_life_test_vector():
enr = ENR.from_repr(REAL_LIFE_TEST_DATA["repr"])
assert enr.sequence_number == REAL_LIFE_TEST_DATA["sequence_number"]
assert enr.public_key == REAL_LIFE_TEST_DATA["public_key"]
assert enr.node_id == REAL_LIFE_TEST_DATA["node_id"]
assert enr.identity_scheme is REAL_LIFE_TEST_DATA["identity_scheme"]
assert dict(enr) == REAL_LIFE_TEST_DATA["kv_pairs"]
assert repr(enr) == REAL_LIFE_TEST_DATA["repr"]
def test_repr(mock_identity_scheme, identity_scheme_registry):
unsigned_enr = UnsignedENR(0, {b"id": b"mock"}, identity_scheme_registry)
enr = unsigned_enr.to_signed_enr(b"\x00" * 32)
base64_encoded_enr = base64.urlsafe_b64encode(rlp.encode(enr))
represented_enr = repr(enr)
assert represented_enr.startswith("enr:")
assert base64_encoded_enr.rstrip(b"=").decode() == represented_enr[4:]
assert ENR.from_repr(represented_enr, identity_scheme_registry) == enr
def test_official_test_vector():
enr = ENR.from_repr(OFFICIAL_TEST_DATA["repr"]) # use default identity scheme registry
assert enr.sequence_number == OFFICIAL_TEST_DATA["sequence_number"]
assert dict(enr) == OFFICIAL_TEST_DATA["kv_pairs"]
assert enr.public_key == OFFICIAL_TEST_DATA["public_key"]
assert enr.node_id == OFFICIAL_TEST_DATA["node_id"]
assert enr.identity_scheme is OFFICIAL_TEST_DATA["identity_scheme"]
assert repr(enr) == OFFICIAL_TEST_DATA["repr"]
unsigned_enr = UnsignedENR(enr.sequence_number, dict(enr))
reconstructed_enr = unsigned_enr.to_signed_enr(OFFICIAL_TEST_DATA["private_key"])
assert reconstructed_enr == enr
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None:
identity_scheme_registry = default_identity_scheme_registry
message_type_registry = default_message_type_registry
nodedb_dir = get_nodedb_dir(boot_info)
nodedb_dir.mkdir(exist_ok=True)
node_db = NodeDB(default_identity_scheme_registry, LevelDB(nodedb_dir))
local_private_key = get_local_private_key(boot_info)
local_enr = await get_local_enr(boot_info, node_db, local_private_key)
local_node_id = local_enr.node_id
routing_table = KademliaRoutingTable(local_node_id,
NUM_ROUTING_TABLE_BUCKETS)
node_db.set_enr(local_enr)
for enr_repr in boot_info.args.discovery_boot_enrs or ():
enr = ENR.from_repr(enr_repr)
node_db.set_enr(enr)
routing_table.update(enr.node_id)
port = boot_info.args.discovery_port
socket = trio.socket.socket(
family=trio.socket.AF_INET,
type=trio.socket.SOCK_DGRAM,
)
outgoing_datagram_channels = trio.open_memory_channel[
OutgoingDatagram](0)
incoming_datagram_channels = trio.open_memory_channel[
IncomingDatagram](0)
outgoing_packet_channels = trio.open_memory_channel[OutgoingPacket](0)
incoming_packet_channels = trio.open_memory_channel[IncomingPacket](0)
outgoing_message_channels = trio.open_memory_channel[OutgoingMessage](
0)
incoming_message_channels = trio.open_memory_channel[IncomingMessage](
0)
endpoint_vote_channels = trio.open_memory_channel[EndpointVote](0)
# types ignored due to https://github.com/ethereum/async-service/issues/5
datagram_sender = DatagramSender( # type: ignore
outgoing_datagram_channels[1],
socket,
)
datagram_receiver = DatagramReceiver( # type: ignore
socket,
incoming_datagram_channels[0],
)
packet_encoder = PacketEncoder( # type: ignore
outgoing_packet_channels[1],
outgoing_datagram_channels[0],
)
packet_decoder = PacketDecoder( # type: ignore
incoming_datagram_channels[1],
incoming_packet_channels[0],
)
packer = Packer(
local_private_key=local_private_key.to_bytes(),
local_node_id=local_node_id,
node_db=node_db,
message_type_registry=message_type_registry,
incoming_packet_receive_channel=incoming_packet_channels[1],
incoming_message_send_channel=incoming_message_channels[0],
outgoing_message_receive_channel=outgoing_message_channels[1],
outgoing_packet_send_channel=outgoing_packet_channels[0],
)
message_dispatcher = MessageDispatcher(
node_db=node_db,
incoming_message_receive_channel=incoming_message_channels[1],
outgoing_message_send_channel=outgoing_message_channels[0],
)
endpoint_tracker = EndpointTracker(
local_private_key=local_private_key.to_bytes(),
local_node_id=local_node_id,
node_db=node_db,
identity_scheme_registry=identity_scheme_registry,
vote_receive_channel=endpoint_vote_channels[1],
)
routing_table_manager = RoutingTableManager(
local_node_id=local_node_id,
routing_table=routing_table,
message_dispatcher=message_dispatcher,
node_db=node_db,
outgoing_message_send_channel=outgoing_message_channels[0],
endpoint_vote_send_channel=endpoint_vote_channels[0],
)
logger.info(f"Starting discovery, listening on port {port}")
logger.info(f"Local Node ID: {encode_hex(local_enr.node_id)}")
logger.info(f"Local ENR: {local_enr}")
await socket.bind(("0.0.0.0", port))
services = (
datagram_sender,
datagram_receiver,
packet_encoder,
packet_decoder,
packer,
message_dispatcher,
endpoint_tracker,
routing_table_manager,
)
async with trio.open_nursery() as nursery:
for service in services:
nursery.start_soon(async_service.TrioManager.run_service,
service)
def __setstate__(self, state: Dict[Any, Any]) -> None:
self._init(ENR.from_repr(state.pop('enr')))
def from_enr_repr(cls: Type[TNode], uri: str) -> TNode:
return cls(ENR.from_repr(uri))
"request_id": 0x01,
"total": 0x01,
"enrs": [],
},
decode_hex("0x04c30101c0"),
],
[
NodesMessage,
{
"request_id":
0x01,
"total":
0x01,
"enrs": [
ENR.from_repr(
"enr:-HW4QBzimRxkmT18hMKaAL3IcZF1UcfTMPyi3Q1pxwZZbcZVRI8DC5infUAB_UauARLOJtYTxa"
"agKoGmIjzQxO2qUygBgmlkgnY0iXNlY3AyNTZrMaEDymNMrg1JrLQB2KTGtv6MVbcNEVv0AHacwUAP"
"MljNMTg"),
ENR.from_repr(
"enr:-HW4QNfxw543Ypf4HXKXdYxkyzfcxcO-6p9X986WldfVpnVTQX1xlTnWrktEWUbeTZnmgOuAY_"
"KUhbVV1Ft98WoYUBMBgmlkgnY0iXNlY3AyNTZrMaEDDiy3QkHAxPyOgWbxp5oF1bDdlYE6dLCUUp8x"
"fVw50jU"),
]
},
decode_hex(
"0x04f8f20101f8eef875b8401ce2991c64993d7c84c29a00bdc871917551c7d330fca2dd0d69c706596dc6"
"55448f030b98a77d4001fd46ae0112ce26d613c5a6a02a81a6223cd0c4edaa532801826964827634897365"
"63703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138f875"
"b840d7f1c39e376297f81d7297758c64cb37dcc5c3beea9f57f7ce9695d7d5a67553417d719539d6ae4b44"
"5946de4d99e680eb8063f29485b555d45b7df16a1850130182696482763489736563703235366b31a1030e"
"2cb74241c0c4fc8e8166f1a79a05d5b0dd95813a74b094529f317d5c39d235"),
],
def load_enr_file(self, path: pathlib.Path) -> ENR:
enr_base64 = path.read_text()
enr = ENR.from_repr(enr_base64, self.identity_scheme_registry)
return enr