def chain_init(ctx, chain_name):
"""
Prepare the current chain for migrations.
contract onto this chain as well as
"""
project = ctx.obj['PROJECT']
ensure_path_exists(project.migrations_dir)
# Determine which chain should be used.
if not chain_name:
chain_name = select_chain(project)
chain_section_name = "chain:{0}".format(chain_name)
if chain_name == 'testrpc':
ctx.abort("Cannot initialize the {0!r} chain".format(chain_name))
# The `mainnet` and `morden` chains have default configurations. If the
# user is working on one of these chains then we need to add the section
# header so that we can write new config to it.
if not project.config.has_section(chain_section_name):
project.config.add_section(chain_section_name)
chain = project.get_chain(chain_name)
if 'registrar' not in chain.chain_config:
# We need to deploy the registrar
with chain:
web3 = chain.web3
if chain_name in {'mainnet', 'morden'}:
show_chain_sync_progress(chain)
account = get_unlocked_deploy_from_address(chain)
# Configure web3 to now send from our chosen account by default
web3.eth.defaultAccount = account
# Deploy the registrar
RegistrarFactory = chain.RegistrarFactory
registrar = deploy_contract_and_verify(
chain,
contract_name='Registrar',
base_contract_factory=RegistrarFactory)
# TODO: set the value in the registrar.
# Write the registrar address to the chain config
project.config.set(chain_section_name, 'registrar',
registrar.address)
config_file_path = project.write_config()
click.echo("Wrote updated chain configuration to {0!r}".format(
config_file_path, ))
click.echo(
"The '{0}' blockchain is ready for migrations.".format(chain_name))
def chain_init(ctx, chain_name):
"""
Prepare the current chain for migrations.
contract onto this chain as well as
"""
project = ctx.obj['PROJECT']
ensure_path_exists(project.migrations_dir)
# Determine which chain should be used.
if not chain_name:
chain_name = select_chain(project)
chain_section_name = "chain:{0}".format(chain_name)
if chain_name == 'testrpc':
ctx.abort("Cannot initialize the {0!r} chain".format(chain_name))
# The `mainnet` and `morden` chains have default configurations. If the
# user is working on one of these chains then we need to add the section
# header so that we can write new config to it.
if not project.config.has_section(chain_section_name):
project.config.add_section(chain_section_name)
chain = project.get_chain(chain_name)
if 'registrar' not in chain.chain_config:
# We need to deploy the registrar
with chain:
web3 = chain.web3
if chain_name in {'mainnet', 'morden'}:
show_chain_sync_progress(chain)
account = get_unlocked_deploy_from_address(chain)
# Configure web3 to now send from our chosen account by default
web3.eth.defaultAccount = account
# Deploy the registrar
RegistrarFactory = chain.RegistrarFactory
registrar = deploy_contract_and_verify(chain,
contract_name='Registrar',
base_contract_factory=RegistrarFactory)
# TODO: set the value in the registrar.
# Write the registrar address to the chain config
project.config.set(chain_section_name, 'registrar', registrar.address)
config_file_path = project.write_config()
click.echo("Wrote updated chain configuration to {0!r}".format(
config_file_path,
))
click.echo("The '{0}' blockchain is ready for migrations.".format(
chain_name
))
def wrapper():
math_contract = deploy_contract_and_verify(
chain,
contract_name='Math',
ContractFactory=Math,
)
exports.append(math_contract)
print("~~{0}~~".format(math_contract.address))
def wrapper():
thrower_contract = deploy_contract_and_verify(
chain,
contract_name='ThrowsInConstructor',
ContractFactory=ThrowsInConstructor,
deploy_args=[True],
)
exports.append(thrower_contract)
print("~~{0}~~".format(thrower_contract.address))
def wrapper():
math_contract = deploy_contract_and_verify(
chain,
contract_name='Thrower',
base_contract_factory=Thrower,
deploy_arguments=[True],
)
exports.append(math_contract)
print("~~{0}~~".format(math_contract.address))
def deploy(project, logger, chain_name, wait_for_sync, contracts_to_deploy):
"""
Deploys the specified contracts to a chain.
"""
# Determine which chain should be used.
if not chain_name:
chain_name = select_chain(project)
compiled_contracts = project.compiled_contract_data
if contracts_to_deploy:
# validate that we *know* about all of the contracts
unknown_contracts = set(contracts_to_deploy).difference(
compiled_contracts.keys()
)
if unknown_contracts:
unknown_contracts_message = (
"Some contracts specified for deploy were not found in the "
"compiled project contracts. These contracts could not be found "
"'{0}'. Searched these known contracts '{1}'".format(
', '.join(sorted(unknown_contracts)),
', '.join(compiled_contracts.keys()),
)
)
raise click.ClickException(unknown_contracts_message)
else:
# prompt the user to select the desired contracts they want to deploy.
# Potentially display the currently deployed status.
contracts_to_deploy = [select_project_contract(project)]
with project.get_chain(chain_name) as chain:
provider = chain.provider
registrar = chain.registrar
# wait for the chain to start syncing.
if wait_for_sync:
logger.info("Waiting for chain to start syncing....")
while chain.wait.for_syncing() and is_synced(chain.web3):
time.sleep(1)
logger.info("Chain sync complete")
# Get the deploy order.
deploy_order = get_deploy_order(
contracts_to_deploy,
compiled_contracts,
)
# Display Start Message Info.
starting_msg = (
"Beginning contract deployment. Deploying {0} total contracts ({1} "
"Specified, {2} because of library dependencies)."
"\n\n" +
(" > ".join(deploy_order))
).format(
len(deploy_order),
len(contracts_to_deploy),
len(deploy_order) - len(contracts_to_deploy),
)
logger.info(starting_msg)
for contract_name in deploy_order:
if not provider.are_contract_dependencies_available(contract_name):
raise ValueError(
"Something is wrong with the deploy order. Some "
"dependencies for {0} are not "
"available.".format(contract_name)
)
# Check if we already have an existing deployed version of that
# contract (via the registry). For each of these, prompt the user
# if they would like to use the existing version.
if provider.is_contract_available(contract_name):
# TODO: this block should be a standalone cli util.
# TODO: this block needs to use the `Provider` API
existing_contract_instance = provider.get_contract(contract_name)
found_existing_contract_prompt = (
"Found existing version of {name} in registrar. "
"Would you like to use the previously deployed "
"contract @ {address}?".format(
name=contract_name,
address=existing_contract_instance.address,
)
)
if click.prompt(found_existing_contract_prompt, default=True):
continue
# We don't have an existing version of this contract available so
# deploy it.
contract_instance = deploy_contract_and_verify(
chain,
contract_name=contract_name,
)
# Store the contract address for linking of subsequent deployed contracts.
registrar.set_contract_address(contract_name, contract_instance.address)
# TODO: fix this message.
success_msg = (
"Deployment Successful."
)
logger.info(success_msg)
def deploy(ctx, chain_name, contracts_to_deploy):
"""
Deploys the specified contracts to a chain.
"""
project = ctx.obj['PROJECT']
# Determine which chain should be used.
if not chain_name:
chain_name = select_chain(project)
compiled_contracts = project.compiled_contracts
if contracts_to_deploy:
# validate that we *know* about all of the contracts
unknown_contracts = set(contracts_to_deploy).difference(
compiled_contracts.keys())
if unknown_contracts:
unknown_contracts_message = (
"Some contracts specified for deploy were not found in the "
"compiled project contracts. These contracts could not be found "
"'{0}'. Searched these known contracts '{1}'".format(
', '.join(sorted(unknown_contracts)),
', '.join(sorted(compiled_contracts.keys())),
))
raise click.ClickException(unknown_contracts_message)
else:
# prompt the user to select the desired contracts they want to deploy.
# Potentially display the currently deployed status.
contracts_to_deploy = [select_project_contract(project)]
chain = project.get_chain(chain_name)
deployed_contracts = OrderedDict()
with chain:
if chain_name in {'mainnet', 'morden'}:
show_chain_sync_progress(chain)
# Get the deploy order.
deploy_order = get_deploy_order(
contracts_to_deploy,
compiled_contracts,
)
# Display Start Message Info.
starting_msg = (
"Beginning contract deployment. Deploying {0} total contracts ({1} "
"Specified, {2} because of library dependencies)."
"\n\n" + (" > ".join(deploy_order.keys()))).format(
len(deploy_order),
len(contracts_to_deploy),
len(deploy_order) - len(contracts_to_deploy),
)
click.echo(starting_msg)
for contract_name, _ in deploy_order.items():
link_dependencies = {
contract_name: contract.address
for contract_name, contract in deployed_contracts.items()
}
contract_factory = chain.contract_factories[contract_name]
# Check if we already have an existing deployed version of that
# contract (via the registry). For each of these, prompt the user
# if they would like to use the existing version.
if contract_name not in contracts_to_deploy and chain.has_registrar:
# TODO: this block should be a standalone cli util.
existing_contract = get_contract_from_registrar(
chain=chain,
contract_name=contract_name,
contract_factory=contract_factory,
link_dependencies=link_dependencies,
)
if existing_contract:
found_existing_contract_prompt = (
"Found existing version of {name} in registrar. "
"Would you like to use the previously deployed "
"contract @ {address}?".format(
name=contract_name,
address=existing_contract.address,
))
if click.prompt(found_existing_contract_prompt):
deployed_contracts[contract_name] = existing_contract
continue
# We don't have an existing version of this contract available so
# deploy it.
contract = deploy_contract_and_verify(
chain,
contract_name=contract_name,
link_dependencies=link_dependencies,
)
if chain.has_registrar:
# TODO: this block should be a standalone cli util.
contract_key = 'contract/{name}'.format(name=contract_name)
register_txn_hash = chain.registrar.transact().setAddress(
contract_key, contract.address)
register_msg = ("Registering contract '{name}' @ {address} "
"in registrar in txn: {txn_hash} ...".format(
name=contract_name,
address=contract.address,
txn_hash=register_txn_hash,
))
click.echo(register_msg, nl=False)
chain.wait.for_receipt(register_txn_hash, timeout=180)
click.echo(' DONE')
deployed_contracts[contract_name] = contract
# TODO: fix this message.
success_msg = ("Deployment Successful.")
click.echo(success_msg)
def deploy(ctx, chain_name, deploy_from, contracts_to_deploy):
"""
Deploys the specified contracts to a chain.
"""
project = ctx.obj['PROJECT']
# Determine which chain should be used.
if not chain_name:
chain_name = select_chain(project)
compiled_contracts = project.compiled_contracts
if contracts_to_deploy:
# validate that we *know* about all of the contracts
unknown_contracts = set(contracts_to_deploy).difference(
compiled_contracts.keys()
)
if unknown_contracts:
unknown_contracts_message = (
"Some contracts specified for deploy were not found in the "
"compiled project contracts. These contracts could not be found "
"'{0}'. Searched these known contracts '{1}'".format(
', '.join(sorted(unknown_contracts)),
', '.join(sorted(compiled_contracts.keys())),
)
)
raise click.ClickException(unknown_contracts_message)
else:
# prompt the user to select the desired contracts they want to deploy.
# Potentially display the currently deployed status.
contracts_to_deploy = [select_project_contract(project)]
chain = project.get_chain(chain_name)
deployed_contracts = OrderedDict()
with chain:
web3 = chain.web3
if chain_name in {'mainnet', 'morden'}:
show_chain_sync_progress(chain)
if deploy_from is None:
deploy_from = get_unlocked_deploy_from_address(chain)
elif deploy_from not in web3.eth.accounts:
try:
deploy_from = web3.eth.accounts[int(deploy_from)]
except IndexError:
raise click.ClickException(
"Unknown deploy_from account: {0}".format(deploy_from)
)
web3.eth.defaultAccount = deploy_from
# Get the deploy order.
deploy_order = get_deploy_order(
contracts_to_deploy,
compiled_contracts,
)
# Display Start Message Info.
starting_msg = (
"Beginning contract deployment. Deploying {0} total contracts ({1} "
"Specified, {2} because of library dependencies)."
"\n\n" +
(" > ".join(deploy_order.keys()))
).format(
len(deploy_order),
len(contracts_to_deploy),
len(deploy_order) - len(contracts_to_deploy),
)
click.echo(starting_msg)
for contract_name, _ in deploy_order.items():
link_dependencies = {
contract_name: contract.address
for contract_name, contract
in deployed_contracts.items()
}
contract_factory = chain.contract_factories[contract_name]
# Check if we already have an existing deployed version of that
# contract (via the registry). For each of these, prompt the user
# if they would like to use the existing version.
if contract_name not in contracts_to_deploy and chain.has_registrar:
# TODO: this block should be a standalone cli util.
existing_contract = get_contract_from_registrar(
chain=chain,
contract_name=contract_name,
contract_factory=contract_factory,
link_dependencies=link_dependencies,
)
if existing_contract:
found_existing_contract_prompt = (
"Found existing version of {name} in registrar. "
"Would you like to use the previously deployed "
"contract @ {address}?".format(
name=contract_name,
address=existing_contract.address,
)
)
if click.prompt(found_existing_contract_prompt):
deployed_contracts[contract_name] = existing_contract
continue
# We don't have an existing version of this contract available so
# deploy it.
contract = deploy_contract_and_verify(
chain,
contract_name=contract_name,
link_dependencies=link_dependencies,
)
if chain.has_registrar:
# TODO: this block should be a standalone cli util.
contract_key = 'contract/{name}'.format(name=contract_name)
register_txn_hash = chain.registrar.transact().setAddress(
contract_key, contract.address
)
register_msg = (
"Registering contract '{name}' @ {address} "
"in registrar in txn: {txn_hash} ...".format(
name=contract_name,
address=contract.address,
txn_hash=register_txn_hash,
)
)
click.echo(register_msg, nl=False)
chain.wait.for_receipt(register_txn_hash, timeout=180)
click.echo(' DONE')
deployed_contracts[contract_name] = contract
# TODO: fix this message.
success_msg = (
"Deployment Successful."
)
click.echo(success_msg)
def deploy(project, logger, chain_name, wait_for_sync, contracts_to_deploy):
"""
Deploys the specified contracts to a chain.
"""
# Determine which chain should be used.
if not chain_name:
chain_name = select_chain(project)
compiled_contracts = project.compiled_contract_data
if contracts_to_deploy:
# validate that we *know* about all of the contracts
unknown_contracts = set(contracts_to_deploy).difference(
compiled_contracts.keys())
if unknown_contracts:
unknown_contracts_message = (
"Some contracts specified for deploy were not found in the "
"compiled project contracts. These contracts could not be found "
"'{0}'. Searched these known contracts '{1}'".format(
', '.join(sorted(unknown_contracts)),
', '.join(compiled_contracts.keys()),
))
raise click.ClickException(unknown_contracts_message)
else:
# prompt the user to select the desired contracts they want to deploy.
# Potentially display the currently deployed status.
contracts_to_deploy = [select_project_contract(project)]
with project.get_chain(chain_name) as chain:
provider = chain.provider
registrar = chain.registrar
# wait for the chain to start syncing.
if wait_for_sync:
logger.info("Waiting for chain to start syncing....")
while chain.wait.for_syncing() and is_synced(chain.web3):
time.sleep(1)
logger.info("Chain sync complete")
# Get the deploy order.
deploy_order = get_deploy_order(
contracts_to_deploy,
compiled_contracts,
)
# Display Start Message Info.
starting_msg = (
"Beginning contract deployment. Deploying {0} total contracts ({1} "
"Specified, {2} because of library dependencies)."
"\n\n" + (" > ".join(deploy_order))).format(
len(deploy_order),
len(contracts_to_deploy),
len(deploy_order) - len(contracts_to_deploy),
)
logger.info(starting_msg)
for contract_name in deploy_order:
if not provider.are_contract_dependencies_available(contract_name):
raise ValueError(
"Something is wrong with the deploy order. Some "
"dependencies for {0} are not "
"available.".format(contract_name))
# Check if we already have an existing deployed version of that
# contract (via the registry). For each of these, prompt the user
# if they would like to use the existing version.
if provider.is_contract_available(contract_name):
# TODO: this block should be a standalone cli util.
# TODO: this block needs to use the `Provider` API
existing_contract_instance = provider.get_contract(
contract_name)
found_existing_contract_prompt = (
"Found existing version of {name} in registrar. "
"Would you like to use the previously deployed "
"contract @ {address}?".format(
name=contract_name,
address=existing_contract_instance.address,
))
if click.prompt(found_existing_contract_prompt, default=True):
continue
# We don't have an existing version of this contract available so
# deploy it.
contract_instance = deploy_contract_and_verify(
chain,
contract_name=contract_name,
)
# Store the contract address for linking of subsequent deployed contracts.
registrar.set_contract_address(contract_name,
contract_instance.address)
# TODO: fix this message.
success_msg = ("Deployment Successful.")
logger.info(success_msg)
def wrapper():
math_contract = deploy_contract_and_verify(
chain, contract_name="Thrower", base_contract_factory=Thrower, deploy_arguments=[True]
)
exports.append(math_contract)
print("~~{0}~~".format(math_contract.address))
def wrapper():
math_contract = deploy_contract_and_verify(chain, contract_name="Math", base_contract_factory=Math)
exports.append(math_contract)
print("~~{0}~~".format(math_contract.address))