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:v0.47.0
    container_name: cadvisor
    restart: unless-stopped
   # privileged: true
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
  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/rln_tree_1.db:/rln_tree_1.db: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/rln_tree_2.db:/rln_tree_2.db: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/rln_tree_3.db:/rln_tree_3.db: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/rln_tree_4.db:/rln_tree_4.db: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/rln_tree_5.db:/rln_tree_5.db: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/rln_tree_6.db:/rln_tree_6.db: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/rln_tree_7.db:/rln_tree_7.db: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/rln_tree_8.db:/rln_tree_8.db: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/rln_tree_9.db:/rln_tree_9.db: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/rln_tree_10.db:/rln_tree_10.db: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/rln_tree_11.db:/rln_tree_11.db: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/rln_tree_12.db:/rln_tree_12.db: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/rln_tree_13.db:/rln_tree_13.db: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/rln_tree_14.db:/rln_tree_14.db: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/rln_tree_15.db:/rln_tree_15.db: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/rln_tree_16.db:/rln_tree_16.db: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/rln_tree_17.db:/rln_tree_17.db: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/rln_tree_18.db:/rln_tree_18.db: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/rln_tree_19.db:/rln_tree_19.db: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/rln_tree_20.db:/rln_tree_20.db: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/rln_tree_21.db:/rln_tree_21.db: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/rln_tree_22.db:/rln_tree_22.db: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/rln_tree_23.db:/rln_tree_23.db: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/rln_tree_24.db:/rln_tree_24.db: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/rln_tree_25.db:/rln_tree_25.db: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/rln_tree_26.db:/rln_tree_26.db: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/rln_tree_27.db:/rln_tree_27.db: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/rln_tree_28.db:/rln_tree_28.db: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/rln_tree_29.db:/rln_tree_29.db: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/rln_tree_30.db:/rln_tree_30.db: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/rln_tree_31.db:/rln_tree_31.db: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/rln_tree_32.db:/rln_tree_32.db: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/rln_tree_33.db:/rln_tree_33.db: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/rln_tree_34.db:/rln_tree_34.db: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/rln_tree_35.db:/rln_tree_35.db: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/rln_tree_36.db:/rln_tree_36.db: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/rln_tree_37.db:/rln_tree_37.db: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/rln_tree_38.db:/rln_tree_38.db: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/rln_tree_39.db:/rln_tree_39.db: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/rln_tree_40.db:/rln_tree_40.db: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/rln_tree_41.db:/rln_tree_41.db: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/rln_tree_42.db:/rln_tree_42.db: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/rln_tree_43.db:/rln_tree_43.db: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/rln_tree_44.db:/rln_tree_44.db: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/rln_tree_45.db:/rln_tree_45.db: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/rln_tree_46.db:/rln_tree_46.db: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/rln_tree_47.db:/rln_tree_47.db: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/rln_tree_48.db:/rln_tree_48.db: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/rln_tree_49.db:/rln_tree_49.db: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/rln_tree_50.db:/rln_tree_50.db: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/rln_tree_51.db:/rln_tree_51.db: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/rln_tree_52.db:/rln_tree_52.db: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/rln_tree_53.db:/rln_tree_53.db: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/rln_tree_54.db:/rln_tree_54.db: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/rln_tree_55.db:/rln_tree_55.db: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/rln_tree_56.db:/rln_tree_56.db: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/rln_tree_57.db:/rln_tree_57.db: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/rln_tree_58.db:/rln_tree_58.db: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/rln_tree_59.db:/rln_tree_59.db: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/rln_tree_60.db:/rln_tree_60.db: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/rln_tree_61.db:/rln_tree_61.db: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/rln_tree_62.db:/rln_tree_62.db: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/rln_tree_63.db:/rln_tree_63.db: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/rln_tree_64.db:/rln_tree_64.db: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/rln_tree_65.db:/rln_tree_65.db: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/rln_tree_66.db:/rln_tree_66.db: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/rln_tree_67.db:/rln_tree_67.db: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/rln_tree_68.db:/rln_tree_68.db: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/rln_tree_69.db:/rln_tree_69.db: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/rln_tree_70.db:/rln_tree_70.db: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/rln_tree_71.db:/rln_tree_71.db: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/rln_tree_72.db:/rln_tree_72.db: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/rln_tree_73.db:/rln_tree_73.db: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/rln_tree_74.db:/rln_tree_74.db: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/rln_tree_75.db:/rln_tree_75.db: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/rln_tree_76.db:/rln_tree_76.db: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/rln_tree_77.db:/rln_tree_77.db: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/rln_tree_78.db:/rln_tree_78.db: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/rln_tree_79.db:/rln_tree_79.db: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/rln_tree_80.db:/rln_tree_80.db: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/rln_tree_81.db:/rln_tree_81.db: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/rln_tree_82.db:/rln_tree_82.db: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/rln_tree_83.db:/rln_tree_83.db: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/rln_tree_84.db:/rln_tree_84.db: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/rln_tree_85.db:/rln_tree_85.db: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/rln_tree_86.db:/rln_tree_86.db: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/rln_tree_87.db:/rln_tree_87.db: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/rln_tree_88.db:/rln_tree_88.db: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/rln_tree_89.db:/rln_tree_89.db: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/rln_tree_90.db:/rln_tree_90.db: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/rln_tree_91.db:/rln_tree_91.db: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/rln_tree_92.db:/rln_tree_92.db: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/rln_tree_93.db:/rln_tree_93.db: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/rln_tree_94.db:/rln_tree_94.db: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/rln_tree_95.db:/rln_tree_95.db: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/rln_tree_96.db:/rln_tree_96.db: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/rln_tree_97.db:/rln_tree_97.db: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/rln_tree_98.db:/rln_tree_98.db: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/rln_tree_99.db:/rln_tree_99.db: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/rln_tree_100.db:/rln_tree_100.db: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