def three_agents(testerchain): """ Musketeers, if you will. Launch the big three contracts on provided chain, make agents for each and return them. """ """Launch all Nucypher ethereum contracts""" origin, *everybody_else = testerchain.interface.w3.eth.accounts token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() token_agent = token_deployer.make_agent() # 1: Token miners_escrow_secret = os.urandom(DISPATCHER_SECRET_LENGTH) miner_escrow_deployer = MinerEscrowDeployer( deployer_address=origin, secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret)) miner_escrow_deployer.deploy() miner_agent = miner_escrow_deployer.make_agent() # 2 Miner Escrow policy_manager_secret = os.urandom(DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer( deployer_address=origin, secret_hash=testerchain.interface.w3.keccak(policy_manager_secret)) policy_manager_deployer.deploy() policy_agent = policy_manager_deployer.make_agent() # 3 Policy Agent return token_agent, miner_agent, policy_agent
def deploy_policy_contract(self, secret): policy_manager_deployer = PolicyManagerDeployer( deployer_address=self.deployer_address, secret_hash=secret) policy_manager_deployer.deploy() self.policy_agent = policy_manager_deployer.make_agent()
def three_agents(testerchain): """ Musketeers, if you will. Launch the big three contracts on provided chain, make agents for each and return them. """ """Launch all Nucypher ethereum contracts""" origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() miner_escrow_deployer = MinerEscrowDeployer(deployer_address=origin) miner_escrow_deployer.deploy( secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin) policy_manager_deployer.deploy( secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) token_agent = token_deployer.make_agent() # 1: Token miner_agent = miner_escrow_deployer.make_agent() # 2 Miner Escrow policy_agent = policy_manager_deployer.make_agent() # 3 Policy Agent adjudicator_deployer = MiningAdjudicatorDeployer(deployer_address=origin) adjudicator_deployer.deploy( secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)) yield token_agent, miner_agent, policy_agent Agency.clear()
def test_upgrade(testerchain, test_registry): deployer = PolicyManagerDeployer(registry=test_registry, deployer_address=testerchain.etherbase_account) bare_contract = testerchain.get_contract_by_name(registry=test_registry, contract_name=PolicyManagerDeployer.contract_name, proxy_name=DispatcherDeployer.contract_name, use_proxy_address=False) old_address = bare_contract.address receipts = deployer.upgrade(ignore_deployed=True, confirmations=0) bare_contract = testerchain.get_contract_by_name(registry=test_registry, contract_name=PolicyManagerDeployer.contract_name, proxy_name=DispatcherDeployer.contract_name, use_proxy_address=False) new_address = bare_contract.address assert old_address != new_address # TODO: Contract ABI is not updated in Agents when upgrade/rollback #1184 transactions = ('deploy', 'retarget') assert len(receipts) == len(transactions) for tx in transactions: assert receipts[tx]['status'] == 1
def deploy_policy_contract(self, secret: bytes): policy_manager_deployer = PolicyManagerDeployer(blockchain=self.blockchain, deployer_address=self.deployer_address, secret_hash=secret) txhashes = policy_manager_deployer.deploy() self.policy_agent = policy_manager_deployer.make_agent() return txhashes
def deploy_policy_contract(self, secret: bytes) -> dict: secret = self.blockchain.interface.w3.keccak(secret) policy_manager_deployer = PolicyManagerDeployer(blockchain=self.blockchain, deployer_address=self.deployer_address, secret_hash=secret) txhashes = policy_manager_deployer.deploy() self.policy_agent = policy_manager_deployer.make_agent() return txhashes
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 _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 policy_manager_deployer(staking_escrow_deployer, testerchain, test_registry): staking_escrow_deployer.deploy(secret_hash=keccak( text=STAKING_ESCROW_DEPLOYMENT_SECRET)) policy_manager_deployer = PolicyManagerDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account) return policy_manager_deployer
def policy_manager_deployer(staking_escrow_deployer, session_testerchain): staking_escrow_deployer.deploy(secret_hash=keccak( text=STAKING_ESCROW_DEPLOYMENT_SECRET)) policy_manager_deployer = PolicyManagerDeployer( blockchain=session_testerchain, deployer_address=session_testerchain.etherbase_account) return policy_manager_deployer
def three_agents(testerchain): """ Musketeers, if you will. Launch the big three contracts on provided chain, make agents for each and return them. """ """Launch all Nucypher ethereum contracts""" origin, *everybody_else = testerchain.interface.w3.eth.accounts token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.arm() token_deployer.deploy() token_agent = token_deployer.make_agent() miner_escrow_deployer = MinerEscrowDeployer(token_agent=token_agent, deployer_address=origin) miner_escrow_deployer.arm() miner_escrow_deployer.deploy() miner_agent = miner_escrow_deployer.make_agent() policy_manager_deployer = PolicyManagerDeployer(miner_agent=miner_agent, deployer_address=origin) policy_manager_deployer.arm() policy_manager_deployer.deploy() policy_agent = policy_manager_deployer.make_agent() return token_agent, miner_agent, policy_agent
def test_deploy_ethereum_contracts(testerchain): """ A bare minimum nucypher deployment fixture. """ origin, *everybody_else = testerchain.interface.w3.eth.accounts token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.arm() token_deployer.deploy() token_agent = NucypherTokenAgent(blockchain=testerchain) miners_escrow_secret = os.urandom(constants.DISPATCHER_SECRET_LENGTH) miner_escrow_deployer = MinerEscrowDeployer( token_agent=token_agent, deployer_address=origin, secret_hash=testerchain.interface.w3.sha3(miners_escrow_secret)) miner_escrow_deployer.arm() miner_escrow_deployer.deploy() miner_agent = MinerAgent(token_agent=token_agent) policy_manager_secret = os.urandom(constants.DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer( miner_agent=miner_agent, deployer_address=origin, secret_hash=testerchain.interface.w3.sha3(policy_manager_secret)) policy_manager_deployer.arm() policy_manager_deployer.deploy() policy_agent = policy_manager_deployer.make_agent()
def test_deploy_ethereum_contracts(testerchain): """ Launch all ethereum contracts: - NuCypherToken - PolicyManager - MinersEscrow - UserEscrow - Issuer """ origin, *everybody_else = testerchain.interface.w3.eth.accounts token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.arm() token_deployer.deploy() token_agent = NucypherTokenAgent(blockchain=testerchain) miner_escrow_deployer = MinerEscrowDeployer(token_agent=token_agent, deployer_address=origin) miner_escrow_deployer.arm() miner_escrow_deployer.deploy() miner_agent = MinerAgent(token_agent=token_agent) policy_manager_deployer = PolicyManagerDeployer(miner_agent=miner_agent, deployer_address=origin) policy_manager_deployer.arm() policy_manager_deployer.deploy() policy_agent = policy_manager_deployer.make_agent()
def test_upgrade(session_testerchain): wrong_secret = b"on second thoughts..." old_secret = bytes(POLICY_MANAGER_DEPLOYMENT_SECRET, encoding='utf-8') new_secret_hash = keccak(b'new' + old_secret) deployer = PolicyManagerDeployer( blockchain=session_testerchain, deployer_address=session_testerchain.etherbase_account) with pytest.raises(deployer.ContractDeploymentError): deployer.upgrade(existing_secret_plaintext=wrong_secret, new_secret_hash=new_secret_hash) receipts = deployer.upgrade(existing_secret_plaintext=old_secret, new_secret_hash=new_secret_hash) for title, receipt in receipts.items(): assert receipt['status'] == 1
def test_policy_manager_deployer(testerchain): origin, *everybody_else = testerchain.interface.w3.eth.accounts token_deployer = NucypherTokenDeployer(blockchain=testerchain, deployer_address=origin) token_deployer.deploy() token_agent = token_deployer.make_agent() # 1: Token miners_escrow_secret = os.urandom(DISPATCHER_SECRET_LENGTH) miner_escrow_deployer = MinerEscrowDeployer( deployer_address=origin, secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret)) miner_escrow_deployer.deploy() miner_agent = miner_escrow_deployer.make_agent() # 2 Miner Escrow policy_manager_secret = os.urandom(DISPATCHER_SECRET_LENGTH) deployer = PolicyManagerDeployer( deployer_address=origin, secret_hash=testerchain.interface.w3.keccak(policy_manager_secret)) deployment_txhashes = deployer.deploy() 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 token instance policy_agent = deployer.make_agent() policy_manager_contract = policy_agent.contract # Retrieve the token from the blockchain some_policy_agent = PolicyAgent() assert some_policy_agent.contract.address == policy_manager_contract.address # Compare the contract address for equality assert policy_agent.contract_address == some_policy_agent.contract_address assert policy_agent == some_policy_agent # __eq__
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_deploy_ethereum_contracts(chain): """ Launch all ethereum contracts: - NuCypherToken - PolicyManager - MinersEscrow - UserEscrow - Issuer """ token_deployer = NucypherTokenDeployer(blockchain=chain) token_deployer.arm() token_deployer.deploy() token_agent = NucypherTokenAgent(blockchain=chain) miner_escrow_deployer = MinerEscrowDeployer(token_agent=token_agent) miner_escrow_deployer.arm() miner_escrow_deployer.deploy() miner_agent = MinerAgent(token_agent=token_agent) policy_manager_contract = PolicyManagerDeployer(miner_agent=miner_agent) policy_manager_contract.arm() policy_manager_contract.deploy()
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_rollback(testerchain, test_registry, transacting_power): deployer = PolicyManagerDeployer(registry=test_registry) policy_manager_agent = PolicyManagerAgent(registry=test_registry) current_target = policy_manager_agent.contract.functions.target().call() # Let's do one more upgrade receipts = deployer.upgrade(ignore_deployed=True, confirmations=0, transacting_power=transacting_power) for title, receipt in receipts.items(): assert receipt['status'] == 1 old_target = current_target current_target = policy_manager_agent.contract.functions.target().call() assert current_target != old_target # It's time to rollback. receipt = deployer.rollback(transacting_power=transacting_power) assert receipt['status'] == 1 new_target = policy_manager_agent.contract.functions.target().call() assert new_target != current_target assert new_target == old_target
def test_upgrade(testerchain, test_registry): wrong_secret = b"on second thoughts..." old_secret = bytes(POLICY_MANAGER_DEPLOYMENT_SECRET, encoding='utf-8') new_secret_hash = keccak(b'new' + old_secret) deployer = PolicyManagerDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account) bare_contract = testerchain.get_contract_by_name( registry=test_registry, contract_name=PolicyManagerDeployer.contract_name, proxy_name=DispatcherDeployer.contract_name, use_proxy_address=False) old_address = bare_contract.address with pytest.raises(deployer.ContractDeploymentError): deployer.upgrade(existing_secret_plaintext=wrong_secret, new_secret_hash=new_secret_hash) receipts = deployer.upgrade(existing_secret_plaintext=old_secret, new_secret_hash=new_secret_hash, ignore_deployed=True) bare_contract = testerchain.get_contract_by_name( registry=test_registry, contract_name=PolicyManagerDeployer.contract_name, proxy_name=DispatcherDeployer.contract_name, use_proxy_address=False) new_address = bare_contract.address assert old_address != new_address # TODO: Contract ABI is not updated in Agents when upgrade/rollback #1184 transactions = ('deploy', 'retarget') assert len(receipts) == len(transactions) for tx in transactions: assert receipts[tx]['status'] == 1
def test_rollback(testerchain, test_registry): deployer = PolicyManagerDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account) policy_manager_agent = PolicyManagerAgent(registry=test_registry) current_target = policy_manager_agent.contract.functions.target().call() # Let's do one more upgrade receipts = deployer.upgrade(ignore_deployed=True) for title, receipt in receipts.items(): assert receipt['status'] == 1 old_target = current_target current_target = policy_manager_agent.contract.functions.target().call() assert current_target != old_target # It's time to rollback. receipt = deployer.rollback() assert receipt['status'] == 1 new_target = policy_manager_agent.contract.functions.target().call() assert new_target != current_target assert new_target == old_target
def test_rollback(testerchain, test_registry): old_secret = bytes('new' + POLICY_MANAGER_DEPLOYMENT_SECRET, encoding='utf-8') new_secret_hash = keccak(text="third time's the charm") deployer = PolicyManagerDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account) policy_manager_agent = PolicyManagerAgent(registry=test_registry) current_target = policy_manager_agent.contract.functions.target().call() # Let's do one more upgrade receipts = deployer.upgrade(existing_secret_plaintext=old_secret, new_secret_hash=new_secret_hash, ignore_deployed=True) for title, receipt in receipts.items(): assert receipt['status'] == 1 old_target = current_target current_target = policy_manager_agent.contract.functions.target().call() assert current_target != old_target # It's time to rollback. But first... wrong_secret = b"WRONG!!" with pytest.raises(deployer.ContractDeploymentError): deployer.rollback(existing_secret_plaintext=wrong_secret, new_secret_hash=new_secret_hash) # OK, *now* is time for rollback old_secret = b"third time's the charm" new_secret_hash = keccak(text="...maybe not.") receipt = deployer.rollback(existing_secret_plaintext=old_secret, new_secret_hash=new_secret_hash) assert receipt['status'] == 1 new_target = policy_manager_agent.contract.functions.target().call() assert new_target != current_target assert new_target == old_target
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 policy_manager_deployer(staking_escrow_stub_deployer, testerchain, test_registry): staking_escrow_stub_deployer.deploy(deployment_mode=INIT) policy_manager_deployer = PolicyManagerDeployer( registry=test_registry, deployer_address=testerchain.etherbase_account) return policy_manager_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 policy_manager_deployer(staking_escrow_deployer, testerchain, test_registry): staking_escrow_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) policy_manager_deployer = PolicyManagerDeployer(registry=test_registry, deployer_address=testerchain.etherbase_account) return policy_manager_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 new_policy_manager_deployer(testerchain, test_registry, new_token_economics): policy_manager_deployer = PolicyManagerDeployer( registry=test_registry, economics=new_token_economics) return policy_manager_deployer