stack

#!/usr/bin/env bash

############################################################################
############################################################################
# LOCAL DEV HELPERS
#
# You "can" use this script in production but it's not designed to be
# It's an opinionated script that helps with local development
############################################################################
############################################################################

set -euo pipefail
IFS=$'\n\t'

export DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
# if we are running geth in docker (for testnets)
# then which folder do we mount the data folder to?
export GETH_DATA_DIRECTORY=${GETH_DATA_DIRECTORY:="/var/lib/hive/geth"}
# which docker network do we connect geth to?
export GETH_DOCKER_NETWORK=${GETH_DOCKER_NETWORK:="hive"}
# what is the docker image that we use for geth?
export GETH_DOCKER_IMAGE=${GETH_DOCKER_IMAGE:="ethereum/client-go:v1.13.5"}
# what is the docker image that we use for the faucet?
export FAUCET_DOCKER_IMAGE=${FAUCET_DOCKER_IMAGE:="hive-faucet"}
# what is the docker image that we use for solc compiler?
export SOLC_DOCKER_IMAGE=${SOLC_DOCKER_IMAGE:="hive-solc"}
# if the LOCAL_GETH variable is set, use a local geth instance rather than geth in docker. needed on macos
# Check if the system is an ARM-based Mac
if [ "$(uname -m)" = "arm64" ] && [ "$(uname -s)" = "Darwin" ]; then
  export LOCAL_GETH=true
fi
# local geth data store folder
export LOCAL_GETH_DATA_DIRECTORY=${LOCAL_GETH_DATA_DIRECTORY:="/tmp/geth"}

# if "$DIR/.env" exists then source it
# this will contian the various addresses and private keys
if [[ -f "$DIR/.env" ]]; then
  source "$DIR/.env"
fi

############################################################################
############################################################################
# setup
############################################################################
############################################################################
function install() {
  build-faucet
  go mod download
  (cd hardhat && yarn install)
  (cd frontend && yarn install)
  (cd hardhat && npx hardhat compile)
  print-env > .env
}

############################################################################
############################################################################
# geth
############################################################################
############################################################################

# run a local geth node in dev mode mounted against a local data directory
function geth() {
  docker network ls | grep " $GETH_DOCKER_NETWORK " || docker network create "$GETH_DOCKER_NETWORK"
  docker run -d --restart always \
    --name geth \
    --network "$GETH_DOCKER_NETWORK" \
    -p 8545:8545 \
    -p 8546:8546 \
    -v ${GETH_DATA_DIRECTORY}:/data/geth \
    $GETH_DOCKER_IMAGE \
      --datadir /data/geth \
      --dev \
      --ws \
      --ws.api web3,eth,net \
      --ws.addr 0.0.0.0 \
      --ws.port 8546 \
      --ws.origins '*' \
      --http \
      --http.api web3,eth,net \
      --http.addr 0.0.0.0 \
      --http.corsdomain '*' \
      --http.port 8545 \
      --http.vhosts '*'
}

# run local geth in dev mode mounted against local data directory
function dev-geth() {
  clean
  /usr/local/bin/geth \
    --datadir /tmp/geth \
    --dev \
    --ws \
    --ws.api web3,eth,net \
    --ws.addr 0.0.0.0 \
    --ws.port 8546 \
    --ws.origins '*' \
    --http \
    --http.api web3,eth,net \
    --http.addr 0.0.0.0 \
    --http.corsdomain '*' \
    --http.port 8545 \
    --http.vhosts '*'
}

function geth-command() {
  if [[ -n $LOCAL_GETH ]]; then
    /usr/local/bin/geth --exec "$@" attach /tmp/geth/geth.ipc
  else
    docker exec -i geth geth --exec "$@" attach /data/geth/geth.ipc
  fi
}

############################################################################
############################################################################
# faucet
############################################################################
############################################################################
function build-faucet() {
  (
    cd ../eth-faucet &&
    docker build -t $FAUCET_DOCKER_IMAGE .
  )
}

# run the faucet container
function faucet() {
  eval $(./stack print-contract-env)
  local privateKey=$(echo -n "$ADMIN_PRIVATE_KEY" | sed 's/^0x//')
  local tokenAddress=$(echo -n "$WEB3_TOKEN_ADDRESS" | sed 's/^0x//')
  if [[ -n $LOCAL_GETH ]]; then
    export WEB3_PROVIDER=${WEB3_PROVIDER:="http://host.docker.internal:8545"}
    echo provider: $WEB3_PROVIDER
    echo docker network: $GETH_DOCKER_NETWORK
  else
    export WEB3_PROVIDER=${WEB3_PROVIDER:="http://geth:8545"}
  fi
  docker network ls | grep " $GETH_DOCKER_NETWORK " || docker network create "$GETH_DOCKER_NETWORK"
  docker run -d \
    --name faucet \
    -p 8085:8080 \
    --restart always \
    --network "$GETH_DOCKER_NETWORK" \
    -e WEB3_PROVIDER=$WEB3_PROVIDER \
    -e PRIVATE_KEY=$privateKey \
    -e TOKEN_ADDRESS=$WEB3_TOKEN_ADDRESS \
    $FAUCET_DOCKER_IMAGE \
      --faucet.amount=100 \
      --faucet.tokenamount=100 \
      --faucet.minutes=1
}

