def test_reward(testerchain, agency, token_economics): testerchain.time_travel(hours=1) token_agent, staking_agent, _policy_agent = agency origin = testerchain.etherbase_account ursula = testerchain.ursula_account(0) # Prepare one staker _txhash = token_agent.transfer( amount=token_economics.minimum_allowed_locked, target_address=ursula, sender_address=origin) testerchain.transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, account=ursula) testerchain.transacting_power.activate() _txhash = token_agent.approve_transfer( amount=token_economics.minimum_allowed_locked, target_address=staking_agent.contract_address, sender_address=ursula) _txhash = staking_agent.deposit_tokens( amount=token_economics.minimum_allowed_locked, lock_periods=100 * token_economics.maximum_rewarded_periods, sender_address=ursula) _txhash = staking_agent.set_worker(staker_address=ursula, worker_address=ursula) # Get a reward for one period _txhash = staking_agent.confirm_activity(worker_address=ursula) testerchain.time_travel(periods=1) _txhash = staking_agent.confirm_activity(worker_address=ursula) assert staking_agent.calculate_staking_reward(staker_address=ursula) == 0 testerchain.time_travel(periods=1) _txhash = staking_agent.confirm_activity(worker_address=ursula) contract_reward = staking_agent.calculate_staking_reward( staker_address=ursula) calculations_reward = token_economics.cumulative_rewards_at_period(1) error = (contract_reward - calculations_reward) / calculations_reward assert error > 0 assert error < MAX_ERROR # Get a reward for other periods for i in range(1, MAX_PERIODS): testerchain.time_travel(periods=1) _txhash = staking_agent.confirm_activity(worker_address=ursula) contract_reward = staking_agent.calculate_staking_reward( staker_address=ursula) calculations_reward = token_economics.cumulative_rewards_at_period(i + 1) next_error = (contract_reward - calculations_reward) / calculations_reward assert next_error > 0 assert next_error < error error = next_error
def test_withdraw_compensation(testerchain, agency, token_economics, test_registry): agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) bidder = testerchain.client.accounts[2] tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client)) balance = testerchain.w3.eth.getBalance(bidder) receipt = agent.withdraw_compensation(transacting_power=tpower) assert receipt['status'] == 1 assert testerchain.w3.eth.getBalance(bidder) > balance assert agent.get_available_compensation( testerchain.client.accounts[2]) == 0
def test_approve_transfer(agent, application_economics): testerchain = agent.blockchain deployer, someone, *everybody_else = testerchain.client.accounts tpower = TransactingPower(account=someone, signer=Web3Signer(testerchain.client)) # Approve receipt = agent.approve_transfer(amount=application_economics.min_authorization, spender_address=agent.contract_address, transacting_power=tpower) assert receipt['status'] == 1, "Transaction Rejected" assert receipt['logs'][0]['address'] == agent.contract_address
def bootstrap_network(cls) -> 'TesterBlockchain': """For use with metric testing scripts""" testerchain = cls(compiler=SolidityCompiler()) power = TransactingPower(blockchain=testerchain, password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.etherbase_account) power.activate() testerchain.transacting_power = power origin = testerchain.client.etherbase deployer = DeployerActor(blockchain=testerchain, deployer_address=origin, bare=True) secrets = dict() for deployer_class in deployer.upgradeable_deployer_classes: secrets[ deployer_class.contract_name] = INSECURE_DEVELOPMENT_PASSWORD _receipts = deployer.deploy_network_contracts(secrets=secrets, interactive=False) return testerchain
def stakers(testerchain, agency, token_economics, test_registry): token_agent, _staking_agent, _policy_agent = agency blockchain = token_agent.blockchain # Mock Powerup consumption (Deployer) blockchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=blockchain.etherbase_account) blockchain.transacting_power.activate() token_airdrop(origin=blockchain.etherbase_account, addresses=blockchain.stakers_accounts, token_agent=token_agent, amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT) stakers = list() for index, account in enumerate(blockchain.stakers_accounts): staker = Staker(is_me=True, checksum_address=account, registry=test_registry) # Mock TransactingPower consumption staker.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=account) staker.transacting_power.activate() 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.set_worker(worker_address=worker_address) stakers.append(staker) # Stake starts next period (or else signature validation will fail) blockchain.time_travel(periods=1) yield stakers
def bootstrap_network( cls, registry: Optional[BaseContractRegistry] = None, economics: BaseEconomics = None ) -> Tuple['TesterBlockchain', 'InMemoryContractRegistry']: """For use with metric testing scripts""" if registry is None: registry = InMemoryContractRegistry() testerchain = cls() if not BlockchainInterfaceFactory.is_interface_initialized( provider_uri=testerchain.provider_uri): BlockchainInterfaceFactory.register_interface( interface=testerchain) power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.etherbase_account) power.activate() testerchain.transacting_power = power origin = testerchain.client.etherbase admin = ContractAdministrator(deployer_address=origin, registry=registry, economics=economics or cls.DEFAULT_ECONOMICS) gas_limit = None # TODO: Gas management - #842 for deployer_class in admin.primary_deployer_classes: if deployer_class is StakingEscrowDeployer: admin.deploy_contract( contract_name=deployer_class.contract_name, gas_limit=gas_limit, deployment_mode=INIT) else: admin.deploy_contract( contract_name=deployer_class.contract_name, gas_limit=gas_limit) admin.deploy_contract( contract_name=StakingEscrowDeployer.contract_name, gas_limit=gas_limit) return testerchain, registry
def test_reward(testerchain, agency, token_economics): testerchain.time_travel(hours=1) token_agent, staking_agent, _policy_agent = agency origin = testerchain.etherbase_account ursula = testerchain.ursula_account(0) origin_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=origin) ursula_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=ursula) # Prepare one staker _txhash = token_agent.transfer(amount=token_economics.minimum_allowed_locked, target_address=ursula, transacting_power=origin_tpower) _txhash = token_agent.approve_transfer(amount=token_economics.minimum_allowed_locked, spender_address=staking_agent.contract_address, transacting_power=ursula_tpower) _txhash = staking_agent.deposit_tokens(amount=token_economics.minimum_allowed_locked, lock_periods=100 * token_economics.maximum_rewarded_periods, transacting_power=ursula_tpower, staker_address=ursula) _txhash = staking_agent.bond_worker(staker_address=ursula, worker_address=ursula) _txhash = staking_agent.set_restaking(staker_address=ursula, value=False) _txhash = staking_agent.commit_to_next_period(worker_address=ursula) testerchain.time_travel(periods=1) _txhash = staking_agent.commit_to_next_period(worker_address=ursula) assert staking_agent.calculate_staking_reward(staker_address=ursula) == 0 # Get a reward switch = token_economics.first_phase_final_period() for i in range(1, switch + MAX_PERIODS_SECOND_PHASE): testerchain.time_travel(periods=1) _txhash = staking_agent.commit_to_next_period(transacting_power=ursula_tpower) contract_reward = staking_agent.calculate_staking_reward(staker_address=ursula) calculations_reward = token_economics.cumulative_rewards_at_period(i) error = abs((contract_reward - calculations_reward) / calculations_reward) if i <= switch: assert error < MAX_ERROR_FIRST_PHASE else: assert error < MAX_ERROR_SECOND_PHASE
def test_bidding(testerchain, agency, token_economics, test_registry): small_bid = token_economics.worklock_min_allowed_bid big_bid = 5 * token_economics.worklock_min_allowed_bid agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) # Round 1 for multiplier, bidder in enumerate(testerchain.client.accounts[:11], start=1): bid = big_bid * multiplier tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client)) receipt = agent.bid(transacting_power=tpower, value=bid) assert receipt['status'] == 1 # Round 2 for multiplier, bidder in enumerate(testerchain.client.accounts[:11], start=1): bid = (small_bid * 2) * multiplier tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client)) receipt = agent.bid(transacting_power=tpower, value=bid) assert receipt['status'] == 1
def test_confirm_activity(agency, testerchain): _token_agent, staking_agent, _policy_agent = agency staker_account, worker_account, *other = testerchain.unassigned_accounts # Mock Powerup consumption (Ursula-Worker) testerchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=worker_account) testerchain.transacting_power.activate() receipt = staking_agent.confirm_activity(worker_address=worker_account) assert receipt['status'] == 1, "Transaction Rejected" assert receipt['logs'][0]['address'] == staking_agent.contract_address
def test_cancel_bid(testerchain, agency, token_economics, test_registry): bidder = testerchain.client.accounts[1] agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client)) assert agent.get_deposited_eth(bidder) # Bid receipt = agent.cancel_bid(transacting_power=tpower) # Cancel assert receipt['status'] == 1 assert not agent.get_deposited_eth(bidder) # No more bid # Can't cancel a bid twice in a row with pytest.raises((TransactionFailed, ValueError)): _receipt = agent.cancel_bid(transacting_power=tpower)
def software_stakeholder(testerchain, agency, stakeholder_config_file_location, test_registry): token_agent, staking_agent, policy_agent = agency # Setup path = stakeholder_config_file_location if os.path.exists(path): os.remove(path) # 0xaAa482c790b4301bE18D75A0D1B11B2ACBEF798B stakeholder_private_key = '255f64a948eeb1595b8a2d1e76740f4683eca1c8f1433d13293db9b6e27676cc' address = testerchain.provider.ethereum_tester.add_account(private_key=stakeholder_private_key, password=INSECURE_DEVELOPMENT_PASSWORD) testerchain.provider.ethereum_tester.unlock_account(account=address, password=INSECURE_DEVELOPMENT_PASSWORD) tx = {'to': address, 'from': testerchain.etherbase_account, 'value': Web3.toWei('1', 'ether')} txhash = testerchain.client.w3.eth.sendTransaction(tx) _receipt = testerchain.wait_for_receipt(txhash) # Mock TransactingPower consumption (Etherbase) transacting_power = TransactingPower(account=testerchain.etherbase_account, signer=Web3Signer(testerchain.client), password=INSECURE_DEVELOPMENT_PASSWORD) transacting_power.activate() token_agent.transfer(amount=NU(200_000, 'NU').to_nunits(), sender_address=testerchain.etherbase_account, target_address=address) # Create stakeholder from on-chain values given accounts over a web3 provider stakeholder = StakeHolder(registry=test_registry, initial_address=address) # Teardown yield stakeholder if os.path.exists(path): os.remove(path)
def __init__(self, registry: BaseContractRegistry, deployer_address: str = None, client_password: str = None, economics: TokenEconomics = None): """ Note: super() is not called here to avoid setting the token agent. TODO: Review this logic ^^ "bare mode". """ self.log = Logger("Deployment-Actor") self.deployer_address = deployer_address self.checksum_address = self.deployer_address self.economics = economics or StandardTokenEconomics() self.registry = registry self.preallocation_escrow_deployers = dict() self.deployers = {d.contract_name: d for d in self.deployer_classes} self.transacting_power = TransactingPower(password=client_password, account=deployer_address) self.transacting_power.activate()
def test_reward(testerchain, agency, token_economics, test_registry): testerchain.time_travel(hours=1) staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry) _policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry) origin = testerchain.etherbase_account ursula1 = testerchain.ursula_account(0) ursula2 = testerchain.ursula_account(1) origin_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=origin) ursula1_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=ursula1) ursula2_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=ursula2) # Prepare one staker prepare_staker(origin_tpower, staking_agent, token_agent, token_economics, ursula1, ursula1_tpower, token_economics.minimum_allowed_locked) prepare_staker(origin_tpower, staking_agent, token_agent, token_economics, ursula2, ursula2_tpower, token_economics.minimum_allowed_locked * 3) # 3x min ursulas_tpowers = [ursula1_tpower, ursula2_tpower] commit_to_next_period(staking_agent, ursulas_tpowers) testerchain.time_travel(periods=1) commit_to_next_period(staking_agent, ursulas_tpowers) assert staking_agent.calculate_staking_reward(staker_address=ursula1) == 0 assert staking_agent.calculate_staking_reward(staker_address=ursula2) == 0 # Get a reward switch = token_economics.first_phase_final_period() for i in range(1, switch + MAX_PERIODS_SECOND_PHASE): testerchain.time_travel(periods=1) commit_to_next_period(staking_agent, ursulas_tpowers) ursula1_rewards = staking_agent.calculate_staking_reward(staker_address=ursula1) ursula2_rewards = staking_agent.calculate_staking_reward(staker_address=ursula2) calculations_reward = token_economics.cumulative_rewards_at_period(i) error = abs((ursula1_rewards + ursula2_rewards - calculations_reward) / calculations_reward) if i <= switch: assert error < MAX_ERROR_FIRST_PHASE else: assert error < MAX_ERROR_SECOND_PHASE
def test_rapid_deployment(token_economics): compiler = SolidityCompiler() allocation_registry = InMemoryAllocationRegistry() blockchain = _TesterBlockchain(eth_airdrop=False, test_accounts=4, compiler=compiler) # TODO: #1092 - TransactingPower blockchain.transacting_power = TransactingPower(blockchain=blockchain, password=INSECURE_DEVELOPMENT_PASSWORD, account=blockchain.etherbase_account) blockchain.transacting_power.activate() deployer_address = blockchain.etherbase_account deployer = DeployerActor(blockchain=blockchain, deployer_address=deployer_address) secrets = dict() for deployer_class in deployer.upgradeable_deployer_classes: secrets[deployer_class.contract_name] = INSECURE_DEVELOPMENT_PASSWORD deployer.deploy_network_contracts(secrets=secrets, emitter=StdoutEmitter()) all_yall = blockchain.unassigned_accounts # Start with some hard-coded cases... allocation_data = [{'address': all_yall[1], 'amount': token_economics.maximum_allowed_locked, 'duration': ONE_YEAR_IN_SECONDS}, {'address': all_yall[2], 'amount': token_economics.minimum_allowed_locked, 'duration': ONE_YEAR_IN_SECONDS*2}, {'address': all_yall[3], 'amount': token_economics.minimum_allowed_locked*100, 'duration': ONE_YEAR_IN_SECONDS*3} ] # Pile on the rest for _ in range(NUMBER_OF_ALLOCATIONS_IN_TESTS - len(allocation_data)): random_password = ''.join(random.SystemRandom().choice(string.ascii_uppercase+string.digits) for _ in range(16)) acct = w3.eth.account.create(random_password) beneficiary_address = acct.address amount = random.randint(token_economics.minimum_allowed_locked, token_economics.maximum_allowed_locked) duration = random.randint(token_economics.minimum_locked_periods*ONE_YEAR_IN_SECONDS, (token_economics.maximum_locked_periods*ONE_YEAR_IN_SECONDS)*3) random_allocation = {'address': beneficiary_address, 'amount': amount, 'duration': duration} allocation_data.append(random_allocation) deployer.deploy_beneficiary_contracts(allocations=allocation_data, allocation_registry=allocation_registry)
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 test_verify_correctness(testerchain, agency, token_economics, test_registry): agent = ContractAgency.get_agent( WorkLockAgent, registry=test_registry) # type: WorkLockAgent caller = testerchain.client.accounts[0] tpower = TransactingPower(account=caller, signer=Web3Signer(testerchain.client)) assert not agent.bidders_checked() assert agent.estimate_verifying_correctness(gas_limit=100000) == 10 receipt = agent.verify_bidding_correctness(transacting_power=tpower, gas_limit=100000) assert receipt['status'] == 1 assert agent.bidders_checked() assert agent.is_claiming_available()
def test_character_transacting_power_signing(testerchain, agency, test_registry): # Pretend to be a character. eth_address = testerchain.etherbase_account signer = Character(is_me=True, eth_provider_uri=MOCK_ETH_PROVIDER_URI, registry=test_registry, checksum_address=eth_address) # Manually consume the power up transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, signer=Web3Signer(testerchain.client), account=eth_address) signer._crypto_power.consume_power_up(transacting_power) # Retrieve the power up power = signer._crypto_power.power_ups(TransactingPower) assert power == transacting_power # Sign Message data_to_sign = b'Premium Select Luxury Pencil Holder' signature = power.sign_message(message=data_to_sign) is_verified = verify_eip_191(address=eth_address, message=data_to_sign, signature=signature) assert is_verified is True # Sign Transaction transaction_dict = { 'nonce': testerchain.client.w3.eth.getTransactionCount(eth_address), 'gasPrice': testerchain.client.w3.eth.gasPrice, 'gas': 100000, 'from': eth_address, 'to': testerchain.unassigned_accounts[1], 'value': 1, 'data': b'' } signed_transaction = power.sign_transaction( transaction_dict=transaction_dict) # Demonstrate that the transaction is valid RLP encoded. restored_transaction = Transaction.from_bytes( serialized_bytes=signed_transaction) restored_dict = restored_transaction.as_dict() assert to_checksum_address(restored_dict['to']) == transaction_dict['to']
def test_force_refund(testerchain, agency, token_economics, test_registry): agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) caller = testerchain.client.accounts[0] tpower = TransactingPower(account=caller, signer=Web3Signer(testerchain.client)) with pytest.raises(BlockchainInterface.InterfaceError): _receipt = agent.verify_bidding_correctness(transacting_power=tpower, gas_limit=100000) receipt = agent.force_refund(transacting_power=tpower, addresses=testerchain.client.accounts[2:11]) assert receipt['status'] == 1 assert agent.get_available_compensation(testerchain.client.accounts[2]) > 0
def test_rapid_deployment(token_economics, test_registry, tmpdir, get_random_checksum_address): compiler = SolidityCompiler() blockchain = _TesterBlockchain(eth_airdrop=False, test_accounts=4, compiler=compiler) # TODO: #1092 - TransactingPower blockchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=blockchain.etherbase_account) blockchain.transacting_power.activate() deployer_address = blockchain.etherbase_account administrator = ContractAdministrator(deployer_address=deployer_address, registry=test_registry) administrator.deploy_network_contracts(emitter=StdoutEmitter(), interactive=False) all_yall = blockchain.unassigned_accounts # Start with some hard-coded cases... allocation_data = [{'checksum_address': all_yall[1], 'amount': token_economics.maximum_allowed_locked, 'lock_periods': token_economics.minimum_locked_periods}, {'checksum_address': all_yall[2], 'amount': token_economics.minimum_allowed_locked, 'lock_periods': token_economics.minimum_locked_periods}, {'checksum_address': all_yall[3], 'amount': token_economics.minimum_allowed_locked*100, 'lock_periods': token_economics.minimum_locked_periods}, ] # Pile on the rest for _ in range(NUMBER_OF_ALLOCATIONS_IN_TESTS - len(allocation_data)): checksum_address = get_random_checksum_address() amount = random.randint(token_economics.minimum_allowed_locked, token_economics.maximum_allowed_locked) duration = random.randint(token_economics.minimum_locked_periods, token_economics.maximum_rewarded_periods) random_allocation = {'checksum_address': checksum_address, 'amount': amount, 'lock_periods': duration} allocation_data.append(random_allocation) filepath = tmpdir / "allocations.json" with open(filepath, 'w') as f: json.dump(allocation_data, f) administrator.batch_deposits(allocation_data_filepath=str(filepath), interactive=False) minimum, default, maximum = 10, 20, 30 administrator.set_fee_rate_range(minimum, default, maximum)
def bootstrap_network( cls, economics: BaseEconomics = None ) -> Tuple['TesterBlockchain', 'InMemoryContractRegistry']: """For use with metric testing scripts""" registry = InMemoryContractRegistry() testerchain = cls(compiler=SolidityCompiler()) BlockchainInterfaceFactory.register_interface(testerchain) power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.etherbase_account) power.activate() testerchain.transacting_power = power origin = testerchain.client.etherbase deployer = ContractAdministrator(deployer_address=origin, registry=registry, economics=economics or cls._default_token_economics, staking_escrow_test_mode=True) _receipts = deployer.deploy_network_contracts(interactive=False) return testerchain, registry
def test_transacting_power_sign_agent_transaction(testerchain, agency): token_agent = NucypherTokenAgent(blockchain=testerchain) contract_function = token_agent.contract.functions.approve(testerchain.etherbase_account, 100) payload = {'chainId': int(testerchain.client.net_version), 'nonce': testerchain.client.w3.eth.getTransactionCount(testerchain.etherbase_account), 'from': testerchain.etherbase_account, 'gasPrice': testerchain.client.gas_price} unsigned_transaction = contract_function.buildTransaction(payload) # Sign with Transacting Power transacting_power = TransactingPower(blockchain=testerchain, password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.etherbase_account) transacting_power.activate() signed_raw_transaction = transacting_power.sign_transaction(unsigned_transaction) # Demonstrate that the transaction is valid RLP encoded. restored_transaction = Transaction.from_bytes(serialized_bytes=signed_raw_transaction) restored_dict = restored_transaction.as_dict() assert to_checksum_address(restored_dict['to']) == unsigned_transaction['to']
def test_create_bidder(testerchain, test_registry, agency, token_economics): bidder_address = testerchain.unassigned_accounts[0] tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client)) bidder = Bidder(domain=TEMPORARY_DOMAIN, registry=test_registry, transacting_power=tpower) assert bidder.checksum_address == bidder_address assert bidder.registry == test_registry assert not bidder.get_deposited_eth assert not bidder.completed_work assert not bidder.remaining_work assert not bidder.refunded_work
def staker(testerchain, agency, test_registry, deployer_transacting_power): token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry) origin, staker_account, *everybody_else = testerchain.client.accounts staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client)) token_airdrop(token_agent=token_agent, transacting_power=deployer_transacting_power, addresses=[staker_account], amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT) staker = Staker(domain=TEMPORARY_DOMAIN, transacting_power=staker_power, registry=test_registry) return staker
def test_cancel_after_bidding(testerchain, agency, token_economics, test_registry): # Wait until the bidding window closes... testerchain.time_travel(seconds=token_economics.bidding_duration+1) bidder = testerchain.client.accounts[0] tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client)) agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) assert agent.get_deposited_eth(bidder) # Bid receipt = agent.cancel_bid(transacting_power=tpower) # Cancel assert receipt['status'] == 1 assert not agent.get_deposited_eth(bidder) # No more bid
def test_transacting_power_sign_agent_transaction(testerchain, agency, test_registry): agent = ContractAgency.get_agent(PREApplicationAgent, registry=test_registry) contract_function = agent.contract.functions.confirmOperatorAddress() payload = { 'chainId': int(testerchain.client.chain_id), 'nonce': testerchain.client.w3.eth.getTransactionCount( testerchain.etherbase_account), 'from': testerchain.etherbase_account, 'gasPrice': testerchain.client.gas_price, 'gas': 500_000 } unsigned_transaction = contract_function.buildTransaction(payload) # Sign with Transacting Power transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, signer=Web3Signer(testerchain.client), account=testerchain.etherbase_account) signed_raw_transaction = transacting_power.sign_transaction( unsigned_transaction) # Demonstrate that the transaction is valid RLP encoded. restored_transaction = Transaction.from_bytes( serialized_bytes=signed_raw_transaction) restored_dict = restored_transaction.as_dict() assert to_checksum_address( restored_dict['to']) == unsigned_transaction['to']
def _make_testerchain(): """ https://github.com/ethereum/eth-tester # available-backends """ # Create the blockchain testerchain = TesterBlockchain(eth_airdrop=True, free_transactions=True) # Mock TransactingPower Consumption (Deployer) testerchain.deployer_address = testerchain.etherbase_account testerchain.transacting_power = TransactingPower( blockchain=testerchain, password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.deployer_address) testerchain.transacting_power.activate() return testerchain
def test_transfer(agent, application_economics): testerchain = agent.blockchain origin, someone, *everybody_else = testerchain.client.accounts tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client)) old_balance = agent.get_balance(someone) receipt = agent.transfer(amount=application_economics.min_authorization, target_address=someone, transacting_power=tpower) assert receipt['status'] == 1, "Transaction Rejected" assert receipt['logs'][0]['address'] == agent.contract_address new_balance = agent.get_balance(someone) assert new_balance == old_balance + application_economics.min_authorization
def test_calculate_refund(testerchain, agency, policy_meta): token_agent, staking_agent, policy_agent = agency agent = policy_agent staker = policy_meta.addresses[-1] worker = staking_agent.get_worker_from_staker(staker) # Mock Powerup consumption (Ursula-Worker) testerchain.transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, account=worker) testerchain.transacting_power.activate() testerchain.time_travel(hours=9) _receipt = staking_agent.confirm_activity(worker_address=worker) # Mock Powerup consumption (Alice) testerchain.transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.alice_account) testerchain.transacting_power.activate() receipt = agent.calculate_refund(policy_id=policy_meta.policy_id, author_address=policy_meta.author) assert receipt['status'] == 1, "Transaction Rejected"
def test_claim_before_checking(testerchain, agency, token_economics, test_registry): agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) bidder = testerchain.client.accounts[2] tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client)) assert not agent.is_claiming_available() with pytest.raises(TransactionFailed): _receipt = agent.claim(transacting_power=tpower) # Wait until the cancellation window closes... testerchain.time_travel(seconds=token_economics.cancellation_end_date+1) assert not agent.is_claiming_available() with pytest.raises(TransactionFailed): _receipt = agent.claim(transacting_power=tpower)
def idle_staker(testerchain, agency, test_registry): token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry) idle_staker_account = testerchain.unassigned_accounts[-2] transacting_power = TransactingPower(account=testerchain.etherbase_account, signer=Web3Signer(testerchain.client)) token_airdrop(transacting_power=transacting_power, addresses=[idle_staker_account], token_agent=token_agent, amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT) # Prepare idle staker idle_staker = Staker(transacting_power=transacting_power, domain=TEMPORARY_DOMAIN, blockchain=testerchain) yield idle_staker