def _factory(seed, block_pool):
key_pair = node_key_pair(seed)
peer_id = node_peer_id(key_pair)
listen_maddr = Multiaddr(
f"/ip4/127.0.0.1/tcp/13{ord(seed[:1]) % 1000}/p2p/{peer_id}"
)
def _block_by_slot(slot):
for block in block_pool:
if block.slot == slot:
return block
return None
def _block_by_root(root):
for block in block_pool:
if block.message.hash_tree_root == root:
return block
return None
host = Host(
key_pair,
peer_id,
_null_peer_updates,
lambda: Status.create(),
lambda _epoch: genesis_block.hash_tree_root,
_block_by_slot,
_block_by_root,
lambda: MetaData.create(seq_number=SeqNumber(ord(seed[:1]))),
lambda: ForkDigest(b"\x00\x00\x00\x00"),
eth2_config,
)
return host, listen_maddr
def test_metadata_roundtrip():
meta = MetaData.create(seq_number=2000, attnets=(True, False) * 32)
meta_encoded = ssz.encode(meta)
meta_recovered = ssz.decode(meta_encoded, MetaData)
assert meta_recovered == meta
def __init__(
self,
local_node_key: PrivateKey,
eth2_config: Eth2Config,
clock: Clock,
chain: BaseBeaconChain,
validator_api_port: int,
client_identifier: str,
p2p_maddr: Multiaddr,
preferred_nodes: Collection[Multiaddr],
bootstrap_nodes: Collection[Multiaddr],
) -> None:
self._local_key_pair = create_new_key_pair(local_node_key.to_bytes())
self._eth2_config = eth2_config
self._clock = clock
self._chain = chain
self._block_pool: Set[SignedBeaconBlock] = set()
self._slashable_block_pool: Set[SignedBeaconBlock] = set()
# FIXME: can we provide `p2p_maddr` as a default listening interface for `_mk_host`?
peer_id = PeerID.from_pubkey(self._local_key_pair.public_key)
if "p2p" in p2p_maddr:
existing_peer_id = p2p_maddr.value_for_protocol("p2p")
existing_p2p_maddr = Multiaddr(f"/p2p/{existing_peer_id}")
self.logger.warning(
"peer identity derived from local key pair %s overriding given identity %s",
peer_id,
existing_peer_id,
)
p2p_maddr = p2p_maddr.decapsulate(existing_p2p_maddr)
self._p2p_maddr = p2p_maddr.encapsulate(Multiaddr(f"/p2p/{peer_id}"))
# TODO: persist metadata and handle updates...
self._metadata_provider = lambda: MetaData.create()
self._peer_updater, self._peer_updates = trio.open_memory_channel[
Tuple[PeerID, Any]](0)
self._host = Host(
self._local_key_pair,
peer_id,
self._accept_peer_updates,
self._get_status,
self._get_finalized_root_by_epoch,
self._get_block_by_slot,
self._get_block_by_root,
self._metadata_provider,
self._get_fork_digest,
self._eth2_config,
)
self._preferred_nodes = preferred_nodes
self._bootstrap_nodes = bootstrap_nodes
self._sync_notifier, self._sync_requests = trio.open_memory_channel[
SyncRequest](0)
self._syncer = _mk_syncer()
api_context = Context(
client_identifier,
eth2_config,
self._syncer,
self._chain,
self._clock,
_mk_block_broadcaster(self),
)
self.validator_api_port = validator_api_port
self._validator_api_server = _mk_validator_api_server(
self.validator_api_port, api_context)