kicker

#!/bin/bash

set -o errexit

GITHUB_ACTIONS_CLEAN_MID_ARTIFACTS=false
# https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
if [ "$CI" = "true" ] && [ -n "$GITHUB_RUN_ID" ]; then
  echo "This script is running in GitHub Actions. GITHUB_RUN_ID: $GITHUB_RUN_ID"

  # Diskspace is limited in GitHub Actions, so we need to manually clean the middle artifacts
  GITHUB_ACTIONS_CLEAN_MID_ARTIFACTS=true
fi

EXECUTABLE=$0
WORKSPACE="$( cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"

# TODO ENABLE_MULTI_CKB_NODES
# TODO WATCH_CKB_REORG
# TODO INSTALL_JS_NODE_MODULE_NOT_COPY
# TODO BUILD_WEB3_INDEXER_ON_LOCAL_OVER_DOCKER
# TODO cargo fetch via proxy

DOCKER_COMPOSE="docker compose"
if docker compose version &> /dev/null
then
  DOCKER_COMPOSE="docker compose"
elif docker-compose version &> /dev/null
then
  DOCKER_COMPOSE="docker-compose"
else 
  echo "docker compose / docker-compose are not found"
  exit 1
fi

echo "Using \`$DOCKER_COMPOSE\`"

function usage() {
    echo "Usage: $EXECUTABLE [OPTIONS] <SUBCOMMAND>"
    echo
    echo "OPTIONS:"
    echo "  --help          Print usage information"
    echo "  -- <args>...    Execute docker compose / docker-compose command"
    echo
    echo "SUBCOMMANDS:"
    echo "  init                    Init running environment"
    echo "  start                   Start services and deploy local network"
    echo "  stop                    Stop services"
    echo "  info                    Print some useful info about the network and running services, such as Web3 RPC URL"
    echo "  clean                   Clean containers volumed data"
    echo "  ps [service]            List services"
    echo "  logs [service]          Tail target service's logs"
    echo "  enter <service>         Enter target service's container"
    echo "  manual-build            Manually build services artifacts"
    echo "  deposit <eth-address> <amount>  Deposit CKB to layer2"
    echo "  get-balance <eth-address>       Get layer2 balance"
    echo "  transfer <eth-address> <amount> <fee> <sudt-id>      Transfer sudt token"
    echo
    echo "EXAMPLES:"
    echo "  * Deploy the local network and print service info"
    echo
    echo "    $ $EXECUTABLE start"
    echo "    $ $EXECUTABLE info"
    echo
    echo "  * Deposit 1000CKB from layer1 to layer2"
    echo
    echo "    $ $EXECUTABLE deposit 0x618cc3C660cEBFDbA8570CA739b1744AE3E2553a 1000"
    echo "    $ $EXECUTABLE get-balance 0x618cc3C660cEBFDbA8570CA739b1744AE3E2553a"
    echo
    echo "  * Redeploy the local network"
    echo
    echo "    $ $EXECUTABLE -- kill"
    echo "    $ $EXECUTABLE stop"
    echo "    $ sudo $EXECUTABLE clean"
    echo "    $ $EXECUTABLE start"
    echo
    echo "  * Execute docker compose / docker-compose commands"
    echo
    echo "    $ $EXECUTABLE -- exec ckb ls -l"
    echo "    $ $EXECUTABLE -- top godwoken"
    echo "    $ $EXECUTABLE -- kill godwoken"
    echo "    $ $EXECUTABLE -- --help"

}

function info() {
    echo -e "\033[0;32m[${FUNCNAME[1]}] $1\033[0m"
}

function error() {
    echo -e "\033[0;31m[${FUNCNAME[1]}] ERROR: $1\033[0m">&2
}

function erun() {
    echo -e "\033[0;32m:> $*\033[0m">&2
    echo
    eval "$*"
}

