def testerchain(solidity_compiler):
"""
https: // github.com / ethereum / eth - tester # available-backends
"""
memory_registry = InMemoryEthereumContractRegistry()
# Use the the custom provider and registrar to init an interface
deployer_interface = BlockchainDeployerInterface(
compiler=solidity_compiler, # freshly recompile if not None
registry=memory_registry,
provider_uri='tester://pyevm')
# Create the blockchain
testerchain = TesterBlockchain(
interface=deployer_interface,
test_accounts=NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK,
airdrop=False)
origin, *everyone = testerchain.interface.w3.eth.accounts
deployer_interface.deployer_address = origin # Set the deployer address from a freshly created test account
testerchain.ether_airdrop(amount=1000000000) # TODO: Use test constant
yield testerchain
testerchain.sever_connection()
def test_rapid_deployment():
compiler = SolidityCompiler()
registry = InMemoryEthereumContractRegistry()
allocation_registry = InMemoryAllocationRegistry()
interface = BlockchainDeployerInterface(compiler=compiler,
registry=registry,
provider_uri='tester://pyevm')
blockchain = TesterBlockchain(interface=interface,
airdrop=False,
test_accounts=4)
blockchain.ether_airdrop(amount=1000000000)
origin, *everyone = blockchain.interface.w3.eth.accounts
deployer = Deployer(blockchain=blockchain, deployer_address=origin)
deployer_address, *all_yall = deployer.blockchain.interface.w3.eth.accounts
# The Big Three (+ Dispatchers)
deployer.deploy_network_contracts(miner_secret=os.urandom(32),
policy_secret=os.urandom(32))
# User Escrow Proxy
deployer.deploy_escrow_proxy(secret=os.urandom(32))
# Deploy User Escrow
total_allocations = 100
# Start with some hard-coded cases...
allocation_data = [{
'address': all_yall[1],
'amount': MAX_ALLOWED_LOCKED,
'duration': ONE_YEAR_IN_SECONDS
}, {
'address': all_yall[2],
'amount': MIN_ALLOWED_LOCKED,
'duration': ONE_YEAR_IN_SECONDS * 2
}, {
'address': all_yall[3],
'amount': MIN_ALLOWED_LOCKED * 100,
'duration': ONE_YEAR_IN_SECONDS * 3
}]
# Pile on the rest
for _ in range(total_allocations - len(allocation_data)):
random_password = ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.digits) for _ in range(16))
acct = w3.eth.account.create(random_password)
beneficiary_address = acct.address
amount = random.randint(MIN_ALLOWED_LOCKED, MAX_ALLOWED_LOCKED)
duration = random.randint(MIN_LOCKED_PERIODS, MAX_MINTING_PERIODS * 3)
random_allocation = {
'address': beneficiary_address,
'amount': amount,
'duration': duration
}
allocation_data.append(random_allocation)
deployer.deploy_beneficiary_contracts(
allocations=allocation_data, allocation_registry=allocation_registry)
def __init__(self,
test_accounts=None,
poa=True,
eth_airdrop=False,
free_transactions=False,
compiler: SolidityCompiler = None,
registry: EthereumContractRegistry = None,
*args, **kwargs):
if not test_accounts:
test_accounts = self._default_test_accounts
self.free_transactions = free_transactions
if compiler:
TesterBlockchain._compiler = compiler
super().__init__(provider_uri=self._PROVIDER_URI,
provider_process=None,
poa=poa,
compiler=self._compiler,
registry=registry or InMemoryEthereumContractRegistry(),
*args, **kwargs)
self.log = Logger("test-blockchain")
# Generate additional ethereum accounts for testing
population = test_accounts
enough_accounts = len(self.w3.eth.accounts) >= population
if not enough_accounts:
accounts_to_make = population - len(self.w3.eth.accounts)
self.__generate_insecure_unlocked_accounts(quantity=accounts_to_make)
assert test_accounts == len(self.w3.eth.accounts)
if eth_airdrop is True: # ETH for everyone!
self.ether_airdrop(amount=DEVELOPMENT_ETH_AIRDROP_AMOUNT)
def connect(cls, *args, **kwargs) -> 'TesterBlockchain':
interface = BlockchainDeployerInterface(provider_uri=cls._PROVIDER_URI,
compiler=SolidityCompiler(test_contract_dir=CONTRACT_ROOT),
registry=InMemoryEthereumContractRegistry())
testerchain = TesterBlockchain(interface=interface, *args, **kwargs)
return testerchain
def test_geth_deployment_integration(instant_geth_dev_node):
# TODO: Move to decorator
if 'CIRCLECI' in os.environ:
pytest.skip("Do not run Geth nodes in CI")
memory_registry = InMemoryEthereumContractRegistry()
blockchain = BlockchainDeployerInterface(
provider_process=instant_geth_dev_node, registry=memory_registry)
# Make Deployer
etherbase = to_checksum_address(instant_geth_dev_node.accounts[0].decode(
)) # TODO: Make property on nucypher geth node instances?
deployer = DeployerActor(
blockchain=blockchain,
deployer_address=etherbase,
client_password=None) # dev accounts have no password.
assert int(deployer.blockchain.client.chain_id) == 1337
# Deploy
secrets = dict()
for deployer_class in deployer.upgradeable_deployer_classes:
secrets[deployer_class.contract_name] = INSECURE_DEVELOPMENT_PASSWORD
deployer.deploy_network_contracts(secrets=secrets, interactive=False)
def testerchain(solidity_compiler):
"""
https: // github.com / ethereum / eth - tester # available-backends
"""
memory_registry = InMemoryEthereumContractRegistry()
# Use the the custom provider and registrar to init an interface
deployer_interface = BlockchainDeployerInterface(
compiler=solidity_compiler, # freshly recompile if not None
registry=memory_registry,
provider_uri=TEST_PROVIDER_URI)
# Create the blockchain
testerchain = TesterBlockchain(interface=deployer_interface,
eth_airdrop=True,
free_transactions=True,
poa=True)
# Set the deployer address from a freshly created test account
deployer_interface.deployer_address = testerchain.etherbase_account
yield testerchain
deployer_interface.disconnect()
testerchain.sever_connection()
def another_testerchain(solidity_compiler):
memory_registry = InMemoryEthereumContractRegistry()
deployer_interface = BlockchainDeployerInterface(
compiler=solidity_compiler,
registry=memory_registry,
provider_uri=TEST_PROVIDER_URI)
testerchain = TesterBlockchain(interface=deployer_interface,
test_accounts=2 *
NUMBER_OF_ETH_TEST_ACCOUNTS,
eth_airdrop=True)
deployer_interface.deployer_address = testerchain.etherbase_account
yield testerchain
testerchain.sever_connection()
def test_rapid_deployment(token_economics):
compiler = SolidityCompiler()
registry = InMemoryEthereumContractRegistry()
allocation_registry = InMemoryAllocationRegistry()
interface = BlockchainDeployerInterface(compiler=compiler,
registry=registry,
provider_uri='tester://pyevm')
blockchain = TesterBlockchain(interface=interface, airdrop=False, test_accounts=4)
deployer_address = blockchain.etherbase_account
deployer = Deployer(blockchain=blockchain, deployer_address=deployer_address)
# The Big Three (+ Dispatchers)
deployer.deploy_network_contracts(miner_secret=MINERS_ESCROW_DEPLOYMENT_SECRET,
policy_secret=POLICY_MANAGER_DEPLOYMENT_SECRET,
adjudicator_secret=MINING_ADJUDICATOR_DEPLOYMENT_SECRET)
# Deploy User Escrow, too (+ Linker)
deployer.deploy_escrow_proxy(secret=USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
total_allocations = NUMBER_OF_ALLOCATIONS_IN_TESTS
all_yall = blockchain.unassigned_accounts
# Start with some hard-coded cases...
allocation_data = [{'address': all_yall[1],
'amount': token_economics.maximum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS},
{'address': all_yall[2],
'amount': token_economics.minimum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS*2},
{'address': all_yall[3],
'amount': token_economics.minimum_allowed_locked*100,
'duration': ONE_YEAR_IN_SECONDS*3}
]
# Pile on the rest
for _ in range(total_allocations - len(allocation_data)):
random_password = ''.join(random.SystemRandom().choice(string.ascii_uppercase+string.digits) for _ in range(16))
acct = w3.eth.account.create(random_password)
beneficiary_address = acct.address
amount = random.randint(token_economics.minimum_allowed_locked, token_economics.maximum_allowed_locked)
duration = random.randint(token_economics.minimum_locked_periods*ONE_YEAR_IN_SECONDS,
(token_economics.maximum_locked_periods*ONE_YEAR_IN_SECONDS)*3)
random_allocation = {'address': beneficiary_address, 'amount': amount, 'duration': duration}
allocation_data.append(random_allocation)
deployer.deploy_beneficiary_contracts(allocations=allocation_data, allocation_registry=allocation_registry)
def deployed_blockchain():
#
# Interface
#
compiler = SolidityCompiler()
registry = InMemoryEthereumContractRegistry()
allocation_registry = InMemoryAllocationRegistry()
interface = BlockchainDeployerInterface(compiler=compiler,
registry=registry,
provider_uri=TEST_PROVIDER_URI)
#
# Blockchain
#
blockchain = TesterBlockchain(interface=interface,
airdrop=False,
test_accounts=5,
poa=True)
blockchain.ether_airdrop(amount=TESTING_ETH_AIRDROP_AMOUNT)
origin, *everyone = blockchain.interface.w3.eth.accounts
#
# Delpoyer
#
deployer = Deployer(blockchain=blockchain, deployer_address=origin)
deployer_address, *all_yall = deployer.blockchain.interface.w3.eth.accounts
# The Big Three (+ Dispatchers)
deployer.deploy_network_contracts(miner_secret=os.urandom(32),
policy_secret=os.urandom(32))
# User Escrow Proxy
deployer.deploy_escrow_proxy(secret=os.urandom(32))
# Start with some hard-coded cases...
allocation_data = [{
'address': all_yall[1],
'amount': MAX_ALLOWED_LOCKED,
'duration': ONE_YEAR_IN_SECONDS
}]
deployer.deploy_beneficiary_contracts(
allocations=allocation_data, allocation_registry=allocation_registry)
yield blockchain, deployer_address, registry
def deployed_blockchain(token_economics):
# Interface
compiler = SolidityCompiler()
registry = InMemoryEthereumContractRegistry()
allocation_registry = InMemoryAllocationRegistry()
interface = BlockchainDeployerInterface(compiler=compiler,
registry=registry,
provider_uri=TEST_PROVIDER_URI)
# Blockchain
blockchain = TesterBlockchain(interface=interface,
airdrop=True,
test_accounts=5,
poa=True)
deployer_address = blockchain.etherbase_account
# Deployer
deployer = Deployer(blockchain=blockchain,
deployer_address=deployer_address)
# The Big Three (+ Dispatchers)
deployer.deploy_network_contracts(miner_secret=os.urandom(32),
policy_secret=os.urandom(32),
adjudicator_secret=os.urandom(32))
# User Escrow Proxy
deployer.deploy_escrow_proxy(secret=os.urandom(32))
# Start with some hard-coded cases...
all_yall = blockchain.unassigned_accounts
allocation_data = [{
'address': all_yall[1],
'amount': token_economics.maximum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS
}]
deployer.deploy_beneficiary_contracts(
allocations=allocation_data, allocation_registry=allocation_registry)
yield blockchain, deployer_address, registry