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