function compose() {
    override=""
    if [ "$ENABLE_MULTI_CKB_NODES" = "true" ]; then
        override="$override -f docker/chaos.compose.yml"
    fi
    if [ "$MANUAL_BUILD_GODWOKEN" = "true" ]; then
        override="$override -f docker/manual-godwoken.compose.yml"
    fi
    if [ "$MANUAL_BUILD_WEB3" = "true" ]; then
        override="$override -f docker/manual-web3.compose.yml"
    fi
    if [ "$MANUAL_BUILD_WEB3_INDEXER" = "true" ]; then
        override="$override -f docker/manual-web3-indexer.compose.yml"
    fi
    if [ "$MANUAL_BUILD_POLYJUICE" = "true" ]; then
        override="$override -f docker/manual-polyjuice.compose.yml"
    fi
    if [ "$MANUAL_BUILD_SCRIPTS" = "true" ]; then
        override="$override -f docker/manual-scripts.compose.yml"
    fi
    if [ "$START_GODWOKEN_V0" = "true" ]; then
        override="$override -f docker/manual-godwoken-v0.compose.yml"
    fi

    erun $DOCKER_COMPOSE -f docker/docker-compose.yml $override "$@"
}

function gw_tools_compose_override() {
    override=""

    if [ "$MANUAL_BUILD_GODWOKEN" = "true" ]; then
        if [ ! -f "$WORKSPACE/docker/manual-artifacts/gw-tools" ]; then
            error "\"MANUAL_BUILD_GODWOKEN = true\" but \"docker/manual-artifacts/gw-tools\" not found"
            exit 1
        fi
        override="$override -f docker/manual-godwoken.compose.yml"
    fi

    echo $override
}

function init() {
    echo -e "\033[0;33mNOTE: Using \`docker compose\` or the docker-compose version should be newer than 1.29.0\033[0m"
    echo
    erun $DOCKER_COMPOSE -f docker/docker-compose.yml build --no-rm

    # In order to compat with old-version kicker, we execute manual-build at init
    manual_build
}

function gw_rpc_request() {
    result=$(echo "{
        \"id\": 2,
        \"jsonrpc\": \"2.0\",
        \"method\": \"$1\",
        \"params\": [\"$2\"]
    }" \
    | tr -d '\n' \
    | curl -H 'content-type: application/json' -d @- \
    http://localhost:8119/instant-finality-hack \
    | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^result/ {print $2}')
}

function try_deposit_zero_address() {
    gw_rpc_request "gw_get_script_hash_by_registry_address" "0x02000000140000000000000000000000000000000000000000000000"
    script_hash=$result

    if [[ -z "$script_hash" ]]; then
        # deposit
        info "Zero address account id not found, deposit ..."
        deposit 0x0000000000000000000000000000000000000000 1000
        info "Zero address deposit succeed."
    else
        # check account id
        gw_rpc_request "gw_get_account_id_by_script_hash" $(echo $script_hash | tr -d '"')
        account_id=$result

        if [[ -z "$account_id" ]]; then
            # deposit
            info "Zero address account id not found, deposit ..."
            deposit 0x0000000000000000000000000000000000000000 1000
            info "Zero address deposit succeed."
        else
            info "Zero address already deposited."
        fi
    fi
}

function start() {
    echo -e "\033[0;33mNOTE: Using \`docker compose\` or the docker-compose version should be newer than 1.29.0\033[0m"
    echo -e "\033[0;33mNOTE: This might take several minutes on the first run\033[0m"
    echo

    if [ "$MANUAL_BUILD_GODWOKEN" = "true" ]; then
        if [ ! -f "$WORKSPACE/docker/manual-artifacts/godwoken" ]; then
            error "\"MANUAL_BUILD_GODWOKEN = true\" but \"docker/manual-artifacts/godwoken\" not found"
            exit 1
        fi
        if [ ! -f "$WORKSPACE/docker/manual-artifacts/gw-tools" ]; then
            error "\"MANUAL_BUILD_GODWOKEN = true\" but \"docker/manual-artifacts/gw-tools\" not found"
            exit 1
        fi
    fi
    if [ "$MANUAL_BUILD_WEB3" = "true" ]; then
        if [ ! -d "$WORKSPACE/docker/manual-artifacts/godwoken-web3/" ]; then
            error "\"MANUAL_BUILD_WEB3 = true\" but \"docker/manual-artifacts/godwoken-web3\" not found"
            erun ls -l -a $WORKSPACE/docker/manual-artifacts/godwoken-web3/
            exit 1
        fi
    fi
    if [ "$MANUAL_BUILD_WEB3_INDEXER" = "true" ]; then
        if [ ! -f "$WORKSPACE/docker/manual-artifacts/gw-web3-indexer" ]; then
            error "\"MANUAL_BUILD_WEB3_INDEXER = true\" but \"docker/manual-artifacts/gw-web3-indexer\" not found"
            exit 1
        fi
    fi

    compose up -d --build
    if [ "$?" = "0" ]; then
        info "Services started successfully"
    fi

    try_deposit_zero_address
}

