docker-compose.yml

x-mining-logging: &mining-logging
  driver: local
  options:
    max-size: "10m"
    max-file: "2"

x-build-args: &build-args
  SNAPSHOT_PATH: ${SNAPSHOT_PATH:-docker/no-snapshot.marker}

x-dev-source-contexts: &dev-source-contexts
  stack_src: ${STACK_SRC_CONTEXT:-.}
  blockdag_corechain: ${BLOCKDAG_CORECHAIN_CONTEXT:-.}
  pool_src: ${POOL_SRC_CONTEXT:-.}
  cpu_miner_src: ${CPU_MINER_SRC_CONTEXT:-.}
  dashboard_src: ${DASHBOARD_SRC_CONTEXT:-../redis-dash}

x-node-critical: &node-critical
  tmpfs:
    - /tmp:size=${BDAG_NODE_TMPFS_SIZE:-512m},mode=1777
    - /var/tmp:size=${BDAG_NODE_TMPFS_SIZE:-512m},mode=1777
    - /run/bdag-ephemeral:size=${BDAG_NODE_TMPFS_SIZE:-512m},mode=1777
  shm_size: ${BDAG_NODE_SHM_SIZE:-512m}
  cpu_shares: 4096
  blkio_config:
    weight: 1000
  oom_score_adj: -900

x-pool-critical: &pool-critical
  cpu_shares: 3072
  blkio_config:
    weight: 900
  oom_score_adj: -800

x-ops-low: &ops-low
  cpu_shares: 256
  blkio_config:
    weight: 100
  oom_score_adj: 300
  


