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_wallet(
root_path: pathlib.Path,
config: Dict,
consensus_constants: ConsensusConstants,
keychain: Keychain,
) -> Dict:
node = WalletNode(
config,
keychain,
root_path,
consensus_constants=consensus_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
genesis_challenge = consensus_constants.GENESIS_CHALLENGE
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=genesis_challenge,
)
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_wallet(root_path):
service_name = "wallet"
config = load_config_cli(root_path, "config.yaml", service_name)
keychain = Keychain(testing=False)
wallet_constants = consensus_constants
if config["testing"] is True:
config["database_path"] = "test_db_wallet.db"
wallet_constants = test_constants
api = WalletNode(config,
keychain,
root_path,
consensus_constants=wallet_constants)
if "full_node_peer" in config:
connect_peers = [
PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
]
else:
connect_peers = []
async def start_callback():
await api._start()
def stop_callback():
api._close()
async def await_closed_callback():
await api._await_closed()
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.WALLET,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
on_connect_callback=api._on_connect,
stop_callback=stop_callback,
start_callback=start_callback,
await_closed_callback=await_closed_callback,
rpc_info=(WalletRpcApi, config["rpc_port"]),
connect_peers=connect_peers,
auth_connect_peers=False,
)
return kwargs
def service_kwargs_for_wallet(
root_path: pathlib.Path,
config: Dict,
consensus_constants: ConsensusConstants,
keychain: Keychain,
) -> Dict:
api = WalletNode(config,
keychain,
root_path,
consensus_constants=consensus_constants)
fnp = config.get("full_node_peer")
if fnp:
connect_peers = [PeerInfo(fnp["host"], fnp["port"])]
else:
connect_peers = []
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.WALLET,
service_name=SERVICE_NAME,
on_connect_callback=api._on_connect,
connect_peers=connect_peers,
auth_connect_peers=False,
)
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
async def setup_wallet_node(
port,
consensus_constants: ConsensusConstants,
full_node_port=None,
introducer_port=None,
key_seed=None,
starting_height=None,
):
config = load_config(bt.root_path, "config.yaml", "wallet")
if starting_height is not None:
config["starting_height"] = starting_height
config["initial_num_public_keys"] = 5
entropy = token_bytes(32)
keychain = Keychain(entropy.hex(), True)
keychain.add_private_key(bytes_to_mnemonic(entropy), "")
first_pk = keychain.get_first_public_key()
assert first_pk is not None
db_path_key_suffix = str(first_pk.get_fingerprint())
db_name = f"test-wallet-db-{port}"
db_path = bt.root_path / f"test-wallet-db-{port}-{db_path_key_suffix}"
if db_path.exists():
db_path.unlink()
config["database_path"] = str(db_name)
config["testing"] = True
api = WalletNode(
config,
keychain,
bt.root_path,
consensus_constants=consensus_constants,
name="wallet1",
)
periodic_introducer_poll = None
if introducer_port is not None:
periodic_introducer_poll = (
PeerInfo(self_hostname, introducer_port),
30,
config["target_peer_count"],
)
connect_peers: List[PeerInfo] = []
if full_node_port is not None:
connect_peers = [PeerInfo(self_hostname, full_node_port)]
started = asyncio.Event()
async def start_callback():
await api._start(new_wallet=True)
nonlocal started
started.set()
def stop_callback():
api._close()
async def await_closed_callback():
await api._await_closed()
service = Service(
root_path=bt.root_path,
api=api,
node_type=NodeType.WALLET,
advertised_port=port,
service_name="wallet",
server_listen_ports=[port],
connect_peers=connect_peers,
auth_connect_peers=False,
on_connect_callback=api._on_connect,
start_callback=start_callback,
stop_callback=stop_callback,
await_closed_callback=await_closed_callback,
periodic_introducer_poll=periodic_introducer_poll,
parse_cli_args=False,
)
run_task = asyncio.create_task(service.run())
await started.wait()
yield api, api.server
service.stop()
await run_task
if db_path.exists():
db_path.unlink()
keychain.delete_all_keys()