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 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 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 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 _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 _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 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 test_staking_interface_deployer(testerchain, deployment_progress, test_registry): # # Setup # origin = testerchain.etherbase_account token_deployer = NucypherTokenDeployer(deployer_address=origin, registry=test_registry) token_deployer.deploy() staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, registry=test_registry) staking_escrow_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin, registry=test_registry) policy_manager_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) adjudicator_deployer = AdjudicatorDeployer(deployer_address=origin, registry=test_registry) adjudicator_deployer.deploy(secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH) # # Test # staking_interface_deployer = StakingInterfaceDeployer( deployer_address=origin, registry=test_registry) staking_interface_receipts = staking_interface_deployer.deploy( secret_hash=INSECURE_DEPLOYMENT_SECRET_HASH, progress=deployment_progress) # deployment steps must match expected number of steps assert deployment_progress.num_steps == len( staking_interface_deployer.deployment_steps) == 2 assert len(staking_interface_receipts) == 2 for step in staking_interface_deployer.deployment_steps: assert staking_interface_receipts[step]['status'] == 1
def _make_agency(testerchain, test_registry, token_economics, deployer_transacting_power): transacting_power = deployer_transacting_power token_deployer = NucypherTokenDeployer(economics=token_economics, registry=test_registry) token_deployer.deploy(transacting_power=transacting_power) staking_escrow_deployer = StakingEscrowDeployer(economics=token_economics, registry=test_registry) staking_escrow_deployer.deploy(deployment_mode=INIT, transacting_power=transacting_power) policy_manager_deployer = PolicyManagerDeployer(economics=token_economics, registry=test_registry) policy_manager_deployer.deploy(transacting_power=transacting_power) adjudicator_deployer = AdjudicatorDeployer(economics=token_economics, registry=test_registry) adjudicator_deployer.deploy(transacting_power=transacting_power) staking_interface_deployer = StakingInterfaceDeployer( economics=token_economics, registry=test_registry) staking_interface_deployer.deploy(transacting_power=transacting_power) worklock_deployer = WorklockDeployer(economics=token_economics, registry=test_registry) worklock_deployer.deploy(transacting_power=transacting_power) staking_escrow_deployer = StakingEscrowDeployer(economics=token_economics, registry=test_registry) staking_escrow_deployer.deploy(deployment_mode=FULL, transacting_power=transacting_power) # Set additional parameters minimum, default, maximum = FEE_RATE_RANGE policy_agent = policy_manager_deployer.make_agent() txhash = policy_agent.contract.functions.setFeeRateRange( minimum, default, maximum).transact() testerchain.wait_for_receipt(txhash)
def test_policy_manager_deployer(testerchain): origin, *everybody_else = testerchain.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_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_deploy_ethereum_contracts(testerchain): origin, *everybody_else = testerchain.interface.w3.eth.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 # # Miner Escrow # miners_escrow_secret = os.urandom(DISPATCHER_SECRET_LENGTH) miner_escrow_deployer = MinerEscrowDeployer( blockchain=testerchain, deployer_address=origin, secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret)) assert miner_escrow_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert miner_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not miner_escrow_deployer.is_deployed miner_escrow_deployer.deploy() assert miner_escrow_deployer.is_deployed assert len(miner_escrow_deployer.contract_address) == 42 miner_agent = MinerAgent(blockchain=testerchain) assert len(miner_agent.contract_address) == 42 assert miner_agent.contract_address == miner_escrow_deployer.contract_address another_miner_agent = miner_escrow_deployer.make_agent() assert len(another_miner_agent.contract_address) == 42 assert another_miner_agent.contract_address == miner_escrow_deployer.contract_address == miner_agent.contract_address # # Policy Manager # policy_manager_secret = os.urandom(DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer( blockchain=testerchain, deployer_address=origin, secret_hash=testerchain.interface.w3.keccak(policy_manager_secret)) 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() 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
def test_deploy_ethereum_contracts(testerchain, deployment_progress, test_registry): testerchain = testerchain origin, *everybody_else = testerchain.client.accounts # # Nucypher Token # token_deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin) assert token_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not token_deployer.is_deployed token_deployer.deploy(progress=deployment_progress) assert token_deployer.is_deployed assert len(token_deployer.contract_address) == 42 token_agent = NucypherTokenAgent(registry=test_registry) assert len(token_agent.contract_address) == 42 assert token_agent.contract_address == token_deployer.contract_address another_token_agent = token_deployer.make_agent() assert len(another_token_agent.contract_address) == 42 assert another_token_agent.contract_address == token_deployer.contract_address == token_agent.contract_address # # StakingEscrow # stakers_escrow_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry, deployer_address=origin) assert staking_escrow_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed staking_escrow_deployer.deploy(secret_hash=keccak(stakers_escrow_secret), progress=deployment_progress) assert staking_escrow_deployer.is_deployed assert len(staking_escrow_deployer.contract_address) == 42 staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) assert len(staking_agent.contract_address) == 42 assert staking_agent.contract_address == staking_escrow_deployer.contract_address another_staking_agent = staking_escrow_deployer.make_agent() assert len(another_staking_agent.contract_address) == 42 assert another_staking_agent.contract_address == staking_escrow_deployer.contract_address == staking_agent.contract_address # # Policy Manager # policy_manager_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer(registry=test_registry, deployer_address=origin) assert policy_manager_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not policy_manager_deployer.is_deployed policy_manager_deployer.deploy(secret_hash=keccak(policy_manager_secret), progress=deployment_progress) assert policy_manager_deployer.is_deployed assert len(policy_manager_deployer.contract_address) == 42 policy_agent = policy_manager_deployer.make_agent() assert len(policy_agent.contract_address) == 42 assert policy_agent.contract_address == policy_manager_deployer.contract_address another_policy_agent = policy_manager_deployer.make_agent() assert len(another_policy_agent.contract_address) == 42 assert another_policy_agent.contract_address == policy_manager_deployer.contract_address == policy_agent.contract_address # # Adjudicator # adjudicator_secret = os.urandom( DispatcherDeployer.DISPATCHER_SECRET_LENGTH) adjudicator_deployer = AdjudicatorDeployer(registry=test_registry, deployer_address=origin) assert adjudicator_deployer.deployer_address == origin with pytest.raises(ContractDeployer.ContractDeploymentError): assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not adjudicator_deployer.is_deployed adjudicator_deployer.deploy(secret_hash=keccak(adjudicator_secret), progress=deployment_progress) assert adjudicator_deployer.is_deployed assert len(adjudicator_deployer.contract_address) == 42 adjudicator_agent = adjudicator_deployer.make_agent() assert len(adjudicator_agent.contract_address) == 42 assert adjudicator_agent.contract_address == adjudicator_deployer.contract_address another_adjudicator_agent = AdjudicatorAgent(registry=test_registry) assert len(another_adjudicator_agent.contract_address) == 42 assert another_adjudicator_agent.contract_address == adjudicator_deployer.contract_address == adjudicator_agent.contract_address # overall deployment steps must match aggregated individual expected number of steps all_deployment_transactions = token_deployer.deployment_steps + staking_escrow_deployer.deployment_steps + \ policy_manager_deployer.deployment_steps + adjudicator_deployer.deployment_steps assert deployment_progress.num_steps == len(all_deployment_transactions)
def test_deploy_ethereum_contracts(testerchain, deployment_progress, test_registry): origin, *everybody_else = testerchain.client.accounts tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client)) # # Nucypher Token # token_deployer = NucypherTokenDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not token_deployer.is_deployed() token_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert token_deployer.is_deployed() assert len(token_deployer.contract_address) == 42 token_agent = NucypherTokenAgent(registry=test_registry) assert len(token_agent.contract_address) == 42 assert token_agent.contract_address == token_deployer.contract_address another_token_agent = token_deployer.make_agent() assert len(another_token_agent.contract_address) == 42 assert another_token_agent.contract_address == token_deployer.contract_address == token_agent.contract_address # # StakingEscrowStub # staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed() staking_escrow_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert not staking_escrow_deployer.is_deployed() assert len(staking_escrow_deployer.contract_address) == 42 # # Policy Manager # policy_manager_deployer = PolicyManagerDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not policy_manager_deployer.is_deployed() policy_manager_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert policy_manager_deployer.is_deployed() assert len(policy_manager_deployer.contract_address) == 42 policy_agent = policy_manager_deployer.make_agent() assert len(policy_agent.contract_address) == 42 assert policy_agent.contract_address == policy_manager_deployer.contract_address another_policy_agent = policy_manager_deployer.make_agent() assert len(another_policy_agent.contract_address) == 42 assert another_policy_agent.contract_address == policy_manager_deployer.contract_address == policy_agent.contract_address # # Adjudicator # adjudicator_deployer = AdjudicatorDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not adjudicator_deployer.is_deployed() adjudicator_deployer.deploy(progress=deployment_progress, transacting_power=tpower) assert adjudicator_deployer.is_deployed() assert len(adjudicator_deployer.contract_address) == 42 adjudicator_agent = adjudicator_deployer.make_agent() assert len(adjudicator_agent.contract_address) == 42 assert adjudicator_agent.contract_address == adjudicator_deployer.contract_address another_adjudicator_agent = AdjudicatorAgent(registry=test_registry) assert len(another_adjudicator_agent.contract_address) == 42 assert another_adjudicator_agent.contract_address == adjudicator_deployer.contract_address == adjudicator_agent.contract_address # StakingEscrow staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry) with pytest.raises(BaseContractDeployer.ContractDeploymentError): assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED assert not staking_escrow_deployer.is_deployed() staking_escrow_deployer.deploy(progress=deployment_progress, deployment_mode=constants.FULL, transacting_power=tpower) assert staking_escrow_deployer.is_deployed() assert len(staking_escrow_deployer.contract_address) == 42 staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) assert len(staking_agent.contract_address) == 42 assert staking_agent.contract_address == staking_escrow_deployer.contract_address another_staking_agent = staking_escrow_deployer.make_agent() assert len(another_staking_agent.contract_address) == 42 assert another_staking_agent.contract_address == staking_escrow_deployer.contract_address == staking_agent.contract_address # overall deployment steps must match aggregated individual expected number of steps all_deployment_transactions = token_deployer.deployment_steps + staking_escrow_deployer.init_steps + \ staking_escrow_deployer.deployment_steps + \ policy_manager_deployer.deployment_steps + adjudicator_deployer.deployment_steps assert deployment_progress.num_steps == len(all_deployment_transactions)
def 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 _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 mock_policy_manager_deployer(mock_miner_agent): policy_manager_deployer = PolicyManagerDeployer( miner_agent=mock_miner_agent) policy_manager_deployer.arm() policy_manager_deployer.deploy() yield policy_manager_deployer
def estimate_gas(): solidity_compiler = SolidityCompiler(test_contract_dir=CONTRACTS_DIR) # create a temporary registrar for the tester blockchain temporary_registry = TemporaryEthereumContractRegistry() # Configure a custom provider overrides = {'gas_limit': 4626271} pyevm_backend = OverridablePyEVMBackend(genesis_overrides=overrides) eth_tester = EthereumTester(backend=pyevm_backend, auto_mine_transactions=True) pyevm_provider = EthereumTesterProvider(ethereum_tester=eth_tester) # Use the the custom provider and registrar to init an interface circumflex = DeployerCircumflex( compiler=solidity_compiler, # freshly recompile registry=temporary_registry, # use temporary registrar providers=(pyevm_provider, )) # use custom test provider # Create the blockchain testerchain = TesterBlockchain(interface=circumflex, test_accounts=10) origin, ursula1, ursula2, ursula3, alice1, *everyone_else = testerchain.interface.w3.eth.accounts circumflex.deployer_address = origin # Set the deployer address from a freshly created test account 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() web3 = testerchain.interface.w3 print("Estimate gas:") # Pre deposit tokens tx = token_agent.contract.functions.approve(miner_agent.contract_address, constants.MIN_ALLOWED_LOCKED * 5)\ .transact({'from': origin}) testerchain.wait_for_receipt(tx) print("Pre-deposit tokens for 5 owners = " + str( miner_agent.contract.functions.preDeposit( everyone_else[0:5], [int(constants.MIN_ALLOWED_LOCKED)] * 5, [int(constants.MIN_LOCKED_PERIODS)] * 5).estimateGas({'from': origin}))) # Give Ursula and Alice some coins print("Transfer tokens = " + str( token_agent.contract.functions.transfer( ursula1, constants.MIN_ALLOWED_LOCKED * 10).estimateGas({'from': origin}))) tx = token_agent.contract.functions.transfer( ursula1, constants.MIN_ALLOWED_LOCKED * 10).transact({'from': origin}) testerchain.wait_for_receipt(tx) tx = token_agent.contract.functions.transfer( ursula2, constants.MIN_ALLOWED_LOCKED * 10).transact({'from': origin}) testerchain.wait_for_receipt(tx) tx = token_agent.contract.functions.transfer( ursula3, constants.MIN_ALLOWED_LOCKED * 10).transact({'from': origin}) testerchain.wait_for_receipt(tx) # Ursula and Alice give Escrow rights to transfer print("Approving transfer = " + str( token_agent.contract.functions.approve( miner_agent.contract_address, constants.MIN_ALLOWED_LOCKED * 6).estimateGas({'from': ursula1}))) tx = token_agent.contract.functions.approve(miner_agent.contract_address, constants.MIN_ALLOWED_LOCKED * 6)\ .transact({'from': ursula1}) testerchain.wait_for_receipt(tx) tx = token_agent.contract.functions.approve(miner_agent.contract_address, constants.MIN_ALLOWED_LOCKED * 6)\ .transact({'from': ursula2}) testerchain.wait_for_receipt(tx) tx = token_agent.contract.functions.approve(miner_agent.contract_address, constants.MIN_ALLOWED_LOCKED * 6)\ .transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Ursula and Alice transfer some tokens to the escrow and lock them print("First initial deposit tokens = " + str( miner_agent.contract.functions.deposit( constants.MIN_ALLOWED_LOCKED * 3, int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.deposit(constants.MIN_ALLOWED_LOCKED * 3, int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second initial deposit tokens = " + str( miner_agent.contract.functions.deposit( constants.MIN_ALLOWED_LOCKED * 3, int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.deposit(constants.MIN_ALLOWED_LOCKED * 3, int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third initial deposit tokens = " + str( miner_agent.contract.functions.deposit( constants.MIN_ALLOWED_LOCKED * 3, int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula3}))) tx = miner_agent.contract.functions.deposit(constants.MIN_ALLOWED_LOCKED * 3, int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Wait 1 period and confirm activity testerchain.time_travel(periods=1) print("First confirm activity = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second confirm activity = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula2}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third confirm activity = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula3}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula3}) testerchain.wait_for_receipt(tx) # Wait 1 period and mint tokens testerchain.time_travel(periods=1) print("First mining (1 stake) = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second mining (1 stake) = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third/last mining (1 stake) = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula3}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula3}) testerchain.wait_for_receipt(tx) print("First confirm activity again = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second confirm activity again = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula2}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third confirm activity again = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula3}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula3}) testerchain.wait_for_receipt(tx) # Confirm again testerchain.time_travel(periods=1) print("First confirm activity + mint = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second confirm activity + mint = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula2}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third confirm activity + mint = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula3}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula3}) testerchain.wait_for_receipt(tx) # Get locked tokens print("Getting locked tokens = " + str( miner_agent.contract.functions.getLockedTokens(ursula1).estimateGas())) # Wait 1 period and withdraw tokens testerchain.time_travel(periods=1) print("First withdraw = " + str( miner_agent.contract.functions.withdraw(1).estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.withdraw(1).transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second withdraw = " + str( miner_agent.contract.functions.withdraw(1).estimateGas( {'from': ursula2}))) tx = miner_agent.contract.functions.withdraw(1).transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third withdraw = " + str( miner_agent.contract.functions.withdraw(1).estimateGas( {'from': ursula3}))) tx = miner_agent.contract.functions.withdraw(1).transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Wait 1 period and confirm activity testerchain.time_travel(periods=1) print("First confirm activity after downtime = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second confirm activity after downtime = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula2}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third confirm activity after downtime = " + str(miner_agent.contract.functions.confirmActivity().estimateGas( {'from': ursula3}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula3}) testerchain.wait_for_receipt(tx) # Ursula and Alice deposit some tokens to the escrow again print("First deposit tokens again = " + str( miner_agent.contract.functions.deposit( constants.MIN_ALLOWED_LOCKED * 2, int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.deposit(constants.MIN_ALLOWED_LOCKED * 2, int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second deposit tokens again = " + str( miner_agent.contract.functions.deposit( constants.MIN_ALLOWED_LOCKED * 2, int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.deposit(constants.MIN_ALLOWED_LOCKED * 2, int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third deposit tokens again = " + str( miner_agent.contract.functions.deposit( constants.MIN_ALLOWED_LOCKED * 2, int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula3}))) tx = miner_agent.contract.functions.deposit(constants.MIN_ALLOWED_LOCKED * 2, int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Wait 1 period and mint tokens testerchain.time_travel(periods=1) print("First mining again = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second mining again = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third/last mining again = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula3}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Create policy policy_id_1 = os.urandom(int(constants.POLICY_ID_LENGTH)) policy_id_2 = os.urandom(int(constants.POLICY_ID_LENGTH)) number_of_periods = 10 print("First creating policy (1 node, 10 periods) = " + str( policy_agent.contract.functions.createPolicy( policy_id_1, number_of_periods, 0, [ursula1]).estimateGas( { 'from': alice1, 'value': 10000 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_1, number_of_periods, 0, [ursula1])\ .transact({'from': alice1, 'value': 10000}) testerchain.wait_for_receipt(tx) print("Second creating policy (1 node, 10 periods) = " + str( policy_agent.contract.functions.createPolicy( policy_id_2, number_of_periods, 0, [ursula1]).estimateGas( { 'from': alice1, 'value': 10000 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_2, number_of_periods, 0, [ursula1])\ .transact({'from': alice1, 'value': 10000}) testerchain.wait_for_receipt(tx) # Revoke policy print("Revoking policy = " + str( policy_agent.contract.functions.revokePolicy(policy_id_1).estimateGas( {'from': alice1}))) tx = policy_agent.contract.functions.revokePolicy(policy_id_1).transact( {'from': alice1}) testerchain.wait_for_receipt(tx) tx = policy_agent.contract.functions.revokePolicy(policy_id_2).transact( {'from': alice1}) testerchain.wait_for_receipt(tx) # Create policy with more periods policy_id_1 = os.urandom(int(constants.POLICY_ID_LENGTH)) policy_id_2 = os.urandom(int(constants.POLICY_ID_LENGTH)) policy_id_3 = os.urandom(int(constants.POLICY_ID_LENGTH)) number_of_periods = 100 print("First creating policy (1 node, " + str(number_of_periods) + " periods, first reward) = " + str( policy_agent.contract.functions.createPolicy( policy_id_1, number_of_periods, 50, [ursula2]).estimateGas( { 'from': alice1, 'value': 10050 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_1, number_of_periods, 50, [ursula2])\ .transact({'from': alice1, 'value': 10050}) testerchain.wait_for_receipt(tx) testerchain.time_travel(periods=1) print("Second creating policy (1 node, " + str(number_of_periods) + " periods, first reward) = " + str( policy_agent.contract.functions.createPolicy( policy_id_2, number_of_periods, 50, [ursula2]).estimateGas( { 'from': alice1, 'value': 10050 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_2, number_of_periods, 50, [ursula2])\ .transact({'from': alice1, 'value': 10050}) testerchain.wait_for_receipt(tx) print("Third creating policy (1 node, " + str(number_of_periods) + " periods, first reward) = " + str( policy_agent.contract.functions.createPolicy( policy_id_3, number_of_periods, 50, [ursula1]).estimateGas( { 'from': alice1, 'value': 10050 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_3, number_of_periods, 50, [ursula1])\ .transact({'from': alice1, 'value': 10050}) testerchain.wait_for_receipt(tx) # Mine and revoke policy testerchain.time_travel(periods=10) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) testerchain.time_travel(periods=1) print("First mining after downtime = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second mining after downtime = " + str( miner_agent.contract.functions.mint().estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.mint().transact({'from': ursula2}) testerchain.wait_for_receipt(tx) testerchain.time_travel(periods=10) print("First revoking policy after downtime = " + str( policy_agent.contract.functions.revokePolicy(policy_id_1).estimateGas( {'from': alice1}))) tx = policy_agent.contract.functions.revokePolicy(policy_id_1).transact( {'from': alice1}) testerchain.wait_for_receipt(tx) print("Second revoking policy after downtime = " + str( policy_agent.contract.functions.revokePolicy(policy_id_2).estimateGas( {'from': alice1}))) tx = policy_agent.contract.functions.revokePolicy(policy_id_2).transact( {'from': alice1}) testerchain.wait_for_receipt(tx) print("Second revoking policy after downtime = " + str( policy_agent.contract.functions.revokePolicy(policy_id_3).estimateGas( {'from': alice1}))) tx = policy_agent.contract.functions.revokePolicy(policy_id_3).transact( {'from': alice1}) testerchain.wait_for_receipt(tx) # Create policy with multiple nodes policy_id_1 = os.urandom(int(constants.POLICY_ID_LENGTH)) policy_id_2 = os.urandom(int(constants.POLICY_ID_LENGTH)) policy_id_3 = os.urandom(int(constants.POLICY_ID_LENGTH)) number_of_periods = 100 print("First creating policy (3 nodes, 100 periods, first reward) = " + str( policy_agent.contract.functions.createPolicy( policy_id_1, number_of_periods, 50, [ursula1, ursula2, ursula3]).estimateGas({ 'from': alice1, 'value': 30150 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_1, number_of_periods, 50, [ursula1, ursula2, ursula3])\ .transact({'from': alice1, 'value': 30150}) testerchain.wait_for_receipt(tx) print("Second creating policy (3 nodes, 100 periods, first reward) = " + str( policy_agent.contract.functions.createPolicy( policy_id_2, number_of_periods, 50, [ursula1, ursula2, ursula3]).estimateGas({ 'from': alice1, 'value': 30150 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_2, number_of_periods, 50, [ursula1, ursula2, ursula3])\ .transact({'from': alice1, 'value': 30150}) testerchain.wait_for_receipt(tx) print("Third creating policy (2 nodes, 100 periods, first reward) = " + str( policy_agent.contract.functions.createPolicy( policy_id_3, number_of_periods, 50, [ursula1, ursula2]).estimateGas({ 'from': alice1, 'value': 20100 }))) tx = policy_agent.contract.functions.createPolicy(policy_id_3, number_of_periods, 50, [ursula1, ursula2])\ .transact({'from': alice1, 'value': 20100}) testerchain.wait_for_receipt(tx) for index in range(5): tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula3}) testerchain.wait_for_receipt(tx) testerchain.time_travel(periods=1) tx = miner_agent.contract.functions.mint().transact({'from': ursula1}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.mint().transact({'from': ursula2}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.mint().transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Check regular deposit print("First deposit tokens = " + str( miner_agent.contract.functions.deposit( int(constants.MIN_ALLOWED_LOCKED), int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.deposit(int(constants.MIN_ALLOWED_LOCKED), int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second deposit tokens = " + str( miner_agent.contract.functions.deposit( int(constants.MIN_ALLOWED_LOCKED), int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.deposit(int(constants.MIN_ALLOWED_LOCKED), int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third deposit tokens = " + str( miner_agent.contract.functions.deposit( int(constants.MIN_ALLOWED_LOCKED), int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula3}))) tx = miner_agent.contract.functions.deposit(int(constants.MIN_ALLOWED_LOCKED), int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # ApproveAndCall testerchain.time_travel(periods=1) tx = miner_agent.contract.functions.mint().transact({'from': ursula1}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.mint().transact({'from': ursula2}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.mint().transact({'from': ursula3}) testerchain.wait_for_receipt(tx) print("First approveAndCall = " + str( token_agent.contract.functions.approveAndCall( miner_agent.contract_address, int(constants.MIN_ALLOWED_LOCKED) * 2, web3.toBytes(int(constants.MIN_LOCKED_PERIODS))).estimateGas( {'from': ursula1}))) tx = token_agent.contract.functions.approveAndCall(miner_agent.contract_address, int(constants.MIN_ALLOWED_LOCKED) * 2, web3.toBytes(int(constants.MIN_LOCKED_PERIODS)))\ .transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second approveAndCall = " + str( token_agent.contract.functions.approveAndCall( miner_agent.contract_address, int(constants.MIN_ALLOWED_LOCKED) * 2, web3.toBytes(int(constants.MIN_LOCKED_PERIODS))).estimateGas( {'from': ursula2}))) tx = token_agent.contract.functions.approveAndCall(miner_agent.contract_address, int(constants.MIN_ALLOWED_LOCKED) * 2, web3.toBytes(int(constants.MIN_LOCKED_PERIODS)))\ .transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third approveAndCall = " + str( token_agent.contract.functions.approveAndCall( miner_agent.contract_address, int(constants.MIN_ALLOWED_LOCKED) * 2, web3.toBytes(int(constants.MIN_LOCKED_PERIODS))).estimateGas( {'from': ursula3}))) tx = token_agent.contract.functions.approveAndCall(miner_agent.contract_address, int(constants.MIN_ALLOWED_LOCKED) * 2, web3.toBytes(int(constants.MIN_LOCKED_PERIODS)))\ .transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Locking tokens testerchain.time_travel(periods=1) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula2}) testerchain.wait_for_receipt(tx) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula3}) testerchain.wait_for_receipt(tx) print("First locking tokens = " + str( miner_agent.contract.functions.lock(int( constants.MIN_ALLOWED_LOCKED), int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula1}))) tx = miner_agent.contract.functions.lock(int(constants.MIN_ALLOWED_LOCKED), int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second locking tokens = " + str( miner_agent.contract.functions.lock(int( constants.MIN_ALLOWED_LOCKED), int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula2}))) tx = miner_agent.contract.functions.lock(int(constants.MIN_ALLOWED_LOCKED), int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula2}) testerchain.wait_for_receipt(tx) print("Third locking tokens = " + str( miner_agent.contract.functions.lock(int( constants.MIN_ALLOWED_LOCKED), int( constants.MIN_LOCKED_PERIODS)).estimateGas({'from': ursula3}))) tx = miner_agent.contract.functions.lock(int(constants.MIN_ALLOWED_LOCKED), int(constants.MIN_LOCKED_PERIODS))\ .transact({'from': ursula3}) testerchain.wait_for_receipt(tx) # Divide stake print("First divide stake = " + str( miner_agent.contract.functions.divideStake( 1, int(constants.MIN_ALLOWED_LOCKED), 2).estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.divideStake( 1, int(constants.MIN_ALLOWED_LOCKED), 2).transact({'from': ursula1}) testerchain.wait_for_receipt(tx) print("Second divide stake = " + str( miner_agent.contract.functions.divideStake( 3, int(constants.MIN_ALLOWED_LOCKED), 2).estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.divideStake( 3, int(constants.MIN_ALLOWED_LOCKED), 2).transact({'from': ursula1}) testerchain.wait_for_receipt(tx) # Divide almost finished stake testerchain.time_travel(periods=1) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) testerchain.time_travel(periods=1) print("Divide stake (next period is not confirmed) = " + str( miner_agent.contract.functions.divideStake( 0, int(constants.MIN_ALLOWED_LOCKED), 2).estimateGas( {'from': ursula1}))) tx = miner_agent.contract.functions.confirmActivity().transact( {'from': ursula1}) testerchain.wait_for_receipt(tx) print("Divide stake (next period is confirmed) = " + str( miner_agent.contract.functions.divideStake( 0, int(constants.MIN_ALLOWED_LOCKED), 2).estimateGas( {'from': ursula1}))) print("All done!")
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 simulate(config, action, nodes, federated_only, geth): """ Simulate the nucypher blockchain network Arguments ========== action - Which action to perform; The choices are: - start: Start a multi-process nucypher network simulation - stop: Stop a running simulation gracefully Options ======== --nodes - The quantity of nodes (processes) to execute during the simulation --duration = The number of periods to run the simulation before termination """ if action == 'start': # # Blockchain Connection # if not federated_only: if geth: test_provider_uri = "ipc:///tmp/geth.ipc" else: test_provider_uri = "pyevm://tester" simulation_registry = TemporaryEthereumContractRegistry() simulation_interface = BlockchainDeployerInterface(provider_uri=test_provider_uri, registry=simulation_registry, compiler=SolidityCompiler()) blockchain = TesterBlockchain(interface=simulation_interface, test_accounts=nodes, airdrop=False) accounts = blockchain.interface.w3.eth.accounts origin, *everyone_else = accounts # Set the deployer address from the freshly created test account simulation_interface.deployer_address = origin # # Blockchain Action # blockchain.ether_airdrop(amount=DEVELOPMENT_ETH_AIRDROP_AMOUNT) click.confirm("Deploy all nucypher contracts to {}?".format(test_provider_uri), abort=True) click.echo("Bootstrapping simulated blockchain network") # Deploy contracts token_deployer = NucypherTokenDeployer(blockchain=blockchain, deployer_address=origin) token_deployer.arm() token_deployer.deploy() token_agent = token_deployer.make_agent() miners_escrow_secret = os.urandom(DISPATCHER_SECRET_LENGTH) miner_escrow_deployer = MinerEscrowDeployer(token_agent=token_agent, deployer_address=origin, secret_hash=miners_escrow_secret) miner_escrow_deployer.arm() miner_escrow_deployer.deploy() miner_agent = miner_escrow_deployer.make_agent() policy_manager_secret = os.urandom(DISPATCHER_SECRET_LENGTH) policy_manager_deployer = PolicyManagerDeployer(miner_agent=miner_agent, deployer_address=origin, secret_hash=policy_manager_secret) policy_manager_deployer.arm() policy_manager_deployer.deploy() policy_agent = policy_manager_deployer.make_agent() airdrop_amount = DEVELOPMENT_TOKEN_AIRDROP_AMOUNT click.echo("Airdropping tokens {} to {} addresses".format(airdrop_amount, len(everyone_else))) _receipts = token_airdrop(token_agent=token_agent, origin=origin, addresses=everyone_else, amount=airdrop_amount) # Commit the current state of deployment to a registry file. click.echo("Writing filesystem registry") _sim_registry_name = blockchain.interface.registry.commit(filepath=DEFAULT_SIMULATION_REGISTRY_FILEPATH) click.echo("Ready to run swarm.") # # Swarm # # Select a port range to use on localhost for sim servers if not federated_only: sim_addresses = everyone_else else: sim_addresses = NotImplemented start_port = 8787 counter = 0 for sim_port_number, sim_address in enumerate(sim_addresses, start=start_port): # # Parse ursula parameters # rest_port = sim_port_number db_name = 'sim-{}'.format(rest_port) cli_exec = os.path.join(BASE_DIR, 'cli', 'main.py') python_exec = 'python' proc_params = ''' python3 {} run_ursula --rest-port {} --db-name {} '''.format(python_exec, cli_exec, rest_port, db_name).split() if federated_only: proc_params.append('--federated-only') else: token_agent = NucypherTokenAgent(blockchain=blockchain) miner_agent = MinerAgent(token_agent=token_agent) miner = Miner(miner_agent=miner_agent, checksum_address=sim_address) # stake a random amount min_stake, balance = MIN_ALLOWED_LOCKED, miner.token_balance value = random.randint(min_stake, balance) # for a random lock duration min_locktime, max_locktime = MIN_LOCKED_PERIODS, MAX_MINTING_PERIODS periods = random.randint(min_locktime, max_locktime) miner.initialize_stake(amount=value, lock_periods=periods) click.echo("{} Initialized new stake: {} tokens for {} periods".format(sim_address, value, periods)) proc_params.extend('--checksum-address {}'.format(sim_address).split()) # Spawn click.echo("Spawning node #{}".format(counter+1)) processProtocol = UrsulaProcessProtocol(command=proc_params) cli_exec = os.path.join(BASE_DIR, 'cli', 'main.py') ursula_proc = reactor.spawnProcess(processProtocol, cli_exec, proc_params) # # post-spawnProcess # # Start with some basic status data, then build on it rest_uri = "http://{}:{}".format('localhost', rest_port) sim_data = "Started simulated Ursula | ReST {}".format(rest_uri) rest_uri = "{host}:{port}".format(host='localhost', port=str(sim_port_number)) sim_data.format(rest_uri) # if not federated_only: # stake_infos = tuple(config.miner_agent.get_all_stakes(miner_address=sim_address)) # sim_data += '| ETH address {}'.format(sim_address) # sim_data += '| {} Active stakes '.format(len(stake_infos)) click.echo(sim_data) counter += 1 click.echo("Starting the reactor") click.confirm("Start the reactor?", abort=True) try: reactor.run() finally: if not federated_only: click.echo("Removing simulation registry") os.remove(DEFAULT_SIMULATION_REGISTRY_FILEPATH) click.echo("Stopping simulated Ursula processes") for process in config.sim_processes: os.kill(process.pid, 9) click.echo("Killed {}".format(process)) click.echo("Simulation completed") elif action == 'stop': # Kill the simulated ursulas for process in config.ursula_processes: process.transport.signalProcess('KILL') elif action == 'status': if not config.simulation_running: status_message = "Simulation not running." else: ursula_processes = len(config.ursula_processes) status_message = """ | Node Swarm Simulation Status | Simulation processes .............. {} """.format(ursula_processes) click.echo(status_message) elif action == 'demo': """Run the finnegans wake demo""" demo_exec = os.path.join(BASE_DIR, 'cli', 'demos', 'finnegans-wake-demo.py') process_args = [sys.executable, demo_exec] if federated_only: process_args.append('--federated-only') subprocess.run(process_args, stdout=subprocess.PIPE)
def simulate(config, action, nodes, federated_only): """ Simulate the nucypher blockchain network Arguments ========== action - Which action to perform; The choices are: - start: Start a multi-process nucypher network simulation - stop: Stop a running simulation gracefully Options ======== --nodes - The quantity of nodes (processes) to execute during the simulation --duration = The number of periods to run the simulation before termination """ if action == 'init': # OK, Try connecting to the blockchain click.echo("Connecting to provider endpoint") config.connect_to_blockchain() # Actual simulation setup logic one_million_eth = 10**6 * 10**18 click.echo("Airdropping {} ETH to {} test accounts".format( one_million_eth, len(config.accounts))) config.blockchain.ether_airdrop( amount=one_million_eth) # wei -> ether | 1 Million ETH # Fin click.echo("Blockchain initialized") if action == 'deploy': if config.simulation_running is True: raise RuntimeError("Network simulation already running") if not federated_only: config.connect_to_blockchain() click.confirm("Deploy all nucypher contracts to blockchain?", abort=True) click.echo("Bootstrapping simulated blockchain network") blockchain = TesterBlockchain.from_config() # TODO: Enforce Saftey - ensure this is "fake" # conditions = () assert True # Parse addresses etherbase, *everybody_else = blockchain.interface.w3.eth.accounts # Deploy contracts token_deployer = NucypherTokenDeployer(blockchain=blockchain, deployer_address=etherbase) token_deployer.arm() token_deployer.deploy() token_agent = token_deployer.make_agent() click.echo("Deployed {}:{}".format(token_agent.contract_name, token_agent.contract_address)) miner_escrow_deployer = MinerEscrowDeployer( token_agent=token_agent, deployer_address=etherbase) miner_escrow_deployer.arm() miner_escrow_deployer.deploy() miner_agent = miner_escrow_deployer.make_agent() click.echo("Deployed {}:{}".format(miner_agent.contract_name, miner_agent.contract_address)) policy_manager_deployer = PolicyManagerDeployer( miner_agent=miner_agent, deployer_address=etherbase) policy_manager_deployer.arm() policy_manager_deployer.deploy() policy_agent = policy_manager_deployer.make_agent() click.echo("Deployed {}:{}".format(policy_agent.contract_name, policy_agent.contract_address)) airdrop_amount = 1000000 * int(constants.M) click.echo("Airdropping tokens {} to {} addresses".format( airdrop_amount, len(everybody_else))) _receipts = token_airdrop(token_agent=token_agent, origin=etherbase, addresses=everybody_else, amount=airdrop_amount) click.echo("Connecting to deployed contracts") config.connect_to_contracts() # Commit the current state of deployment to a registry file. click.echo("Writing filesystem registry") _sim_registry_name = config.blockchain.interface._registry.commit( filepath=DEFAULT_SIMULATION_REGISTRY_FILEPATH) # Fin click.echo("Ready to simulate decentralized swarm.") else: click.echo("Ready to run federated swarm.") elif action == 'swarm': if not federated_only: config.connect_to_blockchain() config.connect_to_contracts(simulation=True) localhost = 'localhost' # Select a port range to use on localhost for sim servers start_port, stop_port = DEFAULT_SIMULATION_PORT, DEFAULT_SIMULATION_PORT + int( nodes) port_range = range(start_port, stop_port) click.echo("Selected local ports {}-{}".format(start_port, stop_port)) for index, sim_port_number in enumerate(port_range): # # Parse ursula parameters # rest_port, dht_port = sim_port_number, sim_port_number + 100 db_name = 'sim-{}'.format(rest_port) proc_params = ''' run_ursula --host {} --rest-port {} --dht-port {} --db-name {} '''.format(localhost, rest_port, dht_port, db_name).split() if federated_only: click.echo("Setting federated operating mode") proc_params.append('--federated-only') else: sim_address = config.accounts[index + 1] miner = Miner(miner_agent=config.miner_agent, checksum_address=sim_address) # stake a random amount min_stake, balance = constants.MIN_ALLOWED_LOCKED, miner.token_balance value = random.randint(min_stake, balance) # for a random lock duration min_locktime, max_locktime = constants.MIN_LOCKED_PERIODS, constants.MAX_MINTING_PERIODS periods = random.randint(min_locktime, max_locktime) miner.initialize_stake(amount=value, lock_periods=periods) click.echo( "{} Initialized new stake: {} tokens for {} periods". format(sim_address, value, periods)) proc_params.extend( '--checksum-address {}'.format(sim_address).split()) # Spawn click.echo("Spawning node #{}".format(index + 1)) processProtocol = UrsulaProcessProtocol(command=proc_params) ursula_proc = reactor.spawnProcess(processProtocol, "nucypher-cli", proc_params) config.sim_processes.append(ursula_proc) # # post-spawnProcess # # Start with some basic status data, then build on it rest_uri = "http://{}:{}".format(localhost, rest_port) dht_uri = "http://{}:{}".format(localhost, dht_port) sim_data = "Started simulated Ursula | ReST {} | DHT {} ".format( rest_uri, dht_uri) rest_uri = "{host}:{port}".format(host=localhost, port=str(sim_port_number)) dht_uri = '{host}:{port}'.format(host=localhost, port=dht_port) sim_data.format(rest_uri, dht_uri) if not federated_only: stake_infos = tuple( config.miner_agent.get_all_stakes( miner_address=sim_address)) sim_data += '| ETH address {}'.format(sim_address) sim_data += '| {} Active stakes '.format(len(stake_infos)) click.echo(sim_data) config.simulation_running = True click.echo("Starting the reactor") try: reactor.run() finally: if config.operating_mode == 'decentralized': click.echo("Removing simulation registry") os.remove(config.sim_registry_filepath) click.echo("Stopping simulated Ursula processes") for process in config.sim_processes: os.kill(process.pid, 9) click.echo("Killed {}".format(process)) config.simulation_running = False click.echo("Simulation stopped") elif action == 'stop': # Kill the simulated ursulas TODO: read PIDs from storage? if config.simulation_running is not True: raise RuntimeError("Network simulation is not running") for process in config.ursula_processes: process.transport.signalProcess('KILL') else: # TODO: Confirm they are dead config.simulation_running = False elif action == 'status': if not config.simulation_running: status_message = "Simulation not running." else: ursula_processes = len(config.ursula_processes) status_message = """ | Node Swarm Simulation Status | Simulation processes .............. {} """.format(ursula_processes) click.echo(status_message) elif action == 'demo': """Run the finnegans wake demo""" demo_exec = os.path.join(BASE_DIR, 'nucypher_cli', 'demos', 'finnegans-wake-demo.py') subprocess.run([sys.executable, demo_exec], stdout=subprocess.PIPE)