def chain_for_beacon_config(
trinity_config: TrinityConfig,
beacon_app_config: BeaconAppConfig,
) -> Iterator[AsyncBeaconChainDB]:
db = DBClient.connect(trinity_config.database_ipc_path)
with db:
yield AsyncBeaconChainDB(db)
async def get_chain_db(blocks=(),
genesis_config=SERENITY_GENESIS_CONFIG,
fork_choice_scoring=higher_slot_scoring):
db = AtomicDB()
chain_db = AsyncBeaconChainDB(db=db, genesis_config=genesis_config)
await chain_db.coro_persist_block_chain(
blocks,
BeaconBlock,
(higher_slot_scoring, ) * len(blocks),
)
return chain_db
async def test_json_rpc_http_server(
aiohttp_raw_server, aiohttp_client, event_bus, base_db, ipc_path
):
manager = DBManager(base_db)
with manager.run(ipc_path):
override_lengths(SERENITY_CONFIG)
fork_choice_scoring = HigherSlotScoring()
genesis_state, genesis_block = create_mock_genesis(
pubkeys=(),
config=SERENITY_CONFIG,
keymap=dict(),
genesis_block_class=BeaconBlock,
genesis_time=0,
)
db = DBClient.connect(ipc_path)
chaindb = AsyncBeaconChainDB.from_genesis(
db, genesis_state, SignedBeaconBlock, fork_choice_scoring
)
try:
rpc = RPCServer(
initialize_beacon_modules(chaindb, event_bus), chaindb, event_bus
)
raw_server = await aiohttp_raw_server(RPCHandler.handle(rpc.execute))
client = await aiohttp_client(raw_server)
request_id = 1
request_data = {
"jsonrpc": "2.0",
"method": "beacon_head",
"params": [],
"id": request_id,
}
response = await client.post("/", json=request_data)
response_data = await response.json()
assert response_data["id"] == request_id
result = response_data["result"]
assert result["slot"] == 0
assert decode_hex(result["block_root"]) == genesis_block.hash_tree_root
assert decode_hex(result["state_root"]) == genesis_state.hash_tree_root
except KeyboardInterrupt:
pass
finally:
await raw_server.close()
db.close()
async def test_http_server(aiohttp_raw_server, aiohttp_client, event_bus,
base_db, ipc_path):
manager = DBManager(base_db)
with manager.run(ipc_path):
# Set chaindb
override_lengths(SERENITY_CONFIG)
db = DBClient.connect(ipc_path)
genesis_config = Eth2GenesisConfig(SERENITY_CONFIG)
chaindb = AsyncBeaconChainDB(db, genesis_config)
fork_choice_scoring = higher_slot_scoring
genesis_state, genesis_block = create_mock_genesis(
pubkeys=(),
config=SERENITY_CONFIG,
keymap=dict(),
genesis_block_class=BeaconBlock,
genesis_time=0,
)
chaindb.persist_state(genesis_state)
chaindb.persist_block(genesis_block, genesis_block.__class__,
fork_choice_scoring)
try:
rpc = RPCServer(initialize_beacon_modules(chaindb, event_bus),
chaindb, event_bus)
raw_server = await aiohttp_raw_server(handler(rpc.execute))
client = await aiohttp_client(raw_server)
request_id = 1
request_data = {
"jsonrpc": "2.0",
"method": "beacon_head",
"params": [],
"id": request_id,
}
response = await client.post('/', json=request_data)
response_data = await response.json()
assert response_data['id'] == request_id
result = response_data['result']
assert result['slot'] == 0
assert decode_hex(
result['block_root']) == genesis_block.signing_root
assert decode_hex(
result['state_root']) == genesis_state.hash_tree_root
except KeyboardInterrupt:
pass
finally:
await raw_server.close()
db.close()
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
key_pair = self._load_or_create_node_key()
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
chain_config = beacon_app_config.get_chain_config()
attestation_pool = AttestationPool()
chain = chain_config.beacon_chain_class(
base_db,
attestation_pool,
chain_config.genesis_config
)
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="127.0.0.1", # FIXME: Should be configurable
listen_port=self.boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
cancel_token=libp2p_node.cancel_token,
)
state = chain.get_state_by_slot(chain_config.genesis_config.GENESIS_SLOT)
registry_pubkeys = [v_record.pubkey for v_record in state.validators]
validator_privkeys = {}
validator_keymap = chain_config.genesis_data.validator_keymap
for pubkey in validator_keymap:
try:
validator_index = cast(ValidatorIndex, registry_pubkeys.index(pubkey))
except ValueError:
self.logger.error(f'Could not find pubkey {pubkey.hex()} in genesis state')
raise
validator_privkeys[validator_index] = validator_keymap[pubkey]
validator = Validator(
chain=chain,
p2p_node=libp2p_node,
validator_privkeys=validator_privkeys,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=receive_server.get_ready_attestations,
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
)
syncer = BeaconChainSyncer(
chain_db=AsyncBeaconChainDB(
base_db,
chain_config.genesis_config,
),
peer_pool=libp2p_node.handshaked_peers,
block_importer=SyncBlockImporter(chain),
genesis_config=chain_config.genesis_config,
token=libp2p_node.cancel_token,
)
asyncio.ensure_future(exit_with_services(
self._event_bus_service,
libp2p_node,
receive_server,
slot_ticker,
validator,
syncer,
))
asyncio.ensure_future(libp2p_node.run())
asyncio.ensure_future(receive_server.run())
asyncio.ensure_future(slot_ticker.run())
asyncio.ensure_future(validator.run())
asyncio.ensure_future(syncer.run())
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None:
trinity_config = boot_info.trinity_config
key_pair = cls._load_or_create_node_key(boot_info)
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
if boot_info.args.debug_libp2p:
logging.getLogger("libp2p").setLevel(logging.DEBUG)
else:
logging.getLogger("libp2p").setLevel(logging.INFO)
with base_db:
chain_config = beacon_app_config.get_chain_config()
chain = chain_config.beacon_chain_class(
base_db, chain_config.genesis_config)
# TODO: To simplify, subsribe all subnets
subnets: Set[SubnetId] = set(
SubnetId(subnet_id)
for subnet_id in range(ATTESTATION_SUBNET_COUNT))
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="0.0.0.0",
listen_port=boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
subnets=subnets,
event_bus=event_bus,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
subnets=subnets,
cancel_token=libp2p_node.cancel_token,
)
state = chain.get_state_by_slot(
chain_config.genesis_config.GENESIS_SLOT)
registry_pubkeys = [
v_record.pubkey for v_record in state.validators
]
validator_privkeys = {}
validator_keymap = chain_config.genesis_data.validator_keymap
for pubkey in validator_keymap:
try:
validator_index = cast(ValidatorIndex,
registry_pubkeys.index(pubkey))
except ValueError:
cls.logger.error(
f'Could not find pubkey {pubkey.hex()} in genesis state'
)
raise
validator_privkeys[validator_index] = validator_keymap[pubkey]
validator = Validator(
chain=chain,
p2p_node=libp2p_node,
validator_privkeys=validator_privkeys,
event_bus=event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=receive_server.
get_ready_attestations,
get_aggregatable_attestations_fn=receive_server.
get_aggregatable_attestations,
import_attestation_fn=receive_server.import_attestation,
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
syncer = BeaconChainSyncer(
chain_db=AsyncBeaconChainDB(
base_db,
chain_config.genesis_config,
),
peer_pool=libp2p_node.handshaked_peers,
block_importer=SyncBlockImporter(chain),
genesis_config=chain_config.genesis_config,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
metrics_server = HTTPServer(
handler=MetricsHandler.handle(chain)(event_bus),
port=boot_info.args.metrics_port,
)
api_server = HTTPServer(
handler=APIHandler.handle(chain)(event_bus),
port=boot_info.args.api_port,
)
services: Tuple[BaseService,
...] = (libp2p_node, receive_server, slot_ticker,
validator, syncer)
if boot_info.args.enable_metrics:
services += (metrics_server, )
if boot_info.args.enable_api:
services += (api_server, )
async with AsyncExitStack() as stack:
for service in services:
await stack.enter_async_context(run_service(service))
await asyncio.gather(*(service.cancellation()
for service in services))
def chain_for_beacon_config(
self, trinity_config: TrinityConfig,
beacon_app_config: BeaconAppConfig) -> AsyncBeaconChainDB:
chain_config = beacon_app_config.get_chain_config()
db = DBClient.connect(trinity_config.database_ipc_path)
return AsyncBeaconChainDB(db, chain_config.genesis_config)
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None:
trinity_config = boot_info.trinity_config
key_pair = _load_secp256k1_key_pair_from(trinity_config)
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
if boot_info.args.debug_libp2p:
logging.getLogger("libp2p").setLevel(logging.DEBUG)
else:
logging.getLogger("libp2p").setLevel(logging.INFO)
with base_db:
chain_config = beacon_app_config.get_chain_config()
chain = chain_config.beacon_chain_class(
base_db, chain_config.genesis_config)
# TODO: To simplify, subsribe all subnets
subnets: Set[SubnetId] = set(
SubnetId(subnet_id)
for subnet_id in range(ATTESTATION_SUBNET_COUNT))
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="0.0.0.0",
listen_port=boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
subnets=subnets,
event_bus=event_bus,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
subnets=subnets,
cancel_token=libp2p_node.cancel_token,
)
chain_maintainer = ChainMaintainer(chain=chain,
event_bus=event_bus,
token=libp2p_node.cancel_token)
validator_handler = ValidatorHandler(
chain=chain,
p2p_node=libp2p_node,
event_bus=event_bus,
get_ready_attestations_fn=receive_server.
get_ready_attestations,
get_aggregatable_attestations_fn=receive_server.
get_aggregatable_attestations,
import_attestation_fn=receive_server.import_attestation,
token=libp2p_node.cancel_token,
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
syncer = BeaconChainSyncer(
chain_db=AsyncBeaconChainDB(base_db,
chain_config.genesis_config),
peer_pool=libp2p_node.handshaked_peers,
block_importer=SyncBlockImporter(chain),
genesis_config=chain_config.genesis_config,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
metrics_server = HTTPServer(
handler=MetricsHandler.handle(chain)(event_bus),
port=boot_info.args.metrics_port,
)
# NOTE: this API server provides an interface into the beacon node
api_server = HTTPServer(
handler=APIHandler.handle(chain)(event_bus),
port=boot_info.args.api_port,
)
# NOTE: this API server provides an interface between the beacon node and
# any connected validator clients.
validator_api_handler = ValidatorAPIHandler(
chain, event_bus, chain_config.genesis_time)
validator_api_server = HTTPAppServer(
routes=validator_api_handler.make_routes(), port=30303)
services: Tuple[BaseService, ...] = (
libp2p_node,
receive_server,
slot_ticker,
syncer,
validator_api_server,
)
if boot_info.args.enable_metrics:
services += (metrics_server, )
if boot_info.args.enable_api:
services += (api_server, )
if boot_info.args.bn_only:
services += (chain_maintainer, validator_handler)
async with AsyncExitStack() as stack:
for service in services:
await stack.enter_async_context(run_service(service))
await asyncio.gather(*(service.cancellation()
for service in services))
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None:
trinity_config = boot_info.trinity_config
key_pair = cls._load_or_create_node_key(boot_info)
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
chain_config = beacon_app_config.get_chain_config()
chain = chain_config.beacon_chain_class(base_db,
chain_config.genesis_config)
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="0.0.0.0",
listen_port=boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
cancel_token=libp2p_node.cancel_token,
)
state = chain.get_state_by_slot(
chain_config.genesis_config.GENESIS_SLOT)
registry_pubkeys = [v_record.pubkey for v_record in state.validators]
validator_privkeys = {}
validator_keymap = chain_config.genesis_data.validator_keymap
for pubkey in validator_keymap:
try:
validator_index = cast(ValidatorIndex,
registry_pubkeys.index(pubkey))
except ValueError:
cls.logger.error(
f'Could not find pubkey {pubkey.hex()} in genesis state')
raise
validator_privkeys[validator_index] = validator_keymap[pubkey]
validator = Validator(
chain=chain,
p2p_node=libp2p_node,
validator_privkeys=validator_privkeys,
event_bus=event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=receive_server.get_ready_attestations,
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
syncer = BeaconChainSyncer(
chain_db=AsyncBeaconChainDB(
base_db,
chain_config.genesis_config,
),
peer_pool=libp2p_node.handshaked_peers,
block_importer=SyncBlockImporter(chain),
genesis_config=chain_config.genesis_config,
token=libp2p_node.cancel_token,
)
services = (libp2p_node, receive_server, slot_ticker, validator,
syncer)
async with AsyncExitStack() as stack:
for service in services:
await stack.enter_async_context(run_service(service))
await asyncio.gather(*(service.cancellation()
for service in services))
