def deploy(sudo_flag, build_flag, up_flag, rollup, password):
# Stop running Arbitrum containers
halt_docker(sudo_flag)
states_path = os.path.abspath(
os.path.join("rollups", rollup, "validator%s"))
n_validators = 1
while True:
if not os.path.exists(states_path % n_validators):
break
n_validators += 1
# Overwrite DOCKER_COMPOSE_FILENAME
compose = os.path.abspath("./" + DOCKER_COMPOSE_FILENAME)
contents = ""
for i in range(0, n_validators):
with open(os.path.join(states_path % i, "config.json")) as json_file:
data = json.load(json_file)
rollup_address = data["rollup_address"]
extra_flags = ""
eth_url = (data["eth_url"].replace("localhost",
"arb-bridge-eth-geth").replace(
"localhost",
"arb-bridge-eth-geth"))
if not password and "password" in data:
extra_flags += " -password="******"password"]
elif password:
extra_flags += " -password="******"arb_deploy requires validator password through [--password=pass] parameter or in config.json file"
)
if i == 0:
contents = compose_header(states_path % 0, extra_flags, eth_url,
rollup_address)
else:
if "blocktime" in data:
extra_flags += " -blocktime=%s" % data["blocktime"]
contents += compose_validator(i, states_path % i, extra_flags,
eth_url, rollup_address)
with open(compose, "w") as f:
f.write(contents)
# Build
if not up_flag or build_flag:
if build_validator_docker.build_validator(sudo_flag) != 0:
exit(1)
# Run
if not build_flag or up_flag:
print("Deploying", n_validators, "validators for rollup",
rollup_address)
run("docker-compose -f %s up" % compose, sudo=sudo_flag)
def build_node(sudo_flag=False):
node_root = os.path.abspath(os.path.join(ROOT_DIR, "packages"))
bootstrap_build_cache("arb-avm-cpp", sudo_flag)
bootstrap_build_cache("arb-node", sudo_flag)
run("git -C %s submodule update --init --recursive" % ROOT_DIR)
return run(
"docker build -t arb-node -f %s/arb-node.Dockerfile %s" %
(node_root, node_root),
sudo=sudo_flag,
)
def bootstrap_build_cache(name, sudo_flag):
if (run(
"docker images -q %s" % name,
capture_stdout=True,
quiet=True,
sudo=sudo_flag,
) == ""):
run("mkdir -p .tmp")
run('echo "%s" > .tmp/Dockerfile' % DOCKERFILE_CACHE)
run("docker build -t %s .tmp" % name, sudo=sudo_flag)
run("rm -rf .tmp")
def halt_docker(sudo_flag):
# Check for DOCKER_COMPOSE_FILENAME and halt if running
if os.path.isfile("./" + DOCKER_COMPOSE_FILENAME):
run(
"docker-compose -f ./%s down -t 0" % DOCKER_COMPOSE_FILENAME,
sudo=sudo_flag,
capture_stdout=True,
)
# Kill and rm all docker containers and images created by any `arb-deploy`
ps = "grep -e 'arb-validator' | awk '{ print $1 }'"
if run(
"docker ps | " + ps, capture_stdout=True, quiet=True,
sudo=sudo_flag) != "":
run(
"docker kill $(" + ("sudo " if sudo_flag else "") +
"docker ps | " + ps + ")",
capture_stdout=True,
sudo=sudo_flag,
)
run(
"docker rm $(" + ("sudo " if sudo_flag else "") +
"docker ps -a | " + ps + ")",
capture_stdout=True,
sudo=sudo_flag,
)
def build_validator(sudo_flag=False):
validator_root = os.path.abspath(os.path.join(ROOT_DIR, "packages"))
bootstrap_build_cache("arb-avm-cpp", sudo_flag)
bootstrap_build_cache("arb-validator", sudo_flag)
return run(
"docker build -t arb-validator -f %s/arb-validator.Dockerfile %s"
% (validator_root, validator_root),
sudo=sudo_flag,
)
def main():
run("./scripts/create-network")
parser = argparse.ArgumentParser(prog=NAME, description=DESCRIPTION)
# Required
parser.add_argument("rollup",
type=str,
help="The address of the rollup chain.")
parser.add_argument("-p",
"--password",
help="Password protecting validator keys.")
# Optional
parser.add_argument(
"-s",
"--sudo",
action="store_true",
dest="sudo",
help="Run docker-compose with sudo",
)
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--build",
action="store_true",
dest="build",
help="Run docker-compose build only",
)
group.add_argument("--up",
action="store_true",
dest="up",
help="Run docker-compose up only")
args = parser.parse_args()
# Deploy
deploy(args.sudo, args.build, args.up, args.rollup, args.password)
def setup_validator_states_ethbridge(contract, n_validators, sudo=False):
keys = "keys.json"
ethaddrs = "bridge_eth_addresses.json"
layer = run("docker create arb-bridge-eth",
capture_stdout=True,
quiet=True,
sudo=sudo).strip()
if layer == "":
print("Docker image arb-bridge-eth does not exist")
return
run(
"docker cp %s:/home/user/bridge_eth_addresses.json %s" %
(layer, ethaddrs),
sudo=sudo,
)
run("docker cp %s:/home/user/keys.json %s" % (layer, keys), sudo=sudo)
run("docker rm %s" % layer, quiet=True, sudo=sudo)
setup_validator_states(contract, n_validators, keys, ethaddrs)
os.remove(keys)
os.remove(ethaddrs)
def is_built(sudo_flag=False):
layer = run("docker create arb-node",
capture_stdout=True,
quiet=True,
sudo=sudo_flag).strip()
return layer != ""
def deploy(args, sudo_flag=False):
if not args.nobuild:
if build_validator_docker.build_validator(sudo_flag) != 0:
exit(1)
if os.path.isdir(setup_states.VALIDATOR_STATES):
shutil.rmtree(setup_states.VALIDATOR_STATES)
if args.is_parity:
image_name = "arb-bridge-eth"
ws_port = 7546
elif args.is_ganache:
image_name = "arb-bridge-eth-ganache"
ws_port = 7545
elif args.is_geth:
image_name = "arb-bridge-eth-geth"
ws_port = 7546
else:
raise Exception("Must select either parity or ganache")
setup_states.setup_validator_states_docker(args.contract,
args.n_validators, image_name,
args.is_geth, sudo_flag)
ethaddrs = "bridge_eth_addresses.json"
layer = run("docker create %s" % image_name,
capture_stdout=True,
quiet=True,
sudo=sudo_flag).strip()
if layer == "":
print("Docker image %s does not exist" % image_name)
return
run(
"docker cp %s:/home/user/bridge_eth_addresses.json %s" %
(layer, ethaddrs),
sudo=sudo_flag,
)
run("docker rm %s" % layer, quiet=True, sudo=sudo_flag)
with open("bridge_eth_addresses.json") as json_file:
data = json.load(json_file)
factory_address = data["ArbFactory"]
os.remove(ethaddrs)
rollup_creation_cmd = (
"docker run -it --network=arb-network -v %s:/home/user/state arb-validator create --password pass state ws://%s:%s %s"
% (
os.path.abspath("validator-states/validator0"),
image_name,
ws_port,
factory_address,
))
rollup_address = run(rollup_creation_cmd, capture_stdout=True, quiet=False)
print("rollup_address", rollup_address)
config = {
"rollup_address": rollup_address.strip(),
"eth_url": "ws://localhost:" + str(ws_port),
"password": "******",
"blocktime": 2,
}
setup_states.setup_validator_configs(config, args.n_validators)
def deploy(
contract_name,
n_validators,
sudo_flag,
build_flag,
up_flag,
avm,
n_extra_wallets,
mnemonic,
gas_limit,
gas_per_wallet,
block_time,
verbose,
):
# Bootstrap the build cache if it does not exist
def bootstrap_build_cache(name):
if (
run(
"docker images -q %s" % name,
capture_stdout=True,
quiet=True,
sudo=sudo_flag,
)
== ""
):
run("mkdir -p .tmp")
run('echo "%s" > .tmp/Dockerfile' % DOCKERFILE_CACHE)
run("docker build -t %s .tmp" % name, sudo=sudo_flag)
run("rm -rf .tmp")
bootstrap_build_cache("arb-avm-cpp")
bootstrap_build_cache("arb-validator")
# Stop running Arbitrum containers
halt_docker(sudo_flag)
# number of wallets
n_wallets = n_validators + n_extra_wallets
# Overwrite DOCKER_COMPOSE_FILENAME
states_path = os.path.abspath(
os.path.join(setup_states.VALIDATOR_STATES, setup_states.VALIDATOR_STATE)
)
compose = os.path.abspath("./" + DOCKER_COMPOSE_FILENAME)
contract = os.path.abspath(contract_name)
contents = compose_header(
os.path.abspath(os.path.join(ROOT_DIR, "packages", "arb-bridge-eth")),
mnemonic,
n_wallets,
gas_per_wallet,
gas_limit,
block_time,
verbose,
states_path % 0,
contract,
os.path.abspath(os.path.join(ROOT_DIR, "packages")),
"arb-validator.Dockerfile",
avm,
) + "".join(
[
compose_validator(i, states_path % i, contract, avm)
for i in range(1, n_validators)
]
)
with open(compose, "w") as f:
f.write(contents)
# Build
if not up_flag or build_flag:
if run("docker-compose -f %s build" % compose, sudo=sudo_flag) != 0:
exit(1)
# Nuke old validator states if it exists
if os.path.isdir(setup_states.VALIDATOR_STATES):
shutil.rmtree(setup_states.VALIDATOR_STATES)
# Setup validator states
setup_states.setup_validator_states_ethbridge(
os.path.abspath(contract_name), n_validators, sudo_flag
)
if not os.path.isdir(setup_states.VALIDATOR_STATES):
setup_states.setup_validator_states_ethbridge(
os.path.abspath(contract_name), n_validators, sudo_flag
)
# Run
if not build_flag or up_flag:
run("docker-compose -f %s up" % compose, sudo=sudo_flag)
