def service_kwargs_for_timelord(
root_path: pathlib.Path,
config: Dict,
constants: ConsensusConstants,
) -> Dict:
connect_peers = [
PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
]
genesis_challenge = bytes32(
bytes.fromhex(
config["network_genesis_challenges"][config["selected_network"]]))
node = Timelord(config,
constants.replace(GENESIS_CHALLENGE=genesis_challenge))
peer_api = TimelordAPI(node)
kwargs = dict(
root_path=root_path,
peer_api=peer_api,
node=node,
node_type=NodeType.TIMELORD,
advertised_port=config["port"],
service_name=SERVICE_NAME,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=False,
network_id=genesis_challenge,
)
return kwargs
def service_kwargs_for_farmer(
root_path: pathlib.Path,
config: Dict,
config_pool: Dict,
keychain: Keychain,
consensus_constants: ConsensusConstants,
) -> Dict:
connect_peers = []
fnp = config.get("full_node_peer")
if fnp is not None:
connect_peers.append(PeerInfo(fnp["host"], fnp["port"]))
genesis_challenge = bytes32(bytes.fromhex(config["network_genesis_challenges"][config["selected_network"]]))
farmer = Farmer(config, config_pool, keychain, consensus_constants.replace(GENESIS_CHALLENGE=genesis_challenge))
peer_api = FarmerAPI(farmer)
kwargs = dict(
root_path=root_path,
node=farmer,
peer_api=peer_api,
node_type=NodeType.FARMER,
advertised_port=config["port"],
service_name=SERVICE_NAME,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=False,
on_connect_callback=farmer.on_connect,
network_id=genesis_challenge,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (FarmerRpcApi, config["rpc_port"])
return kwargs
def service_kwargs_for_harvester(
root_path: pathlib.Path,
config: Dict,
consensus_constants: ConsensusConstants,
) -> Dict:
connect_peers = [
PeerInfo(config["farmer_peer"]["host"], config["farmer_peer"]["port"])
]
genesis_challenge = bytes32(
bytes.fromhex(
config["network_genesis_challenges"][config["selected_network"]]))
harvester = Harvester(
root_path, config,
consensus_constants.replace(GENESIS_CHALLENGE=genesis_challenge))
peer_api = HarvesterAPI(harvester)
kwargs = dict(
root_path=root_path,
node=harvester,
peer_api=peer_api,
node_type=NodeType.HARVESTER,
advertised_port=config["port"],
service_name=SERVICE_NAME,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=True,
network_id=genesis_challenge,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (HarvesterRpcApi, config["rpc_port"])
return kwargs
def service_kwargs_for_harvester(
root_path: pathlib.Path,
config: Dict,
consensus_constants: ConsensusConstants,
) -> Dict:
connect_peers = [
PeerInfo(config["farmer_peer"]["host"], config["farmer_peer"]["port"])
]
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = consensus_constants.replace_str_to_bytes(**overrides)
harvester = Harvester(root_path, config, updated_constants)
peer_api = HarvesterAPI(harvester)
network_id = config["selected_network"]
kwargs = dict(
root_path=root_path,
node=harvester,
peer_api=peer_api,
node_type=NodeType.HARVESTER,
advertised_port=config["port"],
service_name=SERVICE_NAME,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=True,
network_id=network_id,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (HarvesterRpcApi, config["rpc_port"])
return kwargs
def service_kwargs_for_timelord(
root_path: pathlib.Path,
config: Dict,
constants: ConsensusConstants,
) -> Dict:
connect_peers = [PeerInfo(config["full_node_peer"]["host"], config["full_node_peer"]["port"])]
overrides = config["network_overrides"]["constants"][config["selected_network"]]
updated_constants = constants.replace_str_to_bytes(**overrides)
node = Timelord(root_path, config, updated_constants)
peer_api = TimelordAPI(node)
network_id = config["selected_network"]
kwargs = dict(
root_path=root_path,
peer_api=peer_api,
node=node,
node_type=NodeType.TIMELORD,
advertised_port=config["port"],
service_name=SERVICE_NAME,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=False,
network_id=network_id,
)
return kwargs
def service_kwargs_for_full_node(
root_path: pathlib.Path, config: Dict, consensus_constants: ConsensusConstants
) -> Dict:
overrides = config["network_overrides"][config["selected_network"]]
updated_constants = consensus_constants.replace_str_to_bytes(**overrides)
full_node = FullNode(
config,
root_path=root_path,
consensus_constants=updated_constants,
)
api = FullNodeAPI(full_node)
upnp_list = []
if config["enable_upnp"]:
upnp_list = [config["port"]]
kwargs = dict(
root_path=root_path,
node=api.full_node,
peer_api=api,
node_type=NodeType.FULL_NODE,
advertised_port=config["port"],
service_name=SERVICE_NAME,
upnp_ports=upnp_list,
server_listen_ports=[config["port"]],
on_connect_callback=full_node.on_connect,
network_id=updated_constants.GENESIS_CHALLENGE,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (FullNodeRpcApi, config["rpc_port"])
return kwargs
async def setup_full_node(
consensus_constants: ConsensusConstants,
db_name,
port,
local_bt,
introducer_port=None,
simulator=False,
send_uncompact_interval=30,
):
db_path = bt.root_path / f"{db_name}"
if db_path.exists():
db_path.unlink()
config = bt.config["full_node"]
config["database_path"] = db_name
config["send_uncompact_interval"] = send_uncompact_interval
config["target_uncompact_proofs"] = 30
config["peer_connect_interval"] = 50
if introducer_port is not None:
config["introducer_peer"]["host"] = self_hostname
config["introducer_peer"]["port"] = introducer_port
else:
config["introducer_peer"] = None
config["port"] = port
config["rpc_port"] = port + 1000
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = consensus_constants.replace_str_to_bytes(**overrides)
if simulator:
kwargs = service_kwargs_for_full_node_simulator(
local_bt.root_path, config, local_bt)
else:
kwargs = service_kwargs_for_full_node(local_bt.root_path, config,
updated_constants)
kwargs.update(
parse_cli_args=False,
connect_to_daemon=False,
)
service = Service(**kwargs)
await service.start()
yield service._api
service.stop()
await service.wait_closed()
if db_path.exists():
db_path.unlink()
async def wait_for_genesis_challenge(
root_path: Path, constants: ConsensusConstants,
SERVICE_NAME) -> Tuple[Dict, ConsensusConstants]:
while True:
await asyncio.sleep(1)
config = load_config(root_path, "config.yaml", SERVICE_NAME)
selected = config["selected_network"]
challenge = config["network_overrides"]["constants"][selected][
"GENESIS_CHALLENGE"]
if challenge is None:
continue
else:
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = constants.replace_str_to_bytes(**overrides)
return config, updated_constants
def service_kwargs_for_wallet(
root_path: pathlib.Path,
config: Dict,
consensus_constants: ConsensusConstants,
keychain: Keychain,
) -> Dict:
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = consensus_constants.replace_str_to_bytes(**overrides)
node = WalletNode(
config,
keychain,
root_path,
consensus_constants=updated_constants,
)
peer_api = WalletNodeAPI(node)
fnp = config.get("full_node_peer")
if fnp:
connect_peers = [PeerInfo(fnp["host"], fnp["port"])]
node.full_node_peer = PeerInfo(fnp["host"], fnp["port"])
else:
connect_peers = []
node.full_node_peer = None
network_id = config["selected_network"]
kwargs = dict(
root_path=root_path,
node=node,
peer_api=peer_api,
node_type=NodeType.WALLET,
service_name=SERVICE_NAME,
on_connect_callback=node.on_connect,
connect_peers=connect_peers,
auth_connect_peers=False,
network_id=network_id,
)
port = config.get("port")
if port is not None:
kwargs.update(
advertised_port=config["port"],
server_listen_ports=[config["port"]],
)
rpc_port = config.get("rpc_port")
if rpc_port is not None:
kwargs["rpc_info"] = (WalletRpcApi, config["rpc_port"])
return kwargs
def service_kwargs_for_farmer(
root_path: pathlib.Path,
config: Dict,
config_pool: Dict,
keychain: Keychain,
consensus_constants: ConsensusConstants,
) -> Dict:
connect_peers = []
fnp = config.get("full_node_peer")
if fnp is not None:
connect_peers.append(PeerInfo(fnp["host"], fnp["port"]))
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = consensus_constants.replace_str_to_bytes(**overrides)
farmer = Farmer(root_path,
config,
config_pool,
keychain,
consensus_constants=updated_constants)
peer_api = FarmerAPI(farmer)
network_id = config["selected_network"]
kwargs = dict(
root_path=root_path,
node=farmer,
peer_api=peer_api,
node_type=NodeType.FARMER,
advertised_port=config["port"],
service_name=SERVICE_NAME,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=False,
on_connect_callback=farmer.on_connect,
network_id=network_id,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (FarmerRpcApi, config["rpc_port"])
return kwargs