function stop() {
    compose down --remove-orphans
}

function info_() {
    echo "Web3 RPC URL: http://127.0.0.1:8024"
}

function clean() {
    n_alive=$(compose ps --quiet | grep -oE '[0-9a-z]{64}' | wc -l | tr -d " ")
    if [ $n_alive != 0 ]; then
        error "Ensure container services are down"
        compose ps
        exit 1
    fi

    set -x
    rm -rf docker/layer2-v0/data/
    rm -f  docker/layer2-v0/config/scripts-deployment.json
    rm -f  docker/layer2-v0/config/rollup-genesis-deployment.json
    rm -f  docker/layer2-v0/config/godwoken-config.toml
    rm -rf docker/layer2/data/
    rm -rf docker/layer2/data-readonly/
    rm -f  docker/layer2/config/scripts-deployment.json
    rm -f  docker/layer2/config/rollup-genesis-deployment.json
    rm -f  docker/layer2/config/godwoken-config.toml
    rm -f  docker/layer2/config/godwoken-config-readonly.toml
    rm -f  docker/layer2/config/polyjuice-root-account-id
    rm -f  docker/layer2/config/web3-indexer-config.toml
    rm -f  docker/layer2/config/withdrawal-to-v1.toml
    rm -rf docker/ckb-indexer/
    rm -rf docker/layer1/ckb/data/
    rm -rf docker/layer1/ckb2/data/
    rm -rf docker/layer1/ckb3/data/
    rm -rf docker/postgres/data
    rm -rf docker/redis/data
    rm -rf docker/manual-artifacts
}

function ps() {
    compose ps "$@"
}

function logs() {
    compose logs "$@"
}

function enter() {
    service="${1:?"\"$EXECUTABLE enter\" requires 1 arguments"}"
    compose exec "$service" /bin/bash
}

# @example deposit "0x0C1EfCCa2Bcb65A532274f3eF24c044EF4ab6D73" 1000
function deposit() {
    ethaddr=${1:?"\"$EXECUTABLE deposit\" requires eth address as 1st argument"}
    amount=${2:?"\"$EXECUTABLE deposit\" requires amount as 2nd argument"}

    # Use rollup-scripts-deployer to avoid conflict with v0/v1 block submission.
    pkpath=${PRIVATE_KEY_PATH:-"$WORKSPACE/accounts/rollup-scripts-deployer.key"}
    if [ ! -f $pkpath ]; then
        error "$pkpath: No such file or directory"
        exit 1
    fi

    abspkpath="$( cd -- "$(dirname "$pkpath")" >/dev/null 2>&1 ; pwd -P )/$(basename $pkpath)"
    $DOCKER_COMPOSE -f docker/docker-compose.yml $(gw_tools_compose_override) run \
        --no-deps \
        --use-aliases \
        --volume=$WORKSPACE/docker/layer2/config:/config \
        --volume=$abspkpath:/privkey-path \
        --entrypoint "gw-tools deposit-ckb \
                --godwoken-rpc-url http://godwoken:8119 \
                --ckb-rpc http://ckb:8114 \
                --ckb-indexer-rpc http://ckb-indexer:8116 \
                --scripts-deployment-path /config/scripts-deployment.json \
                --config-path /config/godwoken-config.toml \
                --privkey-path /privkey-path \
                --eth-address $ethaddr \
                --capacity $amount" \
        godwoken
}

function transfer() {
    toEthAddress=${1:?"\"$EXECUTABLE transfer\" requires toEthAddress as 1st argument"}
    amount=${2:?"\"$EXECUTABLE transfer\" requires amount as 2nd argument"}
    fee=${3:?"\"$EXECUTABLE transfer\" requires fee as 3nd argument"}
    sudtId=${4:?"\"$EXECUTABLE transfer\" requires sudtId as 4nd argument"}

    pkpath=${PRIVATE_KEY_PATH:-"$WORKSPACE/accounts/ckb-miner-and-faucet.key"}
    if [ ! -f $pkpath ]; then
        error "$pkpath: No such file or directory"
        exit 1
    fi

    abspkpath="$( cd -- "$(dirname "$pkpath")" >/dev/null 2>&1 ; pwd -P )/$(basename $pkpath)"
    $DOCKER_COMPOSE -f docker/docker-compose.yml run \
        --no-deps \
        --use-aliases \
        --volume=$WORKSPACE/docker/layer2/config:/config \
        --volume=$abspkpath:/privkey-path \
        --entrypoint "gw-tools transfer \
                --godwoken-rpc-url http://godwoken:8119 \
                --scripts-deployment-path /config/scripts-deployment.json \
                --config-path /config/godwoken-config.toml \
                --privkey-path /privkey-path \
                --sudt-id $sudtId \
                --to $toEthAddress \
                --fee $fee \
                --amount $amount" \
        godwoken
}

# Note that this function MUST be in tty mode.
# @example get-balance "0x0C1EfCCa2Bcb65A532274f3eF24c044EF4ab6D73"
function get_balance() {
    ethaddr=${1:?"\"$EXECUTABLE get-balance\" requires eth address as 1st argument"}
    script_hash=$(to_script_hash "$ethaddr")
    echo "script hash: ${script_hash}"
    $DOCKER_COMPOSE -f docker/docker-compose.yml $(gw_tools_compose_override) run \
        --no-deps \
        --use-aliases \
        --entrypoint "gw-tools get-balance \
            --godwoken-rpc-url http://godwoken:8119 \
            --account $script_hash" \
        godwoken 2>&1
}

# @to-script-hash "0x0C1EfCCa2Bcb65A532274f3eF24c044EF4ab6D73"
function to_script_hash() {
    ethaddr=${1:?"\"$EXECUTABLE to-script-hash\" requires eth address as 1st argument"}
    compose_override=$(gw_tools_compose_override)
    output=$($DOCKER_COMPOSE -f docker/docker-compose.yml $compose_override run \
        --no-deps \
        --use-aliases \
        --volume=$WORKSPACE/docker/layer2/config:/config \
        --entrypoint "gw-tools to-script-hash \
            --config-path /config/godwoken-config.toml \
            --scripts-deployment-path /config/scripts-deployment.json \
            --eth-address $ethaddr" \
            godwoken 2>&1)
    echo "$output" | grep -oE '0x.*'
}

# TODO: Test deposit v0, remove after abandon v0
# @example deposit-v0 1000
function deposit_v0() {
    amount=${1:?"\"$EXECUTABLE deposit\" requires amount as 1nd argument"}

    pkpath=${PRIVATE_KEY_PATH:-"$WORKSPACE/accounts/rollup-scripts-deployer.key"}
    if [ ! -f $pkpath ]; then
        error "$pkpath: No such file or directory"
        exit 1
    fi

    abspkpath="$( cd -- "$(dirname "$pkpath")" >/dev/null 2>&1 ; pwd -P )/$(basename $pkpath)"
    $DOCKER_COMPOSE -f docker/docker-compose.yml -f docker/manual-godwoken-v0.compose.yml run \
        --no-deps \
        --use-aliases \
        --volume=$WORKSPACE/docker/layer2-v0/config:/config \
        --volume=$abspkpath:/privkey-path \
        --entrypoint "gw-tools deposit-ckb \
                --godwoken-rpc-url http://godwoken-v0:8119 \
                --ckb-rpc http://ckb:8114 \
                --scripts-deployment-path /config/scripts-deployment.json \
                --config-path /config/godwoken-config.toml \
                --privkey-path /privkey-path \
                --capacity $amount" \
        godwoken-v0
}