services:

  # --------------------------------------------------------------------------
  # PostgreSQL for the mining pool. Schema is applied automatically on first
  # boot via /docker-entrypoint-initdb.d.
  # --------------------------------------------------------------------------
  pool-db:
    <<: *pool-critical
    # Guard scripts (watchdog/sentinel) address containers by these runtime
    # names; keep container_name aligned with BDAG_POOL_DB_CONTAINER.
    container_name: postgres
    image: postgres:15-bookworm
    restart: unless-stopped
    logging: *mining-logging
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
      - /var/tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
    environment:
      TMPDIR: /tmp
      TMP: /tmp
      TEMP: /tmp
      POSTGRES_USER:     ${POSTGRES_USER:-bdag_pool}
      POSTGRES_DB:       ${POSTGRES_DB:-bdagpool}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD must be set in .env}
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./sql/pool-schema.sql:/docker-entrypoint-initdb.d/01-pool-schema.sql:ro
    ports:
      - "127.0.0.1:${POSTGRES_HOST_PORT:-55432}:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-bdag_pool} -d ${POSTGRES_DB:-bdagpool}"]
      interval: 5s
      timeout: 5s
      retries: 20

  # --------------------------------------------------------------------------
  # BlockDAG node + nodeworker supervisor. Optional snapshot import happens at
  # container start from a read-only bind mount, not during image build.
  # --------------------------------------------------------------------------
  node:
    <<: *node-critical
    container_name: node
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile}
      target: node
      additional_contexts:
        <<: *dev-source-contexts
      args:
        <<: *build-args
    restart: unless-stopped
    logging: *mining-logging
    network_mode: host
    environment:
      TMPDIR: /tmp
      TMP: /tmp
      TEMP: /tmp
      BDAG_NETWORK: ${BDAG_NETWORK:-}
      P2P_PORT: ${P2P_PORT:-8155}
      BDAG_EPHEMERAL_DIR: /run/bdag-ephemeral
      BDAG_SNAPSHOT_URL: ${BDAG_SNAPSHOT_URL:-}
      BDAG_NODE_ARCHIVAL: ${BDAG_NODE_ARCHIVAL:-0}
      BDAG_NODE_DEBUG_LEVEL: ${BDAG_NODE_DEBUG_LEVEL:-warn}
      BDAG_NODE_NO_FILE_LOGGING: ${BDAG_NODE_NO_FILE_LOGGING:-1}
      BDAG_NODE_OBSOLETE_HEIGHT: ${BDAG_NODE_OBSOLETE_HEIGHT:-20}
      BDAG_NODE_MINING_NO_PENDING_TX: ${BDAG_NODE_MINING_NO_PENDING_TX:-0}
      BDAG_ENABLE_NODE_MINING: ${BDAG_ENABLE_NODE_MINING:-0}
      BDAG_NODE_MODULES: ${BDAG_NODE_MODULES:-Blockdag,miner}
      BDAG_NODE_MINING_ARGS: ${BDAG_NODE_MINING_ARGS:-}
      MINING_POOL_ADDRESS: ${MINING_POOL_ADDRESS:?set MINING_POOL_ADDRESS to a non-zero payout address}
      POOL_COINBASE_ADDRESS: ${POOL_COINBASE_ADDRESS:-}
      MINING_ADDRESS: ${MINING_ADDRESS:-}
      NODE_ARGS_APPEND: ${NODE_ARGS_APPEND:-}
      SYNC_SOURCE_NODE: ${SYNC_SOURCE_NODE:-0}
      BDAG_STORAGE_PROFILE: ${BDAG_STORAGE_PROFILE:-auto}
      BDAG_NETWORK_TOPOLOGY: ${BDAG_NETWORK_TOPOLOGY:-auto}
      BDAG_DETECTED_NETWORK_TOPOLOGY: ${BDAG_DETECTED_NETWORK_TOPOLOGY:-}
      BDAG_ASIC_LAN_INTERFACE: ${BDAG_ASIC_LAN_INTERFACE:-}
      BDAG_ASIC_LAN_CIDRS: ${BDAG_ASIC_LAN_CIDRS:-}
      BDAG_P2P_ADVERTISE_IP: ${BDAG_P2P_ADVERTISE_IP:-}
      BDAG_P2P_INTERFACE: ${BDAG_P2P_INTERFACE:-}
      BOOTSTRAP_PEER_ADDRESSES: ${BOOTSTRAP_PEER_ADDRESSES:-}
      BDAG_ENTRYPOINT_CHOWN_MODE: ${BDAG_ENTRYPOINT_CHOWN_MODE:-needed}
      BDAG_NODEWORKER_LIVENESS_TIMEOUT: ${BDAG_NODEWORKER_LIVENESS_TIMEOUT:-5m}
    volumes:
    # Note: The default behaviour is to keep any DB state from a previous run, 
    # to prevent unintentional loss of synced chain data.
    # so if you want to start fresh, you need to delete the volume explicity.
    # `docker compose down && docker volume rm <project>_node-data`\

      - ${NODE_DATA_DIR:-./data/node}:/var/lib/bdagStack/node
      - nodeworker-data:/var/lib/bdagStack/nodeworker
      - ${SNAPSHOT_HOST_PATH:-./docker/no-snapshot.marker}:/snapshot/latest.bdsnap:ro
      # node.conf in project root (copy from node.conf.example). gitignored.
      - ./node.conf:/etc/bdagStack/node.conf:ro

  # --------------------------------------------------------------------------
  # Mining pool. Connects to node RPC and Postgres.
  # --------------------------------------------------------------------------
  pool:
    <<: *pool-critical
    container_name: pool
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile}
      target: pool
      additional_contexts:
        <<: *dev-source-contexts
      args:
        <<: *build-args
    restart: unless-stopped
    logging: *mining-logging
    network_mode: host
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
      - /var/tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
    depends_on:
      pool-db: { condition: service_healthy }
    environment:
      TMPDIR: /tmp
      TMP: /tmp
      TEMP: /tmp
      # Compose interpolates ${...} from the project root .env file.
      NODE_RPC_URL: ${NODE_RPC_URL:-http://127.0.0.1:38131}
      NODE_RPC_URLS: ${NODE_RPC_URLS:-http://127.0.0.1:38131}
      POOL_SUBMIT_RPC_URLS: ${POOL_SUBMIT_RPC_URLS:-}
      POOL_RPC_BACKENDS: ${POOL_RPC_BACKENDS:-}
      POOL_RUNTIME_ADMIN_ENABLED: ${POOL_RUNTIME_ADMIN_ENABLED:-true}
      PG_URL:       postgres://${POSTGRES_USER:-bdag_pool}:${POSTGRES_PASSWORD}@${POOL_DB_HOST:-127.0.0.1}:${POOL_DB_PORT:-55432}/${POSTGRES_DB:-bdagpool}?sslmode=disable
      # Stratum listen (inside container) — from root .env
      POOL_BIND_ADDR:     ${POOL_BIND_ADDR:-0.0.0.0:3334}
      NODE_RPC_USER:      ${NODE_RPC_USER:-test}
      NODE_RPC_PASS:      ${NODE_RPC_PASS:-test}
      PPLNS_N_WORK:       ${PPLNS_N_WORK:-1000}
      POOL_FEE_PERCENTAGE: ${POOL_FEE_PERCENTAGE:-1.0}
      POOL_BLOCK_MATURITY: ${POOL_BLOCK_MATURITY:-10}
      POOL_PAYOUT_MATURITY: ${POOL_PAYOUT_MATURITY:-4096}
      POOL_PAYOUT_MAX_BLOCKS_PER_TICK: ${POOL_PAYOUT_MAX_BLOCKS_PER_TICK:-5}
      POOL_STRATUM_CONNECTION_LOG_INTERVAL_SECONDS: ${POOL_STRATUM_CONNECTION_LOG_INTERVAL_SECONDS:-60}
      POOL_RPC_ROUTER_NODE_HEALTH_ENABLED: ${POOL_RPC_ROUTER_NODE_HEALTH_ENABLED:-true}
      POOL_RPC_ROUTER_NODE_HEALTH_PROBE_SECONDS: ${POOL_RPC_ROUTER_NODE_HEALTH_PROBE_SECONDS:-15}
      POOL_RPC_ROUTER_NODE_HEALTH_MAX_AGE_SECONDS: ${POOL_RPC_ROUTER_NODE_HEALTH_MAX_AGE_SECONDS:-30}
      POOL_RPC_ROUTER_NODE_HEALTH_FRESH_TEMPLATE_GRACE_SECONDS: ${POOL_RPC_ROUTER_NODE_HEALTH_FRESH_TEMPLATE_GRACE_SECONDS:-15}
      POOL_RPC_ROUTER_NODE_HEALTH_MIN_CONSENSUS_PEERS: ${POOL_RPC_ROUTER_NODE_HEALTH_MIN_CONSENSUS_PEERS:-2}
      POOL_RPC_ROUTER_EVM_HEAD_GUARD_ENABLED: ${POOL_RPC_ROUTER_EVM_HEAD_GUARD_ENABLED:-false}
      POOL_RPC_ROUTER_EVM_HEAD_GUARD_MAX_LAG_BLOCKS: ${POOL_RPC_ROUTER_EVM_HEAD_GUARD_MAX_LAG_BLOCKS:-30}
      POOL_RPC_ROUTER_EVM_REFERENCE_URLS: ${POOL_RPC_ROUTER_EVM_REFERENCE_URLS:-https://rpc.blockdag.engineering,https://rpc.bdagscan.com}
      POOL_TEMPLATE_TTL_REFRESH_MS: ${POOL_TEMPLATE_TTL_REFRESH_MS:-100}
      POOL_SUBMIT_STALE_BLOCK_CANDIDATES: ${POOL_SUBMIT_STALE_BLOCK_CANDIDATES:-false}
      POOL_RECENT_STALE_BLOCK_CANDIDATE_SUBMIT_GRACE_MS: ${POOL_RECENT_STALE_BLOCK_CANDIDATE_SUBMIT_GRACE_MS:-1750}
      POOL_MAX_BLOCK_CANDIDATE_JOB_AGE_MS: ${POOL_MAX_BLOCK_CANDIDATE_JOB_AGE_MS:-1750}
      POOL_AUTO_TUNE_BLOCK_CANDIDATE_JOB_AGE: ${POOL_AUTO_TUNE_BLOCK_CANDIDATE_JOB_AGE:-true}
      POOL_AUTO_TUNE_BLOCK_CANDIDATE_MAX_AGE_MS: ${POOL_AUTO_TUNE_BLOCK_CANDIDATE_MAX_AGE_MS:-8000}
      POOL_SUBMIT_BLOCK_HEADER_V2_ENABLED: ${POOL_SUBMIT_BLOCK_HEADER_V2_ENABLED:-true}
      POOL_STALE_RACE_REJECT_WINDOW_SECONDS: ${POOL_STALE_RACE_REJECT_WINDOW_SECONDS:-10}
      POOL_STALE_RACE_CLIENT_RESEND_THRESHOLD: ${POOL_STALE_RACE_CLIENT_RESEND_THRESHOLD:-1}
      POOL_STALE_RACE_CLIENT_RECONNECT_THRESHOLD: ${POOL_STALE_RACE_CLIENT_RECONNECT_THRESHOLD:-0}
      POOL_STALE_RACE_CLIENT_RECONNECT_WINDOW_SECONDS: ${POOL_STALE_RACE_CLIENT_RECONNECT_WINDOW_SECONDS:-120}
      POOL_STALE_RACE_CLIENT_RECONNECT_COOLDOWN_SECONDS: ${POOL_STALE_RACE_CLIENT_RECONNECT_COOLDOWN_SECONDS:-60}
      POOL_STALE_RACE_RECOVERY_COOLDOWN_SECONDS: ${POOL_STALE_RACE_RECOVERY_COOLDOWN_SECONDS:-5}
      POOL_EXPIRED_JOB_CLIENT_RECONNECT_THRESHOLD: ${POOL_EXPIRED_JOB_CLIENT_RECONNECT_THRESHOLD:-3}
      POOL_EXPIRED_JOB_CLIENT_RECONNECT_WINDOW_SECONDS: ${POOL_EXPIRED_JOB_CLIENT_RECONNECT_WINDOW_SECONDS:-120}
      POOL_EXPIRED_JOB_CLIENT_RECONNECT_COOLDOWN_SECONDS: ${POOL_EXPIRED_JOB_CLIENT_RECONNECT_COOLDOWN_SECONDS:-60}
      POOL_ALLOW_MULTIPLE_BLOCK_CANDIDATES_PER_JOB: ${POOL_ALLOW_MULTIPLE_BLOCK_CANDIDATES_PER_JOB:-true}
      POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_ENABLED: ${POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_ENABLED:-true}
      POOL_PREEMPTIVE_BLOCK_CANDIDATE_CLEAN_REISSUE_ENABLED: ${POOL_PREEMPTIVE_BLOCK_CANDIDATE_CLEAN_REISSUE_ENABLED:-false}
      POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_DELAY_MS: ${POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_DELAY_MS:-0}
      POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_INTERVAL_MS: ${POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_INTERVAL_MS:-20}
      POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_TIMEOUT_MS: ${POOL_PREEMPTIVE_BLOCK_CANDIDATE_REFRESH_TIMEOUT_MS:-1000}
      POOL_BLOCK_TIMING_CONTROLLER_ENABLED: ${POOL_BLOCK_TIMING_CONTROLLER_ENABLED:-true}
      POOL_BLOCK_TIMING_CONTROLLER_WINDOW_SECONDS: ${POOL_BLOCK_TIMING_CONTROLLER_WINDOW_SECONDS:-60}
      POOL_BLOCK_TIMING_CONTROLLER_MIN_CANDIDATES: ${POOL_BLOCK_TIMING_CONTROLLER_MIN_CANDIDATES:-20}
      POOL_BLOCK_TIMING_CONTROLLER_TARGET_WASTE_PERCENT: ${POOL_BLOCK_TIMING_CONTROLLER_TARGET_WASTE_PERCENT:-5}
      POOL_BLOCK_TIMING_CONTROLLER_MIN_JOB_AGE_MS: ${POOL_BLOCK_TIMING_CONTROLLER_MIN_JOB_AGE_MS:-1750}
      POOL_BLOCK_TIMING_CONTROLLER_MAX_JOB_AGE_MS: ${POOL_BLOCK_TIMING_CONTROLLER_MAX_JOB_AGE_MS:-1750}
      POOL_BLOCK_TIMING_CONTROLLER_MIN_TEMPLATE_TTL_MS: ${POOL_BLOCK_TIMING_CONTROLLER_MIN_TEMPLATE_TTL_MS:-100}
      POOL_BLOCK_TIMING_CONTROLLER_MAX_TEMPLATE_TTL_MS: ${POOL_BLOCK_TIMING_CONTROLLER_MAX_TEMPLATE_TTL_MS:-100}
      POOL_BLOCK_TIMING_CONTROLLER_STEP_MS: ${POOL_BLOCK_TIMING_CONTROLLER_STEP_MS:-250}
      POOL_BLOCK_TIMING_CONTROLLER_COOLDOWN_SECONDS: ${POOL_BLOCK_TIMING_CONTROLLER_COOLDOWN_SECONDS:-20}
      BDAG_ASIC_LAN_CIDRS: ${BDAG_ASIC_LAN_CIDRS:-}
      POOL_ASIC_MAC_OVERRIDES: ${POOL_ASIC_MAC_OVERRIDES:-}
      POOL_ASIC_MAC_ALLOWLIST: ${POOL_ASIC_MAC_ALLOWLIST:-}
      WALLET_RPC_URL:     ${WALLET_RPC_URL:-http://127.0.0.1:${EVM_HTTP_PORT:-18545}}
      POOL_PRIVATE_KEY:   ${POOL_PRIVATE_KEY:-}
      POOL_COINBASE_ADDRESS: ${POOL_COINBASE_ADDRESS:-}
      MINING_POOL_ADDRESS: ${MINING_POOL_ADDRESS:?set MINING_POOL_ADDRESS to a non-zero payout address}
      METRICS_ADDR:       ${METRICS_ADDR:-0.0.0.0:9090}
      POOL_INSTANCE_ID:   ${POOL_INSTANCE_ID:-}

  # --------------------------------------------------------------------------
  # Host-side auto-repair layer, containerised. Watchdog and sentinel use
  # dedicated repair targets that inherit the shared ops runtime (python3 +
  # Docker CLI + Compose plugin). They run the
  # stack repo's ops scripts against the host Docker socket. The repo is mounted at
  # its host-identical absolute path so sentinel compose recreates resolve
  # bind mounts correctly. BDAG_STACK_HOST_ROOT defaults to the directory
  # compose is invoked from ($PWD); override it when running compose from
  # outside the stack checkout (e.g. with -f).
  # --------------------------------------------------------------------------
  watchdog:
    <<: *ops-low
    container_name: watchdog
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile}
      target: watchdog
    restart: unless-stopped
    logging: *mining-logging
    user: "${BDAG_OPS_UID:-1000}:${BDAG_OPS_GID:-1000}"
    group_add:
      - "${BDAG_DOCKER_SOCKET_GID:-0}"
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
    working_dir: ${BDAG_STACK_HOST_ROOT:-${PWD}}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    entrypoint:
      - /bin/sh
      - -c
      - >-
        python3 ops/automation_control.py ensure-normal
        --owner watchdog-container --owner-unit docker-compose:watchdog
        --reason 'provision automation control gate for containerised repairs'
        && exec python3 ops/watchdog.py --loop
    environment:
      TMPDIR: /tmp
      COMPOSE_PROJECT_NAME: stack
      BDAG_PROJECT_ROOT: ${BDAG_STACK_HOST_ROOT:-${PWD}}
      BDAG_RUNTIME_DIR: ${BDAG_STACK_HOST_ROOT:-${PWD}}/ops/runtime
      BDAG_POOL_ENV_FILE: ${BDAG_STACK_HOST_ROOT:-${PWD}}/.env
      BDAG_STATUS_SOURCE_URL: http://dashboard:8088/api/status
      BDAG_NODE_SERVICES: node
      BDAG_STACK_SERVICES: postgres,node,pool
      BDAG_POOL_CONTAINER: pool
      BDAG_POOL_CONTAINERS: pool
      BDAG_POOL_DB_CONTAINER: postgres
      BDAG_POOL_HOST: ${BDAG_POOL_HOST:-}
      BDAG_POOL_HOST_NETWORK_METRICS_HOST: ${BDAG_POOL_HOST_NETWORK_METRICS_HOST:-host.docker.internal}
      NODE_RPC_USER: ${NODE_RPC_USER:-test}
      NODE_RPC_PASS: ${NODE_RPC_PASS:-test}
      BDAG_WATCHDOG_INTERVAL: ${BDAG_WATCHDOG_INTERVAL:-60}
      BDAG_WATCHDOG_NATIVE_P2P_PEER_LOSS_REPAIR_SECONDS: ${BDAG_WATCHDOG_NATIVE_P2P_PEER_LOSS_REPAIR_SECONDS:-300}
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ${BDAG_STACK_HOST_ROOT:-${PWD}}:${BDAG_STACK_HOST_ROOT:-${PWD}}

  status-sampler:
    <<: *ops-low
    container_name: status-sampler
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile}
      target: status-sampler
    restart: unless-stopped
    logging: *mining-logging
    user: "${BDAG_OPS_UID:-1000}:${BDAG_OPS_GID:-1000}"
    group_add:
      - "${BDAG_DOCKER_SOCKET_GID:-0}"
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
    working_dir: ${BDAG_STACK_HOST_ROOT:-${PWD}}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    entrypoint:
      - /bin/sh
      - -c
      - >-
        exec python3 ops/status_sampler.py --loop --no-logs
    environment:
      TMPDIR: /tmp
      COMPOSE_PROJECT_NAME: stack
      BDAG_PROJECT_ROOT: ${BDAG_STACK_HOST_ROOT:-${PWD}}
      BDAG_RUNTIME_DIR: ${BDAG_STACK_HOST_ROOT:-${PWD}}/ops/runtime
      BDAG_POOL_ENV_FILE: ${BDAG_STACK_HOST_ROOT:-${PWD}}/.env
      BDAG_STATUS_SAMPLER_FILE: ${BDAG_STACK_HOST_ROOT:-${PWD}}/ops/runtime/status-sampler.json
      BDAG_STATUS_SAMPLER_INTERVAL_SECONDS: ${BDAG_STATUS_SAMPLER_INTERVAL_SECONDS:-10}
      BDAG_STATUS_SAMPLER_EARNINGS_SNAPSHOT_INTERVAL_SECONDS: ${BDAG_STATUS_SAMPLER_EARNINGS_SNAPSHOT_INTERVAL_SECONDS:-60}
      BDAG_MINING_IMPERATIVE_REPAIR_INTERVAL_SECONDS: ${BDAG_MINING_IMPERATIVE_REPAIR_INTERVAL_SECONDS:-30}
      # systemd unit checks do not apply inside a container; empty lists skip them.
      BDAG_MINING_IMPERATIVE_GUARD_UNITS: ""
      # Compose deployments run self-heal directly inside this ops container.
      BDAG_CHAIN_STATE_SELF_HEAL_UNIT: ""
      BDAG_CHAIN_STATE_SELF_HEAL_COMMAND: ${BDAG_CHAIN_STATE_SELF_HEAL_COMMAND:-ops/chain-state-self-heal.sh --from-systemd}
      BDAG_CHAIN_STATE_SELF_HEAL_STATUS_URL: http://dashboard:8088/api/status
      BDAG_NODE_SERVICES: node
      BDAG_NODE_RPC_URLS: node=http://host.docker.internal:38131
      BDAG_STACK_SERVICES: postgres,node,pool
      BDAG_POOL_CONTAINER: pool
      BDAG_POOL_CONTAINERS: pool
      BDAG_POOL_DB_CONTAINER: postgres
      BDAG_POOL_HOST_NETWORK_METRICS_HOST: ${BDAG_POOL_HOST_NETWORK_METRICS_HOST:-host.docker.internal}
      NODE_RPC_USER: ${NODE_RPC_USER:-test}
      NODE_RPC_PASS: ${NODE_RPC_PASS:-test}
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ${BDAG_STACK_HOST_ROOT:-${PWD}}:${BDAG_STACK_HOST_ROOT:-${PWD}}

  sentinel:
    <<: *ops-low
    container_name: sentinel
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile}
      target: sentinel
    restart: unless-stopped
    logging: *mining-logging
    user: "${BDAG_OPS_UID:-1000}:${BDAG_OPS_GID:-1000}"
    group_add:
      - "${BDAG_DOCKER_SOCKET_GID:-0}"
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
    working_dir: ${BDAG_STACK_HOST_ROOT:-${PWD}}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    entrypoint:
      - /bin/sh
      - -c
      - >-
        python3 ops/automation_control.py ensure-normal
        --owner sentinel-container --owner-unit docker-compose:sentinel
        --reason 'provision automation control gate for containerised repairs'
        && while true; do
        python3 ops/stack_sentinel.py;
        sleep $${BDAG_SENTINEL_INTERVAL_SECONDS:-60};
        done
    environment:
      TMPDIR: /tmp
      COMPOSE_PROJECT_NAME: stack
      BDAG_PROJECT_ROOT: ${BDAG_STACK_HOST_ROOT:-${PWD}}
      BDAG_RUNTIME_DIR: ${BDAG_STACK_HOST_ROOT:-${PWD}}/ops/runtime
      BDAG_POOL_ENV_FILE: ${BDAG_STACK_HOST_ROOT:-${PWD}}/.env
      BDAG_SENTINEL_STATUS_URL: http://dashboard:8088/api/status
      BDAG_SENTINEL_INTERVAL_SECONDS: ${BDAG_SENTINEL_INTERVAL_SECONDS:-60}
      # systemd unit checks do not apply inside a container; empty lists skip them.
      BDAG_SENTINEL_USER_SERVICES: ""
      BDAG_SENTINEL_USER_TIMERS: ""
      BDAG_NODE_SERVICES: node
      BDAG_STACK_SERVICES: postgres,node,pool
      BDAG_POOL_CONTAINER: pool
      BDAG_POOL_CONTAINERS: pool
      BDAG_POOL_DB_CONTAINER: postgres
      BDAG_POOL_HOST_NETWORK_METRICS_HOST: ${BDAG_POOL_HOST_NETWORK_METRICS_HOST:-host.docker.internal}
      NODE_RPC_USER: ${NODE_RPC_USER:-test}
      NODE_RPC_PASS: ${NODE_RPC_PASS:-test}
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ${BDAG_STACK_HOST_ROOT:-${PWD}}:${BDAG_STACK_HOST_ROOT:-${PWD}}

  # --------------------------------------------------------------------------
  # Keeps the host route to the remote miner LAN (via the ZeroTier peer)
  # in place so the watchdog can reach the miner HTTP API for health checks
  # and restarts. No-op unless BDAG_MINER_ROUTE_SUBNET is set in .env.
  # --------------------------------------------------------------------------
  miner-route:
    image: alpine:3.20
    container_name: miner-route
    network_mode: host
    cap_add:
      - NET_ADMIN
    restart: unless-stopped
    logging: *mining-logging
    environment:
      BDAG_MINER_ROUTE_SUBNET: ${BDAG_MINER_ROUTE_SUBNET:-}
      BDAG_MINER_ROUTE_GATEWAY: ${BDAG_MINER_ROUTE_GATEWAY:-}
      BDAG_MINER_ROUTE_DEV: ${BDAG_MINER_ROUTE_DEV:-}
    entrypoint:
      - /bin/sh
      - -c
      - >-
        while true; do
        if [ -n "$$BDAG_MINER_ROUTE_SUBNET" ] && [ -n "$$BDAG_MINER_ROUTE_GATEWAY" ]; then
        cmd="ip route replace $$BDAG_MINER_ROUTE_SUBNET via $$BDAG_MINER_ROUTE_GATEWAY";
        [ -n "$$BDAG_MINER_ROUTE_DEV" ] && cmd="$$cmd dev $$BDAG_MINER_ROUTE_DEV";
        $$cmd || echo "miner-route: failed: $$cmd";
        fi;
        sleep 60;
        done

  # --------------------------------------------------------------------------
  # Dashboard runtime: Go UI + private Redis + live ingest workers.
  # --------------------------------------------------------------------------
  dashboard:
    <<: *ops-low
    container_name: dashboard
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile}
      target: dashboard
      additional_contexts:
        <<: *dev-source-contexts
    restart: unless-stopped
    logging: *mining-logging
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
      - /var/tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
      - /run/dashboard-redis:size=16m,mode=0700
    volumes:
      - dashboard-redis:/var/lib/dashboard-redis
      - ${BDAG_HOST_ARP_TABLE_PATH:-/proc/net/arp}:/host/proc/net/arp:ro
    depends_on:
      node: { condition: service_started }
      pool: { condition: service_started }
    extra_hosts:
      - "host.docker.internal:host-gateway"
    environment:
      TMPDIR: /tmp
      TMP: /tmp
      TEMP: /tmp
      ADDR: ${DASHBOARD_LISTEN:-0.0.0.0:8088}
      BDAG_DASHBOARD_REDIS_ENABLED: ${BDAG_DASHBOARD_REDIS_ENABLED:-1}
      BDAG_DASHBOARD_REDIS_MANAGED: ${BDAG_DASHBOARD_REDIS_MANAGED:-1}
      BDAG_REDIS_SOCKET: /run/dashboard-redis/redis.sock
      BDAG_REDIS_CONFIG: /etc/redis/redis.conf
      BDAG_REDIS_APPENDONLY: ${BDAG_REDIS_APPENDONLY:-yes}
      BDAG_REDIS_APPENDFSYNC: ${BDAG_REDIS_APPENDFSYNC:-everysec}
      BDAG_REDIS_MAXMEMORY: ${BDAG_REDIS_MAXMEMORY:-256mb}
      BDAG_REDIS_MAXMEMORY_POLICY: ${BDAG_REDIS_MAXMEMORY_POLICY:-noeviction}
      BDAG_EVM_HTTP_URL: ${BDAG_EVM_HTTP_URL:-http://host.docker.internal:18545}
      BDAG_EVM_WS_URL: ${BDAG_EVM_WS_URL:-ws://host.docker.internal:18546}
      BDAG_EVM_SYNC_BACKOFF_SECONDS: ${BDAG_EVM_SYNC_BACKOFF_SECONDS:-60}
      BDAG_POOL_METRICS_URL: ${BDAG_POOL_METRICS_URL:-http://host.docker.internal:9090/metrics}
      BDAG_NODE_RPC_URL: ${BDAG_NODE_RPC_URL:-http://host.docker.internal:38131}
      BDAG_GLOBAL_BLOCK_WINDOW: ${BDAG_GLOBAL_BLOCK_WINDOW:-600}
      BDAG_GLOBAL_CACHE_MAX_TIP_LAG_BLOCKS: ${BDAG_GLOBAL_CACHE_MAX_TIP_LAG_BLOCKS:-30}
      BDAG_GLOBAL_FAST_WARMUP_BLOCKS: ${BDAG_GLOBAL_FAST_WARMUP_BLOCKS:-120}
      BDAG_GLOBAL_RPC_WORKERS: ${BDAG_GLOBAL_RPC_WORKERS:-4}
      BDAG_GLOBAL_SETTLE_DELAY_SECONDS: ${BDAG_GLOBAL_SETTLE_DELAY_SECONDS:-5}
      BDAG_GLOBAL_MAX_INCREMENTAL_GAP: ${BDAG_GLOBAL_MAX_INCREMENTAL_GAP:-120}
      BDAG_GLOBAL_RPC_CHUNK_SIZE: ${BDAG_GLOBAL_RPC_CHUNK_SIZE:-64}
      BDAG_TREND_HISTORY_ENABLED: ${BDAG_TREND_HISTORY_ENABLED:-1}
      BDAG_TREND_BACKFILL_DAYS: ${BDAG_TREND_BACKFILL_DAYS:-30}
      BDAG_TREND_BACKFILL_CHUNK_SIZE: ${BDAG_TREND_BACKFILL_CHUNK_SIZE:-128}
      BDAG_TREND_RPC_WORKERS: ${BDAG_TREND_RPC_WORKERS:-4}
      BDAG_TREND_BACKFILL_MAX_BLOCKS_PER_PASS: ${BDAG_TREND_BACKFILL_MAX_BLOCKS_PER_PASS:-4096}
      BDAG_TREND_RECENT_WARMUP_BLOCKS: ${BDAG_TREND_RECENT_WARMUP_BLOCKS:-3600}
      BDAG_TREND_SPARSE_SAMPLES_PER_PASS: ${BDAG_TREND_SPARSE_SAMPLES_PER_PASS:-24}
      BDAG_TREND_SPARSE_MAX_SAMPLE_BLOCKS: ${BDAG_TREND_SPARSE_MAX_SAMPLE_BLOCKS:-2048}
      BDAG_TREND_BACKFILL_SLEEP_MS: ${BDAG_TREND_BACKFILL_SLEEP_MS:-100}
      BDAG_TREND_CATCHUP_INTERVAL_SECONDS: ${BDAG_TREND_CATCHUP_INTERVAL_SECONDS:-30}
      BDAG_CHAIN_POLL_SECONDS: ${BDAG_CHAIN_POLL_SECONDS:-2}
      BDAG_CHAIN_POLL_FALLBACK_AFTER_SECONDS: ${BDAG_CHAIN_POLL_FALLBACK_AFTER_SECONDS:-3}
      BDAG_CHAIN_WS_READ_LIMIT_BYTES: ${BDAG_CHAIN_WS_READ_LIMIT_BYTES:-1048576}
      BDAG_CHAIN_WS_READ_TIMEOUT_SECONDS: ${BDAG_CHAIN_WS_READ_TIMEOUT_SECONDS:-10}
      BDAG_DASHBOARD_HEALTH_STALE_SECONDS: ${BDAG_DASHBOARD_HEALTH_STALE_SECONDS:-20}
      DASHBOARD_TIMEZONE: ${DASHBOARD_TIMEZONE:-Africa/Johannesburg}
      BDAG_MINER_CONTROL_ENABLED: ${BDAG_MINER_CONTROL_ENABLED:-1}
      BDAG_ASIC_LAN_CIDRS: ${BDAG_ASIC_LAN_CIDRS:-}
      POOL_ASIC_ARP_TABLE_PATH: ${POOL_ASIC_ARP_TABLE_PATH:-/host/proc/net/arp}
      POOL_ASIC_MAC_OVERRIDES: ${POOL_ASIC_MAC_OVERRIDES:-}
      POOL_ASIC_MAC_ALLOWLIST: ${POOL_ASIC_MAC_ALLOWLIST:-}
      BDAG_POOL_URL: ${BDAG_POOL_URL:-}
      MINING_POOL_ADDRESS: ${MINING_POOL_ADDRESS:?set MINING_POOL_ADDRESS to a non-zero payout address}
      POOL_COINBASE_ADDRESS: ${POOL_COINBASE_ADDRESS:-}
      NODE_RPC_USER: ${NODE_RPC_USER:-test}
      NODE_RPC_PASS: ${NODE_RPC_PASS:-test}
    healthcheck:
      test: ["CMD-SHELL", "curl -fsS http://127.0.0.1:8088/ >/dev/null"]
      interval: 10s
      timeout: 5s
      retries: 12
    ports:
      - "${DASHBOARD_BIND:-0.0.0.0}:${DASHBOARD_HOST_PORT:-8088}:8088"

  # --------------------------------------------------------------------------
  # Optional CPU miner (dockerfile-dev target only). Enable with:
  #   COMPOSE_PROFILES=miner
  # --------------------------------------------------------------------------
  cpu-miner:
    platform: ${DOCKER_PLATFORM:-linux/amd64}
    profiles: [miner]
    build:
      context: .
      dockerfile: ${DOCKERFILE:-dockerfile-dev}
      target: miner
      additional_contexts:
        <<: *dev-source-contexts
      args:
        <<: *build-args
    restart: unless-stopped
    logging: *mining-logging
    tmpfs:
      - /tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
      - /var/tmp:size=${BDAG_CONTAINER_TMPFS_SIZE:-128m},mode=1777
    depends_on:
      pool: { condition: service_started }
    environment:
      TMPDIR: /tmp
      TMP: /tmp
      TEMP: /tmp
      POOL_URL: ${MINER_POOL_URL:-stratum+tcp://pool:3334}
      POOL_USER: ${MINING_POOL_ADDRESS:-0x0000000000000000000000000000000000000000}
      POOL_PASS: ${MINER_POOL_PASS:-x}
      WORKERS: ${MINER_WORKERS:-1}

secrets:
  github_token:
    environment: GITHUB_TOKEN

volumes:
  postgres-data:
  node-data:
  nodeworker-data:
  dashboard-redis: