def test_select_network_cli_action(test_emitter, capsys, mock_stdin,
user_input):
mock_stdin.line(str(user_input))
selection = __NETWORKS[user_input]
result = select_network(emitter=test_emitter)
assert result == selection
captured = capsys.readouterr()
for name in __NETWORKS:
assert name in captured.out
assert mock_stdin.empty()
def init(general_config, config_options, force, config_root):
"""Create a new Ursula node configuration."""
emitter = setup_emitter(general_config, config_options.worker_address)
_pre_launch_warnings(emitter, dev=None, force=force)
if not config_root:
config_root = general_config.config_root
if not config_options.federated_only and not config_options.domain:
config_options.domain = select_network(emitter)
ursula_config = config_options.generate_config(emitter, config_root, force)
paint_new_installation_help(emitter, new_configuration=ursula_config)
def unbond(registry_filepath, eth_provider_uri, signer_uri, staking_provider,
network, force):
"""Unbonds an operator from an authorized staking provider."""
#
# Setup
#
emitter = StdoutEmitter()
if not signer_uri:
emitter.message('--signer is required', color='red')
raise click.Abort()
if not network:
network = select_network(emitter=emitter,
network_type=NetworksInventory.ETH)
connect_to_blockchain(eth_provider_uri=eth_provider_uri, emitter=emitter)
registry = get_registry(network=network,
registry_filepath=registry_filepath)
agent = ContractAgency.get_agent(PREApplicationAgent, registry=registry)
signer = Signer.from_signer_uri(signer_uri)
transacting_power = TransactingPower(account=staking_provider,
signer=signer)
#
# Check
#
bonded, onchain_operator_address = is_bonded(
agent=agent, staking_provider=staking_provider, return_address=True)
if not bonded:
emitter.message(NOT_BONDED.format(provider=staking_provider),
color='red')
raise click.Abort()
check_bonding_requirements(emitter=emitter,
agent=agent,
staking_provider=staking_provider)
#
# Unbond
#
if not force:
click.confirm(CONFIRM_UNBONDING.format(
provider=staking_provider, operator=onchain_operator_address),
abort=True)
transacting_power.unlock(password=get_client_password(
checksum_address=staking_provider,
envvar=NUCYPHER_ENVVAR_STAKING_PROVIDER_ETH_PASSWORD))
emitter.echo(UNBONDING.format(operator=onchain_operator_address))
receipt = agent.bond_operator(operator=NULL_ADDRESS,
transacting_power=transacting_power,
staking_provider=staking_provider)
paint_receipt_summary(receipt=receipt, emitter=emitter)
def init(general_config, config_options, force, config_root):
"""
Create a new Ursula node configuration.
"""
emitter = setup_emitter(general_config, config_options.worker_address)
_pre_launch_warnings(emitter, dev=None, force=force)
if not config_root:
config_root = general_config.config_root
if not config_options.federated_only and not config_options.domains: # TODO: Again, weird network/domains mapping. See UrsulaConfigOptions' constructor. #1580
config_options.domains = {select_network(emitter)}
ursula_config = config_options.generate_config(emitter, config_root, force)
paint_new_installation_help(emitter, new_configuration=ursula_config)
def test_select_network_cli_action_eth(test_emitter, capsys, mock_stdin,
user_input):
mock_stdin.line(str(user_input))
selection = __ETH_NETWORKS[user_input]
result = select_network(emitter=test_emitter,
network_type=NetworksInventory.ETH)
assert result == selection
assert result not in __POLY_NETWORKS
captured = capsys.readouterr()
for name in __ETH_NETWORKS:
assert name in captured.out
assert mock_stdin.empty()
def init(general_config, config_options, force, config_root, key_material):
"""Create a new Ursula node configuration."""
emitter = setup_emitter(general_config, config_options.operator_address)
_pre_launch_warnings(emitter, dev=None, force=force)
if not config_root:
config_root = general_config.config_root
if not config_options.federated_only and not config_options.eth_provider_uri:
raise click.BadOptionUsage(
'--eth-provider',
message="--eth-provider is required to initialize a new ursula.")
if not config_options.federated_only and not config_options.domain:
config_options.domain = select_network(
emitter, message="Select Staking Network")
if not config_options.federated_only and not config_options.payment_network:
config_options.payment_network = select_network(
emitter, message="Select Payment Network")
ursula_config = config_options.generate_config(emitter=emitter,
config_root=config_root,
force=force,
key_material=key_material)
filepath = ursula_config.to_configuration_file()
paint_new_installation_help(emitter,
new_configuration=ursula_config,
filepath=filepath)
def bond(registry_filepath, eth_provider_uri, signer_uri, operator_address,
staking_provider, network, force):
"""
Bond an operator to a staking provider.
The staking provider must be authorized to use the PREApplication.
"""
#
# Setup
#
emitter = StdoutEmitter()
connect_to_blockchain(eth_provider_uri=eth_provider_uri, emitter=emitter)
if not signer_uri:
emitter.message('--signer is required', color='red')
raise click.Abort()
if not network:
network = select_network(emitter=emitter)
signer = Signer.from_signer_uri(signer_uri)
transacting_power = TransactingPower(account=staking_provider,
signer=signer)
registry = get_registry(network=network,
registry_filepath=registry_filepath)
agent = ContractAgency.get_agent(PREApplicationAgent, registry=registry)
#
# Checks
#
# Check for authorization
is_authorized(emitter=emitter,
agent=agent,
staking_provider=staking_provider)
# Check bonding
if is_bonded(agent=agent,
staking_provider=staking_provider,
return_address=False):
# operator is already set - check timing
check_bonding_requirements(emitter=emitter,
agent=agent,
staking_provider=staking_provider)
# Check for pre-existing staking providers for this operator
onchain_staking_provider = agent.get_staking_provider_from_operator(
operator_address=operator_address)
if onchain_staking_provider != NULL_ADDRESS:
emitter.message(ALREADY_BONDED.format(
provider=onchain_staking_provider, operator=operator_address),
color='red')
raise click.Abort() # dont steal bananas
# Check that operator is not human
if staking_provider != operator_address:
# if the operator has a beneficiary it is the staking provider.
beneficiary = agent.get_beneficiary(staking_provider=operator_address)
if beneficiary != NULL_ADDRESS:
emitter.message(UNEXPECTED_HUMAN_OPERATOR, color='red')
raise click.Abort()
#
# Bond
#
if not force:
click.confirm(CONFIRM_BONDING.format(provider=staking_provider,
operator=operator_address),
abort=True)
transacting_power.unlock(password=get_client_password(
checksum_address=staking_provider,
envvar=NUCYPHER_ENVVAR_STAKING_PROVIDER_ETH_PASSWORD))
emitter.echo(BONDING.format(operator=operator_address))
receipt = agent.bond_operator(operator=operator_address,
transacting_power=transacting_power,
staking_provider=staking_provider)
paint_receipt_summary(receipt=receipt, emitter=emitter)
def test_select_network_cli_action_neither(test_emitter):
with pytest.raises(Exception):
select_network(emitter=test_emitter, network_type="FAKE COIN")