# TODO: Test withdraw v0 to v1, remove after abandon v0
# @example withdraw-v0-to-v1 "0x0C1EfCCa2Bcb65A532274f3eF24c044EF4ab6d77" 500
function withdraw_v0_to_v1() {
    ethaddr=${1:?"\"$EXECUTABLE withdraw-v0-to-v1\" requires eth address as 1st argument"}
    amount=${2:?"\"$EXECUTABLE withdraw-v0-to-v1\" requires amount as 2nd argument"}

    pkpath=${PRIVATE_KEY_PATH:-"$WORKSPACE/accounts/rollup-scripts-deployer.key"}
    if [ ! -f $pkpath ]; then
        error "$pkpath: No such file or directory"
        exit 1
    fi

    abspkpath="$( cd -- "$(dirname "$pkpath")" >/dev/null 2>&1 ; pwd -P )/$(basename $pkpath)"
    $DOCKER_COMPOSE -f docker/docker-compose.yml -f docker/manual-godwoken-v0.compose.yml run \
        --no-deps \
        --use-aliases \
        --volume=$WORKSPACE/docker/layer2-v0/config:/config \
        --volume=$abspkpath:/privkey-path \
        --entrypoint "gw-tools withdraw-to-v1 \
                --godwoken-rpc-url http://godwoken-v0:8119 \
                --scripts-deployment-path /config/scripts-deployment.json \
                --config-path /config/godwoken-config.toml \
                --privkey-path /privkey-path \
                --eth-address $ethaddr \
                --capacity $amount" \
        godwoken-v0
}

