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 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
def deploy(click_config, action, poa, provider_uri, deployer_address,
contract_name, allocation_infile, allocation_outfile,
registry_infile, registry_outfile, no_compile, amount,
recipient_address, config_root, force):
"""Manage contract and registry deployment"""
# Ensure config root exists, because we need a default place to put outfiles.
config_root = config_root or DEFAULT_CONFIG_ROOT
if not os.path.exists(config_root):
os.makedirs(config_root)
# Establish a contract Registry
registry, registry_filepath = None, (registry_outfile or registry_infile)
if registry_filepath is not None:
registry = EthereumContractRegistry(
registry_filepath=registry_filepath)
# Connect to Blockchain
blockchain = Blockchain.connect(provider_uri=provider_uri,
registry=registry,
deployer=True,
compile=not no_compile,
poa=poa)
# OK - Let's init a Deployment actor
if not deployer_address:
etherbase = blockchain.interface.w3.eth.accounts[0]
deployer_address = etherbase # TODO: Make this required instead, perhaps interactive
click.confirm(
"Deployer Address is {} - Continue?".format(deployer_address),
abort=True)
deployer = Deployer(blockchain=blockchain,
deployer_address=deployer_address)
# The Big Three
if action == "contracts":
secrets = click_config.collect_deployment_secrets()
# Track tx hashes, and new agents
__deployment_transactions = dict()
__deployment_agents = dict()
if force:
deployer.blockchain.interface.registry._destroy()
try:
txhashes, agents = deployer.deploy_network_contracts(
miner_secret=bytes(secrets.miner_secret, encoding='utf-8'),
policy_secret=bytes(secrets.policy_secret, encoding='utf-8'),
adjudicator_secret=bytes(secrets.mining_adjudicator_secret,
encoding='utf-8'))
except BlockchainInterface.InterfaceError:
raise # TODO: Handle registry management here (contract may already exist)
else:
__deployment_transactions.update(txhashes)
# User Escrow Proxy
deployer.deploy_escrow_proxy(
secret=bytes(secrets.escrow_proxy_secret, encoding='utf-8'))
click.secho("Deployed!", fg='green', bold=True)
#
# Deploy Single Contract
#
if contract_name:
try:
deployer_func = deployer.deployers[contract_name]
except KeyError:
message = "No such contract {}. Available contracts are {}".format(
contract_name, deployer.deployers.keys())
click.secho(message, fg='red', bold=True)
raise click.Abort()
else:
_txs, _agent = deployer_func()
registry_outfile = deployer.blockchain.interface.registry.filepath
click.secho(
'\nDeployment Transaction Hashes for {}'.format(registry_outfile),
bold=True,
fg='blue')
for contract_name, transactions in __deployment_transactions.items():
heading = '\n{} ({})'.format(
contract_name, agents[contract_name].contract_address)
click.secho(heading, bold=True)
click.echo('*' * (42 + 3 + len(contract_name)))
total_gas_used = 0
for tx_name, txhash in transactions.items():
receipt = deployer.blockchain.wait_for_receipt(txhash=txhash)
total_gas_used += int(receipt['gasUsed'])
if receipt['status'] == 1:
click.secho("OK", fg='green', nl=False, bold=True)
else:
click.secho("Failed", fg='red', nl=False, bold=True)
click.secho(" | {}".format(tx_name), fg='yellow', nl=False)
click.secho(" | {}".format(txhash.hex()),
fg='yellow',
nl=False)
click.secho(" ({} gas)".format(receipt['cumulativeGasUsed']))
click.secho("Block #{} | {}\n".format(
receipt['blockNumber'], receipt['blockHash'].hex()))
click.secho(
"Cumulative Gas Consumption: {} gas\n".format(total_gas_used),
bold=True,
fg='blue')
elif action == "allocations":
if not allocation_infile:
allocation_infile = click.prompt("Enter allocation data filepath")
click.confirm("Continue deploying and allocating?", abort=True)
deployer.deploy_beneficiaries_from_file(
allocation_data_filepath=allocation_infile,
allocation_outfile=allocation_outfile)
elif action == "transfer":
token_agent = NucypherTokenAgent(blockchain=blockchain)
click.confirm(
f"Transfer {amount} from {token_agent.contract_address} to {recipient_address}?",
abort=True)
txhash = token_agent.transfer(
amount=amount,
sender_address=token_agent.contract_address,
target_address=recipient_address)
click.secho(f"OK | {txhash}")
return
elif action == "destroy-registry":
registry_filepath = deployer.blockchain.interface.registry.filepath
click.confirm(
f"Are you absolutely sure you want to destroy the contract registry at {registry_filepath}?",
abort=True)
os.remove(registry_filepath)
click.secho(f"Successfully destroyed {registry_filepath}", fg='red')
else:
raise click.BadArgumentUsage(message=f"Unknown action '{action}'")