def _make_agency(testerchain, test_registry): """ Launch the big three contracts on provided chain, make agents for each and return them. """ # Mock TransactingPower Consumption (Deployer) testerchain.transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, account=testerchain.etherbase_account) testerchain.transacting_power.activate() origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(deployer_address=origin, registry=test_registry) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, registry=test_registry, test_mode=True) staking_escrow_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin, registry=test_registry) policy_manager_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) adjudicator_deployer = AdjudicatorDeployer(deployer_address=origin, registry=test_registry) adjudicator_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) staking_interface_deployer = StakingInterfaceDeployer( deployer_address=origin, registry=test_registry) staking_interface_deployer.deploy( secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) token_agent = token_deployer.make_agent() # 1 Token staking_agent = staking_escrow_deployer.make_agent() # 2 Staking Escrow policy_agent = policy_manager_deployer.make_agent() # 3 Policy Agent _adjudicator_agent = adjudicator_deployer.make_agent() # 4 Adjudicator # TODO: Get rid of returning these agents here. # What's important is deploying and creating the first agent for each contract, # and since agents are singletons, in tests it's only necessary to call the agent # constructor again to receive the existing agent. # # For example: # staking_agent = StakingEscrowAgent() # # This is more clear than how we currently obtain an agent instance in tests: # _, staking_agent, _ = agency # # Other advantages is that it's closer to how agents should be use (i.e., there # are no fixtures IRL) and it's more extensible (e.g., AdjudicatorAgent) return token_agent, staking_agent, policy_agent
def staking_escrow_deployer(testerchain, threshold_staking, application_economics, test_registry, deployment_progress, transacting_power): deployer = StakingEscrowDeployer( staking_interface=threshold_staking.address, economics=application_economics, registry=test_registry) deployer.deploy(progress=deployment_progress, deployment_mode=constants.INIT, transacting_power=transacting_power) return deployer
def test_adjudicator_deployer(testerchain, token_economics, deployment_progress, test_registry): testerchain = testerchain origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(deployer_address=origin, registry=test_registry) token_deployer.deploy() stakers_escrow_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, registry=test_registry) staking_escrow_deployer.deploy(secret_hash=keccak(stakers_escrow_secret)) staking_agent = staking_escrow_deployer.make_agent() # 2 Staker Escrow deployer = AdjudicatorDeployer(deployer_address=origin, registry=test_registry) deployment_receipts = deployer.deploy(secret_hash=os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH), progress=deployment_progress) # deployment steps must match expected number of steps assert deployment_progress.num_steps == len( deployer.deployment_steps) == len(deployment_receipts) == 3 for step in deployer.deployment_steps: assert deployment_receipts[step]['status'] == 1 # Create an AdjudicatorAgent instance adjudicator_agent = deployer.make_agent() # Check default Adjudicator deployment parameters assert staking_escrow_deployer.deployer_address != staking_agent.contract_address assert adjudicator_agent.staking_escrow_contract == staking_agent.contract_address assert adjudicator_agent.hash_algorithm == token_economics.hash_algorithm assert adjudicator_agent.base_penalty == token_economics.base_penalty assert adjudicator_agent.penalty_history_coefficient == token_economics.penalty_history_coefficient assert adjudicator_agent.percentage_penalty_coefficient == token_economics.percentage_penalty_coefficient assert adjudicator_agent.reward_coefficient == token_economics.reward_coefficient # Retrieve the AdjudicatorAgent singleton some_policy_agent = AdjudicatorAgent(registry=test_registry) assert adjudicator_agent == some_policy_agent # __eq__ # Compare the contract address for equality assert adjudicator_agent.contract_address == some_policy_agent.contract_address
def test_deploy_bare_upgradeable_contract_deployment(testerchain, test_registry, token_economics, transacting_power): deployer = StakingEscrowDeployer(registry=test_registry, economics=token_economics) enrolled_names = list(test_registry.enrolled_names) old_number_of_enrollments = enrolled_names.count( StakingEscrowDeployer.contract_name) old_number_of_proxy_enrollments = enrolled_names.count( StakingEscrowDeployer._proxy_deployer.contract_name) receipts = deployer.deploy(deployment_mode=BARE, ignore_deployed=True, transacting_power=transacting_power) for title, receipt in receipts.items(): assert receipt['status'] == 1 enrolled_names = list(test_registry.enrolled_names) new_number_of_enrollments = enrolled_names.count( StakingEscrowDeployer.contract_name) new_number_of_proxy_enrollments = enrolled_names.count( StakingEscrowDeployer._proxy_deployer.contract_name) # The principal contract was deployed. assert new_number_of_enrollments == (old_number_of_enrollments + 1) # The Dispatcher was not deployed. assert new_number_of_proxy_enrollments == old_number_of_proxy_enrollments
def test_staking_escrow_deployer_and_agent(testerchain): origin, *everybody_else = testerchain.client.accounts # The big day... token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() secret_hash = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH) deployer = StakingEscrowDeployer(blockchain=testerchain, deployer_address=origin) deployment_txhashes = deployer.deploy(secret_hash=secret_hash) assert len(deployment_txhashes) == 4 for title, txhash in deployment_txhashes.items(): receipt = testerchain.wait_for_receipt(txhash=txhash) assert receipt['status'] == 1, "Transaction Rejected {}:{}".format( title, txhash) # Create a StakingEscrowAgent instance staking_agent = deployer.make_agent() # TODO: #1102 - Check that token contract address and staking parameters are correct # Retrieve the StakingEscrowAgent singleton same_staking_agent = StakingEscrowAgent() assert staking_agent == same_staking_agent # Compare the contract address for equality assert staking_agent.contract_address == same_staking_agent.contract_address testerchain.registry.clear()
def test_deploy_bare_upgradeable_contract_deployment(testerchain, test_registry, token_economics): deployer = StakingEscrowDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account, economics=token_economics) enrolled_names = list(test_registry.enrolled_names) old_number_of_enrollments = enrolled_names.count( StakingEscrowDeployer.contract_name) old_number_of_proxy_enrollments = enrolled_names.count( StakingEscrowDeployer._proxy_deployer.contract_name) receipts = deployer.deploy(initial_deployment=False) for title, receipt in receipts.items(): assert receipt['status'] == 1 enrolled_names = list(test_registry.enrolled_names) new_number_of_enrollments = enrolled_names.count( StakingEscrowDeployer.contract_name) new_number_of_proxy_enrollments = enrolled_names.count( StakingEscrowDeployer._proxy_deployer.contract_name) # The principal contract was deployed. assert new_number_of_enrollments == (old_number_of_enrollments + 1) # The Dispatcher was not deployed. assert new_number_of_proxy_enrollments == old_number_of_proxy_enrollments
def _make_agency(testerchain): """ Launch the big three contracts on provided chain, make agents for each and return them. """ origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, blockchain=testerchain) staking_escrow_deployer.deploy( secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin, blockchain=testerchain) policy_manager_deployer.deploy( secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) adjudicator_deployer = AdjudicatorDeployer(deployer_address=origin, blockchain=testerchain) adjudicator_deployer.deploy( secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) token_agent = token_deployer.make_agent() # 1 Token staking_agent = staking_escrow_deployer.make_agent() # 2 Miner Escrow policy_agent = policy_manager_deployer.make_agent() # 3 Policy Agent _adjudicator_agent = adjudicator_deployer.make_agent() # 4 Adjudicator # TODO: Perhaps we should get rid of returning these agents here. # What's important is deploying and creating the first agent for each contract, # and since agents are singletons, in tests it's only necessary to call the agent # constructor again to receive the existing agent. # # For example: # staking_agent = StakingEscrowAgent() # # This is more clear than how we currently obtain an agent instance in tests: # _, staking_agent, _ = agency # # Other advantages is that it's closer to how agents should be use (i.e., there # are no fixtures IRL) and it's more extensible (e.g., AdjudicatorAgent) return token_agent, staking_agent, policy_agent
def test_adjudicator_deployer(testerchain, token_economics, deployment_progress, test_registry): origin = testerchain.etherbase_account tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client)) token_deployer = NucypherTokenDeployer(registry=test_registry) token_deployer.deploy(transacting_power=tpower) staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry) staking_escrow_deployer.deploy(transacting_power=tpower) staking_agent = staking_escrow_deployer.make_agent() # 2 Staker Escrow deployer = AdjudicatorDeployer(registry=test_registry) deployment_receipts = deployer.deploy(progress=deployment_progress, transacting_power=tpower) # deployment steps must match expected number of steps assert deployment_progress.num_steps == len( deployer.deployment_steps) == len(deployment_receipts) == 2 for step in deployer.deployment_steps: assert deployment_receipts[step]['status'] == 1 # Create an AdjudicatorAgent instance adjudicator_agent = deployer.make_agent() # Check default Adjudicator deployment parameters assert tpower.account != staking_agent.contract_address assert adjudicator_agent.staking_escrow_contract == staking_agent.contract_address assert adjudicator_agent.hash_algorithm == token_economics.hash_algorithm assert adjudicator_agent.base_penalty == token_economics.base_penalty assert adjudicator_agent.penalty_history_coefficient == token_economics.penalty_history_coefficient assert adjudicator_agent.percentage_penalty_coefficient == token_economics.percentage_penalty_coefficient assert adjudicator_agent.reward_coefficient == token_economics.reward_coefficient # Retrieve the AdjudicatorAgent singleton some_policy_agent = AdjudicatorAgent(registry=test_registry) assert adjudicator_agent == some_policy_agent # __eq__ # Compare the contract address for equality assert adjudicator_agent.contract_address == some_policy_agent.contract_address
def test_staking_interface_deployer(testerchain, deployment_progress, test_registry): # # Setup # origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(deployer_address=origin, registry=test_registry) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, registry=test_registry) staking_escrow_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin, registry=test_registry) policy_manager_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) adjudicator_deployer = AdjudicatorDeployer(deployer_address=origin, registry=test_registry) adjudicator_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) # # Test # staking_interface_deployer = StakingInterfaceDeployer( deployer_address=origin, registry=test_registry) staking_interface_receipts = staking_interface_deployer.deploy( secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH, progress=deployment_progress) # deployment steps must match expected number of steps assert deployment_progress.num_steps == len( staking_interface_deployer.deployment_steps) == 2 assert len(staking_interface_receipts) == 2 for step in staking_interface_deployer.deployment_steps: assert staking_interface_receipts[step]['status'] == 1
def _make_agency(testerchain, test_registry, token_economics, deployer_transacting_power): transacting_power = deployer_transacting_power token_deployer = NucypherTokenDeployer(economics=token_economics, registry=test_registry) token_deployer.deploy(transacting_power=transacting_power) staking_escrow_deployer = StakingEscrowDeployer(economics=token_economics, registry=test_registry) staking_escrow_deployer.deploy(deployment_mode=INIT, transacting_power=transacting_power) policy_manager_deployer = PolicyManagerDeployer(economics=token_economics, registry=test_registry) policy_manager_deployer.deploy(transacting_power=transacting_power) adjudicator_deployer = AdjudicatorDeployer(economics=token_economics, registry=test_registry) adjudicator_deployer.deploy(transacting_power=transacting_power) staking_interface_deployer = StakingInterfaceDeployer( economics=token_economics, registry=test_registry) staking_interface_deployer.deploy(transacting_power=transacting_power) worklock_deployer = WorklockDeployer(economics=token_economics, registry=test_registry) worklock_deployer.deploy(transacting_power=transacting_power) staking_escrow_deployer = StakingEscrowDeployer(economics=token_economics, registry=test_registry) staking_escrow_deployer.deploy(deployment_mode=FULL, transacting_power=transacting_power) # Set additional parameters minimum, default, maximum = FEE_RATE_RANGE policy_agent = policy_manager_deployer.make_agent() txhash = policy_agent.contract.functions.setFeeRateRange( minimum, default, maximum).transact() testerchain.wait_for_receipt(txhash)
def test_policy_manager_deployer(testerchain): origin, *everybody_else = testerchain.client.accounts token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() stakers_escrow_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, blockchain=testerchain) staking_escrow_deployer.deploy(secret_hash=keccak(stakers_escrow_secret)) policy_manager_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) deployer = PolicyManagerDeployer(deployer_address=origin, blockchain=testerchain) deployment_txhashes = deployer.deploy( secret_hash=keccak(policy_manager_secret)) assert len(deployment_txhashes) == 3 for title, txhash in deployment_txhashes.items(): receipt = testerchain.wait_for_receipt(txhash=txhash) assert receipt['status'] == 1, "Transaction Rejected {}:{}".format( title, txhash) # Create a PolicyAgent policy_agent = deployer.make_agent() # TODO: #1102 - Check that StakingEscrow contract address and public parameters are correct # Retrieve the PolicyAgent singleton some_policy_agent = PolicyAgent() assert policy_agent == some_policy_agent # __eq__ # Compare the contract address for equality assert policy_agent.contract_address == some_policy_agent.contract_address
def test_adjudicator_deployer(testerchain, slashing_economics): origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() stakers_escrow_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH) staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, blockchain=testerchain) staking_escrow_deployer.deploy(secret_hash=keccak(stakers_escrow_secret)) staking_agent = staking_escrow_deployer.make_agent() # 2 Staker Escrow deployer = AdjudicatorDeployer(deployer_address=origin, blockchain=testerchain) deployment_txhashes = deployer.deploy(secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) assert len(deployment_txhashes) == 3 for title, txhash in deployment_txhashes.items(): receipt = testerchain.wait_for_receipt(txhash=txhash) assert receipt['status'] == 1, "Transaction Rejected {}:{}".format(title, txhash) # Create an AdjudicatorAgent instance adjudicator_agent = deployer.make_agent() # Check default Adjudicator deployment parameters assert adjudicator_agent.staking_escrow_contract == staking_agent.contract_address assert adjudicator_agent.hash_algorithm == slashing_economics.hash_algorithm assert adjudicator_agent.base_penalty == slashing_economics.base_penalty assert adjudicator_agent.penalty_history_coefficient == slashing_economics.penalty_history_coefficient assert adjudicator_agent.percentage_penalty_coefficient == slashing_economics.percentage_penalty_coefficient assert adjudicator_agent.reward_coefficient == slashing_economics.reward_coefficient # Retrieve the AdjudicatorAgent singleton some_policy_agent = AdjudicatorAgent() assert adjudicator_agent == some_policy_agent # __eq__ # Compare the contract address for equality assert adjudicator_agent.contract_address == some_policy_agent.contract_address
def test_upgradeability(temp_dir_path): # Prepare remote source for compilation download_github_dir(GITHUB_SOURCE_LINK, temp_dir_path) # Prepare the blockchain BlockchainDeployerInterface.SOURCES = [ SourceBundle(base_path=SOLIDITY_SOURCE_ROOT), SourceBundle(base_path=Path(temp_dir_path)) ] provider_uri = 'tester://pyevm/2' # TODO: Testerchain caching Issues try: blockchain_interface = BlockchainDeployerInterface( provider_uri=provider_uri, gas_strategy='free') blockchain_interface.connect() origin = blockchain_interface.client.accounts[0] BlockchainInterfaceFactory.register_interface( interface=blockchain_interface) blockchain_interface.transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, account=origin) blockchain_interface.transacting_power.activate() economics = make_token_economics(blockchain_interface) # Check contracts with multiple versions contract_name = AdjudicatorDeployer.contract_name skip_adjudicator_test = skip_test(blockchain_interface, contract_name) contract_name = StakingEscrowDeployer.contract_name skip_staking_escrow_test = skip_test(blockchain_interface, contract_name) contract_name = PolicyManagerDeployer.contract_name skip_policy_manager_test = skip_test(blockchain_interface, contract_name) if not skip_adjudicator_test and not skip_staking_escrow_test and not skip_policy_manager_test: return # Prepare master version of contracts and upgrade to the latest registry = InMemoryContractRegistry() token_deployer = NucypherTokenDeployer(registry=registry, deployer_address=origin, economics=economics) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer( registry=registry, deployer_address=origin, economics=economics) staking_escrow_deployer.deploy(deployment_mode=constants.INIT) policy_manager_deployer = PolicyManagerDeployer( registry=registry, deployer_address=origin, economics=economics) deploy_base_contract(blockchain_interface, policy_manager_deployer, skipt_test=skip_policy_manager_test) adjudicator_deployer = AdjudicatorDeployer(registry=registry, deployer_address=origin, economics=economics) deploy_base_contract(blockchain_interface, adjudicator_deployer, skipt_test=skip_adjudicator_test) if skip_staking_escrow_test: worklock_deployer = WorklockDeployer(registry=registry, deployer_address=origin, economics=economics) worklock_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer( registry=registry, deployer_address=origin, economics=economics) deploy_base_contract(blockchain_interface, staking_escrow_deployer, skipt_test=skip_staking_escrow_test) if not skip_staking_escrow_test: # TODO prepare at least one staker before calling upgrade staking_escrow_deployer.upgrade(contract_version="latest", confirmations=0) if not skip_policy_manager_test: policy_manager_deployer.upgrade(contract_version="latest", confirmations=0) if not skip_adjudicator_test: adjudicator_deployer.upgrade(contract_version="latest", confirmations=0) finally: # Unregister interface # TODO: Move to method? with contextlib.suppress(KeyError): del BlockchainInterfaceFactory._interfaces[provider_uri]
def test_deploy_ethereum_contracts(testerchain): origin, *everybody_else = testerchain.client.accounts # # Nucypher Token # token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) assert token_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not token_deployer.is_deployed token_deployer.deploy() assert token_deployer.is_deployed assert len(token_deployer.contract_address) == 42 token_agent = NucypherTokenAgent(blockchain=testerchain) assert len(token_agent.contract_address) == 42 assert token_agent.contract_address == token_deployer.contract_address another_token_agent = token_deployer.make_agent() assert len(another_token_agent.contract_address) == 42 assert another_token_agent.contract_address == token_deployer.contract_address == token_agent.contract_address # # StakingEscrow # stakers_escrow_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) staking_escrow_deployer = StakingEscrowDeployer(blockchain=testerchain, deployer_address=origin) assert staking_escrow_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed staking_escrow_deployer.deploy(secret_hash=keccak(stakers_escrow_secret)) assert staking_escrow_deployer.is_deployed assert len(staking_escrow_deployer.contract_address) == 42 staking_agent = StakingEscrowAgent(blockchain=testerchain) assert len(staking_agent.contract_address) == 42 assert staking_agent.contract_address == staking_escrow_deployer.contract_address another_staking_agent = staking_escrow_deployer.make_agent() assert len(another_staking_agent.contract_address) == 42 assert another_staking_agent.contract_address == staking_escrow_deployer.contract_address == staking_agent.contract_address # # Policy Manager # policy_manager_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer(blockchain=testerchain, deployer_address=origin) assert policy_manager_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not policy_manager_deployer.is_deployed policy_manager_deployer.deploy(secret_hash=keccak(policy_manager_secret)) assert policy_manager_deployer.is_deployed assert len(policy_manager_deployer.contract_address) == 42 policy_agent = policy_manager_deployer.make_agent() assert len(policy_agent.contract_address) == 42 assert policy_agent.contract_address == policy_manager_deployer.contract_address another_policy_agent = policy_manager_deployer.make_agent() assert len(another_policy_agent.contract_address) == 42 assert another_policy_agent.contract_address == policy_manager_deployer.contract_address == policy_agent.contract_address # # Adjudicator # adjudicator_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) adjudicator_deployer = AdjudicatorDeployer(blockchain=testerchain, deployer_address=origin) assert adjudicator_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not adjudicator_deployer.is_deployed adjudicator_deployer.deploy(secret_hash=keccak(adjudicator_secret)) assert adjudicator_deployer.is_deployed assert len(adjudicator_deployer.contract_address) == 42 adjudicator_agent = adjudicator_deployer.make_agent() assert len(adjudicator_agent.contract_address) == 42 assert adjudicator_agent.contract_address == adjudicator_deployer.contract_address another_adjudicator_agent = adjudicator_deployer.make_agent() assert len(another_adjudicator_agent.contract_address) == 42 assert another_adjudicator_agent.contract_address == adjudicator_deployer.contract_address == adjudicator_agent.contract_address
def test_deploy_ethereum_contracts(testerchain, deployment_progress, test_registry): testerchain = testerchain origin, *everybody_else = testerchain.client.accounts # # Nucypher Token # token_deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin) assert token_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not token_deployer.is_deployed token_deployer.deploy(progress=deployment_progress) assert token_deployer.is_deployed assert len(token_deployer.contract_address) == 42 token_agent = NucypherTokenAgent(registry=test_registry) assert len(token_agent.contract_address) == 42 assert token_agent.contract_address == token_deployer.contract_address another_token_agent = token_deployer.make_agent() assert len(another_token_agent.contract_address) == 42 assert another_token_agent.contract_address == token_deployer.contract_address == token_agent.contract_address # # StakingEscrow # stakers_escrow_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry, deployer_address=origin) assert staking_escrow_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed staking_escrow_deployer.deploy(secret_hash=keccak(stakers_escrow_secret), progress=deployment_progress) assert staking_escrow_deployer.is_deployed assert len(staking_escrow_deployer.contract_address) == 42 staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) assert len(staking_agent.contract_address) == 42 assert staking_agent.contract_address == staking_escrow_deployer.contract_address another_staking_agent = staking_escrow_deployer.make_agent() assert len(another_staking_agent.contract_address) == 42 assert another_staking_agent.contract_address == staking_escrow_deployer.contract_address == staking_agent.contract_address # # Policy Manager # policy_manager_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer(registry=test_registry, deployer_address=origin) assert policy_manager_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not policy_manager_deployer.is_deployed policy_manager_deployer.deploy(secret_hash=keccak(policy_manager_secret), progress=deployment_progress) assert policy_manager_deployer.is_deployed assert len(policy_manager_deployer.contract_address) == 42 policy_agent = policy_manager_deployer.make_agent() assert len(policy_agent.contract_address) == 42 assert policy_agent.contract_address == policy_manager_deployer.contract_address another_policy_agent = policy_manager_deployer.make_agent() assert len(another_policy_agent.contract_address) == 42 assert another_policy_agent.contract_address == policy_manager_deployer.contract_address == policy_agent.contract_address # # Adjudicator # adjudicator_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) adjudicator_deployer = AdjudicatorDeployer(registry=test_registry, deployer_address=origin) assert adjudicator_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not adjudicator_deployer.is_deployed adjudicator_deployer.deploy(secret_hash=keccak(adjudicator_secret), progress=deployment_progress) assert adjudicator_deployer.is_deployed assert len(adjudicator_deployer.contract_address) == 42 adjudicator_agent = adjudicator_deployer.make_agent() assert len(adjudicator_agent.contract_address) == 42 assert adjudicator_agent.contract_address == adjudicator_deployer.contract_address another_adjudicator_agent = AdjudicatorAgent(registry=test_registry) assert len(another_adjudicator_agent.contract_address) == 42 assert another_adjudicator_agent.contract_address == adjudicator_deployer.contract_address == adjudicator_agent.contract_address # overall deployment steps must match aggregated individual expected number of steps all_deployment_transactions = token_deployer.deployment_steps + staking_escrow_deployer.deployment_steps + \ policy_manager_deployer.deployment_steps + adjudicator_deployer.deployment_steps assert deployment_progress.num_steps == len(all_deployment_transactions)
def test_deploy_ethereum_contracts(testerchain, deployment_progress, test_registry): origin, *everybody_else = testerchain.client.accounts tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client)) # # Nucypher Token # token_deployer = NucypherTokenDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not token_deployer.is_deployed() token_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert token_deployer.is_deployed() assert len(token_deployer.contract_address) == 42 token_agent = NucypherTokenAgent(registry=test_registry) assert len(token_agent.contract_address) == 42 assert token_agent.contract_address == token_deployer.contract_address another_token_agent = token_deployer.make_agent() assert len(another_token_agent.contract_address) == 42 assert another_token_agent.contract_address == token_deployer.contract_address == token_agent.contract_address # # StakingEscrowStub # staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed() staking_escrow_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert not staking_escrow_deployer.is_deployed() assert len(staking_escrow_deployer.contract_address) == 42 # # Policy Manager # policy_manager_deployer = PolicyManagerDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not policy_manager_deployer.is_deployed() policy_manager_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert policy_manager_deployer.is_deployed() assert len(policy_manager_deployer.contract_address) == 42 policy_agent = policy_manager_deployer.make_agent() assert len(policy_agent.contract_address) == 42 assert policy_agent.contract_address == policy_manager_deployer.contract_address another_policy_agent = policy_manager_deployer.make_agent() assert len(another_policy_agent.contract_address) == 42 assert another_policy_agent.contract_address == policy_manager_deployer.contract_address == policy_agent.contract_address # # Adjudicator # adjudicator_deployer = AdjudicatorDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not adjudicator_deployer.is_deployed() adjudicator_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert adjudicator_deployer.is_deployed() assert len(adjudicator_deployer.contract_address) == 42 adjudicator_agent = adjudicator_deployer.make_agent() assert len(adjudicator_agent.contract_address) == 42 assert adjudicator_agent.contract_address == adjudicator_deployer.contract_address another_adjudicator_agent = AdjudicatorAgent(registry=test_registry) assert len(another_adjudicator_agent.contract_address) == 42 assert another_adjudicator_agent.contract_address == adjudicator_deployer.contract_address == adjudicator_agent.contract_address # StakingEscrow staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed() staking_escrow_deployer.deploy(progress=deployment_progress, deployment_mode=constants.FULL, transacting_power=tpower) assert staking_escrow_deployer.is_deployed() assert len(staking_escrow_deployer.contract_address) == 42 staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) assert len(staking_agent.contract_address) == 42 assert staking_agent.contract_address == staking_escrow_deployer.contract_address another_staking_agent = staking_escrow_deployer.make_agent() assert len(another_staking_agent.contract_address) == 42 assert another_staking_agent.contract_address == staking_escrow_deployer.contract_address == staking_agent.contract_address # overall deployment steps must match aggregated individual expected number of steps all_deployment_transactions = token_deployer.deployment_steps + staking_escrow_deployer.init_steps + \ staking_escrow_deployer.deployment_steps + \ policy_manager_deployer.deployment_steps + adjudicator_deployer.deployment_steps assert deployment_progress.num_steps == len(all_deployment_transactions)
def _make_agency( testerchain, test_registry, token_economics ) -> Tuple[NucypherTokenAgent, StakingEscrowAgent, PolicyManagerAgent]: """ Launch the big three contracts on provided chain, make agents for each and return them. """ # Mock TransactingPower Consumption (Deployer) testerchain.transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, signer=Web3Signer(client=testerchain.client), account=testerchain.etherbase_account) testerchain.transacting_power.activate() origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(deployer_address=origin, economics=token_economics, registry=test_registry) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, economics=token_economics, registry=test_registry, test_mode=True) staking_escrow_deployer.deploy() policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin, economics=token_economics, registry=test_registry) policy_manager_deployer.deploy() adjudicator_deployer = AdjudicatorDeployer(deployer_address=origin, economics=token_economics, registry=test_registry) adjudicator_deployer.deploy() staking_interface_deployer = StakingInterfaceDeployer( deployer_address=origin, economics=token_economics, registry=test_registry) staking_interface_deployer.deploy() worklock_deployer = WorklockDeployer(deployer_address=origin, economics=token_economics, registry=test_registry) worklock_deployer.deploy() token_agent = token_deployer.make_agent() # 1 Token staking_agent = staking_escrow_deployer.make_agent() # 2 Staking Escrow policy_agent = policy_manager_deployer.make_agent() # 3 Policy Agent _adjudicator_agent = adjudicator_deployer.make_agent() # 4 Adjudicator _worklock_agent = worklock_deployer.make_agent() # 5 Worklock # Set additional parameters minimum, default, maximum = FEE_RATE_RANGE txhash = policy_agent.contract.functions.setFeeRateRange( minimum, default, maximum).transact() _receipt = testerchain.wait_for_receipt(txhash) # TODO: Get rid of returning these agents here. # What's important is deploying and creating the first agent for each contract, # and since agents are singletons, in tests it's only necessary to call the agent # constructor again to receive the existing agent. # # For example: # staking_agent = StakingEscrowAgent() # # This is more clear than how we currently obtain an agent instance in tests: # _, staking_agent, _ = agency # # Other advantages is that it's closer to how agents should be use (i.e., there # are no fixtures IRL) and it's more extensible (e.g., AdjudicatorAgent) return token_agent, staking_agent, policy_agent
def test_upgradeability(temp_dir_path): # Prepare remote source for compilation download_github_dir(GITHUB_SOURCE_LINK, temp_dir_path) # Prepare the blockchain TesterBlockchain.SOURCES = [ SourceBundle(base_path=SOLIDITY_SOURCE_ROOT, other_paths=(TEST_SOLIDITY_SOURCE_ROOT, )), SourceBundle(base_path=Path(temp_dir_path)) ] eth_provider_uri = 'tester://pyevm/2' # TODO: Testerchain caching Issues try: blockchain_interface = TesterBlockchain(gas_strategy='free') blockchain_interface.eth_provider_uri = eth_provider_uri blockchain_interface.connect() origin = blockchain_interface.client.accounts[0] BlockchainInterfaceFactory.register_interface( interface=blockchain_interface) transacting_power = TransactingPower( password=INSECURE_DEVELOPMENT_PASSWORD, signer=Web3Signer(blockchain_interface.client), account=origin) economics = make_token_economics(blockchain_interface) # Check contracts with multiple versions contract_name = StakingEscrowDeployer.contract_name skip_staking_escrow_test = skip_test(blockchain_interface, contract_name) if skip_staking_escrow_test: return # Prepare master version of contracts and upgrade to the latest registry = InMemoryContractRegistry() token_deployer = NucypherTokenDeployer(registry=registry, economics=economics) token_deployer.deploy(transacting_power=transacting_power) staking_escrow_deployer = StakingEscrowDeployer(registry=registry, economics=economics) staking_escrow_deployer.deploy(deployment_mode=constants.INIT, transacting_power=transacting_power) if not skip_staking_escrow_test: economics.worklock_supply = economics.maximum_allowed_locked worklock_deployer = WorklockDeployer(registry=registry, economics=economics) worklock_deployer.deploy(transacting_power=transacting_power) staking_escrow_deployer = StakingEscrowDeployer(registry=registry, economics=economics) deploy_base_contract(blockchain_interface, staking_escrow_deployer, transacting_power=transacting_power, skipt_test=skip_staking_escrow_test) if not skip_staking_escrow_test: prepare_staker(blockchain_interface=blockchain_interface, deployer=staking_escrow_deployer, transacting_power=transacting_power) staking_escrow_deployer.upgrade( transacting_power=transacting_power, contract_version="latest", confirmations=0) finally: # Unregister interface # TODO: Move to method? with contextlib.suppress(KeyError): del BlockchainInterfaceFactory._interfaces[eth_provider_uri]
def test_deploy_idle_network(testerchain, deployment_progress, test_registry): origin, *everybody_else = testerchain.client.accounts # # Nucypher Token # token_deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin) assert token_deployer.deployer_address == origin with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not token_deployer.is_deployed() token_deployer.deploy(progress=deployment_progress) assert token_deployer.is_deployed() token_agent = NucypherTokenAgent(registry=test_registry) assert token_agent.contract_address == token_deployer.contract_address another_token_agent = token_deployer.make_agent() assert another_token_agent.contract_address == token_deployer.contract_address == token_agent.contract_address # # StakingEscrow - in INIT mode, i.e. stub for StakingEscrow # staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry, deployer_address=origin) assert staking_escrow_deployer.deployer_address == origin with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed() staking_escrow_deployer.deploy(progress=deployment_progress, deployment_mode=constants.INIT) assert not staking_escrow_deployer.is_deployed() # # Policy Manager # policy_manager_deployer = PolicyManagerDeployer(registry=test_registry, deployer_address=origin) assert policy_manager_deployer.deployer_address == origin with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not policy_manager_deployer.is_deployed() policy_manager_deployer.deploy(progress=deployment_progress) assert policy_manager_deployer.is_deployed() policy_agent = policy_manager_deployer.make_agent() assert policy_agent.contract_address == policy_manager_deployer.contract_address # # Adjudicator # adjudicator_deployer = AdjudicatorDeployer(registry=test_registry, deployer_address=origin) assert adjudicator_deployer.deployer_address == origin with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not adjudicator_deployer.is_deployed() adjudicator_deployer.deploy(progress=deployment_progress) assert adjudicator_deployer.is_deployed() adjudicator_agent = adjudicator_deployer.make_agent() assert adjudicator_agent.contract_address == adjudicator_deployer.contract_address # # StakingEscrow - in IDLE mode, i.e. without activation steps (approve_funding and initialize) # staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry, deployer_address=origin) assert staking_escrow_deployer.deployer_address == origin with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed() staking_escrow_deployer.deploy(progress=deployment_progress, deployment_mode=constants.IDLE) assert staking_escrow_deployer.is_deployed() staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) assert staking_agent.contract_address == staking_escrow_deployer.contract_address # The contract has no tokens yet assert token_agent.get_balance(staking_agent.contract_address) == 0