# @example MANUAL_BUILD_GODWOKEN=true \
#          GODWOKEN_GIT_URL=ssh://git@github.com/godwokenrises/godwoken \
#          GODWOKEN_GIT_CHECKOUT=develop \
#          ./kicker manual-build
function manual_build() {
    WEB3_GIT_URL=${WEB3_GIT_URL:-"https://github.com/godwokenrises/godwoken"}
    WEB3_GIT_CHECKOUT=${WEB3_GIT_CHECKOUT:-"develop"}
    echo "MANUAL_BUILD_WEB3         =   \"$MANUAL_BUILD_WEB3\""
    echo "WEB3_GIT_URL              =   \"$WEB3_GIT_URL\""
    echo "WEB3_GIT_CHECKOUT         =   \"$WEB3_GIT_CHECKOUT\""
    echo "MANUAL_BUILD_WEB3_INDEXER =   \"$MANUAL_BUILD_WEB3_INDEXER\""

    GODWOKEN_GIT_URL=${GODWOKEN_GIT_URL:-"https://github.com/godwokenrises/godwoken"}
    GODWOKEN_GIT_CHECKOUT=${GODWOKEN_GIT_CHECKOUT:-"develop"}
    echo "MANUAL_BUILD_GODWOKEN     =   \"$MANUAL_BUILD_GODWOKEN\""
    echo "GODWOKEN_GIT_URL          =   \"$GODWOKEN_GIT_URL\""
    echo "GODWOKEN_GIT_CHECKOUT     =   \"$GODWOKEN_GIT_CHECKOUT\""

    SCRIPTS_GIT_URL=${SCRIPTS_GIT_URL:-"https://github.com/godwokenrises/godwoken"}
    SCRIPTS_GIT_CHECKOUT=${SCRIPTS_GIT_CHECKOUT:-"develop"}
    echo "MANUAL_BUILD_SCRIPTS      =   \"$MANUAL_BUILD_SCRIPTS\""
    echo "SCRIPTS_GIT_URL           =   \"$SCRIPTS_GIT_URL\""
    echo "SCRIPTS_GIT_CHECKOUT      =   \"$SCRIPTS_GIT_CHECKOUT\""

    echo "OMNI_LOCK_GIT_URL         =   \"$OMNI_LOCK_GIT_URL\""
    echo "OMNI_LOCK_GIT_CHECKOUT    =   \"$OMNI_LOCK_GIT_CHECKOUT\""

    POLYJUICE_GIT_URL=${POLYJUICE_GIT_URL:-"https://github.com/godwokenrises/godwoken"}
    POLYJUICE_GIT_CHECKOUT=${POLYJUICE_GIT_CHECKOUT:-"develop"}
    echo "MANUAL_BUILD_POLYJUICE    =   \"$MANUAL_BUILD_POLYJUICE\""
    echo "POLYJUICE_GIT_URL         =   \"$POLYJUICE_GIT_URL\""
    echo "POLYJUICE_GIT_CHECKOUT    =   \"$POLYJUICE_GIT_CHECKOUT\""

    DOCKER_MANUAL_BUILD_IMAGE_NAME=${DOCKER_MANUAL_BUILD_IMAGE_NAME:-"retricsu/godwoken-manual-build"}
    DOCKER_MANUAL_BUILD_IMAGE_TAG=${DOCKER_MANUAL_BUILD_IMAGE_TAG:-"node18"}
    DOCKER_MANUAL_BUILD_IMAGE="${DOCKER_MANUAL_BUILD_IMAGE:-"$DOCKER_MANUAL_BUILD_IMAGE_NAME:$DOCKER_MANUAL_BUILD_IMAGE_TAG"}"
    echo "DOCKER_MANUAL_BUILD_IMAGE =   \"$DOCKER_MANUAL_BUILD_IMAGE\""
    echo

    info "Start building..." | tee /tmp/kicker.log
    du -hd6 $WORKSPACE | egrep G | tee --append /tmp/kicker.log

    if [ "$MANUAL_BUILD_WEB3" = "true" ]; then
        info "Start building godwoken-web3"

        # godwoken-web3 is managed in the Godwoken monorepo.
        # See https://github.com/godwokenrises/godwoken/tree/develop/web3
        srcdir=$WORKSPACE/packages/godwoken/web3
        dstdir=$WORKSPACE/docker/manual-artifacts/godwoken-web3

        # Download repo
        prepare_repo godwoken "$WEB3_GIT_URL" "$WEB3_GIT_CHECKOUT"

        # Yarn install via docker (assumes the "web3" docker-compose service installed yarn)

        # ATTENTION: Do not use `compose run ...`. `compose run` will add
        # `-f docker/manual-web3.compose.yml`, and it will volume
        # the `docker/manual-artifacts` directory, it is not what we expect.
        erun $DOCKER_COMPOSE -f docker/docker-compose.yml run \
            --rm \
            --no-deps \
            --volume=$srcdir:/app \
            --workdir=/app \
            --entrypoint "\"bash -c 'yarn install && yarn run build'\"" \
            web3

        # Copy the built artifacts to `docker/manual-artifacts/godwoken-web3`.
        #
        # More: ./docker/manual-web3.compose.yml
        erun rm -rf $dstdir
        erun mkdir -p $dstdir
        erun cp -r $srcdir/packages \
            $srcdir/package.json \
            $srcdir/node_modules \
            $srcdir/yarn.lock \
            $dstdir

        if [[ "$GITHUB_ACTIONS_CLEAN_MID_ARTIFACTS" = "true" ]]; then
            erun sudo rm -rf $srcdir/node_modules
        fi
    else
        info "skip building godwoken-web3"
    fi

    if [ "$MANUAL_BUILD_WEB3_INDEXER" = "true" ]; then
        info "Start building godwoken-web3-indexer"

        srcdir=$WORKSPACE/packages/godwoken
        dstdir=$WORKSPACE/docker/manual-artifacts

        # Download repo
        prepare_repo godwoken "$WEB3_GIT_URL" "$WEB3_GIT_CHECKOUT"

        # Cargo fetch Rust dependencies (in order to access network via
        # host network). The docker image must have installed cargo, molecule
        # and rustfmt.
        erun "cd $srcdir/web3 && CARGO_HOME=$WORKSPACE/packages/.cargo cargo fetch --locked && cd -"

        erun docker run --rm \
            --workdir /app/web3 \
            --volume $srcdir:/app \
            --volume $WORKSPACE/packages/.rustup:/root/.rustup \
            --volume $WORKSPACE/packages/.cargo:/app/web3/.cargo \
            --env CARGO_HOME=/app/web3/.cargo \
            $DOCKER_MANUAL_BUILD_IMAGE cargo build --release --locked

        # Copy the built artifacts to `docker/manual-artifacts/gw-web3-indexer`
        #
        # More: ./docker/manual-web3-indexer.compose.yml
        erun mkdir -p $dstdir
        erun cp $srcdir/web3/target/release/gw-web3-indexer $dstdir

        # Remove Rust target to avoid `out of disk` issue in CI
        if [[ "$GITHUB_ACTIONS_CLEAN_MID_ARTIFACTS" = "true" ]]; then
            sudo rm -rf $srcdir/web3/target
        fi
    else
        info "skip building godwoken-web3-indexer (gw-web3-indexer)"
    fi

    if [ "$MANUAL_BUILD_GODWOKEN" = "true" ]; then
        info "Start building godwoken"

        srcdir=$WORKSPACE/packages/godwoken
        dstdir=$WORKSPACE/docker/manual-artifacts

        # Download repo
        prepare_repo godwoken "$GODWOKEN_GIT_URL" "$GODWOKEN_GIT_CHECKOUT"

        # Cargo fetch Rust dependencies (in order to access network via
        # host network).
        erun "cd $srcdir && CARGO_HOME=$WORKSPACE/packages/.cargo cargo fetch --locked && cd -"

        # Note:
        # 1. The docker image must have installed cargo and molecule
        # 2. The builtin consensus config and binaries are not required on a 
        #    Godwoken devnet, so `--features gw-config/no-builtin` is appended
        #    to `cargo build` arguments.
        erun docker run --rm \
            --workdir /app \
            --volume $srcdir:/app \
            --volume $WORKSPACE/packages/.rustup:/root/.rustup \
            --volume $WORKSPACE/packages/.cargo:/app/.cargo \
            --env CARGO_HOME=/app/.cargo \
            $DOCKER_MANUAL_BUILD_IMAGE \
            cargo build --release --locked --features gw-config/no-builtin

        # Copy the built artifacts to `docker/manual-artifacts/`
        #
        # More: ./docker/manual-godwoken.compose.yml
        erun mkdir -p $dstdir
        erun cp $srcdir/target/release/godwoken $dstdir
        erun cp $srcdir/target/release/gw-tools $dstdir

        # Remove Rust target to avoid `out of disk` issue in CI
        if [[ "$GITHUB_ACTIONS_CLEAN_MID_ARTIFACTS" = "true" ]]; then
            sudo rm -rf $srcdir/target
        fi
    else
        info "skip building Godwoken"
    fi

    if [ "$MANUAL_BUILD_POLYJUICE" = "true" ]; then
        srcdir=$WORKSPACE/packages/godwoken/gwos-evm
        dstdir=$WORKSPACE/docker/manual-artifacts/polyjuice/

        # Download repo
        prepare_repo godwoken "$POLYJUICE_GIT_URL" "$POLYJUICE_GIT_CHECKOUT"

        cd $srcdir
        erun make all-via-docker

        # Copy the built artifacts to `docker/manual-artifacts/`
        mkdir -p $dstdir
        erun cp -r build/* $dstdir
    else
        info "skip building Polyjuice"
    fi

    if [ "$MANUAL_BUILD_SCRIPTS" = "true" ]; then
        srcdir=$WORKSPACE/packages/godwoken/gwos
        dstdir=$WORKSPACE/docker/manual-artifacts/scripts/

        # Download repo
        prepare_repo godwoken "$SCRIPTS_GIT_URL" "$SCRIPTS_GIT_CHECKOUT"

        # Install capsule
        # FIXME: error: Incompatible capsule version 0.10.1, this project requires a version that's compatible with 0.7.0
        CAPSULE_VERSION=0.7.0
        export CARGO_HOME=$WORKSPACE/packages/.cargo
        (which capsule && test "$(capsule --version)" = "Capsule $CAPSULE_VERSION") \
        || erun cargo install ckb-capsule --version $CAPSULE_VERSION --force
        $WORKSPACE/packages/.cargo/bin/capsule --version
        # FIXME: failed to install capsule 0.7.0

        erun cd $srcdir/c \&\& erun make all-via-docker
        erun cd $srcdir \&\& capsule build --release --debug-output

        # Copy the built artifacts to `docker/manual-artifacts/`
        mkdir -p $dstdir
        erun cp -r $srcdir/build/release/* $dstdir
        erun cp $srcdir/c/build/*-generator $dstdir
        erun cp $srcdir/c/build/*-validator $dstdir

        # Copy the prebuild omni-lock to `docker/manual-artifacts/`
        erun $DOCKER_COMPOSE -f $WORKSPACE/docker/docker-compose.yml run \
            --rm --no-deps \
            --volume=$dstdir:/godwoken-scripts \
            --entrypoint "\"bash -c 'cp /scripts/godwoken-scripts/omni_lock /godwoken-scripts/omni_lock'\"" \
            godwoken
    else
        info "skip building Scripts"
    fi

    if [[ "$GITHUB_ACTIONS_CLEAN_MID_ARTIFACTS" = "true" ]]; then
        docker images --format '{{.Repository}}:{{.Tag}}' \
        | grep '$DOCKER_MANUAL_BUILD_IMAGE' | xargs docker rmi \
        && echo "Image removed." \
        || echo "Image does not exist."
    fi

    info "End building." | tee --append /tmp/kicker.log
    du -hd6 $WORKSPACE | egrep G | tee --append /tmp/kicker.log
}

function prepare_repo() {
    name=$1
    url=$2
    checkout=$3
    dir="$WORKSPACE/packages/$name"

    mkdir -p $WORKSPACE/packages
    if [[ -d "$dir" ]]; then
        remote_url=$(git -C $dir remote get-url origin)
        if [ "$url" != "$remote_url" ]; then
            error "$dir already exists and the remote url is not \"$url\""
            exit 1
        fi

        if [ "$ALWAYS_FETCH_NEW_PACKAGE" != "false" ]; then
            erun git -C $dir fetch origin $checkout
            erun git -C $dir checkout FETCH_HEAD
            erun git -C $dir submodule update --init --recursive --depth=1
        fi  
    else
        erun git clone --depth=1 $url $dir
        erun git -C $dir fetch origin $checkout
        erun git -C $dir checkout FETCH_HEAD
        erun git -C $dir submodule update --init --recursive --depth=1
    fi
}

function main() {
    if [ "$#" = "0" ]; then
        usage
        exit 0
    fi

    command="$1"
    shift 1

    case $command in
        "--help")
            usage
            ;;
        "init")
            init
            ;;
        "start")
            start
            ;;
        "stop")
            stop
            ;;
        "info")
            info_
            ;;
        "clean")
            clean
            ;;
        "ps")
            ps "$@"
            ;;
        "logs")
            logs "$@"
            ;;
        "enter")
            enter "$@"
            ;;
        "deposit")
            deposit "$@"
            ;;
        "deposit-v0")
            deposit_v0 "$@"
            ;;
        "transfer")
            transfer "$@"
            ;;
        "withdraw-v0-to-v1")
            withdraw_v0_to_v1 "$@"
            ;;
        "get-balance")
            get_balance "$@"
            ;;
        "manual-build")
            manual_build
            ;;
        "--")
            compose "${@:?"\"$EXECUTABLE --\" requires at least one argument"}"
            ;;
        *)
            error "unknown subcommand: \"$command\""
            echo
            usage
            exit 1
            ;;
    esac
}

cd $WORKSPACE
main "$@"