bootstrap.sh.bak

#!/bin/bash
#
#
#    ▄▄▄▄▄▄
#   ███▀▀▀██▄      nesaorg/bootstrap
#   ███   ███ ███████ ███████  █████
#   ███   ███ ██      ██      ██   ██
#   ▄▄▄   ███ █████   ███████ ███████
#   ███   ███ ██           ██ ██   ██
#   ███   ███ ███████ ███████ ██   ██
#
#
#   noteworthy conventions: variables that are exported to the config file or the container environment files are in all caps

#
# vars
#

trap 'trap " " SIGINT SIGTERM SIGHUP; kill 0; wait; sigterm_handler' SIGINT SIGTERM SIGHUP

# ---- global bootstrap logging (captures ALL stdout/err while keeping the screen interactive) ----
DEFAULT_WORKDIR="${HOME}/.nesa"
LOG_DIR="${DEFAULT_WORKDIR}/logs"
mkdir -p "${LOG_DIR}"



# Mirror STDOUT and STDERR to file; only the copy to file is timestamped.
# This preserves gum's interactive UI on the terminal.
# exec > >(tee >(awk '{ printf "[%s] %s\n", strftime("%Y-%m-%dT%H:%M:%SZ"), $0; fflush() }' >> "${LOG_DIR}/bootstrap.log"))
# exec 2> >(tee >(awk '{ printf "[%s] %s\n", strftime("%Y-%m-%dT%H:%M:%SZ"), $0; fflush() }' >> "${LOG_DIR}/bootstrap.log") >&2)
# -----------------------------------------------------------------------------------------------
LOG_FILE="${LOG_DIR}/bootstrap.log"
_ts() { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
log_line() { printf "[%s] %s\n" "$(_ts)" "$*" >>"$LOG_FILE"; }
log_stream() { while IFS= read -r line; do printf "[%s] %s\n" "$(_ts)" "$line" >>"$LOG_FILE"; done; }
run_and_log() {
  local title="$1"
  shift
  log_line "BEGIN: $title — $*"
  if gum spin -s line --title "$title" -- "$@" 2> >(log_stream) | log_stream; then
    log_line "END: $title (ok)"
    return 0
  else
    log_line "END: $title (fail)"
    return 1
  fi
}

DEFAULT_WORKDIR="${HOME}/.nesa"
LOG_DIR="${DEFAULT_WORKDIR}/logs"
ENV_DIR="${DEFAULT_WORKDIR}/env"
mkdir -p "${DEFAULT_WORKDIR}" "${LOG_DIR}" "${ENV_DIR}"

: > "${LOG_DIR}/bootstrap.log"
touch "${ENV_DIR}/base.env" "${ENV_DIR}/orchestrator.env" "${DEFAULT_WORKDIR}/.env"

sigterm_handler() {
  printf "\n Aborting node setup. Cleaning up...\n"
  # Add any additional cleanup tasks here
  echo
  exit 1
}

# set -x
terminal_size=$(stty size)
terminal_height=${terminal_size% *}
terminal_width=${terminal_size#* }
prompt_height=${PROMPT_HEIGHT:-1}
main_color=43
link_color=69
logo=$(gum style '   ▄▄▄▄▄▄
  ███▀▀▀██▄
  ███   ███
  ███   ███
  ▄▄▄   ███
  ███   ███
  ███   ███')

CHAIN_ID="nesa-testnet-3"
domain="test.nesa.sh"

chain_container="ghcr.io/nesaorg/nesachain:testnet-latest"
import_key_expect_url="https://raw.githubusercontent.com/nesaorg/bootstrap/master/import_key.expect"
node_id_file="$HOME/.nesa/identity/node_id.id"

miner_type_none=0
miner_type_non_distributed=1
miner_type_distributed=2
miner_type_agnostic=3

distributed_type_none=0
distributed_type_new_swarm=1
distributed_type_existing_swarm=2
distributed_type_agnostic=3

# this will never load from the env file, but if they know to override it via ENV vars then they can

WORKING_DIRECTORY=${WORKING_DIRECTORY:-"$DEFAULT_WORKDIR"}
env_dir="$WORKING_DIRECTORY/env"

orchestrator_env_file="$env_dir/orchestrator.env"
base_env_file="$env_dir/base.env"
config_env_file="$env_dir/.env"
init_pwd=$PWD    # so they can get back to where they started!
status="booting" # lol not really doing anything with this currently
ORC_PORT=31333

MONIKER=${MONIKER:-$(hostname -s)}
#
# basic helper functions
#

# print if the output fits on screen
print_test() {
  local no_color
  local max_length
  no_color=$(printf '%b' "${1}" | sed -e 's/\x1B\[[0-9;]*[JKmsu]//g')
  max_length=$(max_line_length "$no_color")

  [ "$(printf '%s' "${no_color}" | wc -l)" -gt $((terminal_height - prompt_height)) ] && return 1
  [ "$max_length" -gt "$terminal_width" ] && return 1

  gum style --align center --width="${terminal_width}" "${1}" ''
  printf '%b' "\033[A"
}

update_header() {
  local dashboard_url
  local op_dashboard_url
  local public_key
  local current_width
  local header

  # Re-read terminal size in case it changed
  terminal_size=$(stty size 2>/dev/null || echo "24 80")
  terminal_height=${terminal_size% *}
  terminal_width=${terminal_size#* }

  if [[ "$NODE_ID" == "pending..." ]]; then
    dashboard_url="https://node.nesa.ai"
  else
    dashboard_url="https://node.nesa.ai/nodes/$NODE_ID"
  fi

  if [[ -n "$NODE_PRIV_KEY" ]]; then
    public_key=$(generate_public_key "$NODE_PRIV_KEY")
    op_dashboard_url="https://node.nesa.ai/$public_key/list"
  else
    public_key="pending..."
    op_dashboard_url="pending..."
  fi

  # Minimum width for horizontal layout (logo + spacer + info panel)
  local min_horizontal_width=100

  if [[ "$terminal_width" -ge "$min_horizontal_width" ]]; then
    # Wide terminal: horizontal layout (logo on left, info on right)
    info=$(gum style "[1;38;5;${main_color}m  ${MONIKER}.${domain}
  ----------------
  [1;38;5;${main_color}mnode id:       ${NODE_ID}
  [1;38;5;${main_color}mpublic key:    ${public_key}
  [1;38;5;${main_color}mdashboard:     [0;38;5;${link_color}m${dashboard_url}
  [1;38;5;${main_color}mop dash:       [0;38;5;${link_color}m${op_dashboard_url}
  [1;38;5;${main_color}mstatus:        ${status}")
    header=$(gum join --horizontal --align top "${logo}" '  ' "${info}")
  else
    # Narrow terminal: vertical layout (logo on top, info below)
    # Truncate long values to fit
    local max_val_width=$((terminal_width - 16))
    local trunc_node_id="${NODE_ID}"
    local trunc_pubkey="${public_key}"
    local trunc_dashboard="${dashboard_url}"
    local trunc_op_dash="${op_dashboard_url}"

    if [[ ${#NODE_ID} -gt $max_val_width ]]; then
      trunc_node_id="${NODE_ID:0:$((max_val_width-3))}..."
    fi
    if [[ ${#public_key} -gt $max_val_width ]]; then
      trunc_pubkey="${public_key:0:$((max_val_width-3))}..."
    fi
    if [[ ${#dashboard_url} -gt $max_val_width ]]; then
      trunc_dashboard="${dashboard_url:0:$((max_val_width-3))}..."
    fi
    if [[ ${#op_dashboard_url} -gt $max_val_width ]]; then
      trunc_op_dash="${op_dashboard_url:0:$((max_val_width-3))}..."
    fi

    info=$(gum style "[1;38;5;${main_color}m${MONIKER}.${domain}
----------------
[1;38;5;${main_color}mnode id:    ${trunc_node_id}
[1;38;5;${main_color}mpublic key: ${trunc_pubkey}
[1;38;5;${main_color}mdashboard:  [0;38;5;${link_color}m${trunc_dashboard}
[1;38;5;${main_color}mop dash:    [0;38;5;${link_color}m${trunc_op_dash}
[1;38;5;${main_color}mstatus:     ${status}")
    header=$(gum join --vertical --align center "${logo}" "${info}")
  fi

  echo -e "\n"
  print_test "${header}"
  echo -e "\n"
}

# check if a command exists
command_exists() {
  command -v "$1" >/dev/null 2>&1
}

# error handling function
handle_install_failure() {
  echo "Failed to install Gum using available methods due to permissions or unsupported OS..."
  echo "Please install Gum manually by visiting: https://github.com/charmbracelet/gum"
  exit 1
}

# install gum using Go
install_gum_go() {
  echo "Installing Gum using Go..."
  go install github.com/charmbracelet/gum@latest || handle_install_failure
}

# install gum based on the operating system and availability of Go
install_gum() {
  # Try to install using Go if available
  if command_exists go; then
    install_gum_go
    return
  fi

  case "$(uname -s)" in
  Darwin)
    echo "Installing Gum using Homebrew..."
    brew install gum || handle_install_failure
    ;;
  Linux)
    if command_exists apt-get; then
      echo "Installing Gum on Ubuntu/Debian..."
      sudo mkdir -p /etc/apt/keyrings
      curl -fsSL https://repo.charm.sh/apt/gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/charm.gpg
      echo "deb [signed-by=/etc/apt/keyrings/charm.gpg] https://repo.charm.sh/apt/ * *" | sudo tee /etc/apt/sources.list.d/charm.list
      sudo apt update && sudo apt install gum || handle_install_failure
    elif command_exists pacman; then
      echo "Installing Gum using pacman..."
      sudo pacman -S gum || handle_install_failure
    elif command_exists nix-env; then
      echo "Installing Gum using Nix..."
      nix-env -iA nixpkgs.gum || handle_install_failure
    else
      handle_install_failure
    fi
    ;;
  CYGWIN* | MINGW32* | MSYS* | MINGW*)
    if command_exists winget; then
      echo "Installing Gum using WinGet..."
      winget install charmbracelet.gum || handle_install_failure
    elif command_exists scoop; then
      echo "Installing Gum using Scoop..."
      scoop install charm-gum || handle_install_failure
    else
      handle_install_failure
    fi
    ;;
  *)
    handle_install_failure
    ;;
  esac
}
log_line "[STAGE 1]: checking deps (gum, jq, python)"

check_gum_installed() {
  if ! command_exists gum; then
    echo "Attempting to install gum..."
    install_gum
  fi
}

check_jq_installed() {
  if ! command -v jq &>/dev/null; then
    install_jq
  fi
}

install_jq() {
  case "$(uname -s)" in
  Linux)
    if command -v apt-get &>/dev/null; then
      gum spin -s line --title "Installing jq with apt-get..." -- sudo apt-get update && sudo apt-get install -y jq
    elif command -v yum &>/dev/null; then
      gum spin -s line --title "Installing jq with yum..." -- sudo yum install -y jq
    elif command -v pacman &>/dev/null; then
      gum spin -s line --title "Installing jq with pacman..." -- sudo pacman -Sy jq
    elif command -v zypper &>/dev/null; then
      gum spin -s line --title "Installing jq with zypper..." -- sudo zypper install -y jq
    elif command -v dnf &>/dev/null; then
      gum spin -s line --title "Installing jq with dnf..." -- sudo dnf install -y jq
    else
      echo "Package manager not found. Please install jq manually."
      exit 1
    fi
    ;;
  Darwin)
    if command -v brew &>/dev/null; then
      gum spin -s line --title "Installing jq with brew..." -- brew install jq
    else
      echo "Homebrew is not installed. Please install jq manually."
      exit 1
    fi
    ;;
  *)
    echo "Unsupported OS. Please install jq manually."
    exit 1
    ;;
  esac
}

# check if Docker is installed
check_docker_installed() {
  if ! command_exists docker; then
    echo "Docker is not installed. Please install Docker and try again."
    exit 1
  fi
}

check_python_and_ecdsa() {
  if ! command -v python3 &>/dev/null; then
    echo "Python 3 is not installed. Please install Python 3 and try again."
    exit 1
  fi

  # Check and install required Python libraries
  local missing_libs=()

  if ! python3 -c "import ecdsa" &>/dev/null; then
    missing_libs+=("ecdsa")
  fi

  if ! python3 -c "import base58" &>/dev/null; then
    missing_libs+=("base58")
  fi

  if ! python3 -c "from cryptography.hazmat.primitives.asymmetric import ed25519" &>/dev/null; then
    missing_libs+=("cryptography")
  fi

  if ! python3 -c "import mospy" &>/dev/null; then
    missing_libs+=("mospy-wallet")
  fi

  if ! python3 -c "import httpx" &>/dev/null; then
    missing_libs+=("httpx")
  fi

  if ! python3 -c "import betterproto" &>/dev/null; then
    missing_libs+=("betterproto")
  fi

  if [ ${#missing_libs[@]} -gt 0 ]; then
    echo "Installing required Python libraries: ${missing_libs[*]}..."
    pip3 install "${missing_libs[@]}"
  fi
}

# TODO: handle the need for sudo here -.-
# check_nvidia_installed() {
#     if ! command_exists nvidia-smi; then
#         echo "NVIDIA drivers are not installed. Please install NVIDIA drivers and try again."
#         exit 1
#     fi

#     if ! command_exists nvidia-container-runtime; then
#         sudo curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
#             && sudo curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
#             sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
#             sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

#         sudo apt-get update
#         sudo apt-get install -y nvidia-container-toolkit

#         sudo nvidia-ctk runtime configure --runtime=docker
#         sudo systemctl restart docker
#     fi
# }

# calculate max line length of the input
max_line_length() {
  local max_len
  local line_len
  max_len=0

  IFS=$'\n'
  for line in $1; do
    line_len=${#line}
    if ((line_len > max_len)); then
      max_len=$line_len
    fi
  done
  echo "$max_len"
}

download_import_key_expect() {
  # curl -o import_key.expect "$IMPORT_KEY_EXPECT_URL"

  cp import_key.expect "$WORKING_DIRECTORY/"
  chmod +x "$WORKING_DIRECTORY/import_key.expect"

}

get_linux_info() {
  local name version kernel architecture cpu cores ram disk_avail gpu gpu_count gpu_memory
  if [ -f /etc/os-release ]; then
    . /etc/os-release
    name=$NAME
    version=$VERSION
  else
    name="Not Available"
    version="Not Available"
  fi
  kernel=$(uname -r)
  architecture=$(uname -m)
  cpu=$(lscpu | grep 'Model name' | awk -F: '{print $2}' | sed 's/^ *//')
  cores=$(lscpu | grep '^CPU(s):' | awk '{print $2}')
  ram=$(free -h | grep Mem | awk '{print $2}')
  disk_avail=$(df -h --total | grep total | awk '{print $4}')

  gpu=$(lspci | grep -i -e '3D controller' -e 'VGA compatible controller' | grep -i -e nvidia -e amd | awk -F: '{print $3}' | sed 's/^ *//')
  gpu_count=$(lspci | grep -i -e '3D controller' -e 'VGA compatible controller' | grep -i -e nvidia -e amd | wc -l | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')

  gpu_memory=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits 2>/dev/null | awk '{total += $1} END {print total " MB"}')

  if [ -z "$gpu_memory" ]; then
    gpu_memory=$(lshw -C display 2>/dev/null | grep -i size | awk '{print $2 " " $3}' | head -n 1)
  fi

  NODE_OS="Linux $version"
  NODE_ARCH="$architecture"
  NODE_CPU="$cpu"
  NODE_CORES="$cores"
  NODE_GPU="${gpu:-NA}"
  NODE_GPU_COUNT="${gpu_count:-0}"
  NODE_RAM="$ram"
  NODE_VRAM="${gpu_memory:-NA}"
  NODE_DISK_AVAIL="$disk_avail"
}

get_macos_info() {
  local product_version build_version architecture cpu cores ram disk_avail gpu gpu_count gpu_memory
  product_version=$(sw_vers -productVersion)
  build_version=$(sw_vers -buildVersion)
  architecture=$(uname -m)
  cpu=$(sysctl -n machdep.cpu.brand_string)
  cores=$(sysctl -n hw.ncpu)
  ram=$(sysctl -n hw.memsize | awk '{print $1/1024/1024/1024 " GB"}')
  disk_avail=$(df -h / | grep / | awk '{print $4}')

  gpu=$(system_profiler SPDisplaysDataType | grep 'Chipset Model' | awk -F: '{print $2}' | sed 's/^ *//')
  gpu_count=$(system_profiler SPDisplaysDataType | grep 'Chipset Model' | wc -l | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
  gpu_memory=$(system_profiler SPDisplaysDataType | grep 'VRAM' | awk -F: '{total += $2} END {print total " MB"}' | sed 's/^ *//')

  NODE_OS="MacOS $product_version ($build_version)"
  NODE_ARCH="$architecture"
  NODE_CPU="$cpu"
  NODE_CORES="$cores"
  NODE_GPU="${gpu:-NA}"
  NODE_GPU_COUNT="${gpu_count:-0}"
  NODE_RAM="$ram"
  NODE_VRAM="${gpu_memory:-NA}"
  NODE_DISK_AVAIL="$disk_avail"
}

get_windows_info() {
  local caption version architecture cpu cores ram disk_avail gpu gpu_count gpu_memory
  caption=$(wmic os get Caption /value | awk -F= '{print $2}')
  version=$(wmic os get Version /value | awk -F= '{print $2}')
  architecture=$(wmic os get OSArchitecture /value | awk -F= '{print $2}')
  cpu=$(wmic cpu get name /value | awk -F= '{print $2}')
  cores=$(wmic cpu get NumberOfCores /value | awk -F= '{print $2}')
  ram=$(wmic computersystem get totalphysicalmemory /value | awk -F= '{print $2/1024/1024/1024 " GB"}')
  disk_avail=$(wmic logicaldisk get size,freespace,caption | awk '{if ($1 == "C:") print $3/1024/1024/1024 " GB"}')

  gpu=$(wmic path win32_videocontroller get name /value | awk -F= '{print $2}')
  gpu_count=$(wmic path win32_videocontroller get name /value | grep -c "Name" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
  gpu_memory=$(wmic path win32_videocontroller get AdapterRAM /value | awk -F= '{total += $2} END {print total/1024/1024 " MB"}')

  NODE_OS="Windows $caption $version"
  NODE_ARCH="$architecture"
  NODE_CPU="$cpu"
  NODE_CORES="$cores"
  NODE_GPU="${gpu:-NA}"
  NODE_GPU_COUNT="${gpu_count:-0}"
  NODE_RAM="$ram"
  NODE_VRAM="${gpu_memory:-NA}"
  NODE_DISK_AVAIL="$disk_avail"
}

get_wsl_info() {
  local name version kernel architecture cpu cores ram disk_avail gpu gpu_count gpu_memory
  if [ -f /etc/os-release ]; then
    . /etc/os-release
    name=$NAME
    version=$VERSION
  else
    name="Not Available"
    version="Not Available"
  fi
  kernel=$(uname -r)
  architecture=$(uname -m)
  cpu=$(grep -m1 'model name' /proc/cpuinfo | awk -F: '{print $2}' | sed 's/^ *//')
  cores=$(grep -c '^processor' /proc/cpuinfo)
  ram=$(free -h | grep Mem | awk '{print $2}')
  disk_avail=$(df -h --total | grep total | awk '{print $4}')

  if command -v nvidia-smi &>/dev/null; then
    gpu=$(nvidia-smi --query-gpu=name --format=csv,noheader)
    gpu_count=$(nvidia-smi --query-gpu=name --format=csv,noheader | wc -l)
    gpu_memory=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | awk '{total += $1} END {print total " MB"}')
  else
    gpu="NA"
    gpu_count=0
    gpu_memory="NA"
  fi

  NODE_OS="WSL $version ($kernel)"
  NODE_ARCH="$architecture"
  NODE_CPU="$cpu"
  NODE_CORES="$cores"
  NODE_GPU="${gpu:-NA}"
  NODE_GPU_COUNT="${gpu_count:-0}"
  NODE_RAM="$ram"
  NODE_VRAM="${gpu_memory:-NA}"
  NODE_DISK_AVAIL="$disk_avail"
}
log_line "[STAGE 2]: detecting hardware capabilities"

detect_hardware_capabilities() {
  case "$(uname -s)" in
  Linux)
    if grep -q Microsoft /proc/version; then
      get_wsl_info
    else
      get_linux_info
    fi
    ;;
  Darwin)
    get_macos_info
    ;;
  CYGWIN* | MINGW* | MSYS*)
    get_windows_info
    ;;
  *)
    echo "Unsupported platform"
    ;;
  esac
}

log_line "[STAGE 3]: setup work dir"
setup_work_dir() {
  if [ ! -d "$WORKING_DIRECTORY" ]; then
    mkdir -p "$WORKING_DIRECTORY"
  fi

  cd "$WORKING_DIRECTORY" || {
    echo -e "Error changing to working directory: $WORKING_DIRECTORY"
    exit 1
  }

  setup_docker_repository
}

setup_docker_repository() {
  if [ ! -d "docker" ]; then
    gum spin -s line --title "Cloning the nesaorg/docker repository..." -- git clone https://github.com/nesaorg/docker.git
  else
    cd docker
    gum spin -s line --title "Pulling latest updates from nesaorg/docker repository..." -- git pull
    cd ..
  fi

  # Create symlink for env directory
  if [ -d "docker" ]; then
    ln -sfn "$env_dir" "docker/env"
  else
    echo "Error: Docker directory does not exist."
    exit 1
  fi
}

get_swarms_map() {
  local url="https://lcd.test.nesa.ai/nesachain/dht/get_orchestrators"
  local json_data
  local excluded_node_ids
  local exclude_node_ids_json
  local map=()

  excluded_node_ids=(
    "QmbtSFavybyKNkP2MAhVftA4S7tAW5HXvbKGiX9hHx9XqF|mistralai|Mixtral-8x7B-Instruct-v0.1"
    "QmR58ndfebR3LXNxT5qx3FgXMkb4AptjpDM83r1CXfAhAw|mistralai|Mixtral-8x7B-Instruct-v0.1"
    "Qmc6GZVS41EzzU5j13cy1pL3HjhwJfaf1N71cjp2zt18HX|Orenguteng|Llama-3-8B-Lexi-Uncensored"
    "QmR4Gi37D1cPnihhkvRG9kRGtBtXYxwAYo92x6y1FYxmij|bigscience|bloom-560m"
    "QmeCvBP1N3BqDiQc7hGxNFgrtguVHncqGKChJJeMZtsM8C|randommodel"
    "QmUxwnuEKAEY9CnB4tEPKvmwK6h6pmuSN3V28vQ9A3s8qQ|randommodel22"
  )

  exclude_node_ids_json=$(printf '%s\n' "${excluded_node_ids[@]}" | jq -R . | jq -s .)

  json_data=$(curl -s "$url")

  map=$(echo "$json_data" | jq -r --argjson exclude_node_ids "$exclude_node_ids_json" '
        .orchestrators |
        map(select(.node_id | (contains("/") | not))) |
        map(select(.node_id as $id | $exclude_node_ids | index($id) | not)) |
        map(
            {
                "node_id": (.node_id | split("|")[0]),
                "organization": (.node_id | split("|")[1]),
                "model_name": (.node_id | split("|")[2]),
                "model_id": ((.node_id | split("|")[1]) + "/" + (.node_id | split("|")[2]))
            }
        )
    ')

  echo "$map"
}

get_model_names() {
  local map="$1"
  local model_names

  model_names=$(echo "$map" | jq -r '.[] | .model_id' | sort | uniq)

  echo "$model_names"
}

get_node_id() {
  local map="$1"
  local model_id="$2"

  local node_id
  node_id=$(echo "$map" | jq -r --arg model_id "$model_id" '
        .[] | select(.model_id == $model_id) | .node_id
    ')

  echo "$node_id"
}

create_combined_node_id() {
  local map="$1"
  local model_id="$2"

  local node_info
  node_info=$(echo "$map" | jq -r --arg model_id "$model_id" '
        .[] | select(.model_id == $model_id) | "\(.node_id)|\(.organization)|\(.model_name)"
    ')

  echo "$node_info"
}

fetch_network_address() {
  local recreated_node_id="$1"
  local url="https://lcd.test.nesa.ai/nesachain/dht/get_node/$recreated_node_id"
  local json_data
  local network_address

  json_data=$(curl -s "$url")
  network_address=$(echo "$json_data" | jq -r '.node.network_address')

  echo "$network_address"
}

generate_public_key() {
  local private_key="$1"
  python3 -c "
import ecdsa

def strip_0x_prefix(key_hex):
    return key_hex[2:] if key_hex.startswith('0x') else key_hex

def private_key_to_public_key(private_key_hex):
    private_key_hex = strip_0x_prefix(private_key_hex)
    private_key_bytes = bytes.fromhex(private_key_hex)
    sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    public_key_compressed = b'\x02' + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b'\x03' + vk.to_string()[:32]
    return public_key_compressed.hex()

print(private_key_to_public_key('$private_key'))
"
}

# Derive wallet address from private key (bech32 format)
derive_wallet_address() {
  local private_key="$1"
  local prefix="${2:-nesa}"

  python3 -c "
import hashlib
import ecdsa

def bech32_polymod(values):
    GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
    chk = 1
    for v in values:
        b = chk >> 25
        chk = (chk & 0x1ffffff) << 5 ^ v
        for i in range(5):
            chk ^= GEN[i] if ((b >> i) & 1) else 0
    return chk

def bech32_hrp_expand(hrp):
    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]

def bech32_create_checksum(hrp, data):
    values = bech32_hrp_expand(hrp) + data
    polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ 1
    return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]

def bech32_encode(hrp, data):
    combined = data + bech32_create_checksum(hrp, data)
    return hrp + '1' + ''.join([\"qpzry9x8gf2tvdw0s3jn54khce6mua7l\"[d] for d in combined])

def convertbits(data, frombits, tobits, pad=True):
    acc = 0
    bits = 0
    ret = []
    maxv = (1 << tobits) - 1
    for value in data:
        acc = (acc << frombits) | value
        bits += frombits
        while bits >= tobits:
            bits -= tobits
            ret.append((acc >> bits) & maxv)
    if pad:
        if bits:
            ret.append((acc << (tobits - bits)) & maxv)
    return ret

def strip_0x_prefix(key_hex):
    return key_hex[2:] if key_hex.startswith('0x') else key_hex

def private_key_to_address(private_key_hex, prefix='$prefix'):
    private_key_hex = strip_0x_prefix(private_key_hex)
    private_key_bytes = bytes.fromhex(private_key_hex)
    sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    public_key_compressed = b'\x02' + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b'\x03' + vk.to_string()[:32]

    sha256_hash = hashlib.sha256(public_key_compressed).digest()
    ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()

    five_bit_data = convertbits(ripemd160_hash, 8, 5)
    return bech32_encode(prefix, five_bit_data)

print(private_key_to_address('$private_key'))
"
}

# Generate NODE_ID from private key (deterministic derivation)
# Algorithm: SHA256(priv_key) -> Ed25519 seed -> Ed25519 pubkey -> SHA256 -> Base58
generate_node_id() {
  local private_key="$1"
  python3 -c "
import hashlib
import base58
from cryptography.hazmat.primitives.asymmetric import ed25519
from cryptography.hazmat.primitives import serialization

def strip_0x_prefix(key_hex):
    return key_hex[2:] if key_hex.startswith('0x') else key_hex

def derive_node_id(private_key_hex):
    private_key_hex = strip_0x_prefix(private_key_hex)
    private_key_bytes = bytes.fromhex(private_key_hex)

    # Derive Ed25519 seed from secp256k1 private key
    seed = hashlib.sha256(private_key_bytes).digest()

    # Create Ed25519 key from seed
    ed_private_key = ed25519.Ed25519PrivateKey.from_private_bytes(seed)
    ed_public_key = ed_private_key.public_key()

    # Get raw public key bytes
    public_bytes = ed_public_key.public_bytes(
        encoding=serialization.Encoding.Raw,
        format=serialization.PublicFormat.Raw
    )

    # Hash and encode
    public_key_hash = hashlib.sha256(public_bytes).digest()
    return base58.b58encode(public_key_hash).decode('utf-8')

print(derive_node_id('$private_key'))
"
}

# Check wallet balance (UNES tokens)
check_wallet_balance() {
  local wallet_address="$1"
  local lcd_url="https://lcd.dev.nesa.ai"

  log_line "Checking wallet balance for ${wallet_address}"

  # Query balance via LCD REST API
  local balance_endpoint="${lcd_url}/cosmos/bank/v1beta1/balances/${wallet_address}"

  local json_data
  local http_code
  json_data=$(curl -s -w "\n%{http_code}" "$balance_endpoint" 2>&1)
  http_code=$(echo "$json_data" | tail -1)
  json_data=$(echo "$json_data" | sed '$d')

  if [ "$http_code" != "200" ]; then
    local err_msg="HTTP $http_code"
    if [ -n "$json_data" ]; then
      local api_err=$(echo "$json_data" | jq -r '.message // .error // empty' 2>/dev/null)
      [ -n "$api_err" ] && err_msg="$err_msg: $api_err"
    fi
    echo "error|0|0|${err_msg}"
    log_line "Error querying balance: $err_msg"
    return 1
  fi

  # Extract UNES balance
  local unes_balance
  unes_balance=$(echo "$json_data" | jq -r '.balances[] | select(.denom == "unes") | .amount' 2>/dev/null)

  if [ -z "$unes_balance" ] || [ "$unes_balance" = "null" ]; then
    unes_balance="0"
  fi

  # Convert from microunes to UNES (use awk for consistent formatting with leading zeros)
  local unes_display
  unes_display=$(awk "BEGIN {printf \"%.6f\", $unes_balance / 1000000}")

  echo "ok|$unes_balance|$unes_display"
}

# Check miner deposit status
check_miner_deposit() {
  local node_id="$1"
  local lcd_url="https://lcd.dev.nesa.ai"

  log_line "Checking miner deposit for node ${node_id}"

  # Query miner via LCD REST API
  local miner_endpoint="${lcd_url}/nesachain/dht/get_miner/${node_id}"

  local json_data
  local http_code
  json_data=$(curl -s -w "\n%{http_code}" "$miner_endpoint" 2>&1)
  http_code=$(echo "$json_data" | tail -1)
  json_data=$(echo "$json_data" | sed '$d')

  # Check for API-level errors (returned in JSON even with HTTP 200)
  local api_code
  api_code=$(echo "$json_data" | jq -r '.code // 0' 2>/dev/null)

  if [ "$http_code" != "200" ] || [ "$api_code" != "0" ]; then
    local err_msg="HTTP $http_code"
    if [ -n "$json_data" ]; then
      local api_err=$(echo "$json_data" | jq -r '.message // .error // empty' 2>/dev/null)
      [ -n "$api_err" ] && err_msg="$api_err"
    fi

    # If error is "miner not found", treat it as not registered (not an error)
    if [[ "$err_msg" == *"miner not found"* ]]; then
      echo "ok|0|0|not_registered|unes"
      return 0
    fi

    echo "error|0|0|not_registered|unes|${err_msg}"
    log_line "Error querying miner: $err_msg"
    return 1
  fi

  # Check if miner exists
  local miner_exists
  miner_exists=$(echo "$json_data" | jq -r '.miner' 2>/dev/null)

  if [ "$miner_exists" = "null" ] || [ -z "$miner_exists" ]; then
    echo "ok|0|0|not_registered|unes"
    return 0
  fi

  # Extract deposit information
  local deposit_amount
  local deposit_denom
  local bond_status

  deposit_amount=$(echo "$json_data" | jq -r '.miner.deposit.amount // "0"')
  deposit_denom=$(echo "$json_data" | jq -r '.miner.deposit.denom // "unes"')
  bond_status=$(echo "$json_data" | jq -r '.miner.bond_status // 0')

  # Convert bond status to readable format (handles both numeric and string enum)
  case "$bond_status" in
    0|"BOND_STATUS_UNBONDED") bond_status="unbonded" ;;
    1|"BOND_STATUS_UNBONDING") bond_status="unbonding" ;;
    2|"BOND_STATUS_BONDED") bond_status="bonded" ;;
    *) bond_status="unknown" ;;
  esac

  # Convert from microunes to UNES (use awk for consistent formatting with leading zeros)
  local deposit_display
  deposit_display=$(awk "BEGIN {printf \"%.6f\", $deposit_amount / 1000000}")

  echo "ok|$deposit_amount|$deposit_display|$bond_status|$deposit_denom"
}

# Check if node is registered on chain
# Returns: ok|registered or ok|not_registered or error|message
check_node_registered() {
  local node_id="$1"
  local lcd_url="https://lcd.dev.nesa.ai"

  log_line "Checking node registration for ${node_id}"

  local node_endpoint="${lcd_url}/nesachain/dht/get_node/${node_id}"

  local json_data
  local http_code
  json_data=$(curl -s -w "\n%{http_code}" "$node_endpoint" 2>&1)
  http_code=$(echo "$json_data" | tail -1)
  json_data=$(echo "$json_data" | sed '$d')

  local api_code
  api_code=$(echo "$json_data" | jq -r '.code // 0' 2>/dev/null)

  if [ "$http_code" != "200" ] || [ "$api_code" != "0" ]; then
    local err_msg="HTTP $http_code"
    if [ -n "$json_data" ]; then
      local api_err=$(echo "$json_data" | jq -r '.message // .error // empty' 2>/dev/null)
      [ -n "$api_err" ] && err_msg="$api_err"
    fi

    # "node not found" means not registered
    if [[ "$err_msg" == *"node not found"* ]] || [[ "$err_msg" == *"not found"* ]]; then
      echo "ok|not_registered"
      return 0
    fi

    echo "error|${err_msg}"
    return 1
  fi

  local node_exists
  node_exists=$(echo "$json_data" | jq -r '.node.node_id // empty' 2>/dev/null)

  if [ -z "$node_exists" ]; then
    echo "ok|not_registered"
  else
    echo "ok|registered"
  fi
}

# Register node on chain (MsgRegisterNode)
# Returns: success|tx_hash or error|message
register_node() {
  local node_id="$1"
  local private_key="$2"
  local public_name="${3:-nesa-miner}"
  local version="${4:-v1.0.0}"
  local network_address="${5:-127.0.0.1:8080}"
  local vram="${6:-8000000000}"
  local network_rps="${7:-100.0}"

  log_line "Registering node: node_id=$node_id"

  python3 << PYEOF
import sys
import json
from dataclasses import dataclass
import betterproto
from mospy import Account, Transaction
from mospy.clients import HTTPClient
from google.protobuf import any_pb2 as any_pb

# Define MsgRegisterNode
@dataclass(eq=False, repr=False)
class MsgRegisterNode(betterproto.Message):
    creator: str = betterproto.string_field(1)
    node_id: str = betterproto.string_field(2)
    public_name: str = betterproto.string_field(3)
    version: str = betterproto.string_field(4)
    network_address: str = betterproto.string_field(5)
    wallet_address: str = betterproto.string_field(6)
    vram: int = betterproto.uint64_field(7)
    network_rps: float = betterproto.double_field(8)
    using_relay: bool = betterproto.bool_field(9)

try:
    private_key = "${private_key}"
    node_id = "${node_id}"
    public_name = "${public_name}"
    version = "${version}"
    network_address = "${network_address}"
    vram = int(${vram})
    network_rps = float(${network_rps})

    # Create account
    account = Account(private_key=private_key, hrp="nesa")
    wallet_address = account.address

    # Create message
    msg = MsgRegisterNode(
        creator=wallet_address,
        node_id=node_id,
        public_name=public_name,
        version=version,
        network_address=network_address,
        wallet_address=wallet_address,
        vram=vram,
        network_rps=network_rps,
        using_relay=False
    )

    # Connect and load account
    client = HTTPClient(api="https://lcd.dev.nesa.ai")
    try:
        client.load_account_data(account=account)
    except Exception as load_err:
        print(f"error|Account not found on chain. Please fund your wallet first: {wallet_address}")
        sys.exit(0)

    # Build transaction
    tx = Transaction(account=account, gas=200000, chain_id="nesa")
    tx.set_fee(amount=1000, denom="unes")

    # Pack message into Any and add to transaction
    msg_any = any_pb.Any()
    msg_any.value = bytes(msg)
    msg_any.type_url = "/dht.v1.MsgRegisterNode"
    tx._tx_body.messages.append(msg_any)

    # Get signed transaction bytes
    tx_bytes = tx.get_tx_bytes_as_string()

    # Broadcast using httpx for more control
    import httpx
    broadcast_url = "https://lcd.dev.nesa.ai/cosmos/tx/v1beta1/txs"
    payload = {"tx_bytes": tx_bytes, "mode": "BROADCAST_MODE_SYNC"}

    with httpx.Client(timeout=30.0) as http_client:
        response = http_client.post(broadcast_url, json=payload)
        result = response.json()

    if "tx_response" in result:
        tx_response = result["tx_response"]
        code = tx_response.get("code", 0)
        if code == 0:
            txhash = tx_response.get("txhash", "unknown")
            print(f"success|{txhash}")
        else:
            raw_log = tx_response.get("raw_log", "Unknown error")
            print(f"error|{raw_log}")
    else:
        error_msg = result.get("message", str(result))
        print(f"error|Broadcast failed: {error_msg}")

except Exception as e:
    print(f"error|{str(e)}")
PYEOF
}

# Register miner on chain (MsgRegisterMiner)
# Returns: success|tx_hash or error|message
register_miner() {
  local node_id="$1"
  local private_key="$2"
  local model_name="${3:-nesaorg/llama-3.2-1b-instruct-ee}"

  log_line "Registering miner: node_id=$node_id model=$model_name"

  python3 << PYEOF
import sys
import json
from dataclasses import dataclass
from typing import List
import betterproto
from mospy import Account, Transaction
from mospy.clients import HTTPClient
from google.protobuf import any_pb2 as any_pb
import httpx

# Define MsgRegisterMiner
@dataclass(eq=False, repr=False)
class MsgRegisterMiner(betterproto.Message):
    creator: str = betterproto.string_field(1)
    node_id: str = betterproto.string_field(2)
    start_block: int = betterproto.uint64_field(3)
    end_block: int = betterproto.uint64_field(4)
    block_ids: List[int] = betterproto.uint32_field(5)
    torch_dtype: str = betterproto.string_field(6)
    quant_type: str = betterproto.string_field(7)
    cache_tokens_left: int = betterproto.uint64_field(8)
    inference_rps: float = betterproto.double_field(9)
    model_name: str = betterproto.string_field(10)

try:
    private_key = "${private_key}"
    node_id = "${node_id}"
    model_name = "${model_name}"

    # Create account
    account = Account(private_key=private_key, hrp="nesa")
    wallet_address = account.address

    # Create message
    msg = MsgRegisterMiner(
        creator=wallet_address,
        node_id=node_id,
        start_block=1,
        end_block=2,
        block_ids=[0],
        torch_dtype="fp16",
        quant_type="fp4",
        cache_tokens_left=0,
        inference_rps=100.0,
        model_name=model_name
    )

    # Connect and load account
    client = HTTPClient(api="https://lcd.dev.nesa.ai")
    try:
        client.load_account_data(account=account)
    except Exception as load_err:
        print(f"error|Account not found on chain. Please fund your wallet first: {wallet_address}")
        sys.exit(0)

    # Build transaction
    tx = Transaction(account=account, gas=200000, chain_id="nesa")
    tx.set_fee(amount=1000, denom="unes")

    # Pack message into Any and add to transaction
    msg_any = any_pb.Any()
    msg_any.value = bytes(msg)
    msg_any.type_url = "/dht.v1.MsgRegisterMiner"
    tx._tx_body.messages.append(msg_any)

    # Get signed transaction bytes
    tx_bytes = tx.get_tx_bytes_as_string()

    # Broadcast using httpx
    broadcast_url = "https://lcd.dev.nesa.ai/cosmos/tx/v1beta1/txs"
    payload = {"tx_bytes": tx_bytes, "mode": "BROADCAST_MODE_SYNC"}

    with httpx.Client(timeout=30.0) as http_client:
        response = http_client.post(broadcast_url, json=payload)
        result = response.json()

    if "tx_response" in result:
        tx_response = result["tx_response"]
        code = tx_response.get("code", 0)
        if code == 0:
            txhash = tx_response.get("txhash", "unknown")
            print(f"success|{txhash}")
        else:
            raw_log = tx_response.get("raw_log", "Unknown error")
            print(f"error|{raw_log}")
    else:
        error_msg = result.get("message", str(result))
        print(f"error|Broadcast failed: {error_msg}")

except Exception as e:
    print(f"error|{str(e)}")
PYEOF
}

# Submit miner deposit transaction
# Returns: success|tx_hash or error|message
submit_miner_deposit() {
  local node_id="$1"
  local amount_microunes="$2"
  local private_key="$3"

  log_line "Submitting miner deposit: node_id=$node_id, amount=${amount_microunes}unes"

  python3 << PYEOF
import sys
import json
from dataclasses import dataclass
import betterproto
from mospy import Account, Transaction
from mospy.clients import HTTPClient
from google.protobuf import any_pb2 as any_pb
import httpx

# Define the Cosmos SDK Coin message
@dataclass(eq=False, repr=False)
class Coin(betterproto.Message):
    denom: str = betterproto.string_field(1)
    amount: str = betterproto.string_field(2)

# Define MsgAddMinerDeposit
@dataclass(eq=False, repr=False)
class MsgAddMinerDeposit(betterproto.Message):
    depositor: str = betterproto.string_field(1)
    node_id: str = betterproto.string_field(2)
    amount: Coin = betterproto.message_field(3)

try:
    private_key = "${private_key}"
    node_id = "${node_id}"
    amount_microunes = "${amount_microunes}"

    # Create account from private key
    account = Account(
        private_key=private_key,
        hrp="nesa",
    )

    # Load account data from chain
    client = HTTPClient(api="https://lcd.dev.nesa.ai")
    try:
        client.load_account_data(account=account)
    except Exception as load_err:
        # Account might not exist yet (no funds received)
        print(f"error|Account not found on chain. Please fund your wallet first: {account.address}")
        sys.exit(0)

    # Check if account has sequence (exists on chain)
    if account.next_sequence is None:
        print(f"error|Account not initialized on chain. Send funds to {account.address} first.")
        sys.exit(0)

    # Create transaction
    tx = Transaction(
        account=account,
        gas=150000,
        chain_id="nesa",
    )
    tx.set_fee(amount=1000, denom="unes")

    # Create deposit message
    msg = MsgAddMinerDeposit(
        depositor=account.address,
        node_id=node_id,
        amount=Coin(denom="unes", amount=amount_microunes)
    )

    # Pack message into Any and add to transaction
    msg_any = any_pb.Any()
    msg_any.value = bytes(msg)
    msg_any.type_url = "/dht.v1.MsgAddMinerDeposit"
    tx._tx_body.messages.append(msg_any)

    # Get signed transaction bytes
    tx_bytes = tx.get_tx_bytes_as_string()

    # Broadcast transaction
    broadcast_url = "https://lcd.dev.nesa.ai/cosmos/tx/v1beta1/txs"
    broadcast_payload = {
        "tx_bytes": tx_bytes,
        "mode": "BROADCAST_MODE_SYNC"
    }

    response = httpx.post(broadcast_url, json=broadcast_payload, timeout=30)
    result = response.json()

    # Check for errors
    if "tx_response" in result:
        tx_response = result["tx_response"]
        code = tx_response.get("code", 0)
        if code == 0:
            tx_hash = tx_response.get("txhash", "")
            print(f"success|{tx_hash}")
        else:
            raw_log = tx_response.get("raw_log", "Unknown error")
            print(f"error|Transaction failed (code {code}): {raw_log}")
    else:
        error_msg = result.get("message", str(result))
        print(f"error|Broadcast failed: {error_msg}")

except Exception as e:
    print(f"error|{str(e)}")
PYEOF
}

# Add miner deposit - wrapper with UI
add_miner_deposit() {
  local node_id="$1"
  local amount_unes="$2"

  log_line "Add miner deposit: node_id=$node_id, amount=${amount_unes} UNES"

  # Convert UNES to microunes
  local amount_microunes
  if command -v bc >/dev/null 2>&1; then
    amount_microunes=$(echo "$amount_unes * 1000000" | bc | cut -d. -f1)
  else
    amount_microunes=$(awk "BEGIN {printf \"%.0f\", $amount_unes * 1000000}")
  fi

  # Load private key from config
  if [ -z "$NODE_PRIV_HEX" ]; then
    local orchestrator_env_file="${env_dir}/orchestrator.env"
    if [ -f "$orchestrator_env_file" ]; then
      source "$orchestrator_env_file" 2>/dev/null || true
    fi
  fi

  if [ -z "$NODE_PRIV_HEX" ]; then
    echo "error|Private key not found"
    return 1
  fi

  # Submit the transaction
  local result
  result=$(submit_miner_deposit "$node_id" "$amount_microunes" "$NODE_PRIV_HEX")

  echo "$result"
}

# Interactive deposit flow with nice UI
# Returns: 0 if deposit successful or skipped, 1 if failed
show_deposit_flow() {
  local wallet_address="$1"
  local node_id="$2"
  local private_key="$3"

  log_line "Starting deposit flow for wallet=$wallet_address node=$node_id"

  # Fetch all required data
  echo ""
  gum spin -s line --title "Fetching wallet and deposit info..." -- sleep 1

  # Get wallet balance
  local balance_result
  balance_result=$(check_wallet_balance "$wallet_address")
  local balance_status=$(echo "$balance_result" | cut -d'|' -f1)
  local balance_microunes=$(echo "$balance_result" | cut -d'|' -f2)
  local balance_display=$(echo "$balance_result" | cut -d'|' -f3)

  if [ "$balance_status" != "ok" ]; then
    gum style --foreground 196 "Failed to fetch wallet balance"
    return 1
  fi

  # Get minimum deposit requirements
  local params_result
  params_result=$(check_min_deposit)
  local params_status=$(echo "$params_result" | cut -d'|' -f1)
  local min_deposit_microunes=$(echo "$params_result" | cut -d'|' -f2)
  local min_deposit_display=$(echo "$params_result" | cut -d'|' -f3)

  if [ "$params_status" != "ok" ]; then
    gum style --foreground 196 "Failed to fetch deposit requirements"
    return 1
  fi

  # Get current miner deposit
  local deposit_result
  deposit_result=$(check_miner_deposit "$node_id")
  local deposit_status=$(echo "$deposit_result" | cut -d'|' -f1)
  local current_deposit_microunes=$(echo "$deposit_result" | cut -d'|' -f2)
  local current_deposit_display=$(echo "$deposit_result" | cut -d'|' -f3)
  local bond_status=$(echo "$deposit_result" | cut -d'|' -f4)

  if [ "$deposit_status" != "ok" ]; then
    current_deposit_microunes="0"
    current_deposit_display="0.000000"
    bond_status="not_registered"
  fi

  # Calculate shortfall
  local shortfall_microunes=$((min_deposit_microunes - current_deposit_microunes))
  if [ "$shortfall_microunes" -lt 0 ]; then
    shortfall_microunes=0
  fi

  local shortfall_display
  shortfall_display=$(awk "BEGIN {printf \"%.6f\", $shortfall_microunes / 1000000}")

  # Check if miner is not registered - auto-register node and miner
  if [ "$bond_status" = "not_registered" ]; then
    echo ""
    gum style --border rounded --padding "1 2" --border-foreground 214 \
      "$(gum style --foreground 214 --bold "REGISTRATION REQUIRED")

  Your node and miner are not yet registered on the blockchain.
  Registering them now..."

    # Step 1: Check and register node
    echo ""
    gum spin -s line --title "Checking node registration..." -- sleep 1

    local node_check
    node_check=$(check_node_registered "$node_id")
    local node_status=$(echo "$node_check" | cut -d'|' -f2)

    if [ "$node_status" = "not_registered" ]; then
      echo ""
      gum style --foreground 43 "Registering node on blockchain..."

      local node_result
      node_result=$(register_node "$node_id" "$private_key")
      local node_tx_status=$(echo "$node_result" | cut -d'|' -f1)
      local node_tx_data=$(echo "$node_result" | cut -d'|' -f2-)

      if [ "$node_tx_status" = "success" ]; then
        gum style --foreground 42 "[OK] Node registered"
        gum style --foreground 245 "    TX: ${node_tx_data}"
        gum spin -s line --title "Waiting for confirmation..." -- sleep 5
      else
        echo ""
        gum style --border rounded --padding "1 2" --border-foreground 196 \
          "$(gum style --foreground 196 --bold "NODE REGISTRATION FAILED")

  $(gum style --foreground 250 "Error:") $node_tx_data"
        echo ""
        read -p "> Press Enter to continue..."
        return 1
      fi
    else
      gum style --foreground 42 "[OK] Node already registered"
    fi

    # Step 2: Register miner
    echo ""
    gum spin -s line --title "Registering miner..." -- sleep 1

    local miner_result
    miner_result=$(register_miner "$node_id" "$private_key" "nesaorg/llama-3.2-1b-instruct-ee")
    local miner_tx_status=$(echo "$miner_result" | cut -d'|' -f1)
    local miner_tx_data=$(echo "$miner_result" | cut -d'|' -f2-)

    if [ "$miner_tx_status" = "success" ]; then
      gum style --foreground 42 "[OK] Miner registered"
      gum style --foreground 245 "    TX: ${miner_tx_data}"
      gum spin -s line --title "Waiting for confirmation..." -- sleep 5
    else
      # Check if error is "miner already registered"
      if [[ "$miner_tx_data" == *"already"* ]] || [[ "$miner_tx_data" == *"exists"* ]]; then
        gum style --foreground 42 "[OK] Miner already registered"
      else
        echo ""
        gum style --border rounded --padding "1 2" --border-foreground 196 \
          "$(gum style --foreground 196 --bold "MINER REGISTRATION FAILED")

  $(gum style --foreground 250 "Error:") $miner_tx_data"
        echo ""
        read -p "> Press Enter to continue..."
        return 1
      fi
    fi

    echo ""
    gum style --foreground 42 --bold "Registration complete. Now let's add your deposit."
    echo ""
    read -p "> Press Enter to continue..."

    # Refresh deposit info after registration
    deposit_result=$(check_miner_deposit "$node_id")
    deposit_status=$(echo "$deposit_result" | cut -d'|' -f1)
    current_deposit_microunes=$(echo "$deposit_result" | cut -d'|' -f2)
    current_deposit_display=$(echo "$deposit_result" | cut -d'|' -f3)
    bond_status=$(echo "$deposit_result" | cut -d'|' -f4)
  fi

  # Check if deposit meets minimum - offer to add more anyway
  local deposit_meets_minimum=false
  if [ "$current_deposit_microunes" -ge "$min_deposit_microunes" ]; then
    deposit_meets_minimum=true
  fi

  # Calculate gas fee estimate (fixed)
  local gas_fee_microunes=1000
  local gas_fee_display="0.001000"

  # Show deposit screen
  while true; do
    clear
    update_header

    echo ""

    # Different header based on whether deposit meets minimum
    if [ "$deposit_meets_minimum" = true ]; then
      local status_color=42
      local status_text="DEPOSIT STATUS"
      local status_desc="Your deposit meets the minimum requirement. You can add more if you wish."
      local amount_needed_line=""
    else
      local status_color=214
      local status_text="MINER DEPOSIT"
      local status_desc="Your node requires a deposit to participate in the network."
      local amount_needed_line="
  $(gum style --foreground 214 "Shortfall:")          ${shortfall_display} UNES"
    fi

    gum style --border rounded --padding "1 2" --border-foreground "$status_color" \
      "$(gum style --foreground "$status_color" --bold "$status_text")

$(gum style --foreground 250 "$status_desc")

  $(gum style --foreground 245 "─────────────────────────────────────────────────────────────────")

  $(gum style --foreground 43 "Wallet:")             ${wallet_address}
  $(gum style --foreground 43 "Balance:")            $(gum style --bold "${balance_display} UNES")

  $(gum style --foreground 245 "─────────────────────────────────────────────────────────────────")

  $(gum style --foreground 43 "Minimum Required:")   ${min_deposit_display} UNES
  $(gum style --foreground 43 "Current Deposit:")    $(gum style --foreground $status_color "${current_deposit_display} UNES")
  $(gum style --foreground 43 "Bond Status:")        $(gum style --foreground $status_color "${bond_status}")${amount_needed_line}

  $(gum style --foreground 245 "─────────────────────────────────────────────────────────────────")

  $(gum style --foreground 250 "Gas Fee:")            ~${gas_fee_display} UNES

$(gum style --foreground 245 --italic "Deposits are held in escrow and can be withdrawn after
a 7-day unbonding period.")"

    echo ""

    # Determine default amount
    local default_amount
    if [ "$deposit_meets_minimum" = true ]; then
      default_amount="0.001"
    elif [ "$shortfall_microunes" -gt 0 ]; then
      default_amount="$shortfall_display"
    else
      default_amount="$min_deposit_display"
    fi

    # If deposit already meets minimum, offer choice first
    if [ "$deposit_meets_minimum" = true ]; then
      local action_choice
      action_choice=$(gum choose --cursor.foreground 42 \
        "Add more deposit" \
        "Back to menu")

      if [ -z "$action_choice" ] || [ "$action_choice" = "Back to menu" ]; then
        return 0
      fi
    fi

    local deposit_amount
    deposit_amount=$(gum input \
      --placeholder "Enter deposit amount in UNES" \
      --value "$default_amount" \
      --prompt "Deposit amount: " \
      --prompt.foreground "$main_color")

    # Handle empty input or cancel
    if [ -z "$deposit_amount" ]; then
      echo ""
      if [ "$deposit_meets_minimum" = true ]; then
        continue
      fi
      local skip_choice
      skip_choice=$(gum choose --cursor.foreground 196 "Try again" "Skip deposit")
      if [ "$skip_choice" = "Skip deposit" ]; then
        gum style --foreground 214 "Warning: Skipping deposit. Your node may not function correctly."
        return 0
      fi
      continue
    fi

    # Convert to microunes for validation
    local deposit_microunes
    if command -v bc >/dev/null 2>&1; then
      deposit_microunes=$(echo "$deposit_amount * 1000000" | bc | cut -d. -f1)
    else
      deposit_microunes=$(awk "BEGIN {printf \"%.0f\", $deposit_amount * 1000000}")
    fi

    # Validate amount
    local total_needed=$((deposit_microunes + gas_fee_microunes))

    if [ "$deposit_microunes" -le 0 ]; then
      gum style --foreground 196 "Amount must be greater than 0"
      sleep 2
      continue
    fi

    if [ "$total_needed" -gt "$balance_microunes" ]; then
      gum style --foreground 196 "Insufficient balance. You need ${deposit_amount} UNES + ~${gas_fee_display} UNES for gas."
      gum style --foreground 196 "Your balance: ${balance_display} UNES"
      sleep 3
      continue
    fi

    # Calculate final deposit
    local final_deposit_microunes=$((current_deposit_microunes + deposit_microunes))
    local final_deposit_display
    final_deposit_display=$(awk "BEGIN {printf \"%.6f\", $final_deposit_microunes / 1000000}")

    local remaining_balance_microunes=$((balance_microunes - total_needed))
    local remaining_balance_display
    remaining_balance_display=$(awk "BEGIN {printf \"%.6f\", $remaining_balance_microunes / 1000000}")

    local meets_minimum="Below minimum"
    local meets_color=196
    if [ "$final_deposit_microunes" -ge "$min_deposit_microunes" ]; then
      meets_minimum="OK"
      meets_color=42
    fi

    # Show confirmation
    echo ""
    gum style --border rounded --padding "1 2" --border-foreground 43 \
      "$(gum style --foreground 43 --bold "CONFIRM TRANSACTION")

  $(gum style --foreground 245 "─────────────────────────────────────────────────────────────────")

  $(gum style --foreground 250 "Deposit Amount:")     ${deposit_amount} UNES
  $(gum style --foreground 250 "Gas Fee:")            ~${gas_fee_display} UNES
  $(gum style --foreground 245 "─────────────────────────────────────────────────────────────────")
  $(gum style --foreground 43 "Total Cost:")          $(gum style --bold "$(awk "BEGIN {printf \"%.6f\", ($deposit_microunes + $gas_fee_microunes) / 1000000}") UNES")

  $(gum style --foreground 245 "─────────────────────────────────────────────────────────────────")

  $(gum style --foreground 250 "After Transaction:")
  $(gum style --foreground 250 "Your Deposit:")       ${final_deposit_display} UNES  $(gum style --foreground $meets_color "[$meets_minimum]")
  $(gum style --foreground 250 "Remaining Balance:")  ${remaining_balance_display} UNES"

    echo ""

    # Confirm - different options if already meets minimum
    local confirm
    if [ "$deposit_meets_minimum" = true ]; then
      confirm=$(gum choose --cursor.foreground 42 "Submit Deposit" "Change Amount" "Cancel")
    else
      confirm=$(gum choose --cursor.foreground 42 "Submit Deposit" "Change Amount" "Skip")
    fi

    case "$confirm" in
      "Submit Deposit")
        echo ""
        gum spin -s line --title "Submitting deposit transaction..." -- sleep 1

        # Actually submit the transaction
        local tx_result
        tx_result=$(add_miner_deposit "$node_id" "$deposit_amount")

        local tx_status=$(echo "$tx_result" | cut -d'|' -f1)
        local tx_data=$(echo "$tx_result" | cut -d'|' -f2-)

        if [ "$tx_status" = "success" ]; then
          echo ""
          gum style --border rounded --padding "1 2" --border-foreground 42 \
            "$(gum style --foreground 42 --bold "DEPOSIT SUCCESSFUL")

  $(gum style --foreground 250 "Transaction Hash:")
  $(gum style --foreground 69 "$tx_data")

  Your deposit of ${deposit_amount} UNES has been submitted.
  It may take a few seconds to confirm on-chain."
          echo ""

          # Update the deposit status for next iteration
          deposit_meets_minimum=true
          current_deposit_microunes=$final_deposit_microunes
          current_deposit_display=$final_deposit_display

          sleep 2
          # Ask if they want to add more
          local more_choice
          more_choice=$(gum choose --cursor.foreground 42 "Add more deposit" "Back to menu")
          if [ -z "$more_choice" ] || [ "$more_choice" = "Back to menu" ]; then
            return 0
          fi
          continue
        else
          echo ""
          gum style --border rounded --padding "1 2" --border-foreground 196 \
            "$(gum style --foreground 196 --bold "DEPOSIT FAILED")

  $(gum style --foreground 250 "Error:") $tx_data

  Please try again or check your wallet balance."
          echo ""
          sleep 3
          continue
        fi
        ;;
      "Change Amount")
        continue
        ;;
      "Skip"|"Cancel")
        if [ "$deposit_meets_minimum" != true ]; then
          gum style --foreground 214 "Warning: Skipping deposit. Your node may not function correctly."
        fi
        return 0
        ;;
    esac
  done
}

# Check minimum deposit requirements
check_min_deposit() {
  local lcd_url="https://lcd.dev.nesa.ai"
  local params_endpoint="${lcd_url}/nesachain/dht/params"

  log_line "Checking minimum deposit requirements"

  local json_data
  local http_code
  json_data=$(curl -s -w "\n%{http_code}" "$params_endpoint" 2>&1)
  http_code=$(echo "$json_data" | tail -1)
  json_data=$(echo "$json_data" | sed '$d')

  if [ "$http_code" != "200" ]; then
    echo "error|Failed to fetch params"
    return 1
  fi

  # Extract miner and orchestrator minimum deposits
  local miner_min_amount=$(echo "$json_data" | jq -r '.params.miner_min_deposit.amount // "0"')
  local miner_min_denom=$(echo "$json_data" | jq -r '.params.miner_min_deposit.denom // "unes"')
  local orch_min_amount=$(echo "$json_data" | jq -r '.params.orchestrator_min_deposit.amount // "0"')
  local orch_min_denom=$(echo "$json_data" | jq -r '.params.orchestrator_min_deposit.denom // "unes"')

  # Extract unbonding periods
  local miner_unbond=$(echo "$json_data" | jq -r '.params.miner_unbonding_period // "0s"')
  local orch_unbond=$(echo "$json_data" | jq -r '.params.orchestrator_unbonding_period // "0s"')

  # Convert to UNES for display (using awk for consistent formatting with leading zeros)
  local miner_min_display
  local orch_min_display
  miner_min_display=$(awk "BEGIN {printf \"%.6f\", $miner_min_amount / 1000000}")
  orch_min_display=$(awk "BEGIN {printf \"%.6f\", $orch_min_amount / 1000000}")

  # Normalize denom for display (unes -> UNES)
  local miner_denom_display="UNES"
  local orch_denom_display="UNES"
  if [ "$miner_min_denom" != "unes" ]; then
    miner_denom_display=$(echo "$miner_min_denom" | tr '[:lower:]' '[:upper:]')
  fi
  if [ "$orch_min_denom" != "unes" ]; then
    orch_denom_display=$(echo "$orch_min_denom" | tr '[:lower:]' '[:upper:]')
  fi

  echo "ok|$miner_min_amount|$miner_min_display|$miner_denom_display|$orch_min_amount|$orch_min_display|$orch_denom_display|$miner_unbond|$orch_unbond"
}

# Management menu for balance and deposit operations
show_management_menu() {
  while true; do
    update_header

    # Load configuration
    local config_env_file="${env_dir}/.env"
    local orchestrator_env_file="${env_dir}/orchestrator.env"

    if [ ! -f "$orchestrator_env_file" ]; then
      echo "Error: Configuration not found. Please run the bootstrap wizard first."
      return 1
    fi

    # Source the config to get NODE_PRIV_HEX
    source "$orchestrator_env_file" 2>/dev/null || true

    if [ -z "$NODE_PRIV_HEX" ]; then
      echo "Error: Private key not found in configuration."
      return 1
    fi

    # Derive wallet address
    local wallet_address
    wallet_address=$(derive_wallet_address "$NODE_PRIV_HEX" "nesa")

    # Get node ID if available
    local node_id=""
    if [ -f "$node_id_file" ]; then
      node_id=$(cat "$node_id_file" 2>/dev/null | tr -d '\n\r')
    fi

    # Show current status
    echo ""
    gum style --border normal --padding "1 2" --border-foreground "$main_color" \
      "$(gum style --foreground "$main_color" --bold "Miner Management")

Wallet Address: $wallet_address
Node ID: ${node_id:-"(not available - start your node first)"}"

    echo ""

    # Menu options
    local choice
    choice=$(gum choose \
      --cursor.foreground "$main_color" \
      --item.foreground "$link_color" \
      "Check Wallet Balance" \
      "Check Miner Deposit Status" \
      "Check Minimum Deposit Requirements" \
      "Add Miner Deposit" \
      "Return to Main Menu" \
      "Exit")

    case "$choice" in
      "Check Wallet Balance")
        echo ""
        gum spin -s line --title "Fetching wallet balance..." -- sleep 1

        local balance_result
        balance_result=$(check_wallet_balance "$wallet_address")
        local status=$(echo "$balance_result" | cut -d'|' -f1)
        local balance_micro=$(echo "$balance_result" | cut -d'|' -f2)
        local balance_display=$(echo "$balance_result" | cut -d'|' -f3)
        local error_msg=$(echo "$balance_result" | cut -d'|' -f4-)

        echo ""
        if [ "$status" = "ok" ]; then
          gum style --border double --padding "1 2" --border-foreground "$main_color" \
            "$(gum style --foreground "$main_color" --bold "Wallet Balance")

Balance: $(gum style --foreground "$main_color" --bold "$balance_display UNES")
         ($balance_micro microunes)"
        else
          echo "Error: Failed to fetch wallet balance."
          if [ -n "$error_msg" ]; then
            echo ""
            echo "Details: $error_msg"
          fi
          echo ""
          echo "Check logs at: ~/.nesa/logs/bootstrap.log"
        fi
        echo ""
        gum input --placeholder "Press Enter to continue..."
        ;;

      "Check Miner Deposit Status")
        if [ -z "$node_id" ]; then
          echo ""
          echo "Error: Node ID not found. Please start your node first to generate a Node ID."
          echo ""
          gum input --placeholder "Press Enter to continue..."
          continue
        fi

        echo ""
        gum spin -s line --title "Fetching miner deposit status..." -- sleep 1

        local deposit_result
        deposit_result=$(check_miner_deposit "$node_id")
        local status=$(echo "$deposit_result" | cut -d'|' -f1)
        local deposit_micro=$(echo "$deposit_result" | cut -d'|' -f2)
        local deposit_display=$(echo "$deposit_result" | cut -d'|' -f3)
        local bond_status=$(echo "$deposit_result" | cut -d'|' -f4)
        local error_msg=$(echo "$deposit_result" | cut -d'|' -f5-)

        echo ""
        if [ "$status" = "ok" ]; then
          local status_color="$main_color"
          case "$bond_status" in
            "bonded") status_color="2" ;;  # green
            "unbonding") status_color="3" ;;  # yellow
            "unbonded") status_color="1" ;;  # red
            "not_registered") status_color="8" ;;  # gray
          esac

          gum style --border double --padding "1 2" --border-foreground "$main_color" \
            "$(gum style --foreground "$main_color" --bold "Miner Deposit Status")

Node ID: $node_id
Deposit: $(gum style --foreground "$main_color" --bold "$deposit_display UNES")
         ($deposit_micro microunes)
Status:  $(gum style --foreground "$status_color" --bold "$bond_status")"
        else
          echo "Error: Failed to fetch miner deposit status."
          if [ -n "$error_msg" ]; then
            echo ""
            echo "Details: $error_msg"
          fi
          echo ""
          echo "Check logs at: ~/.nesa/logs/bootstrap.log"
        fi
        echo ""
        gum input --placeholder "Press Enter to continue..."
        ;;

      "Check Minimum Deposit Requirements")
        echo ""
        gum spin -s line --title "Fetching chain parameters..." -- sleep 1

        local params_result
        params_result=$(check_min_deposit)
        local status=$(echo "$params_result" | cut -d'|' -f1)

        echo ""
        if [ "$status" = "ok" ]; then
          local miner_min_micro=$(echo "$params_result" | cut -d'|' -f2)
          local miner_min_display=$(echo "$params_result" | cut -d'|' -f3)
          local miner_denom=$(echo "$params_result" | cut -d'|' -f4)
          local orch_min_micro=$(echo "$params_result" | cut -d'|' -f5)
          local orch_min_display=$(echo "$params_result" | cut -d'|' -f6)
          local orch_denom=$(echo "$params_result" | cut -d'|' -f7)
          local miner_unbond=$(echo "$params_result" | cut -d'|' -f8)
          local orch_unbond=$(echo "$params_result" | cut -d'|' -f9)

          gum style --border double --padding "1 2" --border-foreground "$main_color" \
            "$(gum style --foreground "$main_color" --bold "Miner Deposit Requirements")

Minimum Deposit:    $(gum style --foreground "$main_color" --bold "$miner_min_display $miner_denom")
Unbonding Period:   $miner_unbond

$(gum style --foreground "8" "Note: You can add deposits anytime. Withdrawals require the unbonding period.")"
        else
          local error_msg=$(echo "$params_result" | cut -d'|' -f2-)
          echo "Error: $error_msg"
        fi
        echo ""
        gum input --placeholder "Press Enter to continue..."
        ;;

      "Add Miner Deposit")
        if [ -z "$node_id" ]; then
          echo ""
          echo "Error: Node ID not found. Please start your node first to generate a Node ID."
          echo ""
          gum input --placeholder "Press Enter to continue..."
          continue
        fi

        # Use the full deposit flow which includes registration check
        show_deposit_flow "$wallet_address" "$node_id" "$NODE_PRIV_HEX"
        continue
        ;;

      "Return to Main Menu")
        return 0
        ;;

      "Exit")
        echo "Goodbye!"
        exit 0
        ;;

      *)
        return 0
        ;;
    esac
  done
}

log_line "[STAGE 4]: collect config (${mode})"

update_config_var() {
  local file=$1
  local var=$2
  local value=$3
  local temp_file

  temp_file=$(mktemp)

  if grep -q "^$var=" "$file"; then
    # Use a temporary file to handle sed differences
    sed "s|^$var=.*|$var=\"$value\"|" "$file" >"$temp_file" && mv "$temp_file" "$file"
  else
    echo "$var=\"$value\"" >>"$file"
  fi

  # Clean up the temporary file if it still exists
  [ -f "$temp_file" ] && rm "$temp_file"
}

strip_0x_prefix() {
  local key="$1"
  # Remove 0x prefix if present
  echo "${key#0x}"
}
log_line "[STAGE 5]: saving env variables"

save_to_env_file() {
  # Config environment variables
  update_config_var "$config_env_file" "IS_CHAIN" "$IS_CHAIN"
  update_config_var "$config_env_file" "IS_VALIDATOR" "$IS_VALIDATOR"
  update_config_var "$config_env_file" "IS_MINER" "$IS_MINER"
  update_config_var "$config_env_file" "MINER_TYPE" "$MINER_TYPE"
  update_config_var "$config_env_file" "DISTRIBUTED_TYPE" "$DISTRIBUTED_TYPE"

  # Orchestrator environment variables
  update_config_var "$orchestrator_env_file" "IS_DIST" "$IS_DIST"
  update_config_var "$orchestrator_env_file" "HUGGINGFACE_API_KEY" "$HUGGINGFACE_API_KEY"
  update_config_var "$orchestrator_env_file" "MONIKER" "$MONIKER"
  update_config_var "$orchestrator_env_file" "NESA_NODE_TYPE" "$NESA_NODE_TYPE"
  update_config_var "$orchestrator_env_file" "NODE_PRIV_KEY" "$NODE_PRIV_KEY"
  update_config_var "$orchestrator_env_file" "NODE_PRIV_HEX" "$NODE_PRIV_KEY"

  # Save NODE_ID if available (so orchestrator doesn't regenerate)
  if [[ -n "$NODE_ID" && "$NODE_ID" != "pending..." ]]; then
    update_config_var "$orchestrator_env_file" "NODE_ID" "$NODE_ID"
  fi

  # Base environment variables
  # update_config_var "$base_env_file" "MODEL_NAME" "$MODEL_NAME"
  update_config_var "$base_env_file" "MONIKER" "$MONIKER"
  # update_config_var "$base_env_file" "OP_EMAIL" "$OP_EMAIL"
  update_config_var "$base_env_file" "REF_CODE" "$REF_CODE"
  update_config_var "$base_env_file" "PUBLIC_IP" "$PUBLIC_IP"
  update_config_var "$base_env_file" "CHAIN_ID" "$CHAIN_ID"

  # update_config_var "$base_env_file" "ORC_PORT" "$ORC_PORT"
  # update_config_var "$base_env_file" "NODE_OS" "$NODE_OS"
  # update_config_var "$base_env_file" "NODE_ARCH" "$NODE_ARCH"
  # update_config_var "$base_env_file" "NODE_CPU" "$NODE_CPU"
  # update_config_var "$base_env_file" "NODE_CORES" "$NODE_CORES"
  # update_config_var "$base_env_file" "NODE_RAM" "$NODE_RAM"
  # update_config_var "$base_env_file" "NODE_GPU" "$NODE_GPU"
  # update_config_var "$base_env_file" "NODE_GPU_COUNT" "$NODE_GPU_COUNT"
  # update_config_var "$base_env_file" "NODE_VRAM" "$NODE_VRAM"
}

display_config() {
  local exclude_keys=("HUGGINGFACE_API_KEY" "NODE_PRIV_KEY" "IS_DIST" "IS_CHAIN" "IS_VALIDATOR" "IS_MINER" "MINER_TYPE" "DISTRIBUTED_TYPE" "NESA_NODE_TYPE")
  local config_content
  local priv_key_display

  config_content=$(cat "$config_env_file" "$orchestrator_env_file" "$base_env_file" | sort | uniq)

  for key in "${exclude_keys[@]}"; do
    config_content=$(echo "$config_content" | grep -v "^$key=")
  done

  config_content=$(echo "$config_content" | grep -v "=$")

  if [[ -n "$NODE_ID" && "$NODE_ID" != "pending..." ]]; then
    config_content="$config_content"$'\n'"NODE_ID=$NODE_ID"
  fi

  if [[ -n "$NODE_PRIV_KEY" ]]; then
    local pub_key=$(generate_public_key "$NODE_PRIV_KEY")
    local length=${#NODE_PRIV_KEY}
    priv_key_display="$(printf '%*s' "$((length - 4))" '' | tr ' ' '*')${NODE_PRIV_KEY: -4}"
    config_content="$config_content"$'\n'"PRIVATE_KEY=$priv_key_display\nPUBLIC_KEY=$pub_key"
  fi

  config_content=$(echo "$config_content" | sed 's/"//g')
  config_content="\`\`\`Makefile\n$config_content\n\`\`\`"

  echo -e "$config_content" | gum format --type markdown --theme dracula

}

CONTAINER_INGEST_URL="${CONTAINER_INGEST_URL:-http://host.docker.internal:8080/ingest}"
export INGEST_URL="$CONTAINER_INGEST_URL"
export NODE_ID MONIKER PUBLIC_IP
export NODE_PRIV_HEX="$NODE_PRIV_KEY"

compose_up() {
  local compose_files="compose.yml"
  cd "$WORKING_DIRECTORY/docker" || {
    echo "Error: Docker directory does not exist."
    exit 1
  }

  if command -v nvidia-smi >/dev/null && [[ "${NOGPU,,}" != "true" && "${NOGPU,,}" != "1" ]]; then
    compose_files="compose.nvidia.yml"
  fi

  local files="-f ${compose_files}"
  if [ -f "compose.logs.yml" ]; then
    files="${files} -f compose.logs.yml"
  fi

   docker compose ${files} \
    --env-file "$base_env_file" \
    --env-file "$orchestrator_env_file" \
    up --pull always -d --wait || {
      echo "Error: Docker Compose failed to start."
      exit 1
    }

  echo "Docker Compose started successfully."
}

load_node_id() {
  if [[ -f "$node_id_file" ]]; then
    # Read the value from the file into an environment variable
    NODE_ID=$(cat "$node_id_file")
  else
    # Set the environment variable to an empty string or default value
    NODE_ID="pending..."
  fi
}

# Generate and save NODE_ID from private key (if not already exists)
ensure_node_id() {
  local private_key="$1"

  # If node_id.id already exists, use it (backwards compatibility)
  if [[ -f "$node_id_file" ]]; then
    NODE_ID=$(cat "$node_id_file")
    log_line "Using existing NODE_ID: $NODE_ID"
    return 0
  fi

  # Generate NODE_ID from private key
  if [[ -n "$private_key" ]]; then
    local identity_dir
    identity_dir=$(dirname "$node_id_file")
    mkdir -p "$identity_dir"

    NODE_ID=$(generate_node_id "$private_key")

    # Save to file
    echo -n "$NODE_ID" > "$node_id_file"
    log_line "Generated and saved NODE_ID: $NODE_ID"
  else
    NODE_ID="pending..."
    log_line "No private key available, NODE_ID pending"
  fi
}

load_from_env_file() {
  if [ -f "$config_env_file" ]; then
    source "$config_env_file"
  elif [ "$1" == "advanced" ]; then
    echo "$config_env_file does not exist. Please run in wizard mode to create the config file."
    exit 1
  else
    mkdir -p "$env_dir"
    touch "$config_env_file"
  fi

  if [ -f "$orchestrator_env_file" ]; then
    source "$orchestrator_env_file"
  elif [ "$1" != "advanced" ]; then
    touch "$orchestrator_env_file"
  fi

  if [ -f "$base_env_file" ]; then
    source "$base_env_file"
  elif [ "$1" != "advanced" ]; then
    touch "$base_env_file"
  fi

  # defaults
  : ${IS_CHAIN:="no"}
  : ${IS_VALIDATOR:="no"}
  : ${IS_MINER:="no"}
  : ${MINER_TYPE:=$MINER_TYPE_NONE}
  : ${DISTRIBUTED_TYPE:=$DISTRIBUTED_TYPE_NONE}
  : ${NESA_NODE_TYPE:="nesa"}

  # TODO: revisit below
  : ${PRIV_KEY:=""}
  : ${HUGGINGFACE_API_KEY:=""}
  : ${MODEL_NAME:=""}
  : ${REF_CODE:=""}
}

load_from_env_file "wizard"
load_node_id
# don't use cached/saved values for these
PUBLIC_IP=$(curl -s4 ifconfig.me)

#
# bootstrap core logic
#

# deps
check_gum_installed
check_docker_installed
check_jq_installed
check_python_and_ecdsa
# check_nvidia_installed
detect_hardware_capabilities
# clear
update_header

# Check if node is already configured
if [ -f "$orchestrator_env_file" ] && [ -f "$config_env_file" ]; then
  # Node is already configured, offer options
  echo ""
  gum style --border normal --padding "1 2" --border-foreground "$main_color" \
    "$(gum style --foreground "$main_color" --bold "Existing Configuration Detected")

Your Nesa node is already configured."

  echo ""
  echo "What would you like to do?"
  echo ""

  existing_choice=$(gum choose \
    --cursor.foreground "$main_color" \
    --item.foreground "$link_color" \
    "Manage Wallet & Deposits" \
    "Start/Restart Node" \
    "Reconfigure Node (Run Wizard Again)" \
    "Exit")

  case "$existing_choice" in
    "Manage Wallet & Deposits")
      show_management_menu
      exit 0
      ;;
    "Start/Restart Node")
      update_header
      echo "Starting node containers..."
      cd "$WORKING_DIRECTORY/docker" || {
        echo "Error: Docker directory does not exist."
        exit 1
      }
      compose_up
      echo ""
      echo -e "$(gum style --foreground "$main_color" "nesa") node containers started!"
      echo ""
      if gum confirm "Would you like to manage your wallet balance and miner deposit now?"; then
        cd "$init_pwd" || exit
        show_management_menu
      fi
      exit 0
      ;;
    "Reconfigure Node (Run Wizard Again)")
      echo "Proceeding to reconfiguration wizard..."
      sleep 1
      ;;
    "Exit")
      exit 0
      ;;
  esac
fi

echo -e "Select a $(gum style --foreground "$main_color" "mode")"
wizard_mode="Wizardy"
advanced_mode="Advanced Wizardy"

mode=$(gum choose "$wizard_mode" "$advanced_mode")

# clear
update_header

gum spin -s line --title "Setting up working directory and cloning node repository..." -- setup_work_dir
setup_work_dir

if grep -q "$advanced_mode" <<<"$mode"; then
  load_from_env_file "advanced"
else

  MONIKER=$(gum input --cursor.foreground "${main_color}" \
    --prompt.foreground "${main_color}" \
    --prompt "Choose a moniker for your node: " \
    --placeholder "$MONIKER" \
    --width 80 \
    --value "$MONIKER")

  MONIKER=$(echo "$MONIKER" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')

  # clear
  update_header

  REF_CODE=$(gum input --cursor.foreground "${main_color}" \
    --prompt.foreground "${main_color}" \
    --prompt "if you have a referral code, enter it here to receive bonus points: " \
    --placeholder "nesa1j6y248qnuawdnd7dtc3hg47jlzfj3jzwqv8rkq" \
    --width 160 \
    --value "$REF_CODE")

  HUGGINGFACE_API_KEY=$(
    gum input --cursor.foreground "${main_color}" \
      --prompt.foreground "${main_color}" \
      --prompt "Please provide your Huggingface API key: " \
      --password \
      --placeholder "$HUGGINGFACE_API_KEY" \
      --width 160 \
      --value "$HUGGINGFACE_API_KEY"
  )

  prompt_for_node_pk=0
  if [ -n "$NODE_PRIV_KEY" ]; then
    if ! gum confirm "Do you want to use the existing private key? "; then
      prompt_for_node_pk=1
    fi
  else
    prompt_for_node_pk=1
  fi

  if [ "$prompt_for_node_pk" -eq 1 ]; then
    NODE_PRIV_KEY=$(gum input --cursor.foreground "${main_color}" \
      --password \
      --prompt.foreground "${main_color}" \
      --prompt "Node's wallet private key: " \
      --width 160)
  fi

  NODE_PRIV_KEY=$(strip_0x_prefix "$NODE_PRIV_KEY")

  # clear
  update_header

fi
NESA_NODE_TYPE="nesa"
MINER_TYPE=$miner_type_agnostic
DISTRIBUTED_TYPE=$distributed_type_agnostic
IS_MINER="yes"
IS_DIST=False

# Generate NODE_ID from private key (if not already exists)
# This ensures NODE_ID is available before orchestrator starts
ensure_node_id "$NODE_PRIV_KEY"

save_to_env_file

# clear
update_header

display_config

if ! gum confirm "Do you want to start the node with the above configuration? "; then
  echo "Configuration saved. You can modify the configuration manually, run the wizard again, or you can simply use advanced wizardry to boot your node."
  exit 0
fi

# Check and handle deposit before starting containers
log_line "[STAGE 5.5]: checking miner deposit"
echo ""
gum style --foreground "$main_color" --bold "Checking deposit status..."

# Get wallet address
WALLET_ADDRESS=$(derive_wallet_address "$NODE_PRIV_KEY" "nesa")

# Show deposit flow (handles checking and prompting if needed)
if ! show_deposit_flow "$WALLET_ADDRESS" "$NODE_ID" "$NODE_PRIV_KEY"; then
  echo ""
  gum style --foreground 214 "Warning: Could not verify deposit status. Continuing anyway..."
  echo ""
fi

cd "$WORKING_DIRECTORY/docker" || {
  echo "Error: Docker directory does not exist."
  exit 1
}
log_line "[STAGE 6]: starting docker containers"

compose_up

cd "$init_pwd" || return
echo -e "Congratulations! Your $(gum style --foreground "$main_color" "nesa") node was successfully bootstrapped!"

# Offer management menu
echo ""
if gum confirm "Would you like to manage your wallet balance and miner deposit now?"; then
  show_management_menu
fi

echo ""
echo "You can run this script again anytime to manage your deposits and check balances."
echo ""
# set +x