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 test_upgradeability(temp_dir_path): # Prepare remote source for compilation download_github_dir(GITHUB_SOURCE_LINK, temp_dir_path) solidity_compiler = SolidityCompiler(source_dirs=[SourceDirs(SolidityCompiler.default_contract_dir()), SourceDirs(temp_dir_path)]) # Prepare the blockchain provider_uri = 'tester://pyevm/2' try: blockchain_interface = BlockchainDeployerInterface(provider_uri=provider_uri, compiler=solidity_compiler, gas_strategy=free_gas_price_strategy) 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() # Check contracts with multiple versions raw_contracts = blockchain_interface._raw_contract_cache contract_name = AdjudicatorDeployer.contract_name test_adjudicator = len(raw_contracts[contract_name]) > 1 contract_name = StakingEscrowDeployer.contract_name test_staking_escrow = len(raw_contracts[contract_name]) > 1 contract_name = PolicyManagerDeployer.contract_name test_policy_manager = len(raw_contracts[contract_name]) > 1 if not test_adjudicator and not test_staking_escrow and not test_policy_manager: return # Prepare master version of contracts and upgrade to the latest registry = InMemoryContractRegistry() token_deployer = NucypherTokenDeployer(registry=registry, deployer_address=origin) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(registry=registry, deployer_address=origin) deploy_earliest_contract(blockchain_interface, staking_escrow_deployer) if test_staking_escrow: staking_escrow_deployer.upgrade(contract_version="latest", confirmations=0) if test_policy_manager: policy_manager_deployer = PolicyManagerDeployer(registry=registry, deployer_address=origin) deploy_earliest_contract(blockchain_interface, policy_manager_deployer) policy_manager_deployer.upgrade(contract_version="latest", confirmations=0) if test_adjudicator: adjudicator_deployer = AdjudicatorDeployer(registry=registry, deployer_address=origin) deploy_earliest_contract(blockchain_interface, adjudicator_deployer) adjudicator_deployer.upgrade(contract_version="latest", confirmations=0) finally: # Unregister interface with contextlib.suppress(KeyError): del BlockchainInterfaceFactory._interfaces[provider_uri]
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 _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, application_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 == application_economics.hash_algorithm assert adjudicator_agent.base_penalty == application_economics.base_penalty assert adjudicator_agent.penalty_history_coefficient == application_economics.penalty_history_coefficient assert adjudicator_agent.percentage_penalty_coefficient == application_economics.percentage_penalty_coefficient assert adjudicator_agent.reward_coefficient == application_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_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 adjudicator_deployer(policy_manager_deployer, testerchain, test_registry, transacting_power): policy_manager_deployer.deploy(transacting_power=transacting_power) adjudicator_deployer = AdjudicatorDeployer(registry=test_registry) return adjudicator_deployer
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 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 adjudicator_deployer(policy_manager_deployer, testerchain, test_registry): policy_manager_deployer.deploy() adjudicator_deployer = AdjudicatorDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account) return adjudicator_deployer
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 adjudicator_deployer(policy_manager_deployer, testerchain, test_registry): policy_manager_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) adjudicator_deployer = AdjudicatorDeployer(registry=test_registry, deployer_address=testerchain.etherbase_account) return adjudicator_deployer
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) 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 = 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, 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) policy_manager_deployer = PolicyManagerDeployer(registry=registry, economics=economics) deploy_base_contract(blockchain_interface, policy_manager_deployer, transacting_power=transacting_power, skipt_test=skip_policy_manager_test) adjudicator_deployer = AdjudicatorDeployer(registry=registry, economics=economics) deploy_base_contract(blockchain_interface, adjudicator_deployer, transacting_power=transacting_power, skipt_test=skip_adjudicator_test) if skip_staking_escrow_test: 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: # TODO prepare at least one staker before calling upgrade staking_escrow_deployer.upgrade( transacting_power=transacting_power, contract_version="latest", confirmations=0) if not skip_policy_manager_test: policy_manager_deployer.upgrade( transacting_power=transacting_power, contract_version="latest", confirmations=0) if not skip_adjudicator_test: adjudicator_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[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
def test_upgradeability(temp_dir_path, token_economics): # Prepare remote source for compilation download_github_dir(GITHUB_SOURCE_LINK, temp_dir_path) solidity_compiler = SolidityCompiler(source_dirs=[ SourceDirs(SolidityCompiler.default_contract_dir()), SourceDirs(temp_dir_path) ]) # Prepare the blockchain blockchain_interface = BlockchainDeployerInterface( provider_uri='tester://pyevm/2', compiler=solidity_compiler) 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() # Check contracts with multiple versions raw_contracts = blockchain_interface._raw_contract_cache contract_name = AdjudicatorDeployer.contract_name test_adjudicator = len(raw_contracts[contract_name]) > 1 contract_name = StakingEscrowDeployer.contract_name test_staking_escrow = len(raw_contracts[contract_name]) > 1 contract_name = PolicyManagerDeployer.contract_name test_policy_manager = len(raw_contracts[contract_name]) > 1 if not test_adjudicator and not test_staking_escrow and not test_policy_manager: return # Prepare master version of contracts and upgrade to the latest registry = InMemoryContractRegistry() token_deployer = NucypherTokenDeployer(registry=registry, deployer_address=origin) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(registry=registry, deployer_address=origin) deploy_earliest_contract(blockchain_interface, staking_escrow_deployer, secret=STAKING_ESCROW_DEPLOYMENT_SECRET) if test_staking_escrow: upgrade_to_latest_contract(staking_escrow_deployer, secret=STAKING_ESCROW_DEPLOYMENT_SECRET) if test_policy_manager: policy_manager_deployer = PolicyManagerDeployer( registry=registry, deployer_address=origin) deploy_earliest_contract(blockchain_interface, policy_manager_deployer, secret=POLICY_MANAGER_DEPLOYMENT_SECRET) upgrade_to_latest_contract(policy_manager_deployer, secret=POLICY_MANAGER_DEPLOYMENT_SECRET) if test_adjudicator: adjudicator_deployer = AdjudicatorDeployer(registry=registry, deployer_address=origin) deploy_earliest_contract(blockchain_interface, adjudicator_deployer, secret=ADJUDICATOR_DEPLOYMENT_SECRET) upgrade_to_latest_contract(adjudicator_deployer, secret=ADJUDICATOR_DEPLOYMENT_SECRET)
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_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 raw_contracts = blockchain_interface._raw_contract_cache contract_name = AdjudicatorDeployer.contract_name test_adjudicator = len(raw_contracts[contract_name]) > 1 contract_name = StakingEscrowDeployer.contract_name test_staking_escrow = len(raw_contracts[contract_name]) > 1 contract_name = PolicyManagerDeployer.contract_name test_policy_manager = len(raw_contracts[contract_name]) > 1 if not test_adjudicator and not test_staking_escrow and not test_policy_manager: 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) deploy_earliest_contract(blockchain_interface, staking_escrow_deployer) policy_manager_deployer = None if test_staking_escrow or test_policy_manager: policy_manager_deployer = PolicyManagerDeployer( registry=registry, deployer_address=origin, economics=economics) deploy_earliest_contract(blockchain_interface, policy_manager_deployer) adjudicator_deployer = None if test_staking_escrow or test_adjudicator: adjudicator_deployer = AdjudicatorDeployer(registry=registry, deployer_address=origin, economics=economics) deploy_earliest_contract(blockchain_interface, adjudicator_deployer) if test_staking_escrow: worklock_deployer = WorklockDeployer(registry=registry, deployer_address=origin, economics=economics) worklock_deployer.deploy() # TODO prepare at least one staker before calling upgrade staking_escrow_deployer.upgrade(contract_version="latest", confirmations=0) if test_policy_manager: policy_manager_deployer.upgrade(contract_version="latest", confirmations=0) if test_adjudicator: adjudicator_deployer.upgrade(contract_version="latest", confirmations=0) finally: # Unregister interface # TODO: Move to method? with contextlib.suppress(KeyError): del BlockchainInterfaceFactory._interfaces[provider_uri]