process-compose.yaml

version: "3"

availability:
  # terminate process compose if process exits
  run-forever: &run-forever
    exit_on_skipped: true
    exit_on_end: true
  # terminate process compose if process exits with non-zero exit code
  run-forever: &exit-ok
    exit_on_skipped: true
    restart: exit_on_failure

environment:
  - ESPRESSO_SEQUENCER_CDN_ENDPOINT=127.0.0.1:${ESPRESSO_CDN_SERVER_PORT}
  - ESPRESSO_SEQUENCER_ORCHESTRATOR_URL=http://localhost:${ESPRESSO_ORCHESTRATOR_PORT}
  - ESPRESSO_SEQUENCER_URL=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
  - ESPRESSO_SEQUENCER_URLS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT},http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}
  - ESPRESSO_SEQUENCER_L1_PROVIDER=http://localhost:${ESPRESSO_SEQUENCER_L1_PORT}
  - ESPRESSO_SEQUENCER_GENESIS_FILE=${ESPRESSO_SEQUENCER_GENESIS_FILE:-data/genesis/demo.toml}
  - ESPRESSO_STATE_RELAY_SERVER_URL=http://localhost:${ESPRESSO_STATE_RELAY_SERVER_PORT}
  - QUERY_SERVICE_URI=http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}/v0/
  - NODE_VALIDATOR_URI=ws://localhost:${ESPRESSO_NODE_VALIDATOR_PORT}/v0/
processes:
  # Cheating a bit here but since we don't usually have to debug go-ethereum
  # it's using the docker compose service which is a bit easier.
  demo-l1-network:
    command: docker compose up demo-l1-network --force-recreate --renew-anon-volumes
    readiness_probe:
      exec:
        command: >-
          curl -H "Content-Type: application/json"
          --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'
          http://localhost:${ESPRESSO_SEQUENCER_L1_PORT}
      failure_threshold: 6
      initial_delay_seconds: 5
    availability: *run-forever

  deploy-sequencer-contracts:
    # The contract addresses are implicitly inherited from .env. We need to unset these or else the
    # script will think they're already deployed.
    command:
      unset
      ESPRESSO_SEQUENCER_FEE_CONTRACT_PROXY_ADDRESS
      ESPRESSO_SEQUENCER_ESP_TOKEN_PROXY_ADDRESS
      ESPRESSO_SEQUENCER_STAKE_TABLE_PROXY_ADDRESS
      && deploy --deploy-ops-timelock --deploy-safe-exit-timelock --deploy-fee --deploy-esp-token --deploy-stake-table --upgrade-stake-table-v2
    namespace: setup
    depends_on:
      demo-l1-network:
        condition: process_healthy
    availability: *exit-ok

  deploy-prover-contracts:
    # The contract addresses are implicitly inherited from .env. We need to unset these or else the
    # script will think they're already deployed.
    command:
      unset ESPRESSO_SEQUENCER_LIGHT_CLIENT_PROXY_ADDRESS
      && deploy --use-mock --deploy-light-client-v1 --upgrade-light-client-v2 --upgrade-light-client-v3
    namespace: setup
    depends_on:
      demo-l1-network:
        condition: process_healthy
      sequencer0:
        condition: process_healthy
      deploy-sequencer-contracts:
        condition: process_completed
    availability: *exit-ok

  fund-builder:
    command: espresso-bridge deposit
    namespace: setup
    environment:
      - L1_PROVIDER=http://localhost:${ESPRESSO_SEQUENCER_L1_PORT}
      - L1_POLLING_INTERVAL=${ESPRESSO_SEQUENCER_L1_POLLING_INTERVAL}
      - ESPRESSO_PROVIDER=http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}
      - CONTRACT_ADDRESS=${ESPRESSO_SEQUENCER_FEE_CONTRACT_PROXY_ADDRESS}
      - MNEMONIC=${ESPRESSO_BUILDER_ETH_MNEMONIC}
      - ACCOUNT_INDEX=${ESPRESSO_BUILDER_ETH_ACCOUNT_INDEX}
      - AMOUNT=1000000000000000000
      - CONFIRMATIONS=1
    depends_on:
      deploy-sequencer-contracts:
        condition: process_completed
      sequencer1:
        condition: process_healthy
    availability: *exit-ok

  stake-for-demo:
    command: staking-cli stake-for-demo
    namespace: setup
    environment:
      - L1_PROVIDER=http://localhost:${ESPRESSO_SEQUENCER_L1_PORT}
      - MNEMONIC=${ESPRESSO_SEQUENCER_ETH_MNEMONIC}
      - ACCOUNT_INDEX=${ESP_TOKEN_INITIAL_GRANT_RECIPIENT_ACCOUNT_INDEX}
      - ESP_TOKEN_ADDRESS=${ESPRESSO_SEQUENCER_ESP_TOKEN_PROXY_ADDRESS}
      - STAKE_TABLE_ADDRESS=${ESPRESSO_SEQUENCER_STAKE_TABLE_PROXY_ADDRESS}
    depends_on:
      deploy-sequencer-contracts:
        condition: process_completed
    availability: *exit-ok

  orchestrator:
    command: orchestrator
    environment:
      - ESPRESSO_ORCHESTRATOR_BUILDER_URLS=http://localhost:${ESPRESSO_BUILDER_SERVER_PORT}
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_ORCHESTRATOR_PORT}
        path: /healthcheck
      initial_delay_seconds: 0
      period_seconds: 1
      timeout_seconds: 1
      success_threshold: 1
      failure_threshold: 100
    availability: *exit-ok

  state-relay-server:
    command: state-relay-server
    readiness_probe:
      failure_threshold: 10
      period_seconds: 1
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_STATE_RELAY_SERVER_PORT}
        path: /healthcheck
    availability: *run-forever

  prover-service:
    # to avoid interfering so much with other work, "nice" the state prover process
    command: nice state-prover -d
    environment:
      - MNEMONIC=${ESPRESSO_SEQUENCER_ETH_MNEMONIC}
      - RAYON_NUM_THREADS=${PROVER_RAYON_NUM_THREADS}
    depends_on:
      sequencer0:
        condition: process_healthy
      state-relay-server:
        condition: process_healthy
      demo-l1-network:
        condition: process_healthy
      deploy-prover-contracts:
        condition: process_completed
    availability: *run-forever

  sequencer0:
    command: sequencer -- storage-sql -- http -- query -- submit -- hotshot-events -- config -- catchup -- light-client
    environment:
      - ESPRESSO_SEQUENCER_API_PORT=${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_LIBP2P_BIND_ADDRESS=0.0.0.0:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_0}
      - ESPRESSO_SEQUENCER_LIBP2P_ADVERTISE_ADDRESS=localhost:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_0}
      - ESPRESSO_SEQUENCER_API_PEERS=http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}
      - ESPRESSO_SEQUENCER_STATE_PEERS=http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}
      - ESPRESSO_SEQUENCER_POSTGRES_HOST=localhost
      - ESPRESSO_SEQUENCER_POSTGRES_PORT=${ESPRESSO_SEQUENCER0_DB_PORT}
      - ESPRESSO_SEQUENCER_POSTGRES_USER=root
      - ESPRESSO_SEQUENCER_POSTGRES_PASSWORD=password
      - ESPRESSO_SEQUENCER_POSTGRES_DATABASE=sequencer
      - ESPRESSO_SEQUENCER_PRIVATE_STAKING_KEY=${ESPRESSO_DEMO_SEQUENCER_STAKING_PRIVATE_KEY_0}
      - ESPRESSO_SEQUENCER_PRIVATE_STATE_KEY=${ESPRESSO_DEMO_SEQUENCER_STATE_PRIVATE_KEY_0}
      - ESPRESSO_SEQUENCER_IS_DA=true
      - ESPRESSO_SEQUENCER_IDENTITY_NODE_NAME=sequencer0
      - ESPRESSO_SEQUENCER_IDENTITY_WALLET_ADDRESS=0x0000000000000000000000000000000000000000
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_NAME=Espresso Systems
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_WEBSITE=https://www.espressosys.com/
      - ESPRESSO_SEQUENCER_IDENTITY_OPERATING_SYSTEM=Linux 5.15.153.1
      - ESPRESSO_SEQUENCER_IDENTITY_NETWORK_TYPE=local
      - ESPRESSO_SEQUENCER_IDENTITY_COUNTRY_CODE=US
      - ESPRESSO_SEQUENCER_IDENTITY_LATITUDE=40.7128
      - ESPRESSO_SEQUENCER_IDENTITY_LONGITUDE=-74.0060
      - ESPRESSO_SEQUENCER_PUBLIC_API_URL=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}/
    depends_on:
      orchestrator:
        condition: process_healthy
      demo-l1-network:
        condition: process_healthy
      state-relay-server:
        condition: process_healthy
      sequencer-db-0:
        condition: process_healthy
      broker_0:
        condition: process_healthy
      broker_1:
        condition: process_healthy
      marshal_0:
        condition: process_healthy
      stake-for-demo:
        condition: process_completed
    availability: *run-forever

    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SEQUENCER0_API_PORT}
        path: /healthcheck
      period_seconds: 1
      failure_threshold: 100

  sequencer1:
    command: sequencer -- storage-sql -- http -- query -- explorer -- catchup
    environment:
      - ESPRESSO_SEQUENCER_API_PORT=${ESPRESSO_SEQUENCER1_API_PORT}
      - ESPRESSO_SEQUENCER_LIBP2P_BIND_ADDRESS=0.0.0.0:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_1}
      - ESPRESSO_SEQUENCER_LIBP2P_ADVERTISE_ADDRESS=localhost:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_1}
      - ESPRESSO_SEQUENCER_API_PEERS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_STATE_PEERS=http://localhost:${ESPRESSO_SEQUENCER2_API_PORT}
      - ESPRESSO_SEQUENCER_POSTGRES_HOST=localhost
      - ESPRESSO_SEQUENCER_POSTGRES_PORT=${ESPRESSO_SEQUENCER1_DB_PORT}
      - ESPRESSO_SEQUENCER_POSTGRES_USER=root
      - ESPRESSO_SEQUENCER_POSTGRES_PASSWORD=password
      - ESPRESSO_SEQUENCER_POSTGRES_DATABASE=sequencer
      - ESPRESSO_SEQUENCER_PRIVATE_STAKING_KEY=${ESPRESSO_DEMO_SEQUENCER_STAKING_PRIVATE_KEY_1}
      - ESPRESSO_SEQUENCER_PRIVATE_STATE_KEY=${ESPRESSO_DEMO_SEQUENCER_STATE_PRIVATE_KEY_1}
      - ESPRESSO_SEQUENCER_IS_DA=true
      - ESPRESSO_SEQUENCER_IDENTITY_NODE_NAME=sequencer1
      - ESPRESSO_SEQUENCER_IDENTITY_WALLET_ADDRESS=0x0000000000000000000000000000000000000001
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_NAME=Espresso Systems
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_WEBSITE=https://www.espressosys.com/
      - ESPRESSO_SEQUENCER_IDENTITY_OPERATING_SYSTEM=Darwin 23.5.0
      - ESPRESSO_SEQUENCER_IDENTITY_NETWORK_TYPE=local
      - ESPRESSO_SEQUENCER_IDENTITY_COUNTRY_CODE=GR
      - ESPRESSO_SEQUENCER_IDENTITY_LATITUDE=39.0742
      - ESPRESSO_SEQUENCER_IDENTITY_LONGITUDE=21.8243
      - ESPRESSO_SEQUENCER_PUBLIC_API_URL=http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}/
      - ESPRESSO_SEQUENCER_L1_WS_PROVIDER=ws://localhost:${ESPRESSO_SEQUENCER_L1_WS_PORT}
    depends_on:
      orchestrator:
        condition: process_healthy
      demo-l1-network:
        condition: process_healthy
      state-relay-server:
        condition: process_healthy
      sequencer-db-1:
        condition: process_healthy
      broker_0:
        condition: process_healthy
      broker_1:
        condition: process_healthy
      marshal_0:
        condition: process_healthy
      stake-for-demo:
        condition: process_completed
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SEQUENCER1_API_PORT}
        path: /healthcheck
      period_seconds: 1
      failure_threshold: 100
    availability: *run-forever

  sequencer2:
    command: sequencer -- http
    environment:
      - ESPRESSO_SEQUENCER_API_PORT=${ESPRESSO_SEQUENCER2_API_PORT}
      - ESPRESSO_SEQUENCER_LIBP2P_BIND_ADDRESS=0.0.0.0:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_2}
      - ESPRESSO_SEQUENCER_LIBP2P_ADVERTISE_ADDRESS=localhost:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_2}
      - ESPRESSO_SEQUENCER_STATE_PEERS=http://localhost:${ESPRESSO_SEQUENCER3_API_PORT}
      - ESPRESSO_SEQUENCER_API_PEERS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_STORAGE_PATH=${ESPRESSO_BASE_STORAGE_PATH}/seq2
      - ESPRESSO_SEQUENCER_PRIVATE_STAKING_KEY=${ESPRESSO_DEMO_SEQUENCER_STAKING_PRIVATE_KEY_2}
      - ESPRESSO_SEQUENCER_PRIVATE_STATE_KEY=${ESPRESSO_DEMO_SEQUENCER_STATE_PRIVATE_KEY_2}
      - ESPRESSO_SEQUENCER_IS_DA=true
      - ESPRESSO_SEQUENCER_IDENTITY_NODE_NAME=sequencer2
      - ESPRESSO_SEQUENCER_IDENTITY_WALLET_ADDRESS=0x0000000000000000000000000000000000000002
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_NAME=Espresso Systems
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_WEBSITE=https://www.espressosys.com/
      - ESPRESSO_SEQUENCER_IDENTITY_OPERATING_SYSTEM=Darwin 23.5.0
      - ESPRESSO_SEQUENCER_IDENTITY_NETWORK_TYPE=local
      - ESPRESSO_SEQUENCER_IDENTITY_COUNTRY_CODE=CN
      - ESPRESSO_SEQUENCER_IDENTITY_LATITUDE=35.8617
      - ESPRESSO_SEQUENCER_IDENTITY_LONGITUDE=104.1954
      - ESPRESSO_SEQUENCER_PUBLIC_API_URL=http://localhost:${ESPRESSO_SEQUENCER2_API_PORT}/
    depends_on:
      orchestrator:
        condition: process_healthy
      demo-l1-network:
        condition: process_healthy
      state-relay-server:
        condition: process_healthy
      broker_0:
        condition: process_healthy
      broker_1:
        condition: process_healthy
      marshal_0:
        condition: process_healthy
      stake-for-demo:
        condition: process_completed
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SEQUENCER2_API_PORT}
        path: /healthcheck
      failure_threshold: 100
      period_seconds: 1
    availability: *run-forever

  sequencer3:
    command: sequencer -- http -- query -- storage-fs
    environment:
      - ESPRESSO_SEQUENCER_API_PORT=${ESPRESSO_SEQUENCER3_API_PORT}
      - ESPRESSO_SEQUENCER_LIBP2P_BIND_ADDRESS=0.0.0.0:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_3}
      - ESPRESSO_SEQUENCER_LIBP2P_ADVERTISE_ADDRESS=localhost:${ESPRESSO_DEMO_SEQUENCER_LIBP2P_PORT_3}
      - ESPRESSO_SEQUENCER_STATE_PEERS=http://localhost:${ESPRESSO_SEQUENCER4_API_PORT}
      - ESPRESSO_SEQUENCER_API_PEERS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_STORAGE_PATH=${ESPRESSO_BASE_STORAGE_PATH}/seq3
      - ESPRESSO_SEQUENCER_PRIVATE_STAKING_KEY=${ESPRESSO_DEMO_SEQUENCER_STAKING_PRIVATE_KEY_3}
      - ESPRESSO_SEQUENCER_PRIVATE_STATE_KEY=${ESPRESSO_DEMO_SEQUENCER_STATE_PRIVATE_KEY_3}
      - ESPRESSO_SEQUENCER_IDENTITY_NODE_NAME=sequencer3
      - ESPRESSO_SEQUENCER_IDENTITY_WALLET_ADDRESS=0x0000000000000000000000000000000000000003
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_NAME=Espresso Systems
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_WEBSITE=https://www.espressosys.com/
      - ESPRESSO_SEQUENCER_IDENTITY_OPERATING_SYSTEM=Microsoft Windows NT 10.0.22621.0
      - ESPRESSO_SEQUENCER_IDENTITY_E=espresso-sequencer@0.1.0
      - ESPRESSO_SEQUENCER_IDENTITY_NETWORK_TYPE=local
      - ESPRESSO_SEQUENCER_IDENTITY_COUNTRY_CODE=CN
      - ESPRESSO_SEQUENCER_IDENTITY_LATITUDE=35.8617
      - ESPRESSO_SEQUENCER_IDENTITY_LONGITUDE=104.1954
      - ESPRESSO_SEQUENCER_PUBLIC_API_URL=http://localhost:${ESPRESSO_SEQUENCER3_API_PORT}/
      - ESPRESSO_SEQUENCER_L1_WS_PROVIDER=ws://localhost:${ESPRESSO_SEQUENCER_L1_WS_PORT}
    depends_on:
      orchestrator:
        condition: process_healthy
      demo-l1-network:
        condition: process_healthy
      state-relay-server:
        condition: process_healthy
      broker_0:
        condition: process_healthy
      broker_1:
        condition: process_healthy
      marshal_0:
        condition: process_healthy
      stake-for-demo:
        condition: process_completed
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SEQUENCER3_API_PORT}
        path: /healthcheck
      failure_threshold: 100
      period_seconds: 1
    availability: *run-forever

  sequencer4:
    command: sequencer-sqlite -- storage-sql -- http -- query
    environment:
      - ESPRESSO_SEQUENCER_LIGHTWEIGHT=true
      - ESPRESSO_SEQUENCER_API_PORT=${ESPRESSO_SEQUENCER4_API_PORT}
      - ESPRESSO_SEQUENCER_STATE_PEERS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_API_PEERS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_STORAGE_PATH=${ESPRESSO_BASE_STORAGE_PATH}/seq4
      - ESPRESSO_SEQUENCER_PRIVATE_STAKING_KEY=${ESPRESSO_DEMO_SEQUENCER_STAKING_PRIVATE_KEY_4}
      - ESPRESSO_SEQUENCER_PRIVATE_STATE_KEY=${ESPRESSO_DEMO_SEQUENCER_STATE_PRIVATE_KEY_4}
      - ESPRESSO_SEQUENCER_IDENTITY_NODE_NAME=sequencer4
      - ESPRESSO_SEQUENCER_IDENTITY_WALLET_ADDRESS=0x0000000000000000000000000000000000000004
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_NAME=Espresso Systems
      - ESPRESSO_SEQUENCER_IDENTITY_COMPANY_WEBSITE=https://www.espressosys.com/
      - ESPRESSO_SEQUENCER_IDENTITY_OPERATING_SYSTEM=TempleOS 5.03
      - ESPRESSO_SEQUENCER_IDENTITY_NETWORK_TYPE=local
      - ESPRESSO_SEQUENCER_IDENTITY_COUNTRY_CODE=AU
      - ESPRESSO_SEQUENCER_IDENTITY_LATITUDE=-25.2744
      - ESPRESSO_SEQUENCER_IDENTITY_LONGITUDE=133.7751
      - ESPRESSO_SEQUENCER_PUBLIC_API_URL=http://localhost:${ESPRESSO_SEQUENCER4_API_PORT}/
      - ESPRESSO_SEQUENCER_IS_DA=true
    depends_on:
      orchestrator:
        condition: process_healthy
      demo-l1-network:
        condition: process_healthy
      state-relay-server:
        condition: process_healthy
      broker_0:
        condition: process_healthy
      broker_1:
        condition: process_healthy
      marshal_0:
        condition: process_healthy
      stake-for-demo:
        condition: process_completed
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SEQUENCER4_API_PORT}
        path: /healthcheck
      failure_threshold: 100
      period_seconds: 1
    availability: *run-forever

  node_validator:
    command: node-metrics --
    environment:
      - ESPRESSO_NODE_VALIDATOR_STAKE_TABLE_SOURCE_BASE_URL=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}/v0/
      - ESPRESSO_NODE_VALIDATOR_LEAF_STREAM_SOURCE_BASE_URL=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}/v0/
      - ESPRESSO_NODE_VALIDATOR_INITIAL_NODE_PUBLIC_BASE_URLS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}/,http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}/,http://localhost:${ESPRESSO_SEQUENCER2_API_PORT}/,http://localhost:${ESPRESSO_SEQUENCER3_API_PORT}/,http://localhost:${ESPRESSO_SEQUENCER4_API_PORT}/
    depends_on:
      broker_0:
        condition: process_healthy
      broker_1:
        condition: process_healthy
      sequencer0:
        condition: process_healthy
      sequencer1:
        condition: process_healthy
      sequencer2:
        condition: process_healthy
      sequencer3:
        condition: process_healthy
      sequencer4:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SEQUENCER1_API_PORT}
        path: /healthcheck
      period_seconds: 1
      failure_threshold: 100
    availability: *run-forever

  # We use KeyDB (a Redis variant) to maintain consistency between
  # different parts of the CDN
  # Cheating a bit here too, but KeyDB is not available as a Nix package.
  # Could do local (SQLite) discovery, but removes some of the spirit
  # from the local demo.
  keydb:
    command: docker run --rm -p 0.0.0.0:6379:6379 eqalpha/keydb --requirepass changeme!
    readiness_probe:
      exec:
        command: nc -zv localhost 6379
      period_seconds: 5
      timeout_seconds: 4
      failure_threshold: 20
    availability: *run-forever

  # The CDN system's main entry point; where users contact first.
  marshal_0:
    command: cdn-marshal -d "redis://:changeme!@localhost:6379" -b ${ESPRESSO_CDN_SERVER_PORT} -m 127.0.0.1:9093
    depends_on:
      keydb:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: 127.0.0.1
        port: 9093
        path: /metrics
      period_seconds: 1
      failure_threshold: 100
    availability: *run-forever

  # A broker is the main message-routing unit of the CDN
  broker_0:
    command: cdn-broker -d "redis://:changeme!@localhost:6379" -m 127.0.0.1:9091
    depends_on:
      keydb:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: 127.0.0.1
        port: 9091
        path: /metrics
      period_seconds: 1
      failure_threshold: 100
    availability: *run-forever

  # A broker is the main message-routing unit of the CDN
  # as we're running a local demo, we need to operate on different ports
  broker_1:
    command:
      cdn-broker --public-bind-endpoint 0.0.0.0:1740 --public-advertise-endpoint local_ip:1740
      --private-bind-endpoint 0.0.0.0:1741 --private-advertise-endpoint local_ip:1741 -d
      "redis://:changeme!@localhost:6379" -m 127.0.0.1:9092
    depends_on:
      keydb:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: 127.0.0.1
        port: 9092
        path: /metrics
      period_seconds: 1
      failure_threshold: 100
    availability: *run-forever

  cdn-whitelist:
    command: cdn-whitelist -d redis://:changeme!@localhost:6379 -o http://localhost:${ESPRESSO_ORCHESTRATOR_PORT}
    namespace: setup
    depends_on:
      orchestrator:
        condition: process_healthy
      keydb:
        condition: process_healthy
    availability: *exit-ok

  submit-transactions-public:
    command: submit-transactions
    environment:
      - ESPRESSO_SUBMIT_TRANSACTIONS_PORT=${ESPRESSO_SUBMIT_TRANSACTIONS_PUBLIC_PORT}
    depends_on:
      sequencer0:
        condition: process_healthy
      # We don't directly depend on the builder, but transactions will not be finalized until it has
      # started, so there is no point in starting before then.
      permissionless-builder:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SUBMIT_TRANSACTIONS_PUBLIC_PORT}
        path: /healthcheck
      failure_threshold: 100
      period_seconds: 1
    availability: *run-forever

  submit-transactions-private:
    command: submit-transactions
    environment:
      - ESPRESSO_SUBMIT_TRANSACTIONS_PORT=${ESPRESSO_SUBMIT_TRANSACTIONS_PRIVATE_PORT}
      - ESPRESSO_SUBMIT_TRANSACTIONS_SUBMIT_URL=http://localhost:${ESPRESSO_BUILDER_SERVER_PORT}/txn_submit
    depends_on:
      sequencer0:
        condition: process_healthy
      permissionless-builder:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_SUBMIT_TRANSACTIONS_PRIVATE_PORT}
        path: /healthcheck
      failure_threshold: 100
      period_seconds: 1
    availability: *run-forever

  permissionless-builder:
    command: permissionless-builder
    environment:
      - ESPRESSO_SEQUENCER_STATE_PEERS=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_SEQUENCER_URL=http://localhost:${ESPRESSO_SEQUENCER0_API_PORT}
      - ESPRESSO_BUILDER_GENESIS_FILE=${ESPRESSO_SEQUENCER_GENESIS_FILE:-data/genesis/demo.toml}
      - ESPRESSO_BUILDER_L1_PROVIDER=http://localhost:${ESPRESSO_SEQUENCER_L1_PORT}
    depends_on:
      sequencer0:
        condition: process_healthy
      fund-builder:
        condition: process_completed
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_BUILDER_SERVER_PORT}
        path: /healthcheck
      failure_threshold: 100
      period_seconds: 1
    availability: *run-forever

  nasty-client:
    command: nasty-client
    environment:
      # Point the nasty client at sequencer1, the only one running the state API.
      - ESPRESSO_SEQUENCER_URL=http://localhost:${ESPRESSO_SEQUENCER1_API_PORT}
    depends_on:
      sequencer0:
        condition: process_healthy
    readiness_probe:
      http_get:
        scheme: http
        host: localhost
        port: ${ESPRESSO_NASTY_CLIENT_PORT}
        path: /healthcheck
      failure_threshold: 100
    availability: *run-forever

  sequencer-db-0:
    command:
      docker run -e POSTGRES_PASSWORD -e POSTGRES_USER -e POSTGRES_DB -p ${ESPRESSO_SEQUENCER0_DB_PORT}:5432 postgres
    environment:
      - POSTGRES_PASSWORD=password
      - POSTGRES_USER=root
      - POSTGRES_DB=sequencer
    readiness_probe:
      exec:
        command: pg_isready -h localhost -p ${ESPRESSO_SEQUENCER0_DB_PORT}
      initial_delay_seconds: 5
      period_seconds: 5
      timeout_seconds: 4
      # Postgres can be falsely "ready" once before running init scripts.
      # See https://github.com/docker-library/postgres/issues/146 for discussion.
      success_threshold: 2
      failure_threshold: 20
    availability: *run-forever

  sequencer-db-1:
    command:
      docker run -e POSTGRES_PASSWORD -e POSTGRES_USER -e POSTGRES_DB -p ${ESPRESSO_SEQUENCER1_DB_PORT}:5432 postgres
    environment:
      - POSTGRES_PASSWORD=password
      - POSTGRES_USER=root
      - POSTGRES_DB=sequencer
    readiness_probe:
      exec:
        command: pg_isready -h localhost -p ${ESPRESSO_SEQUENCER1_DB_PORT}
      initial_delay_seconds: 5
      period_seconds: 5
      timeout_seconds: 4
      # Postgres can be falsely "ready" once before running init scripts.
      # See https://github.com/docker-library/postgres/issues/146 for discussion.
      success_threshold: 2
      failure_threshold: 20
    availability: *run-forever

  block-explorer:
    command:
      docker run --rm -p ${ESPRESSO_BLOCK_EXPLORER_PORT}:3000 -e QUERY_SERVICE_URI -e NODE_VALIDATOR_URI
      ghcr.io/espressosystems/espresso-block-explorer:main
    depends_on:
      sequencer1:
        condition: process_healthy
    availability: *run-forever