function faucet-stop() {
  docker rm -f faucet 2> /dev/null || true
}

############################################################################
############################################################################
# bacalhau
############################################################################
############################################################################

function bacalhau-serve() {
  bacalhau serve \
    --node-type compute,requester \
    --peer none \
    --private-internal-ipfs=false \
    --job-selection-accept-networked
}

# move ALL the money apart from 1 eth to the given admin account
# this expects the .env file to already have been created
function fund-admin() {
  if [[ -z "$ADMIN_ADDRESS" ]]; then
    echo >&2 "ADMIN_ADDRESS must be set (source ${DIR}/.env)"
    exit 1
  fi

  echo ${ADMIN_ADDRESS}
  geth-command "eth.sendTransaction({from: eth.coinbase, to: \"${ADMIN_ADDRESS}\", value: new web3.BigNumber(eth.getBalance(eth.coinbase)).minus(web3.toWei(1, \"ether\")) })"
}

function geth-stop() {
  docker rm -f geth 2> /dev/null || true
}

function clean-deploy() {
  rm -rf ${DIR}/hardhat/artifacts
  rm -rf ${DIR}/hardhat/cache
  rm -rf ${DIR}/hardhat/deployments/geth
}

function clean() {
  echo -n "Are you sure? This will DESTROY GETH DATA (type 'yes' if sure) "
  read response
  if [[ "$response" != "yes" ]]; then
    exit 0
  fi
  if [[ -n $LOCAL_GETH ]]; then
    sudo rm -rf ${LOCAL_GETH_DATA_DIRECTORY}
  else
    docker rm -f $(docker ps -aq) || true
    sudo rm -rf ${GETH_DATA_DIRECTORY}
  fi
  clean-deploy
}

function boot-message() {
  echo ""
  echo "############################################################################"
  echo "# $@"
  echo "############################################################################"
  echo ""
}

function deploy() {
  clean-deploy
  boot-message "Compiling contracts"
  compile-contracts
  boot-message "Deploying contracts"
  deploy-contracts
  boot-message "Funding services with tokens"
  fund-services-tokens
  boot-message "Printing balances"
  balances
}

function boot() {
  clean
  boot-message "Starting geth"
  geth
  sleep 5
  boot-message "Funding admin account"
  fund-admin
  boot-message "Funding services with ether"
  fund-services-ether
  deploy
}

function dev-boot() {
  boot-message "Funding admin account"
  fund-admin
  boot-message "Funding services with ether"
  fund-services-ether
  deploy
}

############################################################################
############################################################################
# hardhat
############################################################################
############################################################################


function go-binding() {
  local name="$1"
  local pkg="$2"

  # compile the sol files into bytecode and ABI
  docker run --rm \
    -v $DIR/hardhat:/src \
    -w /src \
    --entrypoint solc \
    $SOLC_DOCKER_IMAGE \
       --base-path . \
       --include-path node_modules \
       --overwrite \
      --abi --bin \
      "contracts/$name.sol" \
      -o artifacts

  if ! [[ -n $LOCAL_GETH ]]; then
    sudo chown -R $USER:$USER hardhat/artifacts
  fi
  mkdir -p hardhat/artifacts/bindings/$pkg

  # generate the go bindings
  docker run --rm \
    -v $DIR/hardhat:/src \
    -w /src \
    --entrypoint abigen \
    $SOLC_DOCKER_IMAGE \
      "--bin=artifacts/$name.bin" \
      "--abi=artifacts/$name.abi" \
      "--pkg=$pkg" "--out=artifacts/bindings/$pkg/$pkg.go"

  if ! [[ -n $LOCAL_GETH ]]; then
    sudo chown -R $USER:$USER hardhat/artifacts/bindings/$pkg
  fi
  sudo chmod 0644 hardhat/artifacts/bindings/$pkg/$pkg.go
  cp -r hardhat/artifacts/bindings/$pkg pkg/web3/bindings/$pkg

  echo "Generated go binding hardhat/artifacts/bindings/$pkg/$pkg.go"
}

function go-bindings() {
  # check if the $SOLC_DOCKER_IMAGE image exists
  # and only build it if it doesn't
  if [[ -z $(docker images -q $SOLC_DOCKER_IMAGE) ]]; then
    docker build -t $SOLC_DOCKER_IMAGE hardhat/solc
  fi
  mkdir -p pkg/web3/bindings
  go-binding CoopHiveToken token
  go-binding CoopHivePayments payments
  go-binding CoopHiveStorage storage
  go-binding CoopHiveUsers users
  go-binding CoopHiveMediationRandom mediation
  go-binding CoopHiveOnChainJobCreator jobcreator
  go-binding CoopHiveController controller
  
  echo "Generated all go bindings pkg/contract/bindings/"
}

function compile-contracts() {
  (
    set -euo pipefail
    cd hardhat
    npx hardhat compile
  )
  go-bindings
}

function deploy-contracts() {
  (
    set -euo pipefail
    cd hardhat
    npx hardhat deploy --network "$NETWORK"
  )
}

function redeploy-storage() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$ADMIN_PRIVATE_KEY
  export NETWORK=$NETWORK
  (
    set -euo pipefail
    cd hardhat
    npx hardhat run scripts/redeploy-storage.ts --network "$NETWORK"
  )
}

function hardhat-script() {
  (
    set -euo pipefail
    cd hardhat
    npx hardhat run "$@"
  )
}

# print the env settings for the various accounts and private keys
function print-env() {
  hardhat-script scripts/print-env.ts | grep export
}

function print-contract-env() {
  hardhat-script scripts/print-contract-env.ts | grep export
}

function generate-addresses() {
  hardhat-script scripts/generate-addresses.ts | grep export
}

function print-local-dev-env() {
  print-contract-env
}

function fund-services-ether() {
  hardhat-script scripts/fund-services-ether.ts
}

function fund-services-tokens() {
  hardhat-script scripts/fund-services-tokens.ts
}

function balances() {
  hardhat-script scripts/balances.ts
}

function run-cowsay-onchain() {
  export WEB3_PRIVATE_KEY=$JOB_CREATOR_PRIVATE_KEY
  hardhat-script scripts/run-cowsay-onchain.ts
}

############################################################################
############################################################################
# services
############################################################################
############################################################################

function run() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$JOB_CREATOR_PRIVATE_KEY
  export SERVICE_SOLVER=$SOLVER_ADDRESS
  export SERVICE_MEDIATORS=$MEDIATOR_ADDRESS
  echo "$@"
  go run . run "$@"
}

function runsdxl() {
  # Check for the number of arguments provided
  if [ $# -lt 3 ]; then
    echo "Usage: $0 runsdxl <model> PROMPT=\"<prompt>\""
    exit 1
  fi

  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$JOB_CREATOR_PRIVATE_KEY
  export SERVICE_SOLVER=$SOLVER_ADDRESS
  export SERVICE_MEDIATORS=$MEDIATOR_ADDRESS
  local model="$1"
  shift  # Remove the first argument, so "$@" contains only the second one
  local prompt="$@"
  go run . run $model -i "PromptEnv=$prompt"
}

function solver() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$SOLVER_PRIVATE_KEY
  export JOB_CREATOR_ADDRESS=$JOB_CREATOR_ADDRESS
  export SERVICE_MEDIATORS=$MEDIATOR_ADDRESS
  export SERVER_PORT=8080
  export SERVER_URL=http://localhost:8080
  echo "Starting solver"
  go run . solver "$@"
}

# we run the jobcreator as the solver
function jobcreator() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$SOLVER_PRIVATE_KEY
  export SERVICE_SOLVER=$SOLVER_ADDRESS
  export SERVICE_MEDIATORS=$MEDIATOR_ADDRESS
  echo "Starting jobcreator"
  go run . jobcreator "$@"
}

function resource-provider() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$RESOURCE_PROVIDER_PRIVATE_KEY
  export SERVICE_SOLVER=$SOLVER_ADDRESS
  export SERVICE_MEDIATORS=$MEDIATOR_ADDRESS
  echo "Starting resource provider"
  go run . resource-provider "$@"
}

function mediator() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_PRIVATE_KEY=$MEDIATOR_PRIVATE_KEY
  export SERVICE_SOLVER=$SOLVER_ADDRESS
  echo "Starting mediator"
  go run . mediator "$@"
}

############################################################################
############################################################################
# tests
############################################################################
############################################################################

function unit-tests() {
  (
    set -euo pipefail
    cd hardhat
    npx hardhat test --network hardhat
  )
}

# this assumes boot having been run already
function integration-tests() {
  source .env
  eval $(./stack print-local-dev-env)
  export WEB3_SOLVER_ADDRESS=$SOLVER_ADDRESS
  export SERVICE_SOLVER=$SOLVER_ADDRESS
  export SERVICE_MEDIATORS=$MEDIATOR_ADDRESS
  (
    set -euo pipefail
    cd test
    go test -v -count 1 .
  )
}


eval "$@"