def setup_eth1_modules(
self,
trinity_config: TrinityConfig) -> Tuple[Eth1ChainRPCModule, ...]:
db_manager = create_db_consumer_manager(
trinity_config.database_ipc_path)
eth1_app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = trinity_config.get_chain_config()
chain: BaseAsyncChain
if eth1_app_config.database_mode is Eth1DbMode.LIGHT:
header_db = db_manager.get_headerdb() # type: ignore
event_bus_light_peer_chain = EventBusLightPeerChain(
self.context.event_bus)
chain = chain_config.light_chain_class(
header_db, peer_chain=event_bus_light_peer_chain)
elif eth1_app_config.database_mode is Eth1DbMode.FULL:
db = db_manager.get_db() # type: ignore
chain = chain_config.full_chain_class(db)
else:
raise Exception(
f"Unsupported Database Mode: {eth1_app_config.database_mode}")
return initialize_eth1_modules(chain, self.event_bus)
def get_discv5_topic(trinity_config: TrinityConfig, protocol: Type[Protocol]) -> bytes:
db_manager = create_db_consumer_manager(trinity_config.database_ipc_path)
header_db = db_manager.get_headerdb() # type: ignore
genesis_hash = header_db.get_canonical_block_hash(BlockNumber(GENESIS_BLOCK_NUMBER))
return get_v5_topic(protocol, genesis_hash)
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
db_manager = create_db_consumer_manager(
trinity_config.database_ipc_path)
db = db_manager.get_db() # type: ignore
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
chain = chain_config.full_chain_class(db)
if self.boot_info.trinity_config.network_id == MAINNET_NETWORK_ID:
validator = DefaultTransactionValidator(chain,
BYZANTIUM_MAINNET_BLOCK)
elif self.boot_info.trinity_config.network_id == ROPSTEN_NETWORK_ID:
validator = DefaultTransactionValidator(chain,
BYZANTIUM_ROPSTEN_BLOCK)
else:
# TODO: We could hint the user about e.g. a --tx-pool-no-validation flag to run the
# tx pool without tx validation in this case
raise ValueError(
"The TxPool plugin only supports MainnetChain or RopstenChain")
proxy_peer_pool = ETHProxyPeerPool(self.event_bus,
TO_NETWORKING_BROADCAST_CONFIG)
self.tx_pool = TxPool(self.event_bus, proxy_peer_pool, validator)
asyncio.ensure_future(self.tx_pool.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
if trinity_config.has_app_config(Eth1AppConfig):
db_manager = create_db_consumer_manager(
trinity_config.database_ipc_path)
server = self.make_eth1_request_server(
trinity_config.get_app_config(Eth1AppConfig),
db_manager,
)
elif trinity_config.has_app_config(BeaconAppConfig):
db_manager = create_beacon_db_consumer_manager(
trinity_config.database_ipc_path)
server = self.make_beacon_request_server(
trinity_config.get_app_config(BeaconAppConfig),
db_manager,
)
else:
raise Exception(
"Trinity config must have either eth1 or beacon chain config")
asyncio.ensure_future(
exit_with_services(server, self._event_bus_service))
asyncio.ensure_future(server.run())
def __init__(self, event_bus: TrinityEventBusEndpoint,
trinity_config: TrinityConfig) -> None:
super().__init__()
self.trinity_config = trinity_config
self._db_manager = create_db_consumer_manager(
trinity_config.database_ipc_path)
self._headerdb = self._db_manager.get_headerdb() # type: ignore
self._jsonrpc_ipc_path: Path = trinity_config.jsonrpc_ipc_path
self._network_id = trinity_config.network_id
self.event_bus = event_bus
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
chain_config = trinity_config.get_chain_config()
db_manager = create_db_consumer_manager(trinity_config.database_ipc_path)
self._beam_chain = make_pausing_beam_chain(
chain_config.vm_configuration,
chain_config.chain_id,
db_manager.get_db(), # type: ignore
self.event_bus,
)
asyncio.ensure_future(clean_up_endpoint(self.event_bus))
import_server = BlockImportServer(self.event_bus, self._beam_chain)
asyncio.ensure_future(import_server.run())
def get_chain(self) -> BaseChain:
db_manager = create_db_consumer_manager(self.boot_info.trinity_config.database_ipc_path)
chain_config = self.boot_info.trinity_config.get_chain_config()
chain: BaseChain
if self.boot_info.args.sync_mode == SYNC_LIGHT:
header_db = db_manager.get_headerdb() # type: ignore
chain = chain_config.light_chain_class(
header_db,
peer_chain=EventBusLightPeerChain(self.event_bus)
)
else:
db = db_manager.get_db() # type: ignore
chain = chain_config.full_chain_class(db)
return chain
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
db_manager = create_db_consumer_manager(trinity_config.database_ipc_path)
self._beam_chain = make_pausing_beam_chain(
chain_config.vm_configuration,
chain_config.chain_id,
db_manager.get_db(), # type: ignore
self.event_bus,
self._loop,
)
import_server = BlockImportServer(self.event_bus, self._beam_chain)
asyncio.ensure_future(exit_with_services(import_server, self._event_bus_service))
asyncio.ensure_future(import_server.run())
def db_shell(use_ipython: bool, database_dir: Path, trinity_config: TrinityConfig) -> None:
db_ipc_path = trinity_config.database_ipc_path
trinity_already_running = db_ipc_path.exists()
if trinity_already_running:
db_manager = create_db_consumer_manager(db_ipc_path)
db = db_manager.get_db() # type: ignore
else:
db = LevelDB(database_dir)
chaindb = ChainDB(db)
head = chaindb.get_canonical_head()
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
chain = chain_config.full_chain_class(db)
greeter = f"""
Head: #{head.block_number}
Hash: {head.hex_hash}
State Root: {encode_hex(head.state_root)}
Inspecting active Trinity? {trinity_already_running}
Available Context Variables:
- `db`: base database object
- `chaindb`: `ChainDB` instance
- `trinity_config`: `TrinityConfig` instance
- `chain_config`: `ChainConfig` instance
- `chain`: `Chain` instance
"""
namespace = {
'db': db,
'chaindb': chaindb,
'trinity_config': trinity_config,
'chain_config': chain_config,
'chain': chain,
}
shell(use_ipython, namespace, DB_SHELL_BANNER + greeter)
def manager(database_server_ipc_path):
return create_db_consumer_manager(database_server_ipc_path, connect=True)
