def test_transacting_power_sign_message(testerchain):
# Manually create a TransactingPower
eth_address = testerchain.etherbase_account
power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(testerchain.client),
account=eth_address)
# Manually unlock
power.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
# Sign
data_to_sign = b'Premium Select Luxury Pencil Holder'
signature = power.sign_message(message=data_to_sign)
# Verify
is_verified = verify_eip_191(address=eth_address,
message=data_to_sign,
signature=signature)
assert is_verified is True
# Test invalid address/pubkey pair
is_verified = verify_eip_191(address=testerchain.client.accounts[1],
message=data_to_sign,
signature=signature)
assert is_verified is False
def deployer_transacting_power(testerchain):
transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(client=testerchain.client),
account=testerchain.etherbase_account)
transacting_power.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
return transacting_power
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 test_nucypher_status_locked_tokens(click_runner, testerchain,
agency_local_registry, stakers):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent,
registry=agency_local_registry)
# All workers make a commitment
for ursula in testerchain.ursulas_accounts:
tpower = TransactingPower(account=ursula,
signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
staking_agent.commit_to_next_period(transacting_power=tpower)
testerchain.time_travel(periods=1)
periods = 2
status_command = ('locked-tokens', '--registry-filepath',
str(agency_local_registry.filepath.absolute()),
'--provider', TEST_PROVIDER_URI, '--network',
TEMPORARY_DOMAIN, '--periods', periods)
light_parameter = [False, True]
for light in light_parameter:
testerchain.is_light = light
result = click_runner.invoke(status,
status_command,
catch_exceptions=False)
assert result.exit_code == 0
current_period = staking_agent.get_current_period()
all_locked = NU.from_nunits(
staking_agent.get_global_locked_tokens(at_period=current_period))
assert re.search(f"Locked Tokens for next {periods} periods",
result.output, re.MULTILINE)
assert re.search(f"Min: {all_locked} - Max: {all_locked}",
result.output, re.MULTILINE)
def test_collect_inflation_rewards(software_stakeholder, manual_worker,
testerchain, test_registry):
# Get stake
stake = software_stakeholder.staker.stakes[1]
# Make bonded Worker
tpower = TransactingPower(account=manual_worker,
signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
worker = Worker(is_me=True,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
worker_address=manual_worker,
registry=test_registry)
# Wait out stake lock periods, manually make a commitment once per period.
for period in range(stake.periods_remaining - 1):
worker.commit_to_next_period()
testerchain.time_travel(periods=1)
# Collect the staking reward in NU.
result = software_stakeholder.staker.collect_staking_reward()
# TODO: Make Assertions reasonable for this layer.
# Consider recycling logic from test_collect_reward_integration CLI test.
assert result
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 mock_funded_account_password_keystore(tmp_path_factory, testerchain,
threshold_staking,
application_economics,
test_registry):
"""
Generate a random keypair & password and create a local keystore. Then prepare a staking provider
for ursula. Then check that the correct ursula ethereum key signs the commitment.
"""
keystore = tmp_path_factory.mktemp('keystore', numbered=True)
password = secrets.token_urlsafe(12)
account = Account.create()
path = keystore / f'{account.address}'
json.dump(account.encrypt(password), open(path, 'x+t'))
testerchain.wait_for_receipt(
testerchain.client.w3.eth.sendTransaction({
'to':
account.address,
'from':
testerchain.etherbase_account,
'value':
Web3.toWei('1', 'ether')
}))
# initialize threshold stake
provider_address = testerchain.unassigned_accounts[0]
tx = threshold_staking.functions.setRoles(provider_address).transact()
testerchain.wait_for_receipt(tx)
tx = threshold_staking.functions.setStakes(
provider_address, application_economics.min_authorization, 0,
0).transact()
testerchain.wait_for_receipt(tx)
provider_power = TransactingPower(account=provider_address,
signer=Web3Signer(testerchain.client))
provider_power.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
pre_application_agent = ContractAgency.get_agent(PREApplicationAgent,
registry=test_registry)
pre_application_agent.bond_operator(staking_provider=provider_address,
operator=account.address,
transacting_power=provider_power)
return account, password, keystore
def staking_providers(testerchain, agency, test_registry, threshold_staking):
pre_application_agent = ContractAgency.get_agent(PREApplicationAgent,
registry=test_registry)
blockchain = pre_application_agent.blockchain
staking_providers = list()
for provider_address, operator_address in zip(
blockchain.stake_providers_accounts, blockchain.ursulas_accounts):
provider_power = TransactingPower(account=provider_address,
signer=Web3Signer(
testerchain.client))
provider_power.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
# for a random amount
amount = MIN_STAKE_FOR_TESTS + random.randrange(BONUS_TOKENS_FOR_TESTS)
# initialize threshold stake
tx = threshold_staking.functions.setRoles(provider_address).transact()
testerchain.wait_for_receipt(tx)
tx = threshold_staking.functions.setStakes(provider_address, amount, 0,
0).transact()
testerchain.wait_for_receipt(tx)
# We assume that the staking provider knows in advance the account of her operator
pre_application_agent.bond_operator(staking_provider=provider_address,
operator=operator_address,
transacting_power=provider_power)
operator_power = TransactingPower(account=operator_address,
signer=Web3Signer(
testerchain.client))
operator = Operator(is_me=True,
operator_address=operator_address,
domain=TEMPORARY_DOMAIN,
registry=test_registry,
transacting_power=operator_power)
operator.confirm_address(
) # assume we always need a "pre-confirmed" operator for now.
# track
staking_providers.append(provider_address)
yield staking_providers
def stakers(testerchain, agency, token_economics, test_registry,
deployer_transacting_power):
token_agent = ContractAgency.get_agent(NucypherTokenAgent,
registry=test_registry)
blockchain = token_agent.blockchain
token_airdrop(transacting_power=deployer_transacting_power,
addresses=blockchain.stakers_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
stakers = list()
for index, account in enumerate(blockchain.stakers_accounts):
tpower = TransactingPower(account=account,
signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
staker = Staker(transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
registry=test_registry)
amount = MIN_STAKE_FOR_TESTS + random.randrange(BONUS_TOKENS_FOR_TESTS)
# for a random lock duration
min_locktime, max_locktime = token_economics.minimum_locked_periods, token_economics.maximum_rewarded_periods
periods = random.randint(min_locktime, max_locktime)
staker.initialize_stake(amount=amount, lock_periods=periods)
# We assume that the staker knows in advance the account of her worker
worker_address = blockchain.ursula_account(index)
staker.bond_worker(worker_address=worker_address)
stakers.append(staker)
# Stake starts next period
blockchain.time_travel(periods=1)
yield stakers
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)
