docker-compose.yml

# Pin the compose project name. It otherwise defaults to the basename of whatever
# directory the stack is checked out in, and the deploy derives the default
# network name (`<project>_default`) from it to run contract discovery in a
# throwaway container. Pinning the project — rather than renaming the network —
# keeps every service on the one network compose creates by default.
name: dashtec

services:
  web:
    build:
      context: .
      dockerfile: apps/web/Dockerfile
      args:
        NETWORK: mainnet
    image: dashtec-web:latest
    container_name: dashtec-web
    ports:
      - "${WEB_PORT:-3000}:3000"
    env_file:
      - apps/web/.env.mainnet
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@${DB_HOST:-postgres-mainnet}:5432/dashtec
      REDIS_URL: redis://:dashtec@${REDIS_HOST:-redis-mainnet}:6379
      DATABASE_URL_REPLICA: postgresql://dashtec:dashtec@${DB_HOST:-postgres-mainnet}:5432/dashtec
      NEXT_SENTINEL_URL: ${NEXT_SENTINEL_URL}
    depends_on:
      aztec-node-mainnet:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      # These images are Node runtimes with no curl/wget on PATH, so a
      # curl-based test fails regardless of the app's real state and pins the
      # container to "unhealthy" forever. Probe with node itself.
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:3000/api/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    profiles:
      - mainnet

  indexer-ponder:
    build:
      context: .
      dockerfile: packages/indexer-ponder/Dockerfile
    image: dashtec-indexer-ponder:latest
    container_name: dashtec-indexer-ponder
    ports:
      - "${PONDER_PORT:-42069}:42069"
    env_file:
      - packages/indexer-ponder/.env.mainnet
    environment:
      DATABASE_SCHEMA: ponder_prod
      DATABASE_URL: postgresql://dashtec:dashtec@${DB_HOST:-postgres-mainnet}:5432/dashtec
      REDIS_URL: redis://:dashtec@${REDIS_HOST:-redis-mainnet}:6379
    restart: unless-stopped
    healthcheck:
      # These images are Node runtimes with no curl/wget on PATH, so a
      # curl-based test fails regardless of the app's real state and pins the
      # container to "unhealthy" forever. Probe with node itself.
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:42069/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    profiles:
      - mainnet

  indexer-custom:
    build:
      context: .
      dockerfile: packages/indexer-custom/Dockerfile
    image: dashtec-indexer-custom:latest
    container_name: dashtec-indexer-custom
    # Default command runs all collectors (see Dockerfile CMD)
    ports:
      - "${COLLECTOR_VALIDATOR_STATS_PORT:-4000}:4000"
      - "${COLLECTOR_VALIDATOR_LIST_PORT:-4001}:4001"
      - "${COLLECTOR_EPOCH_INTEGRITY_PORT:-4002}:4002"
      - "${COLLECTOR_VALIDATOR_MIGRATION_PORT:-4003}:4003"
      - "${COLLECTOR_PROVIDER_LIST_PORT:-4004}:4004"
    env_file:
      - packages/indexer-custom/.env.mainnet
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@${DB_HOST:-postgres-mainnet}:5432/dashtec
      DATABASE_READ_REPLICA_URL: postgresql://dashtec:dashtec@${DB_HOST:-postgres-mainnet}:5432/dashtec
      REDIS_URL: redis://:dashtec@${REDIS_HOST:-redis-mainnet}:6379
      VALIDATOR_STATS_RPC_URL: ${VALIDATOR_STATS_RPC_URL}
    depends_on:
      aztec-node-mainnet:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      # These images are Node runtimes with no curl/wget on PATH, so a
      # curl-based test fails regardless of the app's real state and pins the
      # container to "unhealthy" forever. Probe with node itself.
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:4000/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    profiles:
      - mainnet

  materializer:
    build:
      context: .
      dockerfile: packages/materializer/Dockerfile
    image: dashtec-materializer:latest
    container_name: dashtec-materializer
    env_file:
      - packages/materializer/.env.mainnet
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@${DB_HOST:-postgres-mainnet}:5432/dashtec
      PONDER_SCHEMA: ponder_prod
    restart: unless-stopped
    healthcheck:
      # No pgrep in the image either. Assert PID 1 is still the node process.
      test:
        - CMD
        - node
        - -e
        - "process.exit(require('fs').readFileSync('/proc/1/cmdline', 'utf8').includes('node') ? 0 : 1)"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 15s
    profiles:
      - mainnet

  # Testnet Web
  web-testnet:
    build:
      context: .
      dockerfile: apps/web/Dockerfile
      args:
        NETWORK: testnet
    image: dashtec-web:testnet
    container_name: dashtec-web-testnet
    ports:
      - "${WEB_TESTNET_PORT:-3001}:3000"
    env_file:
      - apps/web/.env.testnet
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      REDIS_URL: redis://:dashtec@redis-testnet:6379
      DATABASE_URL_REPLICA: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      NEXT_SENTINEL_URL: ${NEXT_SENTINEL_URL_TESTNET}
    depends_on:
      aztec-node-testnet:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      # These images are Node runtimes with no curl/wget on PATH, so a
      # curl-based test fails regardless of the app's real state and pins the
      # container to "unhealthy" forever. Probe with node itself.
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:3000/api/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    profiles:
      - testnet

  # Testnet Indexer Ponder
  indexer-ponder-testnet:
    build:
      context: .
      dockerfile: packages/indexer-ponder/Dockerfile
    image: dashtec-indexer-ponder:testnet
    container_name: dashtec-indexer-ponder-testnet
    ports:
      - "${PONDER_TESTNET_PORT:-42070}:42069"
    env_file:
      - packages/indexer-ponder/.env.testnet
    environment:
      DATABASE_SCHEMA: ponder_prod
      DATABASE_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      REDIS_URL: redis://:dashtec@redis-testnet:6379
    restart: unless-stopped
    healthcheck:
      # These images are Node runtimes with no curl/wget on PATH, so a
      # curl-based test fails regardless of the app's real state and pins the
      # container to "unhealthy" forever. Probe with node itself.
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:42069/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    profiles:
      - testnet

  # Testnet Indexer Custom
  indexer-custom-testnet:
    build:
      context: .
      dockerfile: packages/indexer-custom/Dockerfile
    image: dashtec-indexer-custom:testnet
    container_name: dashtec-indexer-custom-testnet
    ports:
      - "${COLLECTOR_VALIDATOR_STATS_TESTNET_PORT:-4010}:4000"
      - "${COLLECTOR_VALIDATOR_LIST_TESTNET_PORT:-4011}:4001"
      - "${COLLECTOR_EPOCH_INTEGRITY_TESTNET_PORT:-4012}:4002"
      - "${COLLECTOR_VALIDATOR_MIGRATION_TESTNET_PORT:-4013}:4003"
      - "${COLLECTOR_PROVIDER_LIST_TESTNET_PORT:-4014}:4004"
    env_file:
      - packages/indexer-custom/.env.testnet
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      DATABASE_READ_REPLICA_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      REDIS_URL: redis://:dashtec@redis-testnet:6379
      VALIDATOR_STATS_RPC_URL: ${VALIDATOR_STATS_RPC_URL_TESTNET}
    depends_on:
      aztec-node-testnet:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      # These images are Node runtimes with no curl/wget on PATH, so a
      # curl-based test fails regardless of the app's real state and pins the
      # container to "unhealthy" forever. Probe with node itself.
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:4000/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    profiles:
      - testnet

  # Testnet Materializer
  materializer-testnet:
    build:
      context: .
      dockerfile: packages/materializer/Dockerfile
    image: dashtec-materializer:testnet
    container_name: dashtec-materializer-testnet
    env_file:
      - packages/materializer/.env.testnet
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      PONDER_SCHEMA: ponder_prod
    restart: unless-stopped
    healthcheck:
      # No pgrep in the image either. Assert PID 1 is still the node process.
      test:
        - CMD
        - node
        - -e
        - "process.exit(require('fs').readFileSync('/proc/1/cmdline', 'utf8').includes('node') ? 0 : 1)"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 15s
    profiles:
      - testnet

  # Aztec node (mainnet). Replaces the third-party sentinel proxy that
  # NEXT_SENTINEL_URL / VALIDATOR_STATS_RPC_URL used to point at: a full node
  # serves every node_* JSON-RPC method the dashboard needs, and SENTINEL_ENABLED
  # is what makes node_getValidatorsStats available.
  #
  # `NETWORK: mainnet` makes the node resolve its own bootnodes, registry address
  # and snapshot URLs from the published network config — no contract addresses
  # are configured here. The RPC port is not published; sibling compose services
  # reach it as http://aztec-node-mainnet:8080. P2P is published and must be
  # opened in terraform/hetzner.tf.
  aztec-node-mainnet:
    image: ${AZTEC_NODE_IMAGE_MAINNET:-azteclabs/aztec:6.0.0@sha256:59b10cc8e89bb9226db1f771a5abbe5d5f8d71483c00c7472187e6ddc7adab8d}
    container_name: dashtec-aztec-node-mainnet
    command: ["start", "--node"]
    init: true
    ports:
      - "${AZTEC_NODE_P2P_PORT_MAINNET:-40400}:${AZTEC_NODE_P2P_PORT_MAINNET:-40400}/tcp"
      - "${AZTEC_NODE_P2P_PORT_MAINNET:-40400}:${AZTEC_NODE_P2P_PORT_MAINNET:-40400}/udp"
    environment:
      NETWORK: mainnet
      ETHEREUM_HOSTS: ${AZTEC_NODE_ETHEREUM_HOSTS_MAINNET}
      L1_CONSENSUS_HOST_URLS: ${AZTEC_NODE_L1_CONSENSUS_HOSTS_MAINNET}
      AZTEC_PORT: 8080
      AZTEC_ADMIN_PORT: 8880
      P2P_ENABLED: "true"
      # Container and host port are kept equal so the ENR the node advertises
      # matches what peers can actually dial through the published port.
      P2P_PORT: ${AZTEC_NODE_P2P_PORT_MAINNET:-40400}
      P2P_BROADCAST_PORT: ${AZTEC_NODE_P2P_PORT_MAINNET:-40400}
      P2P_QUERY_FOR_IP: "true"
      SENTINEL_ENABLED: "true"
      SENTINEL_HISTORY_LENGTH_IN_EPOCHS: ${AZTEC_NODE_SENTINEL_EPOCHS_MAINNET:-24}
      SYNC_MODE: ${AZTEC_NODE_SYNC_MODE_MAINNET:-snapshot}
      # Whether the archiver may start against an L1 RPC that prunes historical
      # logs. Off for mainnet (archival reth); on for testnet, where no free
      # Sepolia endpoint both retains logs and survives startup. See docs/aztec-node.md.
      ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK: ${AZTEC_NODE_SKIP_HISTORICAL_LOGS_CHECK_MAINNET:-false}
      DATA_DIRECTORY: /data/data
      CRS_PATH: /data/crs
      NODE_OPTIONS: --no-warnings --max-old-space-size=${AZTEC_NODE_HEAP_MB_MAINNET:-4096}
      LOG_LEVEL: info
      LOG_JSON: 1
    volumes:
      - aztec_node_data_mainnet:/data/data
      - aztec_node_crs_mainnet:/data/crs
    restart: unless-stopped
    stop_grace_period: 2m
    healthcheck:
      test:
        - CMD
        - node
        - -e
        - "fetch('http://127.0.0.1:8080/status').then(r => { if (!r.ok) throw new Error(String(r.status)); process.exit(0); }).catch(() => process.exit(1))"
      interval: 15s
      timeout: 10s
      # A snapshot sync can take a long time on first boot; keep the container
      # out of `unhealthy` until it has had a fair chance to catch up.
      retries: 5
      start_period: 30m
    mem_limit: ${AZTEC_NODE_MEM_LIMIT_MAINNET:-8g}
    logging:
      driver: json-file
      options:
        max-size: 20m
        max-file: "3"
    profiles:
      - mainnet

  # Mainnet counterpart of aztec-node-mainnet-previous: V5 keeps producing blocks
  # after mainnet's move to V6, so while it runs this node and a stats-only
  # indexer follow it. Enabled by `previousRollupNode` in mainnet's config.json.
  aztec-node-mainnet-previous:
    image: ${AZTEC_NODE_IMAGE_MAINNET_PREVIOUS:-aztecprotocol/aztec:5.2.0@sha256:2dd0b84a5a42285762390e38f82a6ba737bfeba6e39df688af7f050dae81a3b0}
    container_name: dashtec-aztec-node-mainnet-previous
    command: ["start", "--node"]
    init: true
    ports:
      - "${AZTEC_NODE_P2P_PORT_MAINNET_PREVIOUS:-40401}:${AZTEC_NODE_P2P_PORT_MAINNET_PREVIOUS:-40401}/tcp"
      - "${AZTEC_NODE_P2P_PORT_MAINNET_PREVIOUS:-40401}:${AZTEC_NODE_P2P_PORT_MAINNET_PREVIOUS:-40401}/udp"
    environment:
      NETWORK: ${AZTEC_NODE_NETWORK_MAINNET_PREVIOUS:-mainnet}
      # Pin the rollup this node follows. Unset, it follows the canonical (newer)
      # rollup, finds it incompatible with its software and idles in standby.
      # Rendered from previousRollupNode.rollupVersion, which Ansible requires.
      ROLLUP_VERSION: ${AZTEC_NODE_ROLLUP_VERSION_MAINNET_PREVIOUS:-}
      ETHEREUM_HOSTS: ${AZTEC_NODE_ETHEREUM_HOSTS_MAINNET}
      L1_CONSENSUS_HOST_URLS: ${AZTEC_NODE_L1_CONSENSUS_HOSTS_MAINNET}
      AZTEC_PORT: 8080
      AZTEC_ADMIN_PORT: 8880
      P2P_ENABLED: "true"
      P2P_PORT: ${AZTEC_NODE_P2P_PORT_MAINNET_PREVIOUS:-40401}
      P2P_BROADCAST_PORT: ${AZTEC_NODE_P2P_PORT_MAINNET_PREVIOUS:-40401}
      P2P_QUERY_FOR_IP: "true"
      SENTINEL_ENABLED: "true"
      SENTINEL_HISTORY_LENGTH_IN_EPOCHS: ${AZTEC_NODE_SENTINEL_EPOCHS_MAINNET_PREVIOUS:-24}
      SYNC_MODE: ${AZTEC_NODE_SYNC_MODE_MAINNET_PREVIOUS:-snapshot}
      ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK: ${AZTEC_NODE_SKIP_HISTORICAL_LOGS_CHECK_MAINNET_PREVIOUS:-false}
      DATA_DIRECTORY: /data/data
      CRS_PATH: /data/crs
      NODE_OPTIONS: --no-warnings --max-old-space-size=${AZTEC_NODE_HEAP_MB_MAINNET_PREVIOUS:-4096}
      LOG_LEVEL: info
      LOG_JSON: 1
    volumes:
      - aztec_node_data_mainnet_previous:/data/data
      - aztec_node_crs_mainnet_previous:/data/crs
    restart: unless-stopped
    stop_grace_period: 2m
    healthcheck:
      test:
        - CMD
        - node
        - -e
        # JSON-RPC, not /status: a node waiting in standby for a compatible
        # rollup answers /status but nothing else.
        - "fetch('http://127.0.0.1:8080', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'node_getNodeVersion', params: [] }) }).then(r => r.json()).then(j => process.exit(j.result ? 0 : 1)).catch(() => process.exit(1))"
      interval: 15s
      timeout: 10s
      retries: 5
      start_period: 30m
    mem_limit: ${AZTEC_NODE_MEM_LIMIT_MAINNET_PREVIOUS:-8g}
    logging:
      driver: json-file
      options:
        max-size: 20m
        max-file: "3"
    profiles:
      - mainnet-previous

  # Stats-only collectors for the previous rollup: everything else (validator
  # list, providers, migration, prices) is shared and already runs in
  # indexer-custom (mainnet). Rows it writes carry the previous rollup's address.
  indexer-custom-mainnet-previous:
    build:
      context: .
      dockerfile: packages/indexer-custom/Dockerfile
    image: dashtec-indexer-custom:latest
    container_name: dashtec-indexer-custom-mainnet-previous
    env_file:
      - path: packages/indexer-custom/.env.mainnet-previous
        required: false
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@postgres-mainnet:5432/dashtec
      DATABASE_READ_REPLICA_URL: postgresql://dashtec:dashtec@postgres-mainnet:5432/dashtec
      REDIS_URL: redis://:dashtec@redis-mainnet:6379
      VALIDATOR_STATS_RPC_URL: http://aztec-node-mainnet-previous:8080
      COLLECTORS: validatorStats,epochAggregates,epochIntegrity
    depends_on:
      aztec-node-mainnet-previous:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:4000/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    profiles:
      - mainnet-previous

  # Aztec node (testnet). Same shape as mainnet; a distinct P2P port so both can
  # publish on the one host.
  aztec-node-testnet:
    image: ${AZTEC_NODE_IMAGE_TESTNET:-azteclabs/aztec:6.0.0@sha256:59b10cc8e89bb9226db1f771a5abbe5d5f8d71483c00c7472187e6ddc7adab8d}
    container_name: dashtec-aztec-node-testnet
    command: ["start", "--node"]
    init: true
    ports:
      - "${AZTEC_NODE_P2P_PORT_TESTNET:-40500}:${AZTEC_NODE_P2P_PORT_TESTNET:-40500}/tcp"
      - "${AZTEC_NODE_P2P_PORT_TESTNET:-40500}:${AZTEC_NODE_P2P_PORT_TESTNET:-40500}/udp"
    environment:
      NETWORK: testnet
      ETHEREUM_HOSTS: ${AZTEC_NODE_ETHEREUM_HOSTS_TESTNET}
      L1_CONSENSUS_HOST_URLS: ${AZTEC_NODE_L1_CONSENSUS_HOSTS_TESTNET}
      AZTEC_PORT: 8080
      AZTEC_ADMIN_PORT: 8880
      P2P_ENABLED: "true"
      P2P_PORT: ${AZTEC_NODE_P2P_PORT_TESTNET:-40500}
      P2P_BROADCAST_PORT: ${AZTEC_NODE_P2P_PORT_TESTNET:-40500}
      P2P_QUERY_FOR_IP: "true"
      SENTINEL_ENABLED: "true"
      SENTINEL_HISTORY_LENGTH_IN_EPOCHS: ${AZTEC_NODE_SENTINEL_EPOCHS_TESTNET:-24}
      SYNC_MODE: ${AZTEC_NODE_SYNC_MODE_TESTNET:-snapshot}
      # Whether the archiver may start against an L1 RPC that prunes historical
      # logs. Off for mainnet (archival reth); on for testnet, where no free
      # Sepolia endpoint both retains logs and survives startup. See docs/aztec-node.md.
      ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK: ${AZTEC_NODE_SKIP_HISTORICAL_LOGS_CHECK_TESTNET:-true}
      DATA_DIRECTORY: /data/data
      CRS_PATH: /data/crs
      NODE_OPTIONS: --no-warnings --max-old-space-size=${AZTEC_NODE_HEAP_MB_TESTNET:-4096}
      LOG_LEVEL: info
      LOG_JSON: 1
    volumes:
      - aztec_node_data_testnet:/data/data
      - aztec_node_crs_testnet:/data/crs
    restart: unless-stopped
    stop_grace_period: 2m
    healthcheck:
      test:
        - CMD
        - node
        - -e
        - "fetch('http://127.0.0.1:8080/status').then(r => { if (!r.ok) throw new Error(String(r.status)); process.exit(0); }).catch(() => process.exit(1))"
      interval: 15s
      timeout: 10s
      retries: 5
      start_period: 30m
    mem_limit: ${AZTEC_NODE_MEM_LIMIT_TESTNET:-6g}
    logging:
      driver: json-file
      options:
        max-size: 20m
        max-file: "3"
    profiles:
      - testnet

  # A replaced rollup can keep running: testnet's V5 kept producing blocks for
  # weeks after V6 became canonical. Only a node running that rollup's software
  # can report its sequencers' attestations, so while it runs, this node and a
  # stats-only indexer follow it. Enabled per network by `previousRollupNode`
  # in config.json, which is what puts the testnet-previous profile in play.
  aztec-node-testnet-previous:
    image: ${AZTEC_NODE_IMAGE_TESTNET_PREVIOUS:-aztecprotocol/aztec:5.2.1@sha256:7e06be07547e320e0b5ce859a26fe72fc851e686cc8f18216592259e0054a793}
    container_name: dashtec-aztec-node-testnet-previous
    command: ["start", "--node"]
    init: true
    ports:
      - "${AZTEC_NODE_P2P_PORT_TESTNET_PREVIOUS:-40501}:${AZTEC_NODE_P2P_PORT_TESTNET_PREVIOUS:-40501}/tcp"
      - "${AZTEC_NODE_P2P_PORT_TESTNET_PREVIOUS:-40501}:${AZTEC_NODE_P2P_PORT_TESTNET_PREVIOUS:-40501}/udp"
    environment:
      NETWORK: ${AZTEC_NODE_NETWORK_TESTNET_PREVIOUS:-testnet}
      # Pin the rollup this node follows. Unset, it follows the canonical (newer)
      # rollup, finds it incompatible with its software and idles in standby.
      # Rendered from previousRollupNode.rollupVersion, which Ansible requires.
      ROLLUP_VERSION: ${AZTEC_NODE_ROLLUP_VERSION_TESTNET_PREVIOUS:-}
      ETHEREUM_HOSTS: ${AZTEC_NODE_ETHEREUM_HOSTS_TESTNET}
      L1_CONSENSUS_HOST_URLS: ${AZTEC_NODE_L1_CONSENSUS_HOSTS_TESTNET}
      AZTEC_PORT: 8080
      AZTEC_ADMIN_PORT: 8880
      P2P_ENABLED: "true"
      P2P_PORT: ${AZTEC_NODE_P2P_PORT_TESTNET_PREVIOUS:-40501}
      P2P_BROADCAST_PORT: ${AZTEC_NODE_P2P_PORT_TESTNET_PREVIOUS:-40501}
      P2P_QUERY_FOR_IP: "true"
      SENTINEL_ENABLED: "true"
      SENTINEL_HISTORY_LENGTH_IN_EPOCHS: ${AZTEC_NODE_SENTINEL_EPOCHS_TESTNET_PREVIOUS:-24}
      SYNC_MODE: ${AZTEC_NODE_SYNC_MODE_TESTNET_PREVIOUS:-snapshot}
      ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK: ${AZTEC_NODE_SKIP_HISTORICAL_LOGS_CHECK_TESTNET_PREVIOUS:-true}
      DATA_DIRECTORY: /data/data
      CRS_PATH: /data/crs
      NODE_OPTIONS: --no-warnings --max-old-space-size=${AZTEC_NODE_HEAP_MB_TESTNET_PREVIOUS:-4096}
      LOG_LEVEL: info
      LOG_JSON: 1
    volumes:
      - aztec_node_data_testnet_previous:/data/data
      - aztec_node_crs_testnet_previous:/data/crs
    restart: unless-stopped
    stop_grace_period: 2m
    healthcheck:
      test:
        - CMD
        - node
        - -e
        # JSON-RPC, not /status: a node waiting in standby for a compatible
        # rollup answers /status but nothing else.
        - "fetch('http://127.0.0.1:8080', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'node_getNodeVersion', params: [] }) }).then(r => r.json()).then(j => process.exit(j.result ? 0 : 1)).catch(() => process.exit(1))"
      interval: 15s
      timeout: 10s
      retries: 5
      start_period: 30m
    mem_limit: ${AZTEC_NODE_MEM_LIMIT_TESTNET_PREVIOUS:-6g}
    logging:
      driver: json-file
      options:
        max-size: 20m
        max-file: "3"
    profiles:
      - testnet-previous

  # Stats-only collectors for the previous rollup: everything else (validator
  # list, providers, migration, prices) is shared and already runs in
  # indexer-custom-testnet. Rows it writes carry the previous rollup's address.
  indexer-custom-testnet-previous:
    build:
      context: .
      dockerfile: packages/indexer-custom/Dockerfile
    image: dashtec-indexer-custom:testnet
    container_name: dashtec-indexer-custom-testnet-previous
    env_file:
      - path: packages/indexer-custom/.env.testnet-previous
        required: false
    environment:
      DATABASE_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      DATABASE_READ_REPLICA_URL: postgresql://dashtec:dashtec@postgres-testnet:5432/dashtec
      REDIS_URL: redis://:dashtec@redis-testnet:6379
      VALIDATOR_STATS_RPC_URL: http://aztec-node-testnet-previous:8080
      COLLECTORS: validatorStats,epochAggregates,epochIntegrity
    depends_on:
      aztec-node-testnet-previous:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      test:
        - CMD
        - node
        - -e
        - "fetch('http://localhost:4000/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    profiles:
      - testnet-previous

  # Mainnet Database
  postgres-mainnet:
    image: postgres:16-alpine
    container_name: dashtec-postgres-mainnet
    ports:
      - "${POSTGRES_MAINNET_PORT:-5432}:5432"
    environment:
      POSTGRES_USER: dashtec
      POSTGRES_PASSWORD: dashtec
      POSTGRES_DB: dashtec
    volumes:
      - postgres_data_mainnet:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U dashtec"]
      interval: 10s
      timeout: 5s
      retries: 5
    profiles:
      - mainnet

  # Testnet Database
  postgres-testnet:
    image: postgres:16-alpine
    container_name: dashtec-postgres-testnet
    ports:
      - "${POSTGRES_TESTNET_PORT:-5433}:5432"
    environment:
      POSTGRES_USER: dashtec
      POSTGRES_PASSWORD: dashtec
      POSTGRES_DB: dashtec
    volumes:
      - postgres_data_testnet:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U dashtec"]
      interval: 10s
      timeout: 5s
      retries: 5
    profiles:
      - testnet

  # Mainnet Redis
  redis-mainnet:
    image: redis:7-alpine
    container_name: dashtec-redis-mainnet
    command: redis-server --requirepass ${REDIS_PASSWORD:-dashtec}
    ports:
      - "${REDIS_MAINNET_PORT:-6379}:6379"
    environment:
      REDIS_PASSWORD: ${REDIS_PASSWORD:-dashtec}
    volumes:
      - redis_data_mainnet:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-dashtec}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    profiles:
      - mainnet

  # Testnet Redis
  redis-testnet:
    image: redis:7-alpine
    container_name: dashtec-redis-testnet
    command: redis-server --requirepass ${REDIS_PASSWORD:-dashtec}
    ports:
      - "${REDIS_TESTNET_PORT:-6380}:6379"
    environment:
      REDIS_PASSWORD: ${REDIS_PASSWORD:-dashtec}
    volumes:
      - redis_data_testnet:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-dashtec}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    profiles:
      - testnet

volumes:
  postgres_data_mainnet:
  postgres_data_testnet:
  redis_data_mainnet:
  redis_data_testnet:
  # Aztec node world state + archiver data, and the (large, immutable) CRS. Kept
  # as named volumes so a `docker compose down` does not force a resync.
  aztec_node_data_mainnet:
  aztec_node_crs_mainnet:
  aztec_node_data_testnet:
  aztec_node_crs_testnet:
  aztec_node_data_testnet_previous:
  aztec_node_crs_testnet_previous:
  aztec_node_data_mainnet_previous:
  aztec_node_crs_mainnet_previous: