def __create_trustee(self, registry, transacting: bool = False) -> Trustee:
client_password = None
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri)
if transacting and not self.hw_wallet and not is_clef:
client_password = get_client_password(checksum_address=self.checksum_address)
trustee = Trustee(checksum_address=self.checksum_address, registry=registry, client_password=client_password)
return trustee
def create_character(self,
emitter,
config_file,
json_ipc,
load_seednodes=True):
# TODO: embed compatibility layer?
ursula_config = self.config_options.create_config(emitter, config_file)
is_clef = ClefSigner.is_valid_clef_uri(self.config_options.signer_uri)
# TODO: Oh
client_password = None
if not ursula_config.federated_only:
if not self.config_options.dev and not json_ipc and not is_clef:
client_password = get_client_password(
checksum_address=ursula_config.worker_address,
envvar=NUCYPHER_ENVVAR_WORKER_ETH_PASSWORD)
try:
URSULA = make_cli_character(
character_config=ursula_config,
emitter=emitter,
min_stake=self.min_stake,
teacher_uri=self.teacher_uri,
unlock_keyring=not self.config_options.dev,
lonely=self.config_options.lonely,
client_password=client_password,
start_learning_now=load_seednodes)
return ursula_config, URSULA
except NucypherKeyring.AuthenticationFailed as e:
emitter.echo(str(e), color='red', bold=True)
# TODO: Exit codes (not only for this, but for other exceptions)
return click.get_current_context().exit(1)
def create_character(self, emitter, config_file, json_ipc, load_seednodes=True):
config = self.config_options.create_config(emitter, config_file)
client_password = None
is_clef = ClefSigner.is_valid_clef_uri(self.config_options.signer_uri)
eth_password_is_needed = not config.federated_only and not self.hw_wallet and not config.dev_mode and not is_clef
if eth_password_is_needed:
if json_ipc:
client_password = os.environ.get(NUCYPHER_ENVVAR_ALICE_ETH_PASSWORD, NO_PASSWORD)
if client_password is NO_PASSWORD:
message = f"--json-ipc implies the {NUCYPHER_ENVVAR_ALICE_ETH_PASSWORD} envvar must be set."
click.BadOptionUsage(option_name='--json-ipc', message=message)
else:
client_password = get_client_password(checksum_address=config.checksum_address,
envvar=NUCYPHER_ENVVAR_ALICE_ETH_PASSWORD)
try:
ALICE = make_cli_character(character_config=config,
emitter=emitter,
unlock_keyring=not config.dev_mode,
teacher_uri=self.teacher_uri,
min_stake=self.min_stake,
client_password=client_password,
start_learning_now=load_seednodes,
lonely=self.config_options.lonely)
return ALICE
except NucypherKeyring.AuthenticationFailed as e:
emitter.echo(str(e), color='red', bold=True)
click.get_current_context().exit(1)
def get_password(self, blockchain, client_account):
is_clef = ClefSigner.is_valid_clef_uri(self.staker_options.config_options.signer_uri)
eth_password_needed = not self.hw_wallet and not blockchain.client.is_local and not is_clef
password = None
if eth_password_needed:
password = get_client_password(checksum_address=client_account)
return password
def create_character(self,
emitter,
config_file,
json_ipc,
load_seednodes=True):
ursula_config = self.config_options.create_config(emitter, config_file)
is_clef = ClefSigner.is_valid_clef_uri(self.config_options.signer_uri)
password_required = all(
(not ursula_config.federated_only, not self.config_options.dev,
not json_ipc, not is_clef))
__password = None
if password_required:
__password = get_client_password(
checksum_address=ursula_config.worker_address,
envvar=NUCYPHER_ENVVAR_WORKER_ETH_PASSWORD)
try:
URSULA = make_cli_character(
character_config=ursula_config,
emitter=emitter,
min_stake=self.min_stake,
teacher_uri=self.teacher_uri,
unlock_keyring=not self.config_options.dev,
client_password=__password,
unlock_signer=
False, # Ursula's unlock is managed separately using client_password.
lonely=self.config_options.lonely,
start_learning_now=load_seednodes,
json_ipc=json_ipc)
return ursula_config, URSULA
except NucypherKeyring.AuthenticationFailed as e:
emitter.echo(str(e), color='red', bold=True)
# TODO: Exit codes (not only for this, but for other exceptions)
return click.get_current_context().exit(1)
def __create_bidder(self,
registry,
domain: str,
transacting: bool = True,
hw_wallet: bool = False,
) -> Bidder:
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri)
testnet = self.network != NetworksInventory.MAINNET
signer = Signer.from_signer_uri(self.signer_uri, testnet=testnet) if self.signer_uri else None
password_required = (not is_clef and not hw_wallet)
if signer and transacting and password_required:
client_password = get_client_password(checksum_address=self.bidder_address)
signer.unlock_account(account=self.bidder_address, password=client_password)
transacting_power = None
if transacting:
transacting_power = TransactingPower(account=self.bidder_address, signer=signer)
transacting_power.unlock(password=client_password)
bidder = Bidder(registry=registry,
transacting_power=transacting_power,
checksum_address=self.bidder_address if not transacting_power else None,
domain=domain)
return bidder
def create_character(self, emitter, config_file, debug):
felix_config = self.config_options.create_config(emitter, config_file)
try:
# Authenticate
unlock_nucypher_keyring(
emitter,
character_configuration=felix_config,
password=get_nucypher_password(confirm=False))
client_password = get_client_password(
checksum_address=felix_config.checksum_address,
envvar=NUCYPHER_ENVVAR_WORKER_ETH_PASSWORD)
# Produce Felix
FELIX = felix_config.produce(domain=self.config_options.domain,
client_password=client_password)
FELIX.make_web_app(
) # attach web application, but dont start service
return FELIX
except Exception as e:
if debug:
raise
else:
emitter.echo(str(e), color='red', bold=True)
raise click.Abort
def __create_executive(self, registry, transacting: bool = False) -> Executive:
client_password = None
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri)
if transacting and not self.hw_wallet and not is_clef:
client_password = get_client_password(checksum_address=self.checksum_address)
executive = Executive(checksum_address=self.checksum_address,
registry=registry,
signer=ClefSigner(self.signer_uri),
client_password=client_password)
return executive
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 test_get_client_password(mock_stdin, mock_account, confirm, capsys):
mock_stdin.password(INSECURE_DEVELOPMENT_PASSWORD, confirm=confirm)
result = get_client_password(checksum_address=mock_account.address,
confirm=confirm)
assert result == INSECURE_DEVELOPMENT_PASSWORD
assert mock_stdin.empty()
message = COLLECT_ETH_PASSWORD.format(
checksum_address=mock_account.address)
captured = capsys.readouterr()
assert message in captured.out
if confirm:
assert "Repeat for confirmation:" in captured.out
def __create_bidder(self,
registry,
transacting: bool = True,
hw_wallet: bool = False) -> Bidder:
client_password = None
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri)
if transacting and not is_clef and not hw_wallet:
client_password = get_client_password(checksum_address=self.bidder_address)
signer = Signer.from_signer_uri(self.signer_uri) if self.signer_uri else None
bidder = Bidder(checksum_address=self.bidder_address,
registry=registry,
client_password=client_password,
signer=signer,
transacting=transacting)
return bidder
def __create_participant(self,
registry,
transacting: bool = True,
hw_wallet: bool = False) -> DaoActor:
client_password = None
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri) # TODO: why not allow the clef signer's validator act on this?
if transacting and not is_clef and not hw_wallet:
client_password = get_client_password(checksum_address=self.participant_address)
testnet = self.network != NetworksInventory.MAINNET
signer = Signer.from_signer_uri(self.signer_uri, testnet=testnet) if self.signer_uri else None
actor = DaoActor(checksum_address=self.participant_address,
network=self.network,
registry=registry,
signer=signer,
transacting=transacting)
return actor
def __create_participant(self,
registry,
transacting: bool = True,
hw_wallet: bool = False) -> BaseActor:
client_password = None
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri)
if transacting and not is_clef and not hw_wallet:
client_password = get_client_password(
checksum_address=self.participant_address)
signer = Signer.from_signer_uri(
self.signer_uri) if self.signer_uri else None
actor = EmergencyResponseManager(
checksum_address=self.participant_address,
network=self.network,
registry=registry,
client_password=client_password,
signer=signer,
transacting=transacting)
return actor
def create_actor(self,
emitter: StdoutEmitter,
is_multisig: bool = False
) -> Tuple[ContractAdministrator, str, BlockchainInterface, BaseContractRegistry]:
ensure_config_root(self.config_root)
deployer_interface = initialize_deployer_interface(poa=self.poa,
provider_uri=self.provider_uri,
emitter=emitter,
ignore_solidity_check=self.ignore_solidity_check,
gas_strategy=self.gas_strategy,
max_gas_price=self.max_gas_price)
# Warnings
deployer_pre_launch_warnings(emitter, self.etherscan, self.hw_wallet)
#
# Establish Registry
#
local_registry = establish_deployer_registry(emitter=emitter,
use_existing_registry=bool(self.contract_name), # TODO: Issue #2314
registry_infile=self.registry_infile,
registry_outfile=self.registry_outfile,
dev=self.dev,
network=self.network)
#
# Make Authenticated Deployment Actor
#
# Verify Address & collect password
password = None
if is_multisig:
multisig_agent = ContractAgency.get_agent(MultiSigAgent, registry=local_registry)
deployer_address = multisig_agent.contract.address
is_transacting = False
else:
is_transacting = True
deployer_address = self.deployer_address
if not deployer_address:
deployer_address = select_client_account(emitter=emitter,
prompt=SELECT_DEPLOYER_ACCOUNT,
provider_uri=self.provider_uri,
signer_uri=self.signer_uri,
show_eth_balance=True)
if not self.force:
click.confirm(CONFIRM_SELECTED_ACCOUNT.format(address=deployer_address), abort=True)
is_clef = ClefSigner.is_valid_clef_uri(self.signer_uri)
eth_password_is_needed = not self.hw_wallet and not deployer_interface.client.is_local and not is_clef
if eth_password_is_needed:
password = get_client_password(checksum_address=deployer_address)
# Produce Actor
testnet = deployer_interface.client.chain_name != PUBLIC_CHAINS[1] # Mainnet
signer = Signer.from_signer_uri(self.signer_uri, testnet=testnet) if self.signer_uri else None
ADMINISTRATOR = ContractAdministrator(registry=local_registry,
client_password=password,
deployer_address=deployer_address,
is_transacting=is_transacting,
signer=signer)
# Verify ETH Balance
emitter.echo(DEPLOYER_BALANCE.format(eth_balance=ADMINISTRATOR.eth_balance))
if is_transacting and ADMINISTRATOR.eth_balance == 0:
emitter.echo(DEPLOYER_ADDRESS_ZERO_ETH, color='red', bold=True)
raise click.Abort()
return ADMINISTRATOR, deployer_address, deployer_interface, local_registry
def test_get_client_password_with_invalid_address(mock_stdin):
# `mock_stdin` used to assert the user was not prompted
bad_address = '0xdeadbeef'
with pytest.raises(InvalidChecksumAddress):
get_client_password(checksum_address=bad_address)
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)