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)