def status(click_config, provider_uri, sync, geth, poa):
"""
Echo a snapshot of live network metadata.
"""
emitter = click_config.emitter
click.clear()
emitter.banner(NU_BANNER)
emitter.echo(message="Reading Latest Chaindata...")
try:
ETH_NODE = None
if geth:
ETH_NODE = get_provider_process()
blockchain = BlockchainInterface(provider_uri=provider_uri,
provider_process=ETH_NODE,
poa=poa)
blockchain.connect(sync_now=sync, fetch_registry=True)
paint_contract_status(blockchain=blockchain, emitter=emitter)
return # Exit
except Exception as e:
if click_config.debug:
raise
click.secho(str(e), bold=True, fg='red')
return # Exit
def network(general_config, registry_options):
"""
Overall information of the NuCypher Network.
"""
emitter = _setup_emitter(general_config)
registry = registry_options.get_registry(emitter, general_config.debug)
paint_contract_status(registry, emitter=emitter)
def network(click_config,
# Common Options
provider_uri, geth, poa, light, registry_filepath):
"""
Overall information of the NuCypher Network.
"""
# Init
emitter = _setup_emitter(click_config)
staking_agent = _get_staking_agent(click_config, emitter, geth, poa, light, provider_uri, registry_filepath)
paint_contract_status(staking_agent.registry, emitter=emitter)
def status(click_config, config_file):
"""
Echo a snapshot of live network metadata.
"""
#
# Initialize
#
ursula_config = UrsulaConfiguration.from_configuration_file(
filepath=config_file)
if not ursula_config.federated_only:
ursula_config.connect_to_blockchain(
provider_uri=ursula_config.provider_uri)
ursula_config.connect_to_contracts()
# Contracts
paint_contract_status(ursula_config=ursula_config,
click_config=click_config)
# Known Nodes
paint_known_nodes(ursula=ursula_config)
def status(click_config, config_file):
"""
Echo a snapshot of live network metadata.
"""
#
# Initialize
#
ursula_config = UrsulaConfiguration.from_configuration_file(
filepath=config_file)
if not ursula_config.federated_only:
ursula_config.get_blockchain_interface(
provider_uri=ursula_config.provider_uri)
ursula_config.acquire_agency()
# Contracts
paint_contract_status(click_config.emitter,
ursula_config=ursula_config,
click_config=click_config)
# Known Nodes
paint_known_nodes(emitter=click_config.emitter, ursula=ursula_config)
def view(click_config,
# API Options
geth, provider_uri, network, registry_filepath, staker_address, worker_address, federated_only, rest_host,
rest_port, db_filepath, poa, light, config_file, dev, lonely, teacher_uri, min_stake):
"""
View the Ursula node's configuration.
"""
### Setup ###
_validate_args(geth, federated_only, staker_address, registry_filepath)
emitter = _setup_emitter(click_config, worker_address)
_pre_launch_warnings(emitter, dev=dev, force=None)
ursula_config, provider_uri = _get_ursula_config(emitter, geth, provider_uri, network, registry_filepath, dev,
config_file, staker_address, worker_address, federated_only,
rest_host, rest_port, db_filepath, poa, light)
#############
URSULA = _create_ursula(ursula_config, click_config, dev, emitter, lonely, teacher_uri, min_stake)
if not URSULA.federated_only:
blockchain = URSULA.staking_agent.blockchain
emitter.echo("BLOCKCHAIN ----------\n")
painting.paint_contract_status(emitter=emitter, registry=URSULA.registry)
current_block = blockchain.w3.eth.blockNumber
emitter.echo(f'Block # {current_block}')
# TODO: 1231
emitter.echo(f'NU Balance (staker): {URSULA.token_balance}')
emitter.echo(f'ETH Balance (worker): {blockchain.client.get_balance(URSULA.worker_address)}')
emitter.echo(f'Current Gas Price {blockchain.client.gas_price}')
emitter.echo("CONFIGURATION --------")
response = UrsulaConfiguration._read_configuration_file(filepath=config_file or ursula_config.config_file_location)
return emitter.ipc(response=response, request_id=0, duration=0) # FIXME: what are request_id and duration here?
def ursula(
click_config,
action,
dev,
dry_run,
force,
lonely,
network,
teacher_uri,
min_stake,
rest_host,
rest_port,
db_filepath,
staker_address,
worker_address,
federated_only,
poa,
config_root,
config_file,
provider_uri,
geth,
registry_filepath,
interactive,
sync,
) -> None:
"""
"Ursula the Untrusted" PRE Re-encryption node management commands.
\b
Actions
-------------------------------------------------
\b
init Create a new Ursula node configuration.
view View the Ursula node's configuration.
run Run an "Ursula" node.
save-metadata Manually write node metadata to disk without running
forget Forget all known nodes.
destroy Delete Ursula node configuration.
confirm-activity Manually confirm-activity for the current period.
"""
emitter = click_config.emitter
#
# Validate
#
if federated_only:
if geth:
raise click.BadOptionUsage(
option_name="--geth",
message="Federated only cannot be used with the --geth flag")
if staker_address:
raise click.BadOptionUsage(
option_name='--federated-only',
message="Staking address cannot be used in federated mode.")
# Banner
emitter.banner(URSULA_BANNER.format(worker_address or ''))
#
# Pre-Launch Warnings
#
if dev:
emitter.echo("WARNING: Running in Development mode",
color='yellow',
verbosity=1)
if force:
emitter.echo("WARNING: Force is enabled", color='yellow', verbosity=1)
#
# Internal Ethereum Client
#
ETH_NODE = NO_BLOCKCHAIN_CONNECTION
if geth:
ETH_NODE = actions.get_provider_process()
provider_uri = ETH_NODE.provider_uri(scheme='file')
#
# Eager Actions
#
if action == "init":
"""Create a brand-new persistent Ursula"""
if dev:
raise click.BadArgumentUsage(
"Cannot create a persistent development character")
if (not staker_address or not worker_address) and not federated_only:
# Connect to Blockchain
fetch_registry = registry_filepath is None and not click_config.no_registry
registry = None
if registry_filepath:
registry = EthereumContractRegistry(
registry_filepath=registry_filepath)
blockchain = BlockchainInterface(provider_uri=provider_uri,
registry=registry,
poa=poa)
blockchain.connect(fetch_registry=fetch_registry,
sync_now=sync,
emitter=emitter)
if not staker_address:
prompt = "Select staker account"
staker_address = select_client_account(emitter=emitter,
blockchain=blockchain,
prompt=prompt)
if not worker_address:
prompt = "Select worker account"
worker_address = select_client_account(emitter=emitter,
blockchain=blockchain,
prompt=prompt)
if not config_root: # Flag
config_root = click_config.config_file # Envvar
if not rest_host:
rest_host = actions.determine_external_ip_address(emitter,
force=force)
download_registry = not federated_only and not click_config.no_registry
ursula_config = UrsulaConfiguration.generate(
password=get_nucypher_password(confirm=True),
config_root=config_root,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath,
domains={network} if network else None,
federated_only=federated_only,
checksum_address=staker_address,
worker_address=worker_address,
download_registry=download_registry,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
poa=poa)
painting.paint_new_installation_help(emitter,
new_configuration=ursula_config)
return
#
# Make Ursula
#
if dev:
ursula_config = UrsulaConfiguration(
dev_mode=True,
domains={TEMPORARY_DOMAIN},
poa=poa,
download_registry=False,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
checksum_address=staker_address,
worker_address=worker_address,
federated_only=federated_only,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath)
else:
try:
ursula_config = UrsulaConfiguration.from_configuration_file(
filepath=config_file,
domains={network} if network else None,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath,
poa=poa,
federated_only=federated_only)
except FileNotFoundError:
return actions.handle_missing_configuration_file(
character_config_class=UrsulaConfiguration,
config_file=config_file)
except NucypherKeyring.AuthenticationFailed as e:
emitter.echo(str(e), color='red', bold=True)
click.get_current_context().exit(1)
# TODO: Exit codes (not only for this, but for other exceptions)
#
# Configured Pre-Authentication Actions
#
# Handle destruction and forget *before* network bootstrap and character initialization below
if action == "destroy":
"""Delete all configuration files from the disk"""
if dev:
message = "'nucypher ursula destroy' cannot be used in --dev mode - There is nothing to destroy."
raise click.BadOptionUsage(option_name='--dev', message=message)
actions.destroy_configuration(emitter,
character_config=ursula_config,
force=force)
return
elif action == "forget":
actions.forget(emitter, configuration=ursula_config)
return
#
# Make Ursula
#
client_password = None
if not ursula_config.federated_only:
if not dev and not click_config.json_ipc:
client_password = get_client_password(
checksum_address=ursula_config.worker_address,
envvar="NUCYPHER_WORKER_ETH_PASSWORD")
try:
URSULA = actions.make_cli_character(character_config=ursula_config,
click_config=click_config,
min_stake=min_stake,
teacher_uri=teacher_uri,
dev=dev,
lonely=lonely,
client_password=client_password)
except NucypherKeyring.AuthenticationFailed as e:
emitter.echo(str(e), color='red', bold=True)
click.get_current_context().exit(1)
# TODO: Exit codes (not only for this, but for other exceptions)
#
# Authenticated Action Switch
#
if action == 'run':
"""Seed, Produce, Run!"""
# GO!
try:
# Ursula Deploy Warnings
emitter.message(f"Starting Ursula on {URSULA.rest_interface}",
color='green',
bold=True)
emitter.message(f"Connecting to {','.join(ursula_config.domains)}",
color='green',
bold=True)
emitter.message("Working ~ Keep Ursula Online!",
color='blue',
bold=True)
if interactive:
stdio.StandardIO(
UrsulaCommandProtocol(ursula=URSULA, emitter=emitter))
if dry_run:
return # <-- ABORT - (Last Chance)
# Run - Step 3
node_deployer = URSULA.get_deployer()
node_deployer.addServices()
node_deployer.catalogServers(node_deployer.hendrix)
node_deployer.run() # <--- Blocking Call (Reactor)
# Handle Crash
except Exception as e:
ursula_config.log.critical(str(e))
emitter.message(f"{e.__class__.__name__} {e}",
color='red',
bold=True)
raise # Crash :-(
# Graceful Exit
finally:
emitter.message("Stopping Ursula", color='green')
ursula_config.cleanup()
emitter.message("Ursula Stopped", color='red')
return
elif action == "save-metadata":
"""Manually save a node self-metadata file"""
metadata_path = ursula.write_node_metadata(node=URSULA)
emitter.message(
f"Successfully saved node metadata to {metadata_path}.",
color='green')
return
elif action == "view":
"""Paint an existing configuration to the console"""
if not URSULA.federated_only:
emitter.echo("BLOCKCHAIN ----------\n")
painting.paint_contract_status(emitter=emitter,
blockchain=URSULA.blockchain)
current_block = URSULA.blockchain.w3.eth.blockNumber
emitter.echo(f'Block # {current_block}')
# TODO: 1231
emitter.echo(f'NU Balance (staker): {URSULA.token_balance}')
emitter.echo(
f'ETH Balance (worker): {URSULA.blockchain.client.get_balance(URSULA.worker_address)}'
)
emitter.echo(
f'Current Gas Price {URSULA.blockchain.client.gas_price}')
emitter.echo("CONFIGURATION --------")
response = UrsulaConfiguration._read_configuration_file(
filepath=config_file or ursula_config.config_file_location)
return emitter.ipc(
response=response, request_id=0, duration=0
) # FIXME: #1216 - what are request_id and duration here?
elif action == 'confirm-activity':
receipt = URSULA.confirm_activity()
confirmed_period = URSULA.staking_agent.get_current_period() + 1
date = datetime_at_period(period=confirmed_period)
# TODO: Double-check dates here
emitter.echo(
f'\nActivity confirmed for period #{confirmed_period} '
f'(starting at {date})',
bold=True,
color='blue')
painting.paint_receipt_summary(
emitter=emitter,
receipt=receipt,
chain_name=URSULA.blockchain.client.chain_name)
# TODO: Check ActivityConfirmation event (see #1193)
return
else:
raise click.BadArgumentUsage("No such argument {}".format(action))
def network(general_config, registry_options):
"""Overall information of the NuCypher Network."""
emitter, registry, blockchain = registry_options.setup(
general_config=general_config)
paint_contract_status(registry, emitter=emitter)
def status(click_config, action, provider_uri, sync, geth, poa, periods, staking_address, registry_filepath):
"""
Echo a snapshot of live NuCypher Network metadata.
\b
Actions
-------------------------------------------------
network Overall information of the NuCypher Network
stakers Show relevant information about stakers
locked-tokens Display a graph of evolution of locked tokens
"""
emitter = click_config.emitter
click.clear()
emitter.banner(NU_BANNER)
#
# Connect to Blockchain
#
try:
ETH_NODE = None
if geth:
ETH_NODE = get_provider_process()
# Note: For test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
provider_process=ETH_NODE,
poa=poa,
sync=False,
show_sync_progress=False)
blockchain = BlockchainInterfaceFactory.get_interface(provider_uri=provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
except Exception as e:
if click_config.debug:
raise
click.secho(str(e), bold=True, fg='red')
raise click.Abort
if registry_filepath:
registry = LocalContractRegistry(filepath=registry_filepath)
else:
registry = InMemoryContractRegistry.from_latest_publication()
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=registry)
if action == 'network':
paint_contract_status(registry, emitter=emitter)
return # Exit
elif action == 'stakers':
stakers = [staking_address] if staking_address else staking_agent.get_stakers()
paint_stakers(emitter=emitter, stakers=stakers, agent=staking_agent)
return # Exit
elif action == 'locked-tokens':
paint_locked_tokens_status(emitter=emitter, agent=staking_agent, periods=periods)
return # Exit
else:
ctx = click.get_current_context()
raise click.UsageError(message=f"Unknown action '{action}'.", ctx=ctx)
def ursula(
click_config,
action,
dev,
quiet,
dry_run,
force,
lonely,
network,
teacher_uri,
min_stake,
rest_host,
rest_port,
db_filepath,
checksum_address,
withdraw_address,
federated_only,
poa,
config_root,
config_file,
provider_uri,
geth,
no_registry,
registry_filepath,
value,
duration,
index,
list_,
divide,
sync,
device,
interactive,
) -> None:
"""
Manage and run an "Ursula" PRE node.
\b
Actions
-------------------------------------------------
\b
init Create a new Ursula node configuration.
view View the Ursula node's configuration.
run Run an "Ursula" node.
save-metadata Manually write node metadata to disk without running
forget Forget all known nodes.
destroy Delete Ursula node configuration.
stake Manage stakes for this node.
confirm-activity Manually confirm-activity for the current period.
collect-reward Withdraw staking reward.
"""
#
# Validate
#
if federated_only and geth:
raise click.BadOptionUsage(
option_name="--geth",
message="Federated only cannot be used with the --geth flag")
if click_config.debug and quiet:
raise click.BadOptionUsage(
option_name="quiet",
message="--debug and --quiet cannot be used at the same time.")
# Banner
if not click_config.json_ipc and not click_config.quiet:
click.secho(URSULA_BANNER.format(checksum_address or ''))
#
# Pre-Launch Warnings
#
if not click_config.quiet:
if dev:
click.secho("WARNING: Running in Development mode", fg='yellow')
if force:
click.secho("WARNING: Force is enabled", fg='yellow')
#
# Internal Ethereum Client
#
ETH_NODE = NO_BLOCKCHAIN_CONNECTION
if geth:
ETH_NODE = actions.get_provider_process()
provider_uri = ETH_NODE.provider_uri(scheme='file')
#
# Eager Actions
#
if action == "init":
"""Create a brand-new persistent Ursula"""
if dev:
raise click.BadArgumentUsage(
"Cannot create a persistent development character")
if not config_root: # Flag
config_root = click_config.config_file # Envvar
if not rest_host:
rest_host = actions.determine_external_ip_address(force=force)
ursula_config = UrsulaConfiguration.generate(
password=get_password(confirm=True),
config_root=config_root,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath,
domains={network} if network else None,
federated_only=federated_only,
checksum_address=checksum_address,
download_registry=federated_only or no_registry,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
poa=poa)
painting.paint_new_installation_help(new_configuration=ursula_config)
return
#
# Make Ursula
#
if dev:
ursula_config = UrsulaConfiguration(
dev_mode=True,
domains={TEMPORARY_DOMAIN},
poa=poa,
download_registry=False,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
checksum_address=checksum_address,
federated_only=federated_only,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath)
else:
try:
ursula_config = UrsulaConfiguration.from_configuration_file(
filepath=config_file,
domains={network} if network else None,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath,
poa=poa,
federated_only=federated_only)
except FileNotFoundError:
return actions.handle_missing_configuration_file(
character_config_class=UrsulaConfiguration,
config_file=config_file)
except Exception as e:
if click_config.debug:
raise
else:
click.secho(str(e), fg='red', bold=True)
raise click.Abort
#
# Configured Pre-Authentication Actions
#
# Handle destruction *before* network bootstrap and character initialization below
if action == "destroy":
"""Delete all configuration files from the disk"""
if dev:
message = "'nucypher ursula destroy' cannot be used in --dev mode - There is nothing to destroy."
raise click.BadOptionUsage(option_name='--dev', message=message)
return actions.destroy_configuration(character_config=ursula_config,
force=force)
#
# Make Ursula
#
URSULA = actions.make_cli_character(character_config=ursula_config,
click_config=click_config,
min_stake=min_stake,
teacher_uri=teacher_uri,
dev=dev,
lonely=lonely)
#
# Authenticated Action Switch
#
if action == 'run':
"""Seed, Produce, Run!"""
# GO!
try:
# Ursula Deploy Warnings
click_config.emit(message="Starting Ursula on {}".format(
URSULA.rest_interface),
color='green',
bold=True)
click_config.emit(message="Connecting to {}".format(','.join(
ursula_config.domains)),
color='green',
bold=True)
if not URSULA.federated_only and URSULA.stakes:
click_config.emit(
message=
f"Staking {str(URSULA.current_stake)} ~ Keep Ursula Online!",
color='blue',
bold=True)
if interactive:
stdio.StandardIO(UrsulaCommandProtocol(ursula=URSULA))
if dry_run:
return # <-- ABORT - (Last Chance)
# Run - Step 3
node_deployer = URSULA.get_deployer()
node_deployer.addServices()
node_deployer.catalogServers(node_deployer.hendrix)
node_deployer.run() # <--- Blocking Call (Reactor)
# Handle Crash
except Exception as e:
ursula_config.log.critical(str(e))
click_config.emit(message="{} {}".format(e.__class__.__name__,
str(e)),
color='red',
bold=True)
raise # Crash :-(
# Graceful Exit
finally:
click_config.emit(message="Stopping Ursula", color='green')
ursula_config.cleanup()
click_config.emit(message="Ursula Stopped", color='red')
return
elif action == "save-metadata":
"""Manually save a node self-metadata file"""
metadata_path = ursula.write_node_metadata(node=URSULA)
return click_config.emit(
message="Successfully saved node metadata to {}.".format(
metadata_path),
color='green')
elif action == "view":
"""Paint an existing configuration to the console"""
if not URSULA.federated_only:
click.secho("BLOCKCHAIN ----------\n")
painting.paint_contract_status(click_config=click_config,
ursula_config=ursula_config)
current_block = URSULA.blockchain.w3.eth.blockNumber
click.secho(f'Block # {current_block}')
click.secho(f'NU Balance: {URSULA.token_balance}')
click.secho(f'ETH Balance: {URSULA.eth_balance}')
click.secho(
f'Current Gas Price {URSULA.blockchain.client.gasPrice}')
click.secho("CONFIGURATION --------")
response = UrsulaConfiguration._read_configuration_file(
filepath=config_file or ursula_config.config_file_location)
return click_config.emit(response=response)
elif action == "forget":
actions.forget(configuration=ursula_config)
return
elif action == 'stake':
# List Only
if list_:
if not URSULA.stakes:
click.echo(
f"There are no active stakes for {URSULA.checksum_address}"
)
else:
painting.paint_stakes(stakes=URSULA.stakes)
return
# Divide Only
if divide:
"""Divide an existing stake by specifying the new target value and end period"""
# Validate
if not URSULA.stakes:
click.echo(
f"There are no active stakes for {URSULA.checksum_address}"
)
return
# Selection
if index is None:
painting.paint_stakes(stakes=URSULA.stakes)
index = click.prompt("Select a stake to divide",
type=click.IntRange(
min=0, max=len(URSULA.stakes) - 1))
# Lookup the stake
current_stake = URSULA.stakes[index]
# Value
if not value:
value = click.prompt(
f"Enter target value (must be less than {str(current_stake.value)})",
type=STAKE_VALUE)
value = NU(value, 'NU')
# Duration
if not duration:
extension = click.prompt("Enter number of periods to extend",
type=STAKE_EXTENSION)
else:
extension = duration
if not force:
painting.paint_staged_stake_division(
ursula=URSULA,
original_index=index,
original_stake=current_stake,
target_value=value,
extension=extension)
click.confirm("Is this correct?", abort=True)
modified_stake, new_stake = URSULA.divide_stake(
stake_index=index,
target_value=value,
additional_periods=extension)
if not quiet:
click.secho('Successfully divided stake', fg='green')
click.secho(
f'Transaction Hash ........... {new_stake.receipt}')
# Show the resulting stake list
painting.paint_stakes(stakes=URSULA.stakes)
return
# Confirm new stake init
if not force:
click.confirm("Stage a new stake?", abort=True)
# Validate balance
balance = URSULA.token_balance
if balance == 0:
click.secho(f"{URSULA.checksum_address} has 0 NU.")
raise click.Abort
if not quiet:
click.echo(f"Current balance: {balance}")
# Gather stake value
if not value:
min_locked = NU(URSULA.economics.minimum_allowed_locked, 'NuNit')
value = click.prompt(f"Enter stake value",
type=STAKE_VALUE,
default=min_locked)
else:
value = NU(int(value), 'NU')
# Duration
if not quiet:
message = f"Minimum duration: {URSULA.economics.minimum_allowed_locked} | " \
f"Maximum Duration: {URSULA.economics.maximum_allowed_locked}"
click.echo(message)
if not duration:
duration = click.prompt(
"Enter stake duration in periods (1 Period = 24 Hours)",
type=STAKE_DURATION)
start_period = URSULA.staking_agent.get_current_period()
end_period = start_period + duration
# Review
if not force:
painting.paint_staged_stake(ursula=URSULA,
stake_value=value,
duration=duration,
start_period=start_period,
end_period=end_period)
if not dev:
actions.confirm_staged_stake(ursula=URSULA,
value=value,
duration=duration)
# Last chance to bail
if not force:
click.confirm("Publish staged stake to the blockchain?",
abort=True)
stake = URSULA.initialize_stake(amount=int(value),
lock_periods=duration)
# TODO temporary fix to not break backward compatibility
URSULA.set_worker(worker_address=URSULA.checksum_address)
painting.paint_staking_confirmation(ursula=URSULA,
transactions=stake.transactions)
return
elif action == 'confirm-activity':
if not URSULA.stakes:
click.secho("There are no active stakes for {}".format(
URSULA.checksum_address))
return
URSULA.staking_agent.confirm_activity(
node_address=URSULA.checksum_address)
return
elif action == 'collect-reward':
"""Withdraw staking reward to the specified wallet address"""
if not force:
click.confirm(
f"Send {URSULA.calculate_reward()} to {URSULA.checksum_address}?"
)
inflation_reward = URSULA.calculate_reward()
if inflation_reward:
URSULA.collect_staking_reward()
URSULA.collect_policy_reward(
collector_address=withdraw_address or checksum_address)
else:
raise click.BadArgumentUsage("No such argument {}".format(action))
