logos-messaging-simulator/docker-compose.yml

version: "3.7"
# sudo openssl rand -hex 32 > jwtsecret
# mkdir teku chmod 777 teku
services:
  geth:
    image: "ethereum/client-go:v1.12.2"
    restart: on-failure
    stop_grace_period: 5m
    command:
      - --sepolia
      - --http
      - --http.api=eth,net,engine,admin
      - --http.addr=0.0.0.0
      - --http.vhosts=*
      - --authrpc.vhosts=*
      - --authrpc.addr=0.0.0.0
      - --authrpc.jwtsecret=/jwtsecret
      - --datadir=/geth
      - --port=30303
      - --metrics
      - --metrics.addr=0.0.0.0
    ports:
      - 127.0.0.1:8551:8551
      - 127.0.0.1:8545:8545
      - 127.0.0.1:6060:6060
      - 30303:30303/tcp
      - 30303:30303/udp
    volumes:
      - ./geth:/geth
      - ./jwtsecret:/jwtsecret

  teku:
    image: consensys/teku:23.9.0
    restart: on-failure
    depends_on:
      - geth
    command:
      - --network=sepolia
      - --data-path=/opt/teku/data
      - --ee-endpoint=http://geth:8551
      - --ee-jwt-secret-file=/jwtsecret
      - --metrics-enabled=true
      - --metrics-host-allowlist=*
      - --metrics-interface=0.0.0.0
      - --metrics-port=8008
      - --rest-api-enabled=true
      - --rest-api-host-allowlist=*
      #- --initial-state=https://xxx/eth/v2/debug/beacon/states/finalized
    ports:
      - 127.0.0.1:5051:5051
      - 127.0.0.1:8008:8008
      - 9000:9000
    volumes:
      - ./teku:/opt/teku/data
      - ./jwtsecret:/jwtsecret

  #TODO: disable relay and make it just bootstrap? discv5
  bootstrap:
    image: ${NWAKU_IMAGE}
    restart: on-failure
    #TODO: expose some ports to inject traffic
    ports:
      - 127.0.0.1:60000:60000
      - 127.0.0.1:8008:8008
      - 127.0.0.1:9000:9000
    entrypoint: sh
    command:
    - '/opt/run_bootstrap.sh'
    volumes:
      - ./run_bootstrap.sh:/opt/run_bootstrap.sh:Z

  gowaku:
    image: ${GOWAKU_IMAGE}
    restart: on-failure
    deploy:
      replicas: ${NUM_GOWAKU_NODES}
    entrypoint: sh
    command:
      - '/opt/run_gowaku.sh'
    volumes:
      - ./run_gowaku.sh:/opt/run_gowaku.sh:Z
    depends_on:
      - bootstrap

  #waku-publisher:
  #  image: alrevuelta/waku-publisher:9fb206c
  #  entrypoint: sh
  #    - 'opt/run_wakupublisher.sh'
  #  volumes:
  #    - ./run_wakupublisher.sh:/opt/run_wakupublisher.sh:Z
  #  environment:
  #    MSG_PER_SECOND: 10
  #    MSG_SIZE_KBYTES: 10

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./monitoring/prometheus-config.yml:/etc/prometheus/prometheus.yml:z
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.retention.time=7d
    ports:
      - 127.0.0.1:9090:9090
    restart: on-failure

  grafana:
    image: grafana/grafana:latest
    env_file:
      - ./monitoring/configuration/grafana-plugins.env
    volumes:
      - ./monitoring/configuration/grafana.ini:/etc/grafana/grafana.ini:z
      - ./monitoring/configuration/dashboards.yaml:/etc/grafana/provisioning/dashboards/dashboards.yaml:z
      - ./monitoring/configuration/datasources.yaml:/etc/grafana/provisioning/datasources/datasources.yaml:z
      - ./monitoring/configuration/dashboards:/var/lib/grafana/dashboards/:z
      - ./monitoring/configuration/customizations/custom-logo.svg:/usr/share/grafana/public/img/grafana_icon.svg:z
      - ./monitoring/configuration/customizations/custom-logo.svg:/usr/share/grafana/public/img/grafana_typelogo.svg:z
      - ./monitoring/configuration/customizations/custom-logo.png:/usr/share/grafana/public/img/fav32.png:z
    ports:
      #- 127.0.0.1:3000:3000
      # open port to access the dashboard
      - 3000:3000
    restart: on-failure
    depends_on:
      - prometheus

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    #ports:
    #  - 8080:8080
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    depends_on:
      - redis

  redis:
    image: redis:latest
    container_name: redis
    #ports:
    #  - 6379:6379


  nwaku_1:
    container_name: waku-simulator_nwaku_1
    environment:
      REPLICA: 1
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_1:/data:Z
      - ./keys/rlnKeystore_1.json:/rlnKeystore_1.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_2:
    container_name: waku-simulator_nwaku_2
    environment:
      REPLICA: 2
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_2:/data:Z
      - ./keys/rlnKeystore_2.json:/rlnKeystore_2.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_3:
    container_name: waku-simulator_nwaku_3
    environment:
      REPLICA: 3
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_3:/data:Z
      - ./keys/rlnKeystore_3.json:/rlnKeystore_3.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_4:
    container_name: waku-simulator_nwaku_4
    environment:
      REPLICA: 4
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_4:/data:Z
      - ./keys/rlnKeystore_4.json:/rlnKeystore_4.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_5:
    container_name: waku-simulator_nwaku_5
    environment:
      REPLICA: 5
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_5:/data:Z
      - ./keys/rlnKeystore_5.json:/rlnKeystore_5.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_6:
    container_name: waku-simulator_nwaku_6
    environment:
      REPLICA: 6
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_6:/data:Z
      - ./keys/rlnKeystore_6.json:/rlnKeystore_6.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_7:
    container_name: waku-simulator_nwaku_7
    environment:
      REPLICA: 7
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_7:/data:Z
      - ./keys/rlnKeystore_7.json:/rlnKeystore_7.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_8:
    container_name: waku-simulator_nwaku_8
    environment:
      REPLICA: 8
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_8:/data:Z
      - ./keys/rlnKeystore_8.json:/rlnKeystore_8.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_9:
    container_name: waku-simulator_nwaku_9
    environment:
      REPLICA: 9
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_9:/data:Z
      - ./keys/rlnKeystore_9.json:/rlnKeystore_9.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_10:
    container_name: waku-simulator_nwaku_10
    environment:
      REPLICA: 10
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_10:/data:Z
      - ./keys/rlnKeystore_10.json:/rlnKeystore_10.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_11:
    container_name: waku-simulator_nwaku_11
    environment:
      REPLICA: 11
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_11:/data:Z
      - ./keys/rlnKeystore_11.json:/rlnKeystore_11.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_12:
    container_name: waku-simulator_nwaku_12
    environment:
      REPLICA: 12
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_12:/data:Z
      - ./keys/rlnKeystore_12.json:/rlnKeystore_12.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_13:
    container_name: waku-simulator_nwaku_13
    environment:
      REPLICA: 13
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_13:/data:Z
      - ./keys/rlnKeystore_13.json:/rlnKeystore_13.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_14:
    container_name: waku-simulator_nwaku_14
    environment:
      REPLICA: 14
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_14:/data:Z
      - ./keys/rlnKeystore_14.json:/rlnKeystore_14.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_15:
    container_name: waku-simulator_nwaku_15
    environment:
      REPLICA: 15
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_15:/data:Z
      - ./keys/rlnKeystore_15.json:/rlnKeystore_15.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_16:
    container_name: waku-simulator_nwaku_16
    environment:
      REPLICA: 16
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_16:/data:Z
      - ./keys/rlnKeystore_16.json:/rlnKeystore_16.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_17:
    container_name: waku-simulator_nwaku_17
    environment:
      REPLICA: 17
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_17:/data:Z
      - ./keys/rlnKeystore_17.json:/rlnKeystore_17.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_18:
    container_name: waku-simulator_nwaku_18
    environment:
      REPLICA: 18
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_18:/data:Z
      - ./keys/rlnKeystore_18.json:/rlnKeystore_18.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_19:
    container_name: waku-simulator_nwaku_19
    environment:
      REPLICA: 19
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_19:/data:Z
      - ./keys/rlnKeystore_19.json:/rlnKeystore_19.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_20:
    container_name: waku-simulator_nwaku_20
    environment:
      REPLICA: 20
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_20:/data:Z
      - ./keys/rlnKeystore_20.json:/rlnKeystore_20.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_21:
    container_name: waku-simulator_nwaku_21
    environment:
      REPLICA: 21
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_21:/data:Z
      - ./keys/rlnKeystore_21.json:/rlnKeystore_21.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_22:
    container_name: waku-simulator_nwaku_22
    environment:
      REPLICA: 22
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_22:/data:Z
      - ./keys/rlnKeystore_22.json:/rlnKeystore_22.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_23:
    container_name: waku-simulator_nwaku_23
    environment:
      REPLICA: 23
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_23:/data:Z
      - ./keys/rlnKeystore_23.json:/rlnKeystore_23.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_24:
    container_name: waku-simulator_nwaku_24
    environment:
      REPLICA: 24
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_24:/data:Z
      - ./keys/rlnKeystore_24.json:/rlnKeystore_24.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_25:
    container_name: waku-simulator_nwaku_25
    environment:
      REPLICA: 25
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_25:/data:Z
      - ./keys/rlnKeystore_25.json:/rlnKeystore_25.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_26:
    container_name: waku-simulator_nwaku_26
    environment:
      REPLICA: 26
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_26:/data:Z
      - ./keys/rlnKeystore_26.json:/rlnKeystore_26.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_27:
    container_name: waku-simulator_nwaku_27
    environment:
      REPLICA: 27
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_27:/data:Z
      - ./keys/rlnKeystore_27.json:/rlnKeystore_27.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_28:
    container_name: waku-simulator_nwaku_28
    environment:
      REPLICA: 28
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_28:/data:Z
      - ./keys/rlnKeystore_28.json:/rlnKeystore_28.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_29:
    container_name: waku-simulator_nwaku_29
    environment:
      REPLICA: 29
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_29:/data:Z
      - ./keys/rlnKeystore_29.json:/rlnKeystore_29.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_30:
    container_name: waku-simulator_nwaku_30
    environment:
      REPLICA: 30
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_30:/data:Z
      - ./keys/rlnKeystore_30.json:/rlnKeystore_30.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_31:
    container_name: waku-simulator_nwaku_31
    environment:
      REPLICA: 31
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_31:/data:Z
      - ./keys/rlnKeystore_31.json:/rlnKeystore_31.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_32:
    container_name: waku-simulator_nwaku_32
    environment:
      REPLICA: 32
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_32:/data:Z
      - ./keys/rlnKeystore_32.json:/rlnKeystore_32.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_33:
    container_name: waku-simulator_nwaku_33
    environment:
      REPLICA: 33
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_33:/data:Z
      - ./keys/rlnKeystore_33.json:/rlnKeystore_33.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_34:
    container_name: waku-simulator_nwaku_34
    environment:
      REPLICA: 34
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_34:/data:Z
      - ./keys/rlnKeystore_34.json:/rlnKeystore_34.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_35:
    container_name: waku-simulator_nwaku_35
    environment:
      REPLICA: 35
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_35:/data:Z
      - ./keys/rlnKeystore_35.json:/rlnKeystore_35.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_36:
    container_name: waku-simulator_nwaku_36
    environment:
      REPLICA: 36
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_36:/data:Z
      - ./keys/rlnKeystore_36.json:/rlnKeystore_36.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_37:
    container_name: waku-simulator_nwaku_37
    environment:
      REPLICA: 37
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_37:/data:Z
      - ./keys/rlnKeystore_37.json:/rlnKeystore_37.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_38:
    container_name: waku-simulator_nwaku_38
    environment:
      REPLICA: 38
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_38:/data:Z
      - ./keys/rlnKeystore_38.json:/rlnKeystore_38.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_39:
    container_name: waku-simulator_nwaku_39
    environment:
      REPLICA: 39
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_39:/data:Z
      - ./keys/rlnKeystore_39.json:/rlnKeystore_39.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_40:
    container_name: waku-simulator_nwaku_40
    environment:
      REPLICA: 40
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_40:/data:Z
      - ./keys/rlnKeystore_40.json:/rlnKeystore_40.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_41:
    container_name: waku-simulator_nwaku_41
    environment:
      REPLICA: 41
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_41:/data:Z
      - ./keys/rlnKeystore_41.json:/rlnKeystore_41.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_42:
    container_name: waku-simulator_nwaku_42
    environment:
      REPLICA: 42
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_42:/data:Z
      - ./keys/rlnKeystore_42.json:/rlnKeystore_42.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_43:
    container_name: waku-simulator_nwaku_43
    environment:
      REPLICA: 43
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_43:/data:Z
      - ./keys/rlnKeystore_43.json:/rlnKeystore_43.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_44:
    container_name: waku-simulator_nwaku_44
    environment:
      REPLICA: 44
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_44:/data:Z
      - ./keys/rlnKeystore_44.json:/rlnKeystore_44.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_45:
    container_name: waku-simulator_nwaku_45
    environment:
      REPLICA: 45
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_45:/data:Z
      - ./keys/rlnKeystore_45.json:/rlnKeystore_45.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_46:
    container_name: waku-simulator_nwaku_46
    environment:
      REPLICA: 46
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_46:/data:Z
      - ./keys/rlnKeystore_46.json:/rlnKeystore_46.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_47:
    container_name: waku-simulator_nwaku_47
    environment:
      REPLICA: 47
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_47:/data:Z
      - ./keys/rlnKeystore_47.json:/rlnKeystore_47.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_48:
    container_name: waku-simulator_nwaku_48
    environment:
      REPLICA: 48
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_48:/data:Z
      - ./keys/rlnKeystore_48.json:/rlnKeystore_48.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_49:
    container_name: waku-simulator_nwaku_49
    environment:
      REPLICA: 49
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_49:/data:Z
      - ./keys/rlnKeystore_49.json:/rlnKeystore_49.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_50:
    container_name: waku-simulator_nwaku_50
    environment:
      REPLICA: 50
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_50:/data:Z
      - ./keys/rlnKeystore_50.json:/rlnKeystore_50.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_51:
    container_name: waku-simulator_nwaku_51
    environment:
      REPLICA: 51
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_51:/data:Z
      - ./keys/rlnKeystore_51.json:/rlnKeystore_51.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_52:
    container_name: waku-simulator_nwaku_52
    environment:
      REPLICA: 52
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_52:/data:Z
      - ./keys/rlnKeystore_52.json:/rlnKeystore_52.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_53:
    container_name: waku-simulator_nwaku_53
    environment:
      REPLICA: 53
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_53:/data:Z
      - ./keys/rlnKeystore_53.json:/rlnKeystore_53.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_54:
    container_name: waku-simulator_nwaku_54
    environment:
      REPLICA: 54
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_54:/data:Z
      - ./keys/rlnKeystore_54.json:/rlnKeystore_54.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_55:
    container_name: waku-simulator_nwaku_55
    environment:
      REPLICA: 55
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_55:/data:Z
      - ./keys/rlnKeystore_55.json:/rlnKeystore_55.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_56:
    container_name: waku-simulator_nwaku_56
    environment:
      REPLICA: 56
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_56:/data:Z
      - ./keys/rlnKeystore_56.json:/rlnKeystore_56.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_57:
    container_name: waku-simulator_nwaku_57
    environment:
      REPLICA: 57
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_57:/data:Z
      - ./keys/rlnKeystore_57.json:/rlnKeystore_57.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_58:
    container_name: waku-simulator_nwaku_58
    environment:
      REPLICA: 58
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_58:/data:Z
      - ./keys/rlnKeystore_58.json:/rlnKeystore_58.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_59:
    container_name: waku-simulator_nwaku_59
    environment:
      REPLICA: 59
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_59:/data:Z
      - ./keys/rlnKeystore_59.json:/rlnKeystore_59.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_60:
    container_name: waku-simulator_nwaku_60
    environment:
      REPLICA: 60
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_60:/data:Z
      - ./keys/rlnKeystore_60.json:/rlnKeystore_60.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_61:
    container_name: waku-simulator_nwaku_61
    environment:
      REPLICA: 61
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_61:/data:Z
      - ./keys/rlnKeystore_61.json:/rlnKeystore_61.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_62:
    container_name: waku-simulator_nwaku_62
    environment:
      REPLICA: 62
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_62:/data:Z
      - ./keys/rlnKeystore_62.json:/rlnKeystore_62.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_63:
    container_name: waku-simulator_nwaku_63
    environment:
      REPLICA: 63
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_63:/data:Z
      - ./keys/rlnKeystore_63.json:/rlnKeystore_63.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_64:
    container_name: waku-simulator_nwaku_64
    environment:
      REPLICA: 64
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_64:/data:Z
      - ./keys/rlnKeystore_64.json:/rlnKeystore_64.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_65:
    container_name: waku-simulator_nwaku_65
    environment:
      REPLICA: 65
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_65:/data:Z
      - ./keys/rlnKeystore_65.json:/rlnKeystore_65.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_66:
    container_name: waku-simulator_nwaku_66
    environment:
      REPLICA: 66
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_66:/data:Z
      - ./keys/rlnKeystore_66.json:/rlnKeystore_66.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_67:
    container_name: waku-simulator_nwaku_67
    environment:
      REPLICA: 67
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_67:/data:Z
      - ./keys/rlnKeystore_67.json:/rlnKeystore_67.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_68:
    container_name: waku-simulator_nwaku_68
    environment:
      REPLICA: 68
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_68:/data:Z
      - ./keys/rlnKeystore_68.json:/rlnKeystore_68.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_69:
    container_name: waku-simulator_nwaku_69
    environment:
      REPLICA: 69
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_69:/data:Z
      - ./keys/rlnKeystore_69.json:/rlnKeystore_69.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_70:
    container_name: waku-simulator_nwaku_70
    environment:
      REPLICA: 70
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_70:/data:Z
      - ./keys/rlnKeystore_70.json:/rlnKeystore_70.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_71:
    container_name: waku-simulator_nwaku_71
    environment:
      REPLICA: 71
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_71:/data:Z
      - ./keys/rlnKeystore_71.json:/rlnKeystore_71.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_72:
    container_name: waku-simulator_nwaku_72
    environment:
      REPLICA: 72
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_72:/data:Z
      - ./keys/rlnKeystore_72.json:/rlnKeystore_72.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_73:
    container_name: waku-simulator_nwaku_73
    environment:
      REPLICA: 73
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_73:/data:Z
      - ./keys/rlnKeystore_73.json:/rlnKeystore_73.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_74:
    container_name: waku-simulator_nwaku_74
    environment:
      REPLICA: 74
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_74:/data:Z
      - ./keys/rlnKeystore_74.json:/rlnKeystore_74.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_75:
    container_name: waku-simulator_nwaku_75
    environment:
      REPLICA: 75
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_75:/data:Z
      - ./keys/rlnKeystore_75.json:/rlnKeystore_75.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_76:
    container_name: waku-simulator_nwaku_76
    environment:
      REPLICA: 76
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_76:/data:Z
      - ./keys/rlnKeystore_76.json:/rlnKeystore_76.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_77:
    container_name: waku-simulator_nwaku_77
    environment:
      REPLICA: 77
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_77:/data:Z
      - ./keys/rlnKeystore_77.json:/rlnKeystore_77.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_78:
    container_name: waku-simulator_nwaku_78
    environment:
      REPLICA: 78
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_78:/data:Z
      - ./keys/rlnKeystore_78.json:/rlnKeystore_78.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_79:
    container_name: waku-simulator_nwaku_79
    environment:
      REPLICA: 79
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_79:/data:Z
      - ./keys/rlnKeystore_79.json:/rlnKeystore_79.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_80:
    container_name: waku-simulator_nwaku_80
    environment:
      REPLICA: 80
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_80:/data:Z
      - ./keys/rlnKeystore_80.json:/rlnKeystore_80.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_81:
    container_name: waku-simulator_nwaku_81
    environment:
      REPLICA: 81
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_81:/data:Z
      - ./keys/rlnKeystore_81.json:/rlnKeystore_81.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_82:
    container_name: waku-simulator_nwaku_82
    environment:
      REPLICA: 82
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_82:/data:Z
      - ./keys/rlnKeystore_82.json:/rlnKeystore_82.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_83:
    container_name: waku-simulator_nwaku_83
    environment:
      REPLICA: 83
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_83:/data:Z
      - ./keys/rlnKeystore_83.json:/rlnKeystore_83.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_84:
    container_name: waku-simulator_nwaku_84
    environment:
      REPLICA: 84
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_84:/data:Z
      - ./keys/rlnKeystore_84.json:/rlnKeystore_84.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_85:
    container_name: waku-simulator_nwaku_85
    environment:
      REPLICA: 85
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_85:/data:Z
      - ./keys/rlnKeystore_85.json:/rlnKeystore_85.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_86:
    container_name: waku-simulator_nwaku_86
    environment:
      REPLICA: 86
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_86:/data:Z
      - ./keys/rlnKeystore_86.json:/rlnKeystore_86.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_87:
    container_name: waku-simulator_nwaku_87
    environment:
      REPLICA: 87
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_87:/data:Z
      - ./keys/rlnKeystore_87.json:/rlnKeystore_87.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_88:
    container_name: waku-simulator_nwaku_88
    environment:
      REPLICA: 88
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_88:/data:Z
      - ./keys/rlnKeystore_88.json:/rlnKeystore_88.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_89:
    container_name: waku-simulator_nwaku_89
    environment:
      REPLICA: 89
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_89:/data:Z
      - ./keys/rlnKeystore_89.json:/rlnKeystore_89.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_90:
    container_name: waku-simulator_nwaku_90
    environment:
      REPLICA: 90
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_90:/data:Z
      - ./keys/rlnKeystore_90.json:/rlnKeystore_90.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_91:
    container_name: waku-simulator_nwaku_91
    environment:
      REPLICA: 91
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_91:/data:Z
      - ./keys/rlnKeystore_91.json:/rlnKeystore_91.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_92:
    container_name: waku-simulator_nwaku_92
    environment:
      REPLICA: 92
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_92:/data:Z
      - ./keys/rlnKeystore_92.json:/rlnKeystore_92.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_93:
    container_name: waku-simulator_nwaku_93
    environment:
      REPLICA: 93
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_93:/data:Z
      - ./keys/rlnKeystore_93.json:/rlnKeystore_93.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_94:
    container_name: waku-simulator_nwaku_94
    environment:
      REPLICA: 94
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_94:/data:Z
      - ./keys/rlnKeystore_94.json:/rlnKeystore_94.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_95:
    container_name: waku-simulator_nwaku_95
    environment:
      REPLICA: 95
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_95:/data:Z
      - ./keys/rlnKeystore_95.json:/rlnKeystore_95.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_96:
    container_name: waku-simulator_nwaku_96
    environment:
      REPLICA: 96
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_96:/data:Z
      - ./keys/rlnKeystore_96.json:/rlnKeystore_96.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_97:
    container_name: waku-simulator_nwaku_97
    environment:
      REPLICA: 97
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_97:/data:Z
      - ./keys/rlnKeystore_97.json:/rlnKeystore_97.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_98:
    container_name: waku-simulator_nwaku_98
    environment:
      REPLICA: 98
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_98:/data:Z
      - ./keys/rlnKeystore_98.json:/rlnKeystore_98.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_99:
    container_name: waku-simulator_nwaku_99
    environment:
      REPLICA: 99
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_99:/data:Z
      - ./keys/rlnKeystore_99.json:/rlnKeystore_99.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s

  nwaku_100:
    container_name: waku-simulator_nwaku_100
    environment:
      REPLICA: 100
    image: ${NWAKU_IMAGE}
    restart: on-failure
    entrypoint: sh
    command:
      - '/opt/run_nwaku.sh'
    volumes:
      - ./run_nwaku.sh:/opt/run_nwaku.sh:Z
      - ./data/nwaku_100:/data:Z
      - ./keys/rlnKeystore_100.json:/rlnKeystore_100.json:Z
#      - ./rln_tree.db:/rln_tree.db:Z # this should not be done as its being written by all the replicas
    depends_on:
      - bootstrap
    healthcheck:
      test: curl --fail http://localhost:8645/health || exit 1
      interval: 30s
      retries: 2
      start_period: 10s
      timeout: 5s