fix(k8s): translate service names to localhost for sidecar containers

In docker-compose, services can reference each other by name (e.g., 'db:5432').
In Kubernetes, when multiple containers are in the same pod (sidecars), they
share the same network namespace and must use 'localhost' instead.

This fix adds translate_sidecar_service_names() which replaces docker-compose
service name references with 'localhost' in environment variable values for
containers that share the same pod.

Fixes issue where multi-container pods fail because one container tries to
connect to a sibling using the compose service name instead of localhost.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.gitea/workflows/fixturenet-laconicd-test.yml

@@ -0,0 +1,66 @@
+name: Fixturenet-Laconicd-Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-laconicd-test'
+  schedule:
+    - cron: '1 13 * * *'
+
+jobs:
+  test:
+    name: "Run Laconicd fixturenet and Laconic CLI tests"
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Update'
+        run: apt-get update
+      - name: 'Setup jq'
+        run: apt-get install jq -y
+      - name: 'Check jq'
+        run: |
+          which jq
+          jq --version
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Run fixturenet-laconicd tests"
+        run: ./tests/fixturenet-laconicd/run-test.sh
+      - name: "Run laconic CLI tests"
+        run: ./tests/fixturenet-laconicd/run-cli-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/lint.yml

@@ -0,0 +1,37 @@
+name: Lint Checks
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run linter"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      - name: "Install Python"
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name : "Run flake8"
+        uses: py-actions/flake8@v2
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/publish.yml

@@ -5,6 +5,8 @@ on:
     branches:
       - main
       - publish-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
 jobs:
   publish:
@@ -18,14 +20,22 @@ jobs:
         run: |
           build_tag=$(./scripts/create_build_tag_file.sh)
           echo "build-tag=v${build_tag}" >> $GITHUB_OUTPUT
-      - name: "Install Python"
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
         uses: actions/setup-python@v4
         with:
           python-version: '3.8'
       - name: "Print Python version"
         run: python3 --version
       - name: "Install shiv"
-        run: pip install shiv
+        run: pip install shiv==1.0.6
       - name: "Build local shiv package"
         id: build
         run: |
@@ -44,3 +54,19 @@ jobs:
           # Hack using endsWith to workaround Gitea sometimes sending "publish-test" vs "refs/heads/publish-test"
           draft: ${{ endsWith('publish-test', github.ref ) }}
           files: ./laconic-so
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-container-registry.yml

@@ -0,0 +1,69 @@
+name: Container Registry Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-container-registry'
+      - '.gitea/workflows/test-container-registry.yml'
+      - 'tests/container-registry/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '6 19 * * *'
+
+jobs:
+  test:
+    name: "Run contaier registry hosting test on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Install ed" # Only needed until we remove the need to edit the spec file
+        run: apt update && apt install -y ed
+      - name: "Run container registry deployment test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/container-registry/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-database.yml

@@ -0,0 +1,67 @@
+name: Database Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-database'
+      - '.gitea/workflows/test-database.yml'
+      - 'tests/database/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '5 18 * * *'
+
+jobs:
+  test:
+    name: "Run database hosting test on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run database deployment test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/database/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-deploy.yml

@@ -2,15 +2,15 @@ name: Deploy Test
 
 on:
   pull_request:
-    branches: '*'
+    branches:
+      - main
   push:
     branches:
       - main
       - ci-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
-# Needed until we can incorporate docker startup into the executor container
-env:
-  DOCKER_HOST: unix:///var/run/dind.sock
 
 jobs:
   test:
@@ -19,21 +19,41 @@ jobs:
     steps:
       - name: "Clone project repository"
         uses: actions/checkout@v3
-      - name: "Install Python"
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
         uses: actions/setup-python@v4
         with:
           python-version: '3.8'
       - name: "Print Python version"
         run: python3 --version
       - name: "Install shiv"
-        run: pip install shiv
+        run: pip install shiv==1.0.6
       - name: "Generate build version file"
         run: ./scripts/create_build_tag_file.sh
       - name: "Build local shiv package"
         run: ./scripts/build_shiv_package.sh
-      - name: Start dockerd # Also needed until we can incorporate into the executor
-        run: |
-          dockerd -H $DOCKER_HOST --userland-proxy=false &
-          sleep 5
       - name: "Run deploy tests"
         run: ./tests/deploy/run-deploy-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-external-stack.yml

@@ -0,0 +1,58 @@
+name: External Stack Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-external-stack'
+      - '.gitea/workflows/test-external-stack.yml'
+      - 'tests/external-stack/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '8 19 * * *'
+
+jobs:
+  test:
+    name: "Run external stack test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Run external stack tests"
+        run: ./tests/external-stack/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-k8s-deploy.yml

@@ -0,0 +1,70 @@
+name: K8s Deploy Test
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-k8s-deploy'
+      - '.gitea/workflows/test-k8s-deploy.yml'
+      - 'tests/k8s-deploy/run-deploy-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '3 15 * * *'
+
+jobs:
+  test:
+    name: "Run deploy test suite on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run k8s deployment test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/k8s-deploy/run-deploy-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-k8s-deployment-control.yml

@@ -0,0 +1,70 @@
+name: K8s Deployment Control Test
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-k8s-deployment-control'
+      - '.gitea/workflows/test-k8s-deployment-control.yml'
+      - 'tests/k8s-deployment-control/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '3 30 * * *'
+
+jobs:
+  test:
+    name: "Run deployment control suite on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run k8s deployment control test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/k8s-deployment-control/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-webapp.yml

@@ -0,0 +1,60 @@
+name: Webapp Test
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+      - ci-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
+
+jobs:
+  test:
+    name: "Run webapp test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Install wget" # 20240109 - Only needed until the executors are updated.
+        run: apt update && apt install -y wget
+      - name: "Run webapp tests"
+        run: ./tests/webapp-test/run-webapp-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test.yml

@@ -7,10 +7,9 @@ on:
     branches:
       - main
       - ci-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
-# Needed until we can incorporate docker startup into the executor container
-env:
-  DOCKER_HOST: unix:///var/run/dind.sock
 
 jobs:
   test:
@@ -19,21 +18,41 @@ jobs:
     steps:
       - name: "Clone project repository"
         uses: actions/checkout@v3
-      - name: "Install Python"
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
         uses: actions/setup-python@v4
         with:
           python-version: '3.8'
       - name: "Print Python version"
         run: python3 --version
       - name: "Install shiv"
-        run: pip install shiv
+        run: pip install shiv==1.0.6
       - name: "Generate build version file"
         run: ./scripts/create_build_tag_file.sh
       - name: "Build local shiv package"
         run: ./scripts/build_shiv_package.sh
-      - name: Start dockerd # Also needed until we can incorporate into the executor
-        run: |
-          dockerd -H $DOCKER_HOST --userland-proxy=false &
-          sleep 5
       - name: "Run smoke tests"
         run: ./tests/smoke-test/run-smoke-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/triggers/fixturenet-laconicd-test

@@ -0,0 +1,10 @@
+Change this file to trigger running the fixturenet-laconicd-test CI job
+Trigger
+Trigger
+Trigger
+Trigger
+Trigger
+Trigger
+Trigger
+Trigger
+Trigger

.gitea/workflows/triggers/test-container-registry

@@ -0,0 +1,3 @@
+Change this file to trigger running the test-container-registry CI job
+Triggered: 2026-01-21
+Triggered: 2026-01-21 19:28:29

.gitea/workflows/triggers/test-database

@@ -0,0 +1,2 @@
+Change this file to trigger running the test-database CI job
+Trigger test run

.gitea/workflows/triggers/test-external-stack

@@ -0,0 +1,2 @@
+Change this file to trigger running the external-stack CI job
+trigger

.gitea/workflows/triggers/test-k8s-deploy

@@ -0,0 +1,2 @@
+Change this file to trigger running the test-k8s-deploy CI job
+Trigger test on PR branch

.github/workflows/fixturenet-eth.yml

@@ -1,12 +1,15 @@
-name: Fixturenet-Eth-Test
+name: Fixturenet-Eth Test
 
 on:
   push:
-    branches: 'ci-test'
+    branches: '*'
+    paths:
+      - '!**'
+      - '.github/workflows/triggers/fixturenet-eth-test'
 
 jobs:
   test:
-    name: "Run an Ethereum fixturenet test"
+    name: "Run fixturenet-eth test suite"
     runs-on: ubuntu-latest
     steps:
       - name: "Clone project repository"

.github/workflows/fixturenet-laconicd.yml

@@ -0,0 +1,30 @@
+name: Fixturenet-Laconicd Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.github/workflows/triggers/fixturenet-laconicd-test'
+
+jobs:
+  test:
+    name: "Run fixturenet-laconicd test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      - name: "Install Python"
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Run fixturenet-laconicd tests"
+        run: ./tests/fixturenet-laconicd/run-test.sh

.github/workflows/lint.yml

@@ -0,0 +1,21 @@
+name: Lint Checks
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run linter"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      - name: "Install Python"
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name : "Run flake8"
+        uses: py-actions/flake8@v2

.github/workflows/test-webapp.yml

@@ -0,0 +1,29 @@
+name: Webapp Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run webapp test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      - name: "Install Python"
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Run webapp tests"
+        run: ./tests/webapp-test/run-webapp-test.sh

.github/workflows/triggers/fixturenet-eth-test

@@ -0,0 +1 @@
+Change this file to trigger running the fixturenet-eth-test CI job

.github/workflows/triggers/fixturenet-laconicd-test

@@ -0,0 +1,3 @@
+Change this file to trigger running the fixturenet-laconicd-test CI job
+
+trigger

.gitignore

@@ -6,5 +6,5 @@ laconic_stack_orchestrator.egg-info
 __pycache__
 *~
 package
-app/data/build_tag.txt
-build
+stack_orchestrator/data/build_tag.txt
+/build

.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+        args: ['--allow-multiple-documents']
+      - id: check-json
+      - id: check-merge-conflict
+      - id: check-added-large-files
+
+  - repo: https://github.com/psf/black
+    rev: 23.12.1
+    hooks:
+      - id: black
+        language_version: python3
+
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8
+        args: ['--max-line-length=88', '--extend-ignore=E203,W503,E402']
+
+  - repo: https://github.com/RobertCraigie/pyright-python
+    rev: v1.1.345
+    hooks:
+      - id: pyright
+
+  - repo: https://github.com/adrienverge/yamllint
+    rev: v1.35.1
+    hooks:
+      - id: yamllint
+        args: [-d, relaxed]

AI-FRIENDLY-PLAN.md

@@ -0,0 +1,151 @@
+# Plan: Make Stack-Orchestrator AI-Friendly
+
+## Goal
+
+Make the stack-orchestrator repository easier for AI tools (Claude Code, Cursor, Copilot) to understand and use for generating stacks, including adding a `create-stack` command.
+
+---
+
+## Part 1: Documentation & Context Files
+
+### 1.1 Add CLAUDE.md
+
+Create a root-level context file for AI assistants.
+
+**File:** `CLAUDE.md`
+
+Contents:
+- Project overview (what stack-orchestrator does)
+- Stack creation workflow (step-by-step)
+- File naming conventions
+- Required vs optional fields in stack.yml
+- Common patterns and anti-patterns
+- Links to example stacks (simple, medium, complex)
+
+### 1.2 Add JSON Schema for stack.yml
+
+Create formal validation schema.
+
+**File:** `schemas/stack-schema.json`
+
+Benefits:
+- AI tools can validate generated stacks
+- IDEs provide autocomplete
+- CI can catch errors early
+
+### 1.3 Add Template Stack with Comments
+
+Create an annotated template for reference.
+
+**File:** `stack_orchestrator/data/stacks/_template/stack.yml`
+
+```yaml
+# Stack definition template - copy this directory to create a new stack
+version: "1.2"  # Required: 1.0, 1.1, or 1.2
+name: my-stack  # Required: lowercase, hyphens only
+description: "Human-readable description"  # Optional
+repos:          # Git repositories to clone
+  - github.com/org/repo
+containers:     # Container images to build (must have matching container-build/)
+  - cerc/my-container
+pods:           # Deployment units (must have matching docker-compose-{pod}.yml)
+  - my-pod
+```
+
+### 1.4 Document Validation Rules
+
+Create explicit documentation of constraints currently scattered in code.
+
+**File:** `docs/stack-format.md`
+
+Contents:
+- Container names must start with `cerc/`
+- Pod names must match compose file: `docker-compose-{pod}.yml`
+- Repository format: `host/org/repo[@ref]`
+- Stack directory name should match `name` field
+- Version field options and differences
+
+---
+
+## Part 2: Add `create-stack` Command
+
+### 2.1 Command Overview
+
+```bash
+laconic-so create-stack --repo github.com/org/my-app [--name my-app] [--type webapp]
+```
+
+**Behavior:**
+1. Parse repo URL to extract app name (if --name not provided)
+2. Create `stacks/{name}/stack.yml`
+3. Create `container-build/cerc-{name}/Dockerfile` and `build.sh`
+4. Create `compose/docker-compose-{name}.yml`
+5. Update list files (repository-list.txt, container-image-list.txt, pod-list.txt)
+
+### 2.2 Files to Create
+
+| File | Purpose |
+|------|---------|
+| `stack_orchestrator/create/__init__.py` | Package init |
+| `stack_orchestrator/create/create_stack.py` | Command implementation |
+
+### 2.3 Files to Modify
+
+| File | Change |
+|------|--------|
+| `stack_orchestrator/main.py` | Add import and `cli.add_command()` |
+
+### 2.4 Command Options
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| `--repo` | Yes | Git repository URL (e.g., github.com/org/repo) |
+| `--name` | No | Stack name (defaults to repo name) |
+| `--type` | No | Template type: webapp, service, empty (default: webapp) |
+| `--force` | No | Overwrite existing files |
+
+### 2.5 Template Types
+
+| Type | Base Image | Port | Use Case |
+|------|------------|------|----------|
+| webapp | node:20-bullseye-slim | 3000 | React/Vue/Next.js apps |
+| service | python:3.11-slim | 8080 | Python backend services |
+| empty | none | none | Custom from scratch |
+
+---
+
+## Part 3: Implementation Summary
+
+### New Files (6)
+
+1. `CLAUDE.md` - AI assistant context
+2. `schemas/stack-schema.json` - Validation schema
+3. `stack_orchestrator/data/stacks/_template/stack.yml` - Annotated template
+4. `docs/stack-format.md` - Stack format documentation
+5. `stack_orchestrator/create/__init__.py` - Package init
+6. `stack_orchestrator/create/create_stack.py` - Command implementation
+
+### Modified Files (1)
+
+1. `stack_orchestrator/main.py` - Register create-stack command
+
+---
+
+## Verification
+
+```bash
+# 1. Command appears in help
+laconic-so --help | grep create-stack
+
+# 2. Dry run works
+laconic-so --dry-run create-stack --repo github.com/org/test-app
+
+# 3. Creates all expected files
+laconic-so create-stack --repo github.com/org/test-app
+ls stack_orchestrator/data/stacks/test-app/
+ls stack_orchestrator/data/container-build/cerc-test-app/
+ls stack_orchestrator/data/compose/docker-compose-test-app.yml
+
+# 4. Build works with generated stack
+laconic-so --stack test-app build-containers
+```

CLAUDE.md

@@ -0,0 +1,121 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with the stack-orchestrator project.
+
+## Some rules to follow
+NEVER speculate about the cause of something
+NEVER assume your hypotheses are true without evidence
+
+ALWAYS clearly state when something is a hypothesis
+ALWAYS use evidence from the systems your interacting with to support your claims and hypotheses
+ALWAYS run `pre-commit run --all-files` before committing changes
+
+## Key Principles
+
+### Development Guidelines
+- **Single responsibility** - Each component has one clear purpose
+- **Fail fast** - Let errors propagate, don't hide failures
+- **DRY/KISS** - Minimize duplication and complexity
+
+## Development Philosophy: Conversational Literate Programming
+
+### Approach
+This project follows principles inspired by literate programming, where development happens through explanatory conversation rather than code-first implementation.
+
+### Core Principles
+- **Documentation-First**: All changes begin with discussion of intent and reasoning
+- **Narrative-Driven**: Complex systems are explained through conversational exploration
+- **Justification Required**: Every coding task must have a corresponding TODO.md item explaining the "why"
+- **Iterative Understanding**: Architecture and implementation evolve through dialogue
+
+### Working Method
+1. **Explore and Understand**: Read existing code to understand current state
+2. **Discuss Architecture**: Workshop complex design decisions through conversation
+3. **Document Intent**: Update TODO.md with clear justification before coding
+4. **Explain Changes**: Each modification includes reasoning and context
+5. **Maintain Narrative**: Conversations serve as living documentation of design evolution
+
+### Implementation Guidelines
+- Treat conversations as primary documentation
+- Explain architectural decisions before implementing
+- Use TODO.md as the "literate document" that justifies all work
+- Maintain clear narrative threads across sessions
+- Workshop complex ideas before coding
+
+This approach treats the human-AI collaboration as a form of **conversational literate programming** where understanding emerges through dialogue before code implementation.
+
+## External Stacks Preferred
+
+When creating new stacks for any reason, **use the external stack pattern** rather than adding stacks directly to this repository.
+
+External stacks follow this structure:
+
+```
+my-stack/
+└── stack-orchestrator/
+    ├── stacks/
+    │   └── my-stack/
+    │       ├── stack.yml
+    │       └── README.md
+    ├── compose/
+    │   └── docker-compose-my-stack.yml
+    └── config/
+        └── my-stack/
+            └── (config files)
+```
+
+### Usage
+
+```bash
+# Fetch external stack
+laconic-so fetch-stack github.com/org/my-stack
+
+# Use external stack
+STACK_PATH=~/cerc/my-stack/stack-orchestrator/stacks/my-stack
+laconic-so --stack $STACK_PATH deploy init --output spec.yml
+laconic-so --stack $STACK_PATH deploy create --spec-file spec.yml --deployment-dir deployment
+laconic-so deployment --dir deployment start
+```
+
+### Examples
+
+- `zenith-karma-stack` - Karma watcher deployment
+- `urbit-stack` - Fake Urbit ship for testing
+- `zenith-desk-stack` - Desk deployment stack
+
+## Architecture: k8s-kind Deployments
+
+### One Cluster Per Host
+One Kind cluster per host by design. Never request or expect separate clusters.
+
+- `create_cluster()` in `helpers.py` reuses any existing cluster
+- `cluster-id` in deployment.yml is an identifier, not a cluster request
+- All deployments share: ingress controller, etcd, certificates
+
+### Stack Resolution
+- External stacks detected via `Path(stack).exists()` in `util.py`
+- Config/compose resolution: external path first, then internal fallback
+- External path structure: `stack_orchestrator/data/stacks/<name>/stack.yml`
+
+### Secret Generation Implementation
+- `GENERATE_TOKEN_PATTERN` in `deployment_create.py` matches `$generate:type:length$`
+- `_generate_and_store_secrets()` creates K8s Secret
+- `cluster_info.py` adds `envFrom` with `secretRef` to containers
+- Non-secret config written to `config.env`
+
+### Repository Cloning
+`setup-repositories --git-ssh` clones repos defined in stack.yml's `repos:` field. Requires SSH agent.
+
+### Key Files (for codebase navigation)
+- `repos/setup_repositories.py`: `setup-repositories` command (git clone)
+- `deployment_create.py`: `deploy create` command, secret generation
+- `deployment.py`: `deployment start/stop/restart` commands
+- `deploy_k8s.py`: K8s deployer, cluster management calls
+- `helpers.py`: `create_cluster()`, etcd cleanup, kind operations
+- `cluster_info.py`: K8s resource generation (Deployment, Service, Ingress)
+
+## Insights and Observations
+
+### Design Principles
+- **When something times out that doesn't mean it needs a longer timeout it means something that was expected never happened, not that we need to wait longer for it.**
+- **NEVER change a timeout because you believe something truncated, you don't understand timeouts, don't edit them unless told to explicitly by user.**

LICENSE

@@ -658,4 +658,4 @@
                                    You should also get your employer (if you work as a programmer) or school,
                                  if any, to sign a "copyright disclaimer" for the program, if necessary.
                                  For more information on this, and how to apply and follow the GNU AGPL, see
-                                 <http://www.gnu.org/licenses/>.
+                                 <http://www.gnu.org/licenses/>.

README.md

@@ -6,7 +6,7 @@ Stack Orchestrator allows building and deployment of a Laconic Stack on a single
 
 ## Install
 
-**To get started quickly** on a fresh Ubuntu instance (e.g, Digital Ocean); [try this script](./scripts/quick-install-ubuntu.sh). **WARNING:** always review scripts prior to running them so that you know what is happening on your machine.
+**To get started quickly** on a fresh Ubuntu instance (e.g, Digital Ocean); [try this script](./scripts/quick-install-linux.sh). **WARNING:** always review scripts prior to running them so that you know what is happening on your machine.
 
 For any other installation, follow along below and **adapt these instructions based on the specifics of your system.**
 
@@ -16,6 +16,7 @@ Ensure that the following are already installed:
 - [Python3](https://wiki.python.org/moin/BeginnersGuide/Download): `python3 --version` >= `3.8.10` (the Python3 shipped in Ubuntu 20+ is good to go)
 - [Docker](https://docs.docker.com/get-docker/): `docker --version` >= `20.10.21`
 - [jq](https://stedolan.github.io/jq/download/): `jq --version` >= `1.5`
+- [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git): `git --version` >= `2.10.3`
 
 Note: if installing docker-compose via package manager on Linux (as opposed to Docker Desktop), you must [install the plugin](https://docs.docker.com/compose/install/linux/#install-the-plugin-manually), e.g. :
 
@@ -25,13 +26,13 @@ curl -SL https://github.com/docker/compose/releases/download/v2.11.2/docker-comp
 chmod +x ~/.docker/cli-plugins/docker-compose
 ```
 
-Next decide on a directory where you would like to put the stack-orchestrator program. Typically this would be 
+Next decide on a directory where you would like to put the stack-orchestrator program. Typically this would be
 a "user" binary directory such as `~/bin` or perhaps `/usr/local/laconic` or possibly just the current working directory.
 
-Now, having selected that directory, download the latest release from [this page](https://github.com/cerc-io/stack-orchestrator/tags) into it (we're using `~/bin` below for concreteness but edit to suit if you selected a different directory). Also be sure that the destination directory exists and is writable:
+Now, having selected that directory, download the latest release from [this page](https://git.vdb.to/cerc-io/stack-orchestrator/tags) into it (we're using `~/bin` below for concreteness but edit to suit if you selected a different directory). Also be sure that the destination directory exists and is writable:
 
 ```bash
-curl -L -o ~/bin/laconic-so https://github.com/cerc-io/stack-orchestrator/releases/latest/download/laconic-so
+curl -L -o ~/bin/laconic-so https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so
 ```
 
 Give it execute permissions:
@@ -48,15 +49,80 @@ Verify operation (your version will probably be different, just check here that
 laconic-so version
 Version: 1.1.0-7a607c2-202304260513
 ```
+Save the distribution url to `~/.laconic-so/config.yml`:
+```bash
+mkdir ~/.laconic-so
+echo "distribution-url: https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so" >  ~/.laconic-so/config.yml
+```
+
+### Update
+If Stack Orchestrator was installed using the process described above, it is able to subsequently self-update to the current latest version by running:
+
+```bash
+laconic-so update
+```
 
 ## Usage
 
-The various [stacks](/app/data/stacks) each contain instructions for running different stacks based on your use case. For example:
+The various [stacks](/stack_orchestrator/data/stacks) each contain instructions for running different stacks based on your use case. For example:
 
-- [self-hosted Gitea](/app/data/stacks/build-support)
-- [an Optimism Fixturenet](/app/data/stacks/fixturenet-optimism)
-- [laconicd with console and CLI](app/data/stacks/fixturenet-laconic-loaded)
-- [kubo (IPFS)](app/data/stacks/kubo)
+- [self-hosted Gitea](/stack_orchestrator/data/stacks/build-support)
+- [an Optimism Fixturenet](/stack_orchestrator/data/stacks/fixturenet-optimism)
+- [laconicd with console and CLI](stack_orchestrator/data/stacks/fixturenet-laconic-loaded)
+- [kubo (IPFS)](stack_orchestrator/data/stacks/kubo)
+
+## Deployment Types
+
+- **compose**: Docker Compose on local machine
+- **k8s**: External Kubernetes cluster (requires kubeconfig)
+- **k8s-kind**: Local Kubernetes via Kind - one cluster per host, shared by all deployments
+
+## External Stacks
+
+Stacks can live in external git repositories. Required structure:
+
+```
+<repo>/
+  stack_orchestrator/data/
+    stacks/<stack-name>/stack.yml
+    compose/docker-compose-<pod-name>.yml
+  deployment/spec.yml
+```
+
+## Deployment Commands
+
+```bash
+# Create deployment from spec
+laconic-so --stack <path> deploy create --spec-file <spec.yml> --deployment-dir <dir>
+
+# Start (creates cluster on first run)
+laconic-so deployment --dir <dir> start
+
+# GitOps restart (git pull + redeploy, preserves data)
+laconic-so deployment --dir <dir> restart
+
+# Stop
+laconic-so deployment --dir <dir> stop
+```
+
+## spec.yml Reference
+
+```yaml
+stack: stack-name-or-path
+deploy-to: k8s-kind
+network:
+  http-proxy:
+    - host-name: app.example.com
+      routes:
+        - path: /
+          proxy-to: service-name:port
+  acme-email: admin@example.com
+config:
+  ENV_VAR: value
+  SECRET_VAR: $generate:hex:32$   # Auto-generated, stored in K8s Secret
+volumes:
+  volume-name:
+```
 
 ## Contributing
 
@@ -65,5 +131,3 @@ See the [CONTRIBUTING.md](/docs/CONTRIBUTING.md) for developer mode install.
 ## Platform Support
 
 Native aarm64 is _not_ currently supported. x64 emulation on ARM64 macos should work (not yet tested).
-
-

STACK-CREATION-GUIDE.md

@@ -0,0 +1,413 @@
+# Implementing `laconic-so create-stack` Command
+
+A plan for adding a new CLI command to scaffold stack files automatically.
+
+---
+
+## Overview
+
+Add a `create-stack` command that generates all required files for a new stack:
+
+```bash
+laconic-so create-stack --name my-stack --type webapp
+```
+
+**Output:**
+```
+stack_orchestrator/data/
+├── stacks/my-stack/stack.yml
+├── container-build/cerc-my-stack/
+│   ├── Dockerfile
+│   └── build.sh
+└── compose/docker-compose-my-stack.yml
+
+Updated: repository-list.txt, container-image-list.txt, pod-list.txt
+```
+
+---
+
+## CLI Architecture Summary
+
+### Command Registration Pattern
+
+Commands are Click functions registered in `main.py`:
+
+```python
+# main.py (line ~70)
+from stack_orchestrator.create import create_stack
+cli.add_command(create_stack.command, "create-stack")
+```
+
+### Global Options Access
+
+```python
+from stack_orchestrator.opts import opts
+
+if not opts.o.quiet:
+    print("message")
+if opts.o.dry_run:
+    print("(would create files)")
+```
+
+### Key Utilities
+
+| Function | Location | Purpose |
+|----------|----------|---------|
+| `get_yaml()` | `util.py` | YAML parser (ruamel.yaml) |
+| `get_stack_path(stack)` | `util.py` | Resolve stack directory path |
+| `error_exit(msg)` | `util.py` | Print error and exit(1) |
+
+---
+
+## Files to Create
+
+### 1. Command Module
+
+**`stack_orchestrator/create/__init__.py`**
+```python
+# Empty file to make this a package
+```
+
+**`stack_orchestrator/create/create_stack.py`**
+```python
+import click
+import os
+from pathlib import Path
+from shutil import copy
+from stack_orchestrator.opts import opts
+from stack_orchestrator.util import error_exit, get_yaml
+
+# Template types
+STACK_TEMPLATES = {
+    "webapp": {
+        "description": "Web application with Node.js",
+        "base_image": "node:20-bullseye-slim",
+        "port": 3000,
+    },
+    "service": {
+        "description": "Backend service",
+        "base_image": "python:3.11-slim",
+        "port": 8080,
+    },
+    "empty": {
+        "description": "Minimal stack with no defaults",
+        "base_image": None,
+        "port": None,
+    },
+}
+
+
+def get_data_dir() -> Path:
+    """Get path to stack_orchestrator/data directory"""
+    return Path(__file__).absolute().parent.parent.joinpath("data")
+
+
+def validate_stack_name(name: str) -> None:
+    """Validate stack name follows conventions"""
+    import re
+    if not re.match(r'^[a-z0-9][a-z0-9-]*[a-z0-9]$', name) and len(name) > 2:
+        error_exit(f"Invalid stack name '{name}'. Use lowercase alphanumeric with hyphens.")
+    if name.startswith("cerc-"):
+        error_exit("Stack name should not start with 'cerc-' (container names will add this prefix)")
+
+
+def create_stack_yml(stack_dir: Path, name: str, template: dict, repo_url: str) -> None:
+    """Create stack.yml file"""
+    config = {
+        "version": "1.2",
+        "name": name,
+        "description": template.get("description", f"Stack: {name}"),
+        "repos": [repo_url] if repo_url else [],
+        "containers": [f"cerc/{name}"],
+        "pods": [name],
+    }
+
+    stack_dir.mkdir(parents=True, exist_ok=True)
+    with open(stack_dir / "stack.yml", "w") as f:
+        get_yaml().dump(config, f)
+
+
+def create_dockerfile(container_dir: Path, name: str, template: dict) -> None:
+    """Create Dockerfile"""
+    base_image = template.get("base_image", "node:20-bullseye-slim")
+    port = template.get("port", 3000)
+
+    dockerfile_content = f'''# Build stage
+FROM {base_image} AS builder
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+# Production stage
+FROM {base_image}
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY --from=builder /app/dist ./dist
+
+EXPOSE {port}
+CMD ["npm", "run", "start"]
+'''
+
+    container_dir.mkdir(parents=True, exist_ok=True)
+    with open(container_dir / "Dockerfile", "w") as f:
+        f.write(dockerfile_content)
+
+
+def create_build_script(container_dir: Path, name: str) -> None:
+    """Create build.sh script"""
+    build_script = f'''#!/usr/bin/env bash
+# Build cerc/{name}
+
+source ${{CERC_CONTAINER_BASE_DIR}}/build-base.sh
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${{BASH_SOURCE[0]}}" )" &> /dev/null && pwd )
+
+docker build -t cerc/{name}:local \\
+    -f ${{SCRIPT_DIR}}/Dockerfile \\
+    ${{build_command_args}} \\
+    ${{CERC_REPO_BASE_DIR}}/{name}
+'''
+
+    build_path = container_dir / "build.sh"
+    with open(build_path, "w") as f:
+        f.write(build_script)
+
+    # Make executable
+    os.chmod(build_path, 0o755)
+
+
+def create_compose_file(compose_dir: Path, name: str, template: dict) -> None:
+    """Create docker-compose file"""
+    port = template.get("port", 3000)
+
+    compose_content = {
+        "version": "3.8",
+        "services": {
+            name: {
+                "image": f"cerc/{name}:local",
+                "restart": "unless-stopped",
+                "ports": [f"${{HOST_PORT:-{port}}}:{port}"],
+                "environment": {
+                    "NODE_ENV": "${NODE_ENV:-production}",
+                },
+            }
+        }
+    }
+
+    with open(compose_dir / f"docker-compose-{name}.yml", "w") as f:
+        get_yaml().dump(compose_content, f)
+
+
+def update_list_file(data_dir: Path, filename: str, entry: str) -> None:
+    """Add entry to a list file if not already present"""
+    list_path = data_dir / filename
+
+    # Read existing entries
+    existing = set()
+    if list_path.exists():
+        with open(list_path, "r") as f:
+            existing = set(line.strip() for line in f if line.strip())
+
+    # Add new entry
+    if entry not in existing:
+        with open(list_path, "a") as f:
+            f.write(f"{entry}\n")
+
+
+@click.command()
+@click.option("--name", required=True, help="Name of the new stack (lowercase, hyphens)")
+@click.option("--type", "stack_type", default="webapp",
+              type=click.Choice(list(STACK_TEMPLATES.keys())),
+              help="Stack template type")
+@click.option("--repo", help="Git repository URL (e.g., github.com/org/repo)")
+@click.option("--force", is_flag=True, help="Overwrite existing files")
+@click.pass_context
+def command(ctx, name: str, stack_type: str, repo: str, force: bool):
+    """Create a new stack with all required files.
+
+    Examples:
+
+        laconic-so create-stack --name my-app --type webapp
+
+        laconic-so create-stack --name my-service --type service --repo github.com/org/repo
+    """
+    # Validate
+    validate_stack_name(name)
+
+    template = STACK_TEMPLATES[stack_type]
+    data_dir = get_data_dir()
+
+    # Define paths
+    stack_dir = data_dir / "stacks" / name
+    container_dir = data_dir / "container-build" / f"cerc-{name}"
+    compose_dir = data_dir / "compose"
+
+    # Check for existing files
+    if not force:
+        if stack_dir.exists():
+            error_exit(f"Stack already exists: {stack_dir}\nUse --force to overwrite")
+        if container_dir.exists():
+            error_exit(f"Container build dir exists: {container_dir}\nUse --force to overwrite")
+
+    # Dry run check
+    if opts.o.dry_run:
+        print(f"Would create stack '{name}' with template '{stack_type}':")
+        print(f"  - {stack_dir}/stack.yml")
+        print(f"  - {container_dir}/Dockerfile")
+        print(f"  - {container_dir}/build.sh")
+        print(f"  - {compose_dir}/docker-compose-{name}.yml")
+        print(f"  - Update repository-list.txt")
+        print(f"  - Update container-image-list.txt")
+        print(f"  - Update pod-list.txt")
+        return
+
+    # Create files
+    if not opts.o.quiet:
+        print(f"Creating stack '{name}' with template '{stack_type}'...")
+
+    create_stack_yml(stack_dir, name, template, repo)
+    if opts.o.verbose:
+        print(f"  Created {stack_dir}/stack.yml")
+
+    create_dockerfile(container_dir, name, template)
+    if opts.o.verbose:
+        print(f"  Created {container_dir}/Dockerfile")
+
+    create_build_script(container_dir, name)
+    if opts.o.verbose:
+        print(f"  Created {container_dir}/build.sh")
+
+    create_compose_file(compose_dir, name, template)
+    if opts.o.verbose:
+        print(f"  Created {compose_dir}/docker-compose-{name}.yml")
+
+    # Update list files
+    if repo:
+        update_list_file(data_dir, "repository-list.txt", repo)
+        if opts.o.verbose:
+            print(f"  Added {repo} to repository-list.txt")
+
+    update_list_file(data_dir, "container-image-list.txt", f"cerc/{name}")
+    if opts.o.verbose:
+        print(f"  Added cerc/{name} to container-image-list.txt")
+
+    update_list_file(data_dir, "pod-list.txt", name)
+    if opts.o.verbose:
+        print(f"  Added {name} to pod-list.txt")
+
+    # Summary
+    if not opts.o.quiet:
+        print(f"\nStack '{name}' created successfully!")
+        print(f"\nNext steps:")
+        print(f"  1. Edit {stack_dir}/stack.yml")
+        print(f"  2. Customize {container_dir}/Dockerfile")
+        print(f"  3. Run: laconic-so --stack {name} build-containers")
+        print(f"  4. Run: laconic-so --stack {name} deploy-system up")
+```
+
+### 2. Register Command in main.py
+
+**Edit `stack_orchestrator/main.py`**
+
+Add import:
+```python
+from stack_orchestrator.create import create_stack
+```
+
+Add command registration (after line ~78):
+```python
+cli.add_command(create_stack.command, "create-stack")
+```
+
+---
+
+## Implementation Steps
+
+### Step 1: Create module structure
+```bash
+mkdir -p stack_orchestrator/create
+touch stack_orchestrator/create/__init__.py
+```
+
+### Step 2: Create the command file
+Create `stack_orchestrator/create/create_stack.py` with the code above.
+
+### Step 3: Register in main.py
+Add the import and `cli.add_command()` line.
+
+### Step 4: Test the command
+```bash
+# Show help
+laconic-so create-stack --help
+
+# Dry run
+laconic-so --dry-run create-stack --name test-app --type webapp
+
+# Create a stack
+laconic-so create-stack --name test-app --type webapp --repo github.com/org/test-app
+
+# Verify
+ls -la stack_orchestrator/data/stacks/test-app/
+cat stack_orchestrator/data/stacks/test-app/stack.yml
+```
+
+---
+
+## Template Types
+
+| Type | Base Image | Port | Use Case |
+|------|------------|------|----------|
+| `webapp` | node:20-bullseye-slim | 3000 | React/Vue/Next.js apps |
+| `service` | python:3.11-slim | 8080 | Python backend services |
+| `empty` | none | none | Custom from scratch |
+
+---
+
+## Future Enhancements
+
+1. **Interactive mode** - Prompt for values if not provided
+2. **More templates** - Go, Rust, database stacks
+3. **Template from existing** - `--from-stack existing-stack`
+4. **External stack support** - Create in custom directory
+5. **Validation command** - `laconic-so validate-stack --name my-stack`
+
+---
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `stack_orchestrator/create/__init__.py` | New (empty) |
+| `stack_orchestrator/create/create_stack.py` | New (command implementation) |
+| `stack_orchestrator/main.py` | Add import and `cli.add_command()` |
+
+---
+
+## Verification
+
+```bash
+# 1. Command appears in help
+laconic-so --help | grep create-stack
+
+# 2. Dry run works
+laconic-so --dry-run create-stack --name verify-test --type webapp
+
+# 3. Full creation works
+laconic-so create-stack --name verify-test --type webapp
+ls stack_orchestrator/data/stacks/verify-test/
+ls stack_orchestrator/data/container-build/cerc-verify-test/
+ls stack_orchestrator/data/compose/docker-compose-verify-test.yml
+
+# 4. Build works
+laconic-so --stack verify-test build-containers
+
+# 5. Cleanup
+rm -rf stack_orchestrator/data/stacks/verify-test
+rm -rf stack_orchestrator/data/container-build/cerc-verify-test
+rm stack_orchestrator/data/compose/docker-compose-verify-test.yml
+```

TODO.md

@@ -0,0 +1,16 @@
+# TODO
+
+## Features Needed
+
+### Update Stack Command
+We need an "update stack" command in stack orchestrator and cleaner documentation regarding how to do continuous deployment with and without payments.
+
+**Context**: Currently, `deploy init` generates a spec file and `deploy create` creates a deployment directory. The `deployment update` command (added by Thomas Lackey) only syncs env vars and restarts - it doesn't regenerate configurations. There's a gap in the workflow for updating stack configurations after initial deployment.
+
+## Architecture Refactoring
+
+### Separate Deployer from Stack Orchestrator CLI
+The deployer logic should be decoupled from the CLI tool to allow independent development and reuse.
+
+### Separate Stacks from Stack Orchestrator Repo
+Stacks should live in their own repositories, not bundled with the orchestrator tool. This allows stacks to evolve independently and be maintained by different teams.

app/build_containers.py

@@ -1,142 +0,0 @@
-# Copyright © 2022, 2023 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-# Builds or pulls containers for the system components
-
-# env vars:
-# CERC_REPO_BASE_DIR defaults to ~/cerc
-
-# TODO: display the available list of containers; allow re-build of either all or specific containers
-
-import os
-import sys
-from decouple import config
-import subprocess
-import click
-import importlib.resources
-from pathlib import Path
-from .util import include_exclude_check, get_parsed_stack_config
-from .base import get_npm_registry_url
-
-# TODO: find a place for this
-#    epilog="Config provided either in .env or settings.ini or env vars: CERC_REPO_BASE_DIR (defaults to ~/cerc)"
-
-
-@click.command()
-@click.option('--include', help="only build these containers")
-@click.option('--exclude', help="don\'t build these containers")
-@click.option("--force-rebuild", is_flag=True, default=False, help="Override dependency checking -- always rebuild")
-@click.option("--extra-build-args", help="Supply extra arguments to build")
-@click.pass_context
-def command(ctx, include, exclude, force_rebuild, extra_build_args):
-    '''build the set of containers required for a complete stack'''
-
-    quiet = ctx.obj.quiet
-    verbose = ctx.obj.verbose
-    dry_run = ctx.obj.dry_run
-    debug = ctx.obj.debug
-    local_stack = ctx.obj.local_stack
-    stack = ctx.obj.stack
-    continue_on_error = ctx.obj.continue_on_error
-
-    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-    container_build_dir = Path(__file__).absolute().parent.joinpath("data", "container-build")
-
-    if local_stack:
-        dev_root_path = os.getcwd()[0:os.getcwd().rindex("stack-orchestrator")]
-        print(f'Local stack dev_root_path (CERC_REPO_BASE_DIR) overridden to: {dev_root_path}')
-    else:
-        dev_root_path = os.path.expanduser(config("CERC_REPO_BASE_DIR", default="~/cerc"))
-
-    if not quiet:
-        print(f'Dev Root is: {dev_root_path}')
-
-    if not os.path.isdir(dev_root_path):
-        print('Dev root directory doesn\'t exist, creating')
-
-    # See: https://stackoverflow.com/a/20885799/1701505
-    from . import data
-    with importlib.resources.open_text(data, "container-image-list.txt") as container_list_file:
-        all_containers = container_list_file.read().splitlines()
-
-    containers_in_scope = []
-    if stack:
-        stack_config = get_parsed_stack_config(stack)
-        containers_in_scope = stack_config['containers']
-    else:
-        containers_in_scope = all_containers
-
-    if verbose:
-        print(f'Containers: {containers_in_scope}')
-        if stack:
-            print(f"Stack: {stack}")
-
-    # TODO: make this configurable
-    container_build_env = {
-        "CERC_NPM_REGISTRY_URL": get_npm_registry_url(),
-        "CERC_NPM_AUTH_TOKEN": config("CERC_NPM_AUTH_TOKEN", default=""),
-        "CERC_REPO_BASE_DIR": dev_root_path,
-        "CERC_CONTAINER_BASE_DIR": container_build_dir,
-        "CERC_HOST_UID": f"{os.getuid()}",
-        "CERC_HOST_GID": f"{os.getgid()}",
-        "DOCKER_BUILDKIT": config("DOCKER_BUILDKIT", default="0")
-    }
-    container_build_env.update({"CERC_SCRIPT_DEBUG": "true"} if debug else {})
-    container_build_env.update({"CERC_FORCE_REBUILD": "true"} if force_rebuild else {})
-    container_build_env.update({"CERC_CONTAINER_EXTRA_BUILD_ARGS": extra_build_args} if extra_build_args else {})
-    docker_host_env = os.getenv("DOCKER_HOST")
-    if docker_host_env:
-        container_build_env.update({"DOCKER_HOST": docker_host_env})
-
-    def process_container(container):
-        if not quiet:
-            print(f"Building: {container}")
-        build_dir = os.path.join(container_build_dir, container.replace("/", "-"))
-        build_script_filename = os.path.join(build_dir, "build.sh")
-        if verbose:
-            print(f"Build script filename: {build_script_filename}")
-        if os.path.exists(build_script_filename):
-            build_command = build_script_filename
-        else:
-            if verbose:
-                print(f"No script file found: {build_script_filename}, using default build script")
-            repo_dir = container.split('/')[1]
-            # TODO: make this less of a hack -- should be specified in some metadata somewhere
-            # Check if we have a repo for this container. If not, set the context dir to the container-build subdir
-            repo_full_path = os.path.join(dev_root_path, repo_dir)
-            repo_dir_or_build_dir = repo_full_path if os.path.exists(repo_full_path) else build_dir
-            build_command = os.path.join(container_build_dir, "default-build.sh") + f" {container}:local {repo_dir_or_build_dir}"
-        if not dry_run:
-            if verbose:
-                print(f"Executing: {build_command} with environment: {container_build_env}")
-            build_result = subprocess.run(build_command, shell=True, env=container_build_env)
-            if verbose:
-                print(f"Return code is: {build_result.returncode}")
-            if build_result.returncode != 0:
-                print(f"Error running build for {container}")
-                if not continue_on_error:
-                    print("FATAL Error: container build failed and --continue-on-error not set, exiting")
-                    sys.exit(1)
-                else:
-                    print("****** Container Build Error, continuing because --continue-on-error is set")
-        else:
-            print("Skipped")
-
-    for container in containers_in_scope:
-        if include_exclude_check(container, include, exclude):
-            process_container(container)
-        else:
-            if verbose:
-                print(f"Excluding: {container}")

app/data/compose/docker-compose-kubo.yml

@@ -1,13 +0,0 @@
-version: "3.2"
-# See: https://docs.ipfs.tech/install/run-ipfs-inside-docker/#set-up
-services:
-  ipfs:
-    image: ipfs/kubo:master-2023-02-20-714a968
-    restart: always
-    volumes:
-      - ./ipfs/import:/import
-      - ./ipfs/data:/data/ipfs
-    ports:
-      - "0.0.0.0:8080:8080"
-      - "0.0.0.0:4001:4001"
-      - "0.0.0.0:5001:5001"

app/data/compose/docker-compose-watcher-azimuth.yml

@@ -1,304 +0,0 @@
-version: '3.2'
-
-services:
-  # Starts the PostgreSQL database for watchers
-  watcher-db:
-    restart: unless-stopped
-    image: postgres:14-alpine
-    environment:
-      - POSTGRES_USER=vdbm
-      - POSTGRES_MULTIPLE_DATABASES=azimuth-watcher,azimuth-watcher-job-queue,censures-watcher,censures-watcher-job-queue,claims-watcher,claims-watcher-job-queue,conditional-star-release-watcher,conditional-star-release-watcher-job-queue,delegated-sending-watcher,delegated-sending-watcher-job-queue,ecliptic-watcher,ecliptic-watcher-job-queue,linear-star-release-watcher,linear-star-release-watcher-job-queue,polls-watcher,polls-watcher-job-queue
-      - POSTGRES_EXTENSION=azimuth-watcher-job-queue:pgcrypto,censures-watcher-job-queue:pgcrypto,claims-watcher-job-queue:pgcrypto,conditional-star-release-watcher-job-queue:pgcrypto,delegated-sending-watcher-job-queue:pgcrypto,ecliptic-watcher-job-queue:pgcrypto,linear-star-release-watcher-job-queue:pgcrypto,polls-watcher-job-queue:pgcrypto,
-      - POSTGRES_PASSWORD=password
-    volumes:
-      - ../config/postgresql/multiple-postgressql-databases.sh:/docker-entrypoint-initdb.d/multiple-postgressql-databases.sh
-      - watcher_db_data:/var/lib/postgresql/data
-    ports:
-      - "0.0.0.0:15432:5432"
-    healthcheck:
-      test: ["CMD", "nc", "-v", "localhost", "5432"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 10s
-
-  # Starts the azimuth-watcher server
-  azimuth-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/azimuth-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/azimuth-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/azimuth-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/azimuth-watcher/start-server.sh
-    ports:
-      - "3001"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3001"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the censures-watcher server
-  censures-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/censures-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/censures-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/censures-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/censures-watcher/start-server.sh
-    ports:
-      - "3002"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3002"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the claims-watcher server
-  claims-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/claims-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/claims-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/claims-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/claims-watcher/start-server.sh
-    ports:
-      - "3003"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3003"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the conditional-star-release-watcher server
-  conditional-star-release-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/conditional-star-release-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/conditional-star-release-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/conditional-star-release-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/conditional-star-release-watcher/start-server.sh
-    ports:
-      - "3004"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3004"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the delegated-sending-watcher server
-  delegated-sending-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/delegated-sending-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/delegated-sending-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/delegated-sending-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/delegated-sending-watcher/start-server.sh
-    ports:
-      - "3005"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3005"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the ecliptic-watcher server
-  ecliptic-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/ecliptic-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/ecliptic-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/ecliptic-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/ecliptic-watcher/start-server.sh
-    ports:
-      - "3006"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3006"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the linear-star-release-watcher server
-  linear-star-release-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/linear-star-release-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/linear-star-release-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/linear-star-release-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/linear-star-release-watcher/start-server.sh
-    ports:
-      - "3007"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3007"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the polls-watcher server
-  polls-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/polls-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/polls-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/polls-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/polls-watcher/start-server.sh
-    ports:
-      - "3008"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3008"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the gateway-server for proxying queries
-  gateway-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      azimuth-watcher-server:
-        condition: service_healthy
-      censures-watcher-server:
-        condition: service_healthy
-      claims-watcher-server:
-        condition: service_healthy
-      conditional-star-release-watcher-server:
-        condition: service_healthy
-      delegated-sending-watcher-server:
-        condition: service_healthy
-      ecliptic-watcher-server:
-        condition: service_healthy
-      linear-star-release-watcher-server:
-        condition: service_healthy
-      polls-watcher-server:
-        condition: service_healthy
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-    working_dir: /app/packages/gateway-server
-    command: "yarn server"
-    volumes:
-      - ../config/watcher-azimuth/gateway-watchers.json:/app/packages/gateway-server/dist/watchers.json
-    ports:
-      - "0.0.0.0:4000:4000"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "4000"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-volumes:
-  watcher_db_data:

app/data/config/fixturenet-laconicd/create-fixturenet.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-# TODO: this file is now an unmodified copy of cerc-io/laconicd/init.sh
-# so we should have a mechanism to bundle it inside the container rather than link from here
-# at deploy time.
-
-KEY="mykey"
-CHAINID="laconic_9000-1"
-MONIKER="localtestnet"
-KEYRING="test"
-KEYALGO="eth_secp256k1"
-LOGLEVEL="info"
-# trace evm
-TRACE="--trace"
-# TRACE=""
-
-# validate dependencies are installed
-command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; }
-
-# remove existing daemon and client
-rm -rf ~/.laconic*
-
-make install
-
-laconicd config keyring-backend $KEYRING
-laconicd config chain-id $CHAINID
-
-# if $KEY exists it should be deleted
-laconicd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO
-
-# Set moniker and chain-id for Ethermint (Moniker can be anything, chain-id must be an integer)
-laconicd init $MONIKER --chain-id $CHAINID
-
-# Change parameter token denominations to aphoton
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["staking"]["params"]["bond_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["crisis"]["constant_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["mint"]["params"]["mint_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-# Custom modules
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commit_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveal_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_minimum_bid"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-if [[ "$TEST_REGISTRY_EXPIRY" == "true" ]]; then
-  echo "Setting timers for expiry tests."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-if [[ "$TEST_AUCTION_ENABLED" == "true" ]]; then
-  echo "Enabling auction and setting timers."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_enabled"]=true' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="300s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commits_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveals_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-# increase block time (?)
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["time_iota_ms"]="1000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# Set gas limit in genesis
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["max_gas"]="10000000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# disable produce empty block
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-  else
-    sed -i 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-fi
-
-if [[ $1 == "pending" ]]; then
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-      sed -i '' 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  else
-      sed -i 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  fi
-fi
-
-# Allocate genesis accounts (cosmos formatted addresses)
-laconicd add-genesis-account $KEY 100000000000000000000000000aphoton --keyring-backend $KEYRING
-
-# Sign genesis transaction
-laconicd gentx $KEY 1000000000000000000000aphoton --keyring-backend $KEYRING --chain-id $CHAINID
-
-# Collect genesis tx
-laconicd collect-gentxs
-
-# Run this to ensure everything worked and that the genesis file is setup correctly
-laconicd validate-genesis
-
-if [[ $1 == "pending" ]]; then
-  echo "pending mode is on, please wait for the first block committed."
-fi
-
-# Start the node (remove the --pruning=nothing flag if historical queries are not needed)
-laconicd start --pruning=nothing --evm.tracer=json $TRACE --log_level $LOGLEVEL --minimum-gas-prices=0.0001aphoton --json-rpc.api eth,txpool,personal,net,debug,web3,miner --api.enable --gql-server --gql-playground

app/data/config/fixturenet-lotus/genesis/.genesis-sectors/cache/s-t01000-0/p_aux

@@ -1 +0,0 @@
-}+V�{iνΆΠΉ�²�¨ΣΗ\k»qς␍—?δΪAΒfκ’~μ©™LΉ�tb
·yqτ·²ηξΔ�Ο?ξaΣ�J

app/data/config/fixturenet-lotus/genesis/.genesis-sectors/cache/s-t01000-0/sc-02-data-tree-r-last.dat

@@ -1 +0,0 @@
-Βfκ’~μ©™LΉ�tb
·yqτ·²ηξΔ�Ο?ξaΣ�J

app/data/config/fixturenet-lotus/genesis/.genesis-sectors/pre-seal-t01000.json

@@ -1,71 +0,0 @@
-{
-  "t01000": {
-    "ID": "t01000",
-    "Owner": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-    "Worker": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-    "PeerId": "12D3KooWG5q6pWJVdPBhDBv9AjWVbUh4xxTAZ7xvgZSjczWuD2Z9",
-    "MarketBalance": "0",
-    "PowerBalance": "0",
-    "SectorSize": 2048,
-    "Sectors": [
-      {
-        "CommR": {
-          "/": "bagboea4b5abcboxypcewlkmrat2myu4vthk3ii2pcomak7nhqmdbb6sxlolp2wdf"
-        },
-        "CommD": {
-          "/": "baga6ea4seaqn3jfixthmdgksv4vhfeuyvr6upw6tvaqbmzmsyxnzosm4pwgnmlq"
-        },
-        "SectorID": 0,
-        "Deal": {
-          "PieceCID": {
-            "/": "baga6ea4seaqn3jfixthmdgksv4vhfeuyvr6upw6tvaqbmzmsyxnzosm4pwgnmlq"
-          },
-          "PieceSize": 2048,
-          "VerifiedDeal": false,
-          "Client": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-          "Provider": "t01000",
-          "Label": "0",
-          "StartEpoch": 0,
-          "EndEpoch": 9001,
-          "StoragePricePerEpoch": "0",
-          "ProviderCollateral": "0",
-          "ClientCollateral": "0"
-        },
-        "DealClientKey": {
-          "Type": "bls",
-          "PrivateKey": "tFvSRiSg2G3Ssgg0PSYy23XyjaIMXpsmdyG2B7UFLT4="
-        },
-        "ProofType": 5
-      },
-      {
-        "CommR": {
-          "/": "bagboea4b5abcb6krzypqcczhcnbeyjcqkeo6omfergm336o3kitugh3jgjog2yqq"
-        },
-        "CommD": {
-          "/": "baga6ea4seaqhondpb2373hjasjplxvbjzi5n5mm4fbbhjxp5ptnbq4cibapkeii"
-        },
-        "SectorID": 1,
-        "Deal": {
-          "PieceCID": {
-            "/": "baga6ea4seaqhondpb2373hjasjplxvbjzi5n5mm4fbbhjxp5ptnbq4cibapkeii"
-          },
-          "PieceSize": 2048,
-          "VerifiedDeal": false,
-          "Client": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-          "Provider": "t01000",
-          "Label": "1",
-          "StartEpoch": 0,
-          "EndEpoch": 9001,
-          "StoragePricePerEpoch": "0",
-          "ProviderCollateral": "0",
-          "ClientCollateral": "0"
-        },
-        "DealClientKey": {
-          "Type": "bls",
-          "PrivateKey": "tFvSRiSg2G3Ssgg0PSYy23XyjaIMXpsmdyG2B7UFLT4="
-        },
-        "ProofType": 5
-      }
-    ]
-  }
-}

app/data/config/fixturenet-lotus/genesis/.genesis-sectors/pre-seal-t01000.key

@@ -1 +0,0 @@
-7b2254797065223a22626c73222c22507269766174654b6579223a227446765352695367324733537367673050535979323358796a61494d5870736d64794732423755464c54343d227d

app/data/config/fixturenet-lotus/genesis/.genesis-sectors/sectorstore.json

@@ -1,11 +0,0 @@
-{
-  "ID": "f355523e-69d0-4984-bd0e-9588487c6231",
-  "Weight": 0,
-  "CanSeal": false,
-  "CanStore": false,
-  "MaxStorage": 0,
-  "Groups": null,
-  "AllowTo": null,
-  "AllowTypes": null,
-  "DenyTypes": null
-}

app/data/config/fixturenet-lotus/genesis/localnet.json

@@ -1,108 +0,0 @@
-{
-  "NetworkVersion": 18,
-  "Accounts": [
-    {
-      "Type": "account",
-      "Balance": "50000000000000000000000000",
-      "Meta": {
-        "Owner": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q"
-      }
-    }
-  ],
-  "Miners": [
-    {
-      "ID": "t01000",
-      "Owner": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-      "Worker": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-      "PeerId": "12D3KooWG5q6pWJVdPBhDBv9AjWVbUh4xxTAZ7xvgZSjczWuD2Z9",
-      "MarketBalance": "0",
-      "PowerBalance": "0",
-      "SectorSize": 2048,
-      "Sectors": [
-        {
-          "CommR": {
-            "/": "bagboea4b5abcboxypcewlkmrat2myu4vthk3ii2pcomak7nhqmdbb6sxlolp2wdf"
-          },
-          "CommD": {
-            "/": "baga6ea4seaqn3jfixthmdgksv4vhfeuyvr6upw6tvaqbmzmsyxnzosm4pwgnmlq"
-          },
-          "SectorID": 0,
-          "Deal": {
-            "PieceCID": {
-              "/": "baga6ea4seaqn3jfixthmdgksv4vhfeuyvr6upw6tvaqbmzmsyxnzosm4pwgnmlq"
-            },
-            "PieceSize": 2048,
-            "VerifiedDeal": false,
-            "Client": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-            "Provider": "t01000",
-            "Label": "0",
-            "StartEpoch": 0,
-            "EndEpoch": 9001,
-            "StoragePricePerEpoch": "0",
-            "ProviderCollateral": "0",
-            "ClientCollateral": "0"
-          },
-          "DealClientKey": {
-            "Type": "bls",
-            "PrivateKey": "tFvSRiSg2G3Ssgg0PSYy23XyjaIMXpsmdyG2B7UFLT4="
-          },
-          "ProofType": 5
-        },
-        {
-          "CommR": {
-            "/": "bagboea4b5abcb6krzypqcczhcnbeyjcqkeo6omfergm336o3kitugh3jgjog2yqq"
-          },
-          "CommD": {
-            "/": "baga6ea4seaqhondpb2373hjasjplxvbjzi5n5mm4fbbhjxp5ptnbq4cibapkeii"
-          },
-          "SectorID": 1,
-          "Deal": {
-            "PieceCID": {
-              "/": "baga6ea4seaqhondpb2373hjasjplxvbjzi5n5mm4fbbhjxp5ptnbq4cibapkeii"
-            },
-            "PieceSize": 2048,
-            "VerifiedDeal": false,
-            "Client": "t3spusn5ia57qezc3fwpe3n2lhb4y4xt67xoflqbqy2muliparw2uktevletuv7gl4qakjpafgcl7jk2s2er3q",
-            "Provider": "t01000",
-            "Label": "1",
-            "StartEpoch": 0,
-            "EndEpoch": 9001,
-            "StoragePricePerEpoch": "0",
-            "ProviderCollateral": "0",
-            "ClientCollateral": "0"
-          },
-          "DealClientKey": {
-            "Type": "bls",
-            "PrivateKey": "tFvSRiSg2G3Ssgg0PSYy23XyjaIMXpsmdyG2B7UFLT4="
-          },
-          "ProofType": 5
-        }
-      ]
-    }
-  ],
-  "NetworkName": "localnet-6d52dae5-ff29-4bac-a45d-f84e6c07564c",
-  "VerifregRootKey": {
-    "Type": "multisig",
-    "Balance": "0",
-    "Meta": {
-      "Signers": [
-        "t1ceb34gnsc6qk5dt6n7xg6ycwzasjhbxm3iylkiy"
-      ],
-      "Threshold": 1,
-      "VestingDuration": 0,
-      "VestingStart": 0
-    }
-  },
-  "RemainderAccount": {
-    "Type": "multisig",
-    "Balance": "0",
-    "Meta": {
-      "Signers": [
-        "t1ceb34gnsc6qk5dt6n7xg6ycwzasjhbxm3iylkiy"
-      ],
-      "Threshold": 1,
-      "VestingDuration": 0,
-      "VestingStart": 0
-    }
-  }
-}

app/data/config/fixturenet-lotus/lotus-env.env

@@ -1,5 +0,0 @@
-LOTUS_PATH=~/.lotus-local-net
-LOTUS_MINER_PATH=~/.lotus-miner-local-net
-LOTUS_SKIP_GENESIS_CHECK=_yes_
-CGO_CFLAGS_ALLOW="-D__BLST_PORTABLE__"
-CGO_CFLAGS="-D__BLST_PORTABLE__"

app/data/config/fixturenet-lotus/setup-miner.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-lotus --version
-
-# # remove old bootnode peer info if present
-# [ -f /root/.lotus-shared/miner.addr ] && rm /root/.lotus-shared/miner.addr
-
-##TODO: generate genesis files inside container instead of bundling in config dir
-##something like commands below should work, other scripts/compose will have to be updated to corresponding directories
-# lotus fetch-params 2048
-# lotus-seed pre-seal --sector-size 2KiB --num-sectors 2
-# lotus-seed genesis new localnet.json
-# lotus-seed genesis add-miner localnet.json ~/.genesis-sectors/pre-seal-t01000.json
-
-
-# start daemon
-nohup lotus daemon  --genesis=/devgen.car --profile=bootstrapper --bootstrap=false > /var/log/lotus.log 2>&1 &
-
-# Loop until the daemon is started
-echo "Waiting for daemon to start..."
-while ! grep -q "started ChainNotify channel" /var/log/lotus.log ; do
-    sleep 5
-done
-echo "Daemon started."
-
-# publish bootnode peer info to shared volume
-lotus net listen | awk 'NR==1{print}' > /root/.lotus-shared/miner.addr
-
-# if miner not already initialized
-if [ ! -d /root/.lotus-miner-local-net ]; then
-  # initialize miner
-  lotus wallet import --as-default ~/.genesis-sectors/pre-seal-t01000.key
-  lotus-miner init --genesis-miner --actor=t01000 --sector-size=2KiB --pre-sealed-sectors=~/.genesis-sectors --pre-sealed-metadata=~/.genesis-sectors/pre-seal-t01000.json --nosync
-fi
-
-# start miner
-nohup lotus-miner run --nosync &
-
-tail -f /dev/null

app/data/config/fixturenet-lotus/setup-node.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-lotus --version
-
-##TODO: paths can use values from lotus-env.env file
-
-# if not already initialized
-if [ ! -f /root/.lotus-local-net/config.toml ]; then
-  # init node config
-  mkdir $HOME/.lotus-local-net
-  lotus config default > $HOME/.lotus-local-net/config.toml
-
-  # add bootstrap peer info if available
-  if [ -f /root/.lotus-shared/miner.addr ]; then
-    MINER_ADDR=\"$(cat /root/.lotus-shared/miner.addr)\"
-    # add bootstrap peer id to config file
-    sed -i "/^\[Libp2p\]/a \ \ BootstrapPeers = [$MINER_ADDR]" $HOME/.lotus-local-net/config.toml
-  else
-    echo "Bootstrap peer info not found, unable to configure. Manual peering will be required."
-  fi
-fi
-
-# start node
-lotus daemon --genesis=/devgen.car

app/data/config/fixturenet-optimism/generate-l2-config.sh

@@ -1,37 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-# Check existing config if it exists
-if [ -f /app/jwt.txt ] && [ -f /app/rollup.json ]; then
-  echo "Found existing L2 config, cross-checking with L1 deployment config"
-
-  SOURCE_L1_CONF=$(cat /contracts-bedrock/deploy-config/getting-started.json)
-  EXP_L1_BLOCKHASH=$(echo "$SOURCE_L1_CONF" | jq -r '.l1StartingBlockTag')
-  EXP_BATCHER=$(echo "$SOURCE_L1_CONF" | jq -r '.batchSenderAddress')
-
-  GEN_L2_CONF=$(cat /app/rollup.json)
-  GEN_L1_BLOCKHASH=$(echo "$GEN_L2_CONF" | jq -r '.genesis.l1.hash')
-  GEN_BATCHER=$(echo "$GEN_L2_CONF" | jq -r '.genesis.system_config.batcherAddr')
-
-  if [ "$EXP_L1_BLOCKHASH" = "$GEN_L1_BLOCKHASH" ] && [ "$EXP_BATCHER" = "$GEN_BATCHER" ]; then
-    echo "Config cross-checked, exiting"
-    exit 0
-  fi
-
-  echo "Existing L2 config doesn't match the L1 deployment config, please clear L2 config volume before starting"
-  exit 1
-fi
-
-op-node genesis l2 \
-  --deploy-config /contracts-bedrock/deploy-config/getting-started.json \
-  --deployment-dir /contracts-bedrock/deployments/getting-started/ \
-  --outfile.l2 /app/genesis.json \
-  --outfile.rollup /app/rollup.json \
-  --l1-rpc $CERC_L1_RPC
-
-openssl rand -hex 32 > /app/jwt.txt

app/data/config/fixturenet-optimism/optimism-contracts/run.sh

@@ -1,131 +0,0 @@
-#!/bin/bash
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_CHAIN_ID="${CERC_L1_CHAIN_ID:-${DEFAULT_CERC_L1_CHAIN_ID}}"
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-CERC_L1_ACCOUNTS_CSV_URL="${CERC_L1_ACCOUNTS_CSV_URL:-${DEFAULT_CERC_L1_ACCOUNTS_CSV_URL}}"
-
-echo "Using L1 RPC endpoint ${CERC_L1_RPC}"
-
-IMPORT_1="import './verify-contract-deployment'"
-IMPORT_2="import './rekey-json'"
-IMPORT_3="import './send-balance'"
-
-# Append mounted tasks to tasks/index.ts file if not present
-if ! grep -Fxq "$IMPORT_1" tasks/index.ts; then
-  echo "$IMPORT_1" >> tasks/index.ts
-  echo "$IMPORT_2" >> tasks/index.ts
-  echo "$IMPORT_3" >> tasks/index.ts
-fi
-
-# Update the chainId in the hardhat config
-sed -i "/getting-started/ {n; s/.*chainId.*/      chainId: $CERC_L1_CHAIN_ID,/}" hardhat.config.ts
-
-# Exit if a deployment already exists (on restarts)
-# Note: fixturenet-eth-geth currently starts fresh on a restart
-if [ -d "deployments/getting-started" ]; then
-  echo "Deployment directory deployments/getting-started found, checking SystemDictator deployment"
-
-  # Read JSON file into variable
-  SYSTEM_DICTATOR_DETAILS=$(cat deployments/getting-started/SystemDictator.json)
-
-  # Parse JSON into variables
-  SYSTEM_DICTATOR_ADDRESS=$(echo "$SYSTEM_DICTATOR_DETAILS" | jq -r '.address')
-  SYSTEM_DICTATOR_TXHASH=$(echo "$SYSTEM_DICTATOR_DETAILS" | jq -r '.transactionHash')
-
-  if yarn hardhat verify-contract-deployment --contract "${SYSTEM_DICTATOR_ADDRESS}" --transaction-hash "${SYSTEM_DICTATOR_TXHASH}"; then
-    echo "Deployment verfication successful, exiting"
-    exit 0
-  else
-    echo "Deployment verfication failed, please clear L1 deployment volume before starting"
-    exit 1
-  fi
-fi
-
-# Generate the L2 account addresses
-yarn hardhat rekey-json --output /l2-accounts/keys.json
-
-# Read JSON file into variable
-KEYS_JSON=$(cat /l2-accounts/keys.json)
-
-# Parse JSON into variables
-ADMIN_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Admin.address')
-ADMIN_PRIV_KEY=$(echo "$KEYS_JSON" | jq -r '.Admin.privateKey')
-PROPOSER_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Proposer.address')
-BATCHER_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Batcher.address')
-SEQUENCER_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Sequencer.address')
-
-# Get the private keys of L1 accounts
-if [ -n "$CERC_L1_ACCOUNTS_CSV_URL" ] && \
-  l1_accounts_response=$(curl -L --write-out '%{http_code}' --silent --output /dev/null "$CERC_L1_ACCOUNTS_CSV_URL") && \
-  [ "$l1_accounts_response" -eq 200 ];
-then
-  echo "Fetching L1 account credentials using provided URL"
-  mkdir -p /geth-accounts
-  wget -O /geth-accounts/accounts.csv "$CERC_L1_ACCOUNTS_CSV_URL"
-
-  CERC_L1_ADDRESS=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 2)
-  CERC_L1_PRIV_KEY=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 3)
-  CERC_L1_ADDRESS_2=$(awk -F, 'NR==2{print $(NF-1)}' /geth-accounts/accounts.csv)
-  CERC_L1_PRIV_KEY_2=$(awk -F, 'NR==2{print $NF}' /geth-accounts/accounts.csv)
-else
-  echo "Couldn't fetch L1 account credentials, using them from env"
-fi
-
-# Send balances to the above L2 addresses
-yarn hardhat send-balance --to "${ADMIN_ADDRESS}" --amount 2 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-yarn hardhat send-balance --to "${PROPOSER_ADDRESS}" --amount 5 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-yarn hardhat send-balance --to "${BATCHER_ADDRESS}" --amount 1000 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-
-echo "Balances sent to L2 accounts"
-
-# Select a finalized L1 block as the starting point for roll ups
-until FINALIZED_BLOCK=$(cast block finalized --rpc-url "$CERC_L1_RPC"); do
-    echo "Waiting for a finalized L1 block to exist, retrying after 10s"
-    sleep 10
-done
-
-L1_BLOCKNUMBER=$(echo "$FINALIZED_BLOCK" | awk '/number/{print $2}')
-L1_BLOCKHASH=$(echo "$FINALIZED_BLOCK" | awk '/hash/{print $2}')
-L1_BLOCKTIMESTAMP=$(echo "$FINALIZED_BLOCK" | awk '/timestamp/{print $2}')
-
-echo "Selected L1 block ${L1_BLOCKNUMBER} as the starting block for roll ups"
-
-# Update the deployment config
-sed -i 's/"l2OutputOracleStartingTimestamp": TIMESTAMP/"l2OutputOracleStartingTimestamp": '"$L1_BLOCKTIMESTAMP"'/g' deploy-config/getting-started.json
-jq --arg chainid "$CERC_L1_CHAIN_ID" '.l1ChainID = ($chainid | tonumber)' deploy-config/getting-started.json > tmp.json && mv tmp.json deploy-config/getting-started.json
-
-node update-config.js deploy-config/getting-started.json "$ADMIN_ADDRESS" "$PROPOSER_ADDRESS" "$BATCHER_ADDRESS" "$SEQUENCER_ADDRESS" "$L1_BLOCKHASH"
-
-echo "Updated the deployment config"
-
-# Create a .env file
-echo "L1_RPC=$CERC_L1_RPC" > .env
-echo "PRIVATE_KEY_DEPLOYER=$ADMIN_PRIV_KEY" >> .env
-
-echo "Deploying the L1 smart contracts, this will take a while..."
-
-# Deploy the L1 smart contracts
-yarn hardhat deploy --network getting-started --tags l1
-
-echo "Deployed the L1 smart contracts"
-
-# Read Proxy contract's JSON and get the address
-PROXY_JSON=$(cat deployments/getting-started/Proxy__OVM_L1StandardBridge.json)
-PROXY_ADDRESS=$(echo "$PROXY_JSON" | jq -r '.address')
-
-# Send balance to the above Proxy contract in L1 for reflecting balance in L2
-# First account
-yarn hardhat send-balance --to "${PROXY_ADDRESS}" --amount 1 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-# Second account
-yarn hardhat send-balance --to "${PROXY_ADDRESS}" --amount 1 --private-key "${CERC_L1_PRIV_KEY_2}" --network getting-started
-
-echo "Balance sent to Proxy L2 contract"
-echo "Use following accounts for transactions in L2:"
-echo "${CERC_L1_ADDRESS}"
-echo "${CERC_L1_ADDRESS_2}"
-echo "Done"

app/data/config/fixturenet-optimism/optimism-contracts/update-config.js

@@ -1,36 +0,0 @@
-const fs = require('fs')
-
-// Get the command-line argument
-const configFile = process.argv[2]
-const adminAddress = process.argv[3]
-const proposerAddress = process.argv[4]
-const batcherAddress = process.argv[5]
-const sequencerAddress = process.argv[6]
-const blockHash = process.argv[7]
-
-// Read the JSON file
-const configData = fs.readFileSync(configFile)
-const configObj = JSON.parse(configData)
-
-// Update the finalSystemOwner property with the ADMIN_ADDRESS value
-configObj.finalSystemOwner =
-  configObj.portalGuardian =
-  configObj.controller =
-  configObj.l2OutputOracleChallenger =
-  configObj.proxyAdminOwner =
-  configObj.baseFeeVaultRecipient =
-  configObj.l1FeeVaultRecipient =
-  configObj.sequencerFeeVaultRecipient =
-  configObj.governanceTokenOwner =
-    adminAddress
-
-configObj.l2OutputOracleProposer = proposerAddress
-
-configObj.batchSenderAddress = batcherAddress
-
-configObj.p2pSequencerAddress = sequencerAddress
-
-configObj.l1StartingBlockTag = blockHash
-
-// Write the updated JSON object back to the file
-fs.writeFileSync(configFile, JSON.stringify(configObj, null, 2))

app/data/config/fixturenet-optimism/run-op-geth.sh

@@ -1,90 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-# TODO: Add in container build or use other tool
-echo "Installing jq"
-apk update && apk add jq
-
-# Get Sequencer key from keys.json
-SEQUENCER_KEY=$(jq -r '.Sequencer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-# Initialize op-geth if datadir/geth not found
-if [ -f /op-node/jwt.txt ] && [ -d datadir/geth ]; then
-  echo "Found existing datadir, checking block signer key"
-
-  BLOCK_SIGNER_KEY=$(cat datadir/block-signer-key)
-
-  if [ "$SEQUENCER_KEY" = "$BLOCK_SIGNER_KEY" ]; then
-    echo "Sequencer and block signer keys match, skipping initialization"
-  else
-    echo "Sequencer and block signer keys don't match, please clear L2 geth data volume before starting"
-    exit 1
-  fi
-else
-  echo "Initializing op-geth"
-
-  mkdir -p datadir
-  echo "pwd" > datadir/password
-  echo $SEQUENCER_KEY > datadir/block-signer-key
-
-  geth account import --datadir=datadir --password=datadir/password datadir/block-signer-key
-
-  while [ ! -f "/op-node/jwt.txt" ]
-  do
-    echo "Config files not created. Checking after 5 seconds."
-    sleep 5
-  done
-
-  echo "Config files created by op-node, proceeding with the initialization..."
-
-  geth init --datadir=datadir /op-node/genesis.json
-  echo "Node Initialized"
-fi
-
-SEQUENCER_ADDRESS=$(jq -r '.Sequencer.address' /l2-accounts/keys.json | tr -d '"')
-echo "SEQUENCER_ADDRESS: ${SEQUENCER_ADDRESS}"
-
-cleanup() {
-    echo "Signal received, cleaning up..."
-    kill ${geth_pid}
-
-    wait
-    echo "Done"
-}
-trap 'cleanup' INT TERM
-
-# Run op-geth
-geth \
-  --datadir ./datadir \
-  --http \
-  --http.corsdomain="*" \
-  --http.vhosts="*" \
-  --http.addr=0.0.0.0 \
-  --http.api=web3,debug,eth,txpool,net,engine \
-  --ws \
-  --ws.addr=0.0.0.0 \
-  --ws.port=8546 \
-  --ws.origins="*" \
-  --ws.api=debug,eth,txpool,net,engine \
-  --syncmode=full \
-  --gcmode=archive \
-  --nodiscover \
-  --maxpeers=0 \
-  --networkid=42069 \
-  --authrpc.vhosts="*" \
-  --authrpc.addr=0.0.0.0 \
-  --authrpc.port=8551 \
-  --authrpc.jwtsecret=/op-node/jwt.txt \
-  --rollup.disabletxpoolgossip=true \
-  --password=./datadir/password \
-  --allow-insecure-unlock \
-  --mine \
-  --miner.etherbase=$SEQUENCER_ADDRESS \
-  --unlock=$SEQUENCER_ADDRESS \
-  &
-
-geth_pid=$!
-wait $geth_pid

app/data/config/fixturenet-optimism/run-op-node.sh

@@ -1,26 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-# Get Sequencer key from keys.json
-SEQUENCER_KEY=$(jq -r '.Sequencer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-# Run op-node
-op-node \
-  --l2=http://op-geth:8551 \
-  --l2.jwt-secret=/op-node-data/jwt.txt \
-  --sequencer.enabled \
-  --sequencer.l1-confs=3 \
-  --verifier.l1-confs=3 \
-  --rollup.config=/op-node-data/rollup.json \
-  --rpc.addr=0.0.0.0 \
-  --rpc.port=8547 \
-  --p2p.disable \
-  --rpc.enable-admin \
-  --p2p.sequencer.key=$SEQUENCER_KEY \
-  --l1=$CERC_L1_RPC \
-  --l1.rpckind=any

app/data/config/fixturenet-optimism/run-op-proposer.sh

@@ -1,36 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-# Read the L2OutputOracle contract address from the deployment
-L2OO_DEPLOYMENT=$(cat /contracts-bedrock/deployments/getting-started/L2OutputOracle.json)
-L2OO_ADDR=$(echo "$L2OO_DEPLOYMENT" | jq -r '.address')
-
-# Get Proposer key from keys.json
-PROPOSER_KEY=$(jq -r '.Proposer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-cleanup() {
-    echo "Signal received, cleaning up..."
-    kill ${proposer_pid}
-
-    wait
-    echo "Done"
-}
-trap 'cleanup' INT TERM
-
-# Run op-proposer
-op-proposer \
-  --poll-interval 12s \
-  --rpc.port 8560 \
-  --rollup-rpc http://op-node:8547 \
-  --l2oo-address $L2OO_ADDR \
-  --private-key $PROPOSER_KEY \
-  --l1-eth-rpc $CERC_L1_RPC \
-  &
-
-proposer_pid=$!
-wait $proposer_pid

app/data/config/fixturenet-plugeth/plugins/README.md

@@ -1 +0,0 @@
-See: https://docs.plugeth.org/

app/data/config/mainnet-go-opera/go-opera.env

@@ -1 +0,0 @@
-

app/data/config/mainnet-laconicd/create-fixturenet.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-# TODO: this file is now an unmodified copy of cerc-io/laconicd/init.sh
-# so we should have a mechanism to bundle it inside the container rather than link from here
-# at deploy time.
-
-KEY="mykey"
-CHAINID="laconic_9000-1"
-MONIKER="localtestnet"
-KEYRING="test"
-KEYALGO="eth_secp256k1"
-LOGLEVEL="info"
-# trace evm
-TRACE="--trace"
-# TRACE=""
-
-# validate dependencies are installed
-command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; }
-
-# remove existing daemon and client
-rm -rf ~/.laconic*
-
-make install
-
-laconicd config keyring-backend $KEYRING
-laconicd config chain-id $CHAINID
-
-# if $KEY exists it should be deleted
-laconicd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO
-
-# Set moniker and chain-id for Ethermint (Moniker can be anything, chain-id must be an integer)
-laconicd init $MONIKER --chain-id $CHAINID
-
-# Change parameter token denominations to aphoton
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["staking"]["params"]["bond_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["crisis"]["constant_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["mint"]["params"]["mint_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-# Custom modules
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commit_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveal_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_minimum_bid"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-if [[ "$TEST_REGISTRY_EXPIRY" == "true" ]]; then
-  echo "Setting timers for expiry tests."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-if [[ "$TEST_AUCTION_ENABLED" == "true" ]]; then
-  echo "Enabling auction and setting timers."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_enabled"]=true' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="300s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commits_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveals_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-# increase block time (?)
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["time_iota_ms"]="1000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# Set gas limit in genesis
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["max_gas"]="10000000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# disable produce empty block
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-  else
-    sed -i 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-fi
-
-if [[ $1 == "pending" ]]; then
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-      sed -i '' 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  else
-      sed -i 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  fi
-fi
-
-# Allocate genesis accounts (cosmos formatted addresses)
-laconicd add-genesis-account $KEY 100000000000000000000000000aphoton --keyring-backend $KEYRING
-
-# Sign genesis transaction
-laconicd gentx $KEY 1000000000000000000000aphoton --keyring-backend $KEYRING --chain-id $CHAINID
-
-# Collect genesis tx
-laconicd collect-gentxs
-
-# Run this to ensure everything worked and that the genesis file is setup correctly
-laconicd validate-genesis
-
-if [[ $1 == "pending" ]]; then
-  echo "pending mode is on, please wait for the first block committed."
-fi
-
-# Start the node (remove the --pruning=nothing flag if historical queries are not needed)
-laconicd start --pruning=nothing --evm.tracer=json $TRACE --log_level $LOGLEVEL --minimum-gas-prices=0.0001aphoton --json-rpc.api eth,txpool,personal,net,debug,web3,miner --api.enable --gql-server --gql-playground

app/data/config/watcher-azimuth/start-server.sh

@@ -1,27 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_IPLD_ETH_RPC="${CERC_IPLD_ETH_RPC:-${DEFAULT_CERC_IPLD_ETH_RPC}}"
-CERC_IPLD_ETH_GQL="${CERC_IPLD_ETH_GQL:-${DEFAULT_CERC_IPLD_ETH_GQL}}"
-
-echo "Using IPLD ETH RPC endpoint ${CERC_IPLD_ETH_RPC}"
-echo "Using IPLD GQL endpoint ${CERC_IPLD_ETH_GQL}"
-
-# Replace env variables in template TOML file
-# Read in the config template TOML file and modify it
-WATCHER_CONFIG_TEMPLATE=$(cat environments/watcher-config-template.toml)
-WATCHER_CONFIG=$(echo "$WATCHER_CONFIG_TEMPLATE" | \
-  sed -E "s|REPLACE_WITH_CERC_IPLD_ETH_RPC|${CERC_IPLD_ETH_RPC}|g; \
-          s|REPLACE_WITH_CERC_IPLD_ETH_GQL|${CERC_IPLD_ETH_GQL}| ")
-
-# Write the modified content to a new file
-echo "$WATCHER_CONFIG" > environments/watcher-config.toml
-
-# Merge SO watcher config with existing config file
-node merge-toml.js
-
-echo 'yarn server'
-yarn server

app/data/config/watcher-azimuth/watcher-config-template.toml

@@ -1,14 +0,0 @@
-[server]
-  host = "0.0.0.0"
-  maxSimultaneousRequests = -1
-
-[database]
-  host = "watcher-db"
-  port = 5432
-  username = "vdbm"
-  password = "password"
-
-[upstream]
-  [upstream.ethServer]
-    gqlApiEndpoint = "REPLACE_WITH_CERC_IPLD_ETH_GQL"
-    rpcProviderEndpoint = "REPLACE_WITH_CERC_IPLD_ETH_RPC"

app/data/config/watcher-azimuth/watcher-params.env

@@ -1,5 +0,0 @@
-# Defaults
-
-# ipld-eth-server endpoints
-DEFAULT_CERC_IPLD_ETH_RPC=
-DEFAULT_CERC_IPLD_ETH_GQL=

app/data/container-build/cerc-fixturenet-eth-geth/Dockerfile

@@ -1,39 +0,0 @@
-FROM skylenet/ethereum-genesis-generator@sha256:210353ce7c898686bc5092f16c61220a76d357f51eff9c451e9ad1b9ad03d4d3 AS ethgen
-
-# Using the same golang image as used to build geth: https://github.com/cerc-io/go-ethereum/blob/HEAD/Dockerfile
-FROM golang:1.18-alpine as delve
-RUN go install github.com/go-delve/delve/cmd/dlv@latest
-
-FROM cerc/go-ethereum:local as geth
-
-FROM alpine:3.17
-RUN apk add --no-cache python3 python3-dev py3-pip curl wget jq build-base gettext libintl openssl bash bind-tools postgresql-client
-
-COPY --from=delve  /go/bin/dlv /usr/local/bin/
-COPY --from=ethgen /usr/local/bin/eth2-testnet-genesis /usr/local/bin/
-COPY --from=ethgen /usr/local/bin/eth2-val-tools /usr/local/bin/
-COPY --from=ethgen /apps /apps
-
-RUN cd /apps/el-gen && pip3 install -r requirements.txt
-
-COPY genesis /opt/testnet
-COPY run-el.sh /opt/testnet/run.sh
-
-RUN cd /opt/testnet && make genesis-el
-
-COPY --from=geth  /usr/local/bin/geth /usr/local/bin/
-
-# Snag the genesis block info.
-RUN geth --datadir ~/ethdata init /opt/testnet/build/el/geth.json && rm -f ~/ethdata/geth/nodekey
-RUN cp -rp ~/ethdata ~/tmpeth && \
-    geth --datadir ~/tmpeth init /opt/testnet/build/el/geth.json && \
-    geth --datadir ~/tmpeth --http & \
-    sleep 5 && \
-    curl -q --location 'localhost:8545' \
-        --header 'Content-Type: application/json' \
-        --data '{ "jsonrpc": "2.0", "id": 14, "method": "eth_getBlockByNumber", "params": ["0x0", false] }' \
-        -o /opt/testnet/build/el/genesis_block.json && \
-    killall -9 geth && \
-    rm -rf ~/tmpeth
-
-ENTRYPOINT ["/opt/testnet/run.sh"]

app/data/container-build/cerc-fixturenet-eth-geth/genesis/el/build_el.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-# See: https://github.com/skylenet/ethereum-genesis-generator/blob/master/entrypoint.sh
-
-rm -rf ../build/el
-mkdir -p ../build/el
-
-tmp_dir=$(mktemp -d -t ci-XXXXXXXXXX)
-envsubst < el-config.yaml > $tmp_dir/genesis-config.yaml
-
-ttd=`cat $tmp_dir/genesis-config.yaml | grep terminal_total_difficulty | awk '{ print $2 }'`
-homestead_block=`cat $tmp_dir/genesis-config.yaml | grep homestead_block | awk '{ print $2 }'`
-eip150_block=`cat $tmp_dir/genesis-config.yaml | grep eip150_block | awk '{ print $2 }'`
-eip155_block=`cat $tmp_dir/genesis-config.yaml | grep eip155_block | awk '{ print $2 }'`
-eip158_block=`cat $tmp_dir/genesis-config.yaml | grep eip158_block | awk '{ print $2 }'`
-byzantium_block=`cat $tmp_dir/genesis-config.yaml | grep byzantium_block | awk '{ print $2 }'`
-constantinople_block=`cat $tmp_dir/genesis-config.yaml | grep constantinople_block | awk '{ print $2 }'`
-petersburg_block=`cat $tmp_dir/genesis-config.yaml | grep petersburg_block | awk '{ print $2 }'`
-istanbul_block=`cat $tmp_dir/genesis-config.yaml | grep istanbul_block | awk '{ print $2 }'`
-berlin_block=`cat $tmp_dir/genesis-config.yaml | grep berlin_block | awk '{ print $2 }'`
-london_block=`cat $tmp_dir/genesis-config.yaml | grep london_block | awk '{ print $2 }'`
-merge_fork_block=`cat $tmp_dir/genesis-config.yaml | grep merge_fork_block | awk '{ print $2 }'`
-
-python3 /apps/el-gen/genesis_geth.py $tmp_dir/genesis-config.yaml | \
-  jq ".config.terminalTotalDifficulty=$ttd" | \
-  jq ".config.homesteadBlock=$homestead_block" | \
-  jq ".config.eip150Block=$eip150_block" | \
-  jq ".config.eip155Block=$eip155_block" | \
-  jq ".config.eip158Block=$eip158_block" | \
-  jq ".config.byzantiumBlock=$byzantium_block" | \
-  jq ".config.constantinopleBlock=$constantinople_block" | \
-  jq ".config.petersburgBlock=$petersburg_block" | \
-  jq ".config.istanbulBlock=$istanbul_block" | \
-  jq ".config.berlinBlock=$berlin_block" | \
-  jq ".config.londonBlock=$london_block" | \
-  jq ".config.mergeForkBlock=$merge_fork_block" | \
-  jq ".config.mergeNetsplitBlock=$merge_fork_block" \
-  > ../build/el/geth.json
-python3 ../accounts/mnemonic_to_csv.py $tmp_dir/genesis-config.yaml > ../build/el/accounts.csv

app/data/container-build/cerc-fixturenet-plugeth-lighthouse/Dockerfile

@@ -1,34 +0,0 @@
-FROM cerc/lighthouse-cli:local AS lcli
-FROM skylenet/ethereum-genesis-generator@sha256:210353ce7c898686bc5092f16c61220a76d357f51eff9c451e9ad1b9ad03d4d3 AS ethgen
-FROM cerc/fixturenet-plugeth-plugeth:local AS fnetgeth
-
-FROM cerc/lighthouse:local
-
-# cerc/lighthouse is based on Ubuntu
-RUN apt-get update && apt-get -y upgrade && apt-get install -y --no-install-recommends \
-  libssl-dev ca-certificates \
-  curl socat iproute2 telnet wget jq \
-  build-essential python3 python3-dev python3-pip gettext-base \
-  && apt-get clean \
-  && rm -rf /var/lib/apt/lists/*
-
-COPY genesis /opt/testnet
-COPY run-cl.sh /opt/testnet/run.sh
-
-COPY --from=lcli /usr/local/bin/lcli /usr/local/bin/lcli
-COPY --from=ethgen /usr/local/bin/eth2-testnet-genesis /usr/local/bin/eth2-testnet-genesis
-COPY --from=ethgen /usr/local/bin/eth2-val-tools /usr/local/bin/eth2-val-tools
-COPY --from=ethgen /apps /apps
-COPY --from=fnetgeth /opt/testnet/el /opt/testnet/el
-COPY --from=fnetgeth /opt/testnet/build/el /opt/testnet/build/el
-
-RUN cd /opt/testnet && make genesis-cl
-
-# Work around some bugs in lcli where the default path is always used.
-RUN mkdir -p /root/.lighthouse && cd /root/.lighthouse && ln -s /opt/testnet/build/cl/testnet
-
-RUN mkdir -p /scripts
-COPY scripts/status-internal.sh /scripts
-COPY scripts/status.sh /scripts
-
-ENTRYPOINT ["/opt/testnet/run.sh"]

app/data/container-build/cerc-fixturenet-plugeth-lighthouse/build.sh

@@ -1,20 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/fixturenet-plugeth-lighthouse
-
-source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
-
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-
-if [ ! -d "${SCRIPT_DIR}/genesis" ]; then
-  cp -frp ${SCRIPT_DIR}/../cerc-fixturenet-eth-lighthouse/genesis ${SCRIPT_DIR}/genesis
-fi
-
-if [ ! -e "${SCRIPT_DIR}/run-cl.sh" ]; then
-  cp -fp ${SCRIPT_DIR}/../cerc-fixturenet-eth-lighthouse/run-cl.sh ${SCRIPT_DIR}/
-fi
-
-if [ ! -d "${SCRIPT_DIR}/scripts" ]; then
-  cp -frp ${SCRIPT_DIR}/../cerc-fixturenet-eth-lighthouse/scripts ${SCRIPT_DIR}/
-fi
-
-docker build -t cerc/fixturenet-plugeth-lighthouse:local -f ${SCRIPT_DIR}/Dockerfile ${build_command_args} $SCRIPT_DIR

app/data/container-build/cerc-fixturenet-plugeth-plugeth/Dockerfile

@@ -1,42 +0,0 @@
-FROM skylenet/ethereum-genesis-generator@sha256:210353ce7c898686bc5092f16c61220a76d357f51eff9c451e9ad1b9ad03d4d3 AS ethgen
-
-FROM golang:1.19-alpine as delve
-RUN go install github.com/go-delve/delve/cmd/dlv@latest
-
-FROM cerc/plugeth:local as geth
-FROM cerc/plugeth-statediff:local as statediff
-
-FROM alpine:3.17
-RUN apk add --no-cache python3 python3-dev py3-pip curl wget jq build-base gettext libintl openssl bash bind-tools postgresql-client
-
-COPY --from=delve  /go/bin/dlv /usr/local/bin/
-COPY --from=ethgen /usr/local/bin/eth2-testnet-genesis /usr/local/bin/
-COPY --from=ethgen /usr/local/bin/eth2-val-tools /usr/local/bin/
-COPY --from=ethgen /apps /apps
-
-RUN cd /apps/el-gen && pip3 install -r requirements.txt
-
-COPY genesis /opt/testnet
-COPY run-el.sh /opt/testnet/run.sh
-
-RUN cd /opt/testnet && make genesis-el
-
-COPY --from=geth  /usr/local/bin/geth /usr/local/bin/
-
-RUN mkdir -p /usr/local/lib/plugeth/
-COPY --from=statediff  /usr/local/lib/statediff.so /usr/local/lib/plugeth/
-
-# Snag the genesis block info.
-RUN geth --datadir ~/ethdata init /opt/testnet/build/el/geth.json && rm -f ~/ethdata/geth/nodekey
-RUN cp -rp ~/ethdata ~/tmpeth && \
-    geth --datadir ~/tmpeth init /opt/testnet/build/el/geth.json && \
-    geth --datadir ~/tmpeth --http & \
-    sleep 5 && \
-    curl -q --location 'localhost:8545' \
-        --header 'Content-Type: application/json' \
-        --data '{ "jsonrpc": "2.0", "id": 14, "method": "eth_getBlockByNumber", "params": ["0x0", false] }' \
-        -o /opt/testnet/build/el/genesis_block.json && \
-    killall -9 geth && \
-    rm -rf ~/tmpeth
-
-ENTRYPOINT ["/opt/testnet/run.sh"]

app/data/container-build/cerc-laconic-console-host/config.yml

@@ -1,6 +0,0 @@
-# Config for laconic-console running in a fixturenet with laconicd
-
-services:
-  wns:
-    server: 'LACONIC_HOSTED_ENDPOINT:9473/api'
-    webui: 'LACONIC_HOSTED_ENDPOINT:9473/console'

app/data/container-build/cerc-laconic-console-host/start-serving-app.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-    set -x
-fi
-# TODO: Don't hard wire this:
-webapp_files_dir=/usr/local/share/.config/yarn/global/node_modules/@cerc-io/console-app/dist/production
-/scripts/apply-webapp-config.sh /config/config.yml ${webapp_files_dir}
-http-server -p 80 ${webapp_files_dir}

app/data/container-build/cerc-laconic-registry-cli/create-demo-records.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# Create some demo/test records in the registry
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-registry_command="laconic cns"
-record_1_filename=demo-record-1.yml
-cat <<EOF > ${record_1_filename}
-record:
-  type: WebsiteRegistrationRecord
-  url: 'https://cerc.io'
-  repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
-  build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
-  tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
-  version: 1.0.23
-EOF
-# Check we have funds
-funds_response=$(${registry_command} account get --address $(cat my-address.txt))
-funds_balance=$(echo ${funds_response} | jq -r .[0].balance[0].quantity)
-echo "Balance is: ${funds_balance}"
-# Create a bond
-bond_create_result=$(${registry_command} bond create --type aphoton --quantity 1000000000)
-bond_id=$(echo ${bond_create_result} | jq -r .bondId)
-echo "Created bond with id: ${bond_id}"
-# Publish a demo record
-publish_response=$(${registry_command} record publish --filename ${record_1_filename} --bond-id ${bond_id})
-published_record_id=$(echo ${publish_response} | jq -r .id)
-echo "Published ${record_1_filename} with id: ${published_record_id}"

app/data/container-build/cerc-lighthouse/Dockerfile

@@ -1,9 +0,0 @@
-ARG TAG_SUFFIX="-modern"
-FROM sigp/lighthouse:v4.1.0${TAG_SUFFIX}
-
-RUN apt-get update; apt-get install bash netcat curl less jq -y;
-
-WORKDIR /root/
-ADD start-lighthouse.sh .
-
-ENTRYPOINT [ "./start-lighthouse.sh" ]

app/data/container-build/cerc-mobymask-ui/apply-webapp-config.sh

@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-    set -x
-fi
-if [[ $# -ne 3 ]]; then
-    echo "Illegal number of parameters" >&2
-    exit 1
-fi
-config_file_name=$1
-webapp_files_dir=$2
-config_prefix=$3
-if ! [[ -f ${config_file_name} ]]; then
-    echo "Config file ${config_file_name} does not exist" >&2
-    exit 1
-fi
-if ! [[ -d ${webapp_files_dir} ]]; then
-    echo "Webapp directory ${webapp_files_dir} does not exist" >&2
-    exit 1
-fi
-# First some magic using sed to translate our yaml config file into an array of key value pairs like:
-# ${config_prefix}<path-through-objects>=<value>
-# sed "s/'//g" is used to remove single quote for relayNodes value
-readarray -t config_kv_pair_array < <( sed -E 's/([^:]+):\s*(.*)/\1=\2/g' ${config_file_name} | sed "s/'//g" |  sed "s/^/${config_prefix}_/" )
-declare -p config_kv_pair_array
-# Then iterate over that kv array making the template substitution in our web app files
-for kv_pair_string in "${config_kv_pair_array[@]}"
-do
-    kv_pair=(${kv_pair_string//=/ })
-    template_string_to_replace=${kv_pair[0]}
-    template_value_to_substitute=${kv_pair[1]}
-    # Run find and sed to do the substitution of one variable over all files
-    # See: https://stackoverflow.com/a/21479607/1701505
-    echo "Substituting: ${template_string_to_replace} = ${template_value_to_substitute}"
-
-    # TODO: Pass keys to be replaced without double quotes
-    if [[ "$template_string_to_replace" =~ ^${config_prefix}_(relayNodes|chainId|denyMultiaddrs)$ ]]; then
-        find ${webapp_files_dir} -type f -exec sed -i 's#"'"${template_string_to_replace}"'"#'"${template_value_to_substitute}"'#g' {} +
-    else
-        # Note: we do not escape our strings, on the expectation they do not container the '#' char.
-        find ${webapp_files_dir} -type f -exec sed -i 's#'${template_string_to_replace}'#'${template_value_to_substitute}'#g' {} +
-    fi
-done

app/data/container-build/cerc-mobymask-ui/start-serving-app.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-    set -x
-fi
-
-# TODO: Don't hard wire this:
-webapp_files_dir="/usr/local/share/.config/yarn/global/node_modules/${CERC_BUILD_DIR}"
-/scripts/apply-webapp-config.sh /config/config.yml ${webapp_files_dir} MOBYMASK_HOSTED_CONFIG
-http-server -p 80 ${webapp_files_dir}

app/data/container-build/cerc-test-container/run.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-# Test if the container's filesystem is old (run previously) or new
-EXISTSFILENAME=/data/exists
-echo "Test container starting"
-if [[ -f "$EXISTSFILENAME" ]];
-then
-    TIMESTAMP=`cat $EXISTSFILENAME`
-    echo "Filesystem is old, created: $TIMESTAMP" 
-else
-    echo "Filesystem is fresh"
-    echo `date` > $EXISTSFILENAME
-fi
-
-# Run nginx which will block here forever
-/usr/sbin/nginx -g "daemon off;"

app/data/container-build/cerc-watcher-azimuth/Dockerfile

@@ -1,13 +0,0 @@
-FROM node:18.16.0-alpine3.16
-
-RUN apk --update --no-cache add git python3 alpine-sdk
-
-WORKDIR /app
-
-COPY . .
-
-RUN echo "Building azimuth-watcher-ts" && \
-    yarn && yarn build
-
-RUN echo "Install toml-js to update watcher config files" && \
-    yarn add --dev --ignore-workspace-root-check toml-js

app/data/container-build/cerc-watcher-erc20/Dockerfile

@@ -1,13 +0,0 @@
-FROM node:16.17.1-alpine3.16
-
-RUN apk --update --no-cache add git python3 alpine-sdk
-
-WORKDIR /app
-
-COPY . .
-
-RUN echo "Building watcher-ts" && \
-    git checkout v0.2.19 && \
-    yarn && yarn build
-
-WORKDIR /app/packages/erc20-watcher

app/data/stacks/azimuth/README.md

@@ -1,72 +0,0 @@
-# Azimuth Watcher
-
-Instructions to setup and deploy Azimuth Watcher stack
-
-## Setup
-
-Prerequisite: `ipld-eth-server` RPC and GQL endpoints
-
-Clone required repositories:
-
-```bash
-laconic-so --stack azimuth setup-repositories
-```
-
-NOTE: If the repository already exists and checked out to a different version, `setup-repositories` command will throw an error.
-For getting around this, the `azimuth-watcher-ts` repository can be removed and then run the command.
-
-Checkout to the required versions and branches in repos
-
-```bash
-# azimuth-watcher-ts
-cd ~/cerc/azimuth-watcher-ts
-git checkout v0.1.0
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack azimuth build-containers
-```
-
-This should create the required docker images in the local image registry.
-
-### Configuration
-
-* Create and update an env file to be used in the next step:
-
-  ```bash
-  # External ipld-eth-server endpoints
-  CERC_IPLD_ETH_RPC=
-  CERC_IPLD_ETH_GQL=
-  ```
-
-* NOTE: If `ipld-eth-server` is running on the host machine, use `host.docker.internal` as the hostname to access host ports
-
-### Deploy the stack
-
-* Deploy the containers:
-
-  ```bash
-  laconic-so --stack azimuth deploy-system --env-file <PATH_TO_ENV_FILE> up
-  ```
-
-* List and check the health status of all the containers using `docker ps` and wait for them to be `healthy`
-
-## Clean up
-
-Stop all the services running in background run:
-
-```bash
-laconic-so --stack azimuth deploy-system down
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*watcher_db_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*watcher_db_data")
-```

app/data/stacks/chain-chunker/stack.yml

@@ -1,13 +0,0 @@
-version: "1.0"
-name: chain-chunker
-decription: "Stack to build containers for chain-chunker"
-repos:
-  - github.com/cerc-io/ipld-eth-state-snapshot@v5
-  - github.com/cerc-io/eth-statediff-service@v5
-  - github.com/cerc-io/ipld-eth-db@v5
-  - github.com/cerc-io/ipld-eth-server@v5
-containers:
-  - cerc/ipld-eth-state-snapshot
-  - cerc/eth-statediff-service
-  - cerc/ipld-eth-db
-  - cerc/ipld-eth-server

app/data/stacks/fixturenet-lotus/README.md

@@ -1,28 +0,0 @@
-# Lotus Fixturenet
-
-Instructions for deploying a local Lotus (Filecoin) chain for development and testing purposes using laconic-stack-orchestrator.
-
-## 1. Clone required repositories
-```
-$ laconic-so --stack fixturenet-lotus setup-repositories
-```
-## 2. Build the stack's packages and containers
-```
-$ laconic-so --stack fixturenet-lotus build-containers
-```
-## 3. Deploy the stack
-```
-$ laconic-so --stack fixturenet-lotus deploy up
-```
-Correct operation should be verified by checking the container logs with:
-```
-$ laconic-so --stack fixturenet-lotus deploy logs lotus-miner
-$ laconic-so --stack fixturenet-lotus deploy logs lotus-node-1
-$ laconic-so --stack fixturenet-lotus deploy logs lotus-node-2
-```
-or by checking the chain status on each node:
-```
-$ laconic-so --stack fixturenet-lotus deploy exec lotus-miner "lotus status"
-$ laconic-so --stack fixturenet-lotus deploy exec lotus-node-1 "lotus status"
-$ laconic-so --stack fixturenet-lotus deploy exec lotus-node-2 "lotus status"
-```

app/data/stacks/fixturenet-optimism/README.md

@@ -1,118 +0,0 @@
-# fixturenet-optimism
-
-Instructions to setup and deploy an end-to-end L1+L2 stack with [fixturenet-eth](../fixturenet-eth/) (L1) and [Optimism](https://stack.optimism.io) (L2)
-
-We support running just the L2 part of stack, given an external L1 endpoint. Follow the [L2 only doc](./l2-only.md) for the same.
-
-## Setup
-
-Clone required repositories:
-
-```bash
-laconic-so --stack fixturenet-optimism setup-repositories
-
-# If this throws an error as a result of being already checked out to a branch/tag in a repo, remove the repositories mentioned below and re-run the command
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack fixturenet-optimism build-containers
-```
-
-Note: this will take >10 mins depending on the specs of your machine, and **requires** 16GB of memory or greater.
-
-This should create the required docker images in the local image registry:
-* `cerc/go-ethereum`
-* `cerc/lighthouse`
-* `cerc/fixturenet-eth-geth`
-* `cerc/fixturenet-eth-lighthouse`
-* `cerc/foundry`
-* `cerc/optimism-contracts`
-* `cerc/optimism-l2geth`
-* `cerc/optimism-op-node`
-* `cerc/optimism-op-batcher`
-* `cerc/optimism-op-proposer`
-
-## Deploy
-
-Deploy the stack:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy up
-```
-
-The `fixturenet-optimism-contracts` service takes a while to complete running as it:
-1. waits for the 'Merge' to happen on L1
-2. waits for a finalized block to exist on L1 (so that it can be taken as a starting block for roll ups)
-3. deploys the L1 contracts
-It may restart a few times after running into errors.
-
-To list and monitor the running containers:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy ps
-
-# With status
-docker ps
-
-# Check logs for a container
-docker logs -f <CONTAINER_ID>
-```
-
-## Clean up
-
-Stop all services running in the background:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy down 30
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data")
-```
-
-## Troubleshooting
-
-* If `op-geth` service aborts or is restarted, the following error might occur in the `op-node` service:
-
-  ```bash
-  WARN [02-16|21:22:02.868] Derivation process temporary error       attempts=14 err="stage 0 failed resetting: temp: failed to find the L2 Heads to start from: failed to fetch L2 block by hash 0x0000000000000000000000000000000000000000000000000000000000000000: failed to determine block-hash of hash 0x0000000000000000000000000000000000000000000000000000000000000000, could not get payload: not found"
-  ```
-
-* This means that the data directory that `op-geth` is using is corrupted and needs to be reinitialized; the containers `op-geth`, `op-node` and `op-batcher` need to be started afresh:
-
-  WARNING: This will reset the L2 chain; consequently, all the data on it will be lost
-
-  * Stop and remove the concerned containers:
-
-    ```bash
-    # List the containers
-    docker ps -f "name=op-geth|op-node|op-batcher"
-
-    # Force stop and remove the listed containers
-    docker rm -f $(docker ps -qf "name=op-geth|op-node|op-batcher")
-    ```
-
-  * Remove the concerned volume:
-
-    ```bash
-    # List the volume
-    docker volume ls -q --filter name=l2_geth_data
-
-    # Remove the listed volume
-    docker volume rm $(docker volume ls -q --filter name=l2_geth_data)
-    ```
-
-  * Re-run the deployment command used in [Deploy](#deploy) to restart the stopped containers
-
-## Known Issues
-
-* Resource requirements (memory + time) for building the `cerc/foundry` image are on the higher side
-  * `cerc/optimism-contracts` image is currently based on `cerc/foundry` (Optimism requires foundry installation)

app/data/stacks/fixturenet-optimism/l2-only.md

@@ -1,100 +0,0 @@
-# fixturenet-optimism
-
-Instructions to setup and deploy L2 fixturenet using [Optimism](https://stack.optimism.io)
-
-## Setup
-
-Prerequisite: An L1 Ethereum RPC endpoint
-
-Clone required repositories:
-
-```bash
-laconic-so --stack fixturenet-optimism setup-repositories --exclude github.com/cerc-io/go-ethereum
-
-# If this throws an error as a result of being already checked out to a branch/tag in a repo, remove the repositories mentioned below and re-run the command
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack fixturenet-optimism build-containers --include cerc/foundry,cerc/optimism-contracts,cerc/optimism-op-node,cerc/optimism-l2geth,cerc/optimism-op-batcher,cerc/optimism-op-proposer
-```
-
-This should create the required docker images in the local image registry:
-* `cerc/foundry`
-* `cerc/optimism-contracts`
-* `cerc/optimism-l2geth`
-* `cerc/optimism-op-node`
-* `cerc/optimism-op-batcher`
-* `cerc/optimism-op-proposer`
-
-## Deploy
-
-Create and update an env file to be used in the next step ([defaults](../../config/fixturenet-optimism/l1-params.env)):
-
-  ```bash
-  # External L1 endpoint
-  CERC_L1_CHAIN_ID=
-  CERC_L1_RPC=
-  CERC_L1_HOST=
-  CERC_L1_PORT=
-
-  # URL to get CSV with credentials for accounts on L1
-  # that are used to send balance to Optimism Proxy contract
-  # (enables them to do transactions on L2)
-  CERC_L1_ACCOUNTS_CSV_URL=
-
-  # OR
-  # Specify the required account credentials
-  CERC_L1_ADDRESS=
-  CERC_L1_PRIV_KEY=
-  CERC_L1_ADDRESS_2=
-  CERC_L1_PRIV_KEY_2=
-  ```
-
-* NOTE: If L1 is running on the host machine, use `host.docker.internal` as the hostname to access the host port
-
-Deploy the stack:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy --include fixturenet-optimism --env-file <PATH_TO_ENV_FILE> up
-```
-
-The `fixturenet-optimism-contracts` service may take a while (`~15 mins`) to complete running as it:
-1. waits for the 'Merge' to happen on L1
-2. waits for a finalized block to exist on L1 (so that it can be taken as a starting block for roll ups)
-3. deploys the L1 contracts
-
-To list down and monitor the running containers:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy --include fixturenet-optimism ps
-
-# With status
-docker ps
-
-# Check logs for a container
-docker logs -f <CONTAINER_ID>
-```
-
-## Clean up
-
-Stop all services running in the background:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy --include fixturenet-optimism down 30
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data")
-```
-
-## Troubleshooting
-
-See [Troubleshooting](./README.md#troubleshooting)

app/data/stacks/mainnet-laconic/deploy/commands.py

@@ -1,57 +0,0 @@
-# Copyright © 2022, 2023 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-import click
-import os
-from shutil import copyfile
-import sys
-from .util import get_stack_config_filename, get_parsed_deployment_spec
-
-default_spec_file_content = """stack: mainnet-laconic
-data_dir: /my/path
-node_name: my-node-name
-"""
-
-
-def make_default_deployment_dir():
-    return "deployment-001"
-
-@click.command()
-@click.option("--output", required=True, help="Write yaml spec file here")
-@click.pass_context
-def init(ctx, output):
-    with open(output, "w") as output_file:
-        output_file.write(default_spec_file_content)
-
-
-@click.command()
-@click.option("--spec-file", required=True, help="Spec file to use to create this deployment")
-@click.option("--deployment-dir", help="Create deployment files in this directory")
-@click.pass_context
-def create(ctx, spec_file, deployment_dir):
-    # This function fails with a useful error message if the file doens't exist
-    parsed_spec = get_parsed_deployment_spec(spec_file)
-    if ctx.debug:
-        print(f"parsed spec: {parsed_spec}")
-    if deployment_dir is None:
-        deployment_dir = make_default_deployment_dir()
-    if os.path.exists(deployment_dir):
-        print(f"Error: {deployment_dir} already exists")
-        sys.exit(1)
-    os.mkdir(deployment_dir)
-    # Copy spec file and the stack file into the deployment dir
-    copyfile(spec_file, os.path.join(deployment_dir, os.path.basename(spec_file)))
-    stack_file = get_stack_config_filename(parsed_spec.stack)
-    copyfile(stack_file, os.path.join(deployment_dir, os.path.basename(stack_file)))

app/data/stacks/mainnet-laconic/stack.yml

@@ -1,31 +0,0 @@
-version: "1.0"
-name: mainnet-laconic
-description: "Mainnet laconic node"
-repos:
-  - cerc-io/laconicd
-  - lirewine/debug
-  - lirewine/crypto
-  - lirewine/gem
-  - lirewine/sdk
-  - cerc-io/laconic-sdk
-  - cerc-io/laconic-registry-cli
-  - cerc-io/laconic-console
-npms:
-  - laconic-sdk
-  - laconic-registry-cli
-  - debug
-  - crypto
-  - sdk
-  - gem
-  - laconic-console
-containers:
-  - cerc/laconicd
-  - cerc/laconic-registry-cli
-  - cerc/laconic-console-host
-pods:
-  - mainnet-laconicd
-  - fixturenet-laconic-console
-config:
-  cli:
-    key: laconicd.mykey
-    address: laconicd.myaddress

app/data/stacks/mobymask/README.md

@@ -1,53 +0,0 @@
-# MobyMask
-
-The MobyMask watcher is a Laconic Network component that provides efficient access to MobyMask contract data from Ethereum, along with evidence allowing users to verify the correctness of that data. The watcher source code is available in [this repository](https://github.com/cerc-io/watcher-ts/tree/main/packages/mobymask-watcher) and a developer-oriented Docker Compose setup for the watcher can be found [here](https://github.com/cerc-io/mobymask-watcher). The watcher can be deployed automatically using the Laconic Stack Orchestrator tool as detailed below:
-
-## Deploy the MobyMask Watcher
-
-The instructions below show how to deploy a MobyMask watcher using laconic-stack-orchestrator (the installation of which is covered [here](https://github.com/cerc-io/stack-orchestrator#user-mode)).
-
-This deployment expects that ipld-eth-server's endpoints are available on the local machine at http://ipld-eth-server.example.com:8083/graphql and http://ipld-eth-server.example.com:8082. More advanced configurations are supported by modifying the watcher's [config file](../../config/watcher-mobymask/mobymask-watcher.toml).
-
-## Clone required repositories
-
-```
-$ laconic-so setup-repositories --include github.com/cerc-io/watcher-ts
-```
-
-## Build the watcher container
-
-```
-$ laconic-so build-containers --include cerc/watcher-mobymask
-```
-
-This should create a container with tag `cerc/watcher-mobymask` in the local image registry.
-
-## Deploy the stack
-
-First the watcher database has to be initialized. Start only the mobymask-watcher-db service:
-
-```
-$ laconic-so deploy-system --include watcher-mobymask up mobymask-watcher-db
-```
-
-Next find the container's id using `docker ps` then run the following command to initialize the database:
-
-```
-$ docker exec -i <mobymask-watcher-db-container> psql -U vdbm mobymask-watcher < config/watcher-mobymask/mobymask-watcher-db.sql
-```
-
-Finally start the remaining containers:
-
-```
-$ laconic-so deploy-system --include watcher-mobymask up
-```
-
-Correct operation should be verified by following the instructions [here](https://github.com/cerc-io/mobymask-watcher/tree/main/mainnet-watcher-only#run), checking GraphQL queries return valid results in the watcher's [playground](http://127.0.0.1:3001/graphql).
-
-## Clean up
-
-Stop all the services running in background:
-
-```bash
-$ laconic-so deploy-system --include watcher-mobymask down
-```

app/data/stacks/package-registry/README.md

@@ -1,5 +0,0 @@
-# Package Registry Stack
-
-The Package Registry Stack supports a build environment that requires a package registry (initially for NPM packages only).
-
-Setup instructions can be found [here](../build-support/README.md).

app/data/stacks/package-registry/stack.yml

@@ -1,15 +0,0 @@
-version: "1.1"
-name: package-registry
-decription: "Local Package Registry"
-repos:
-  - github.com/cerc-io/hosting
-  - gitea.com/gitea/act_runner
-containers:
-  - cerc/act-runner
-  - cerc/act-runner-task-executor
-pods:
-  - name: gitea
-    repository: cerc-io/hosting
-    path: gitea
-    pre_start_command: "run-this-first.sh"
-    post_start_command: "initialize-gitea.sh"

app/data/stacks/test/README.md

@@ -1,3 +0,0 @@
-# Test Stack
-
-A stack for test/demo purposes.

app/deploy.py

@@ -1,422 +0,0 @@
-# Copyright © 2022, 2023 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-# Deploys the system components using docker-compose
-
-import hashlib
-import copy
-import os
-import sys
-from dataclasses import dataclass
-from decouple import config
-from importlib import resources
-import subprocess
-from python_on_whales import DockerClient, DockerException
-import click
-from pathlib import Path
-from .util import include_exclude_check, get_parsed_stack_config, global_options2
-from .deployment_create import create as deployment_create
-from .deployment_create import init as deployment_init
-
-
-class DeployCommandContext(object):
-    def __init__(self, cluster_context, docker):
-        self.cluster_context = cluster_context
-        self.docker = docker
-
-
-@click.group()
-@click.option("--include", help="only start these components")
-@click.option("--exclude", help="don\'t start these components")
-@click.option("--env-file", help="env file to be used")
-@click.option("--cluster", help="specify a non-default cluster name")
-@click.pass_context
-def command(ctx, include, exclude, env_file, cluster):
-    '''deploy a stack'''
-
-    if ctx.parent.obj.debug:
-        print(f"ctx.parent.obj: {ctx.parent.obj}")
-    ctx.obj = create_deploy_context(global_options2(ctx), global_options2(ctx).stack, include, exclude, cluster, env_file)
-    # Subcommand is executed now, by the magic of click
-
-
-def create_deploy_context(global_context, stack, include, exclude, cluster, env_file):
-    cluster_context = _make_cluster_context(global_context, stack, include, exclude, cluster, env_file)
-    # See: https://gabrieldemarmiesse.github.io/python-on-whales/sub-commands/compose/
-    docker = DockerClient(compose_files=cluster_context.compose_files, compose_project_name=cluster_context.cluster,
-                          compose_env_file=cluster_context.env_file)
-    return DeployCommandContext(cluster_context, docker)
-
-
-def up_operation(ctx, services_list):
-    global_context = ctx.parent.parent.obj
-    deploy_context = ctx.obj
-    if not global_context.dry_run:
-        cluster_context = deploy_context.cluster_context
-        container_exec_env = _make_runtime_env(global_context)
-        for attr, value in container_exec_env.items():
-            os.environ[attr] = value
-        if global_context.verbose:
-            print(f"Running compose up with container_exec_env: {container_exec_env}, extra_args: {services_list}")
-        for pre_start_command in cluster_context.pre_start_commands:
-            _run_command(global_context, cluster_context.cluster, pre_start_command)
-        deploy_context.docker.compose.up(detach=True, services=services_list)
-        for post_start_command in cluster_context.post_start_commands:
-            _run_command(global_context, cluster_context.cluster, post_start_command)
-        _orchestrate_cluster_config(global_context, cluster_context.config, deploy_context.docker, container_exec_env)
-
-
-def down_operation(ctx, delete_volumes, extra_args_list):
-    global_context = ctx.parent.parent.obj
-    if not global_context.dry_run:
-        if global_context.verbose:
-            print("Running compose down")
-        timeout_arg = None
-        if extra_args_list:
-            timeout_arg = extra_args_list[0]
-        # Specify shutdown timeout (default 10s) to give services enough time to shutdown gracefully
-        ctx.obj.docker.compose.down(timeout=timeout_arg, volumes=delete_volumes)
-
-
-def ps_operation(ctx):
-    global_context = ctx.parent.parent.obj
-    if not global_context.dry_run:
-        if global_context.verbose:
-            print("Running compose ps")
-        container_list = ctx.obj.docker.compose.ps()
-        if len(container_list) > 0:
-            print("Running containers:")
-            for container in container_list:
-                print(f"id: {container.id}, name: {container.name}, ports: ", end="")
-                ports = container.network_settings.ports
-                comma = ""
-                for port_mapping in ports.keys():
-                    mapping = ports[port_mapping]
-                    print(comma, end="")
-                    if mapping is None:
-                        print(f"{port_mapping}", end="")
-                    else:
-                        print(f"{mapping[0]['HostIp']}:{mapping[0]['HostPort']}->{port_mapping}", end="")
-                    comma = ", "
-                print()
-        else:
-            print("No containers running")
-
-
-def port_operation(ctx, extra_args):
-    global_context = ctx.parent.parent.obj
-    extra_args_list = list(extra_args) or None
-    if not global_context.dry_run:
-        if extra_args_list is None or len(extra_args_list) < 2:
-            print("Usage: port <service> <exposed-port>")
-            sys.exit(1)
-        service_name = extra_args_list[0]
-        exposed_port = extra_args_list[1]
-        if global_context.verbose:
-            print(f"Running compose port {service_name} {exposed_port}")
-        mapped_port_data = ctx.obj.docker.compose.port(service_name, exposed_port)
-        print(f"{mapped_port_data[0]}:{mapped_port_data[1]}")
-
-
-def exec_operation(ctx, extra_args):
-    global_context = ctx.parent.parent.obj
-    extra_args_list = list(extra_args) or None
-    if not global_context.dry_run:
-        if extra_args_list is None or len(extra_args_list) < 2:
-            print("Usage: exec <service> <cmd>")
-            sys.exit(1)
-        service_name = extra_args_list[0]
-        command_to_exec = ["sh", "-c"] + extra_args_list[1:]
-        container_exec_env = _make_runtime_env(global_context)
-        if global_context.verbose:
-            print(f"Running compose exec {service_name} {command_to_exec}")
-        try:
-            ctx.obj.docker.compose.execute(service_name, command_to_exec, envs=container_exec_env)
-        except DockerException as error:
-            print(f"container command returned error exit status")
-
-
-def logs_operation(ctx, extra_args):
-    global_context = ctx.parent.parent.obj
-    extra_args_list = list(extra_args) or None
-    if not global_context.dry_run:
-        if global_context.verbose:
-            print("Running compose logs")
-        logs_output = ctx.obj.docker.compose.logs(services=extra_args_list if extra_args_list is not None else [])
-        print(logs_output)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: up <service1> <service2>
-@click.pass_context
-def up(ctx, extra_args):
-    extra_args_list = list(extra_args) or None
-    up_operation(ctx, extra_args_list)
-
-
-@command.command()
-@click.option("--delete-volumes/--preserve-volumes", default=False, help="delete data volumes")
-@click.argument('extra_args', nargs=-1)  # help: command: down<service1> <service2>
-@click.pass_context
-def down(ctx, delete_volumes, extra_args):
-    extra_args_list = list(extra_args) or None
-    down_operation(ctx, delete_volumes, extra_args_list)
-
-
-@command.command()
-@click.pass_context
-def ps(ctx):
-    ps_operation(ctx)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: port <service1> <service2>
-@click.pass_context
-def port(ctx, extra_args):
-    port_operation(ctx, extra_args)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: exec <service> <command>
-@click.pass_context
-def exec(ctx, extra_args):
-    exec_operation(ctx, extra_args)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: logs <service1> <service2>
-@click.pass_context
-def logs(ctx, extra_args):
-    logs_operation(ctx, extra_args)
-
-
-def get_stack_status(ctx, stack):
-
-    ctx_copy = copy.copy(ctx)
-    ctx_copy.stack = stack
-
-    cluster_context = _make_cluster_context(ctx_copy, stack, None, None, None, None)
-    docker = DockerClient(compose_files=cluster_context.compose_files, compose_project_name=cluster_context.cluster)
-    # TODO: refactor to avoid duplicating this code above
-    if ctx.verbose:
-        print("Running compose ps")
-    container_list = docker.compose.ps()
-    if len(container_list) > 0:
-        if ctx.debug:
-            print(f"Container list from compose ps: {container_list}")
-        return True
-    else:
-        if ctx.debug:
-            print("No containers found from compose ps")
-        False
-
-
-def _make_runtime_env(ctx):
-    container_exec_env = {
-        "CERC_HOST_UID": f"{os.getuid()}",
-        "CERC_HOST_GID": f"{os.getgid()}"
-    }
-    container_exec_env.update({"CERC_SCRIPT_DEBUG": "true"} if ctx.debug else {})
-    return container_exec_env
-
-
-# stack has to be either PathLike pointing to a stack yml file, or a string with the name of a known stack
-def _make_cluster_context(ctx, stack, include, exclude, cluster, env_file):
-
-    if ctx.local_stack:
-        dev_root_path = os.getcwd()[0:os.getcwd().rindex("stack-orchestrator")]
-        print(f'Local stack dev_root_path (CERC_REPO_BASE_DIR) overridden to: {dev_root_path}')
-    else:
-        dev_root_path = os.path.expanduser(config("CERC_REPO_BASE_DIR", default="~/cerc"))
-
-    # TODO: huge hack, fix this
-    # If the caller passed a path for the stack file, then we know that we can get the compose files
-    # from the same directory
-    if isinstance(stack, os.PathLike):
-        compose_dir = stack.parent.joinpath("compose")
-    else:
-        # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-        compose_dir = Path(__file__).absolute().parent.joinpath("data", "compose")
-
-    if cluster is None:
-        # Create default unique, stable cluster name from confile file path and stack name if provided
-        # TODO: change this to the config file path
-        path = os.path.realpath(sys.argv[0])
-        unique_cluster_descriptor = f"{path},{stack},{include},{exclude}"
-        if ctx.debug:
-            print(f"pre-hash descriptor: {unique_cluster_descriptor}")
-        hash = hashlib.md5(unique_cluster_descriptor.encode()).hexdigest()
-        cluster = f"laconic-{hash}"
-        if ctx.verbose:
-            print(f"Using cluster name: {cluster}")
-
-    # See: https://stackoverflow.com/a/20885799/1701505
-    from . import data
-    with resources.open_text(data, "pod-list.txt") as pod_list_file:
-        all_pods = pod_list_file.read().splitlines()
-
-    pods_in_scope = []
-    if stack:
-        stack_config = get_parsed_stack_config(stack)
-        # TODO: syntax check the input here
-        pods_in_scope = stack_config['pods']
-        cluster_config = stack_config['config'] if 'config' in stack_config else None
-    else:
-        pods_in_scope = all_pods
-        cluster_config = None
-
-    # Convert all pod definitions to v1.1 format
-    pods_in_scope = _convert_to_new_format(pods_in_scope)
-
-    if ctx.verbose:
-        print(f"Pods: {pods_in_scope}")
-
-    # Construct a docker compose command suitable for our purpose
-
-    compose_files = []
-    pre_start_commands = []
-    post_start_commands = []
-    for pod in pods_in_scope:
-        pod_name = pod["name"]
-        pod_repository = pod["repository"]
-        pod_path = pod["path"]
-        if include_exclude_check(pod_name, include, exclude):
-            if pod_repository is None or pod_repository == "internal":
-                compose_file_name = os.path.join(compose_dir, f"docker-compose-{pod_path}.yml")
-            else:
-                pod_root_dir = os.path.join(dev_root_path, pod_repository.split("/")[-1], pod["path"])
-                compose_file_name = os.path.join(pod_root_dir, "docker-compose.yml")
-                pod_pre_start_command = pod["pre_start_command"]
-                pod_post_start_command = pod["post_start_command"]
-                if pod_pre_start_command is not None:
-                    pre_start_commands.append(os.path.join(pod_root_dir, pod_pre_start_command))
-                if pod_post_start_command is not None:
-                    post_start_commands.append(os.path.join(pod_root_dir, pod_post_start_command))
-            compose_files.append(compose_file_name)
-        else:
-            if ctx.verbose:
-                print(f"Excluding: {pod_name}")
-
-    if ctx.verbose:
-        print(f"files: {compose_files}")
-
-    return cluster_context(cluster, compose_files, pre_start_commands, post_start_commands, cluster_config, env_file)
-
-
-class cluster_context:
-    def __init__(self, cluster, compose_files, pre_start_commands, post_start_commands, config, env_file) -> None:
-        self.cluster = cluster
-        self.compose_files = compose_files
-        self.pre_start_commands = pre_start_commands
-        self.post_start_commands = post_start_commands
-        self.config = config
-        self.env_file = env_file
-
-
-def _convert_to_new_format(old_pod_array):
-    new_pod_array = []
-    for old_pod in old_pod_array:
-        if isinstance(old_pod, dict):
-            new_pod_array.append(old_pod)
-        else:
-            new_pod = {
-                "name": old_pod,
-                "repository": "internal",
-                "path": old_pod
-            }
-            new_pod_array.append(new_pod)
-    return new_pod_array
-
-
-def _run_command(ctx, cluster_name, command):
-    if ctx.verbose:
-        print(f"Running command: {command}")
-    command_dir = os.path.dirname(command)
-    command_file = os.path.join(".", os.path.basename(command))
-    command_env = os.environ.copy()
-    command_env["CERC_SO_COMPOSE_PROJECT"] = cluster_name
-    if ctx.debug:
-        command_env["CERC_SCRIPT_DEBUG"] = "true"
-    command_result = subprocess.run(command_file, shell=True, env=command_env, cwd=command_dir)
-    if command_result.returncode != 0:
-        print(f"FATAL Error running command: {command}")
-        sys.exit(1)
-
-
-def _orchestrate_cluster_config(ctx, cluster_config, docker, container_exec_env):
-
-    @dataclass
-    class ConfigDirective:
-        source_container: str
-        source_variable: str
-        destination_container: str
-        destination_variable: str
-
-    if cluster_config is not None:
-        for container in cluster_config:
-            container_config = cluster_config[container]
-            if ctx.verbose:
-                print(f"{container} config: {container_config}")
-            for directive in container_config:
-                pd = ConfigDirective(
-                    container_config[directive].split(".")[0],
-                    container_config[directive].split(".")[1],
-                    container,
-                    directive
-                )
-                if ctx.verbose:
-                    print(f"Setting {pd.destination_container}.{pd.destination_variable}"
-                          f" = {pd.source_container}.{pd.source_variable}")
-                # TODO: add a timeout
-                waiting_for_data = True
-                destination_output = "*** no output received yet ***"
-                while waiting_for_data:
-                    # TODO: fix the script paths so they're consistent between containers
-                    source_value = None
-                    try:
-                        source_value = docker.compose.execute(pd.source_container,
-                                                              ["sh", "-c",
-                                                                  "sh /docker-entrypoint-scripts.d/export-"
-                                                                  f"{pd.source_variable}.sh"],
-                                                              tty=False,
-                                                              envs=container_exec_env)
-                    except DockerException as error:
-                        if ctx.debug:
-                            print(f"Docker exception reading config source: {error}")
-                        # If the script executed failed for some reason, we get:
-                        # "It returned with code 1"
-                        if "It returned with code 1" in str(error):
-                            if ctx.verbose:
-                                print("Config export script returned an error, re-trying")
-                        # If the script failed to execute (e.g. the file is not there) then we get:
-                        # "It returned with code 2"
-                        if "It returned with code 2" in str(error):
-                            print(f"Fatal error reading config source: {error}")
-                    if source_value:
-                        if ctx.debug:
-                            print(f"fetched source value: {source_value}")
-                        destination_output = docker.compose.execute(pd.destination_container,
-                                                                    ["sh", "-c",
-                                                                        f"sh /scripts/import-{pd.destination_variable}.sh"
-                                                                        f" {source_value}"],
-                                                                    tty=False,
-                                                                    envs=container_exec_env)
-                        waiting_for_data = False
-                    if ctx.debug:
-                        print(f"destination output: {destination_output}")
-
-
-command.add_command(deployment_init)
-command.add_command(deployment_create)

app/deployment.py

@@ -1,141 +0,0 @@
-# Copyright © 2022, 2023 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-import click
-from dataclasses import dataclass
-from pathlib import Path
-import sys
-from .deploy import up_operation, down_operation, ps_operation, port_operation, exec_operation, logs_operation, create_deploy_context
-from .util import global_options
-
-
-@dataclass
-class DeploymentContext:
-    dir: Path
-
-
-@click.group()
-@click.option("--dir", required=True, help="path to deployment directory")
-@click.pass_context
-def command(ctx, dir):
-    # Check that --stack wasn't supplied
-    if ctx.parent.obj.stack:
-        print("Error: --stack can't be supplied with the deployment command")
-        sys.exit(1)
-    # Check dir is valid
-    dir_path = Path(dir)
-    if not dir_path.exists():
-        print(f"Error: deployment directory {dir} does not exist")
-        sys.exit(1)
-    if not dir_path.is_dir():
-        print(f"Error: supplied deployment directory path {dir} exists but is a file not a directory")
-        sys.exit(1)
-    # Store the deployment context for subcommands
-    ctx.obj = DeploymentContext(dir_path)
-
-
-def make_deploy_context(ctx):
-    # Get the stack config file name
-    stack_file_path = ctx.obj.dir.joinpath("stack.yml")
-    # TODO: add cluster name and env file here
-    return create_deploy_context(ctx.parent.parent.obj, stack_file_path, None, None, None, None)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: up <service1> <service2>
-@click.pass_context
-def up(ctx, extra_args):
-    ctx.obj = make_deploy_context(ctx)
-    services_list = list(extra_args) or None
-    up_operation(ctx, services_list)
-
-
-# start is the preferred alias for up
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: up <service1> <service2>
-@click.pass_context
-def start(ctx, extra_args):
-    ctx.obj = make_deploy_context(ctx)
-    services_list = list(extra_args) or None
-    up_operation(ctx, services_list)
-
-
-@command.command()
-@click.option("--delete-volumes/--preserve-volumes", default=False, help="delete data volumes")
-@click.argument('extra_args', nargs=-1)  # help: command: down <service1> <service2>
-@click.pass_context
-def down(ctx, delete_volumes, extra_args):
-    # Get the stack config file name
-    # TODO: add cluster name and env file here
-    ctx.obj = make_deploy_context(ctx)
-    down_operation(ctx, delete_volumes, extra_args)
-
-
-# stop is the preferred alias for down
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: down <service1> <service2>
-@click.pass_context
-def stop(ctx, extra_args):
-    # TODO: add cluster name and env file here
-    ctx.obj = make_deploy_context(ctx)
-    down_operation(ctx, extra_args, None)
-
-
-@command.command()
-@click.pass_context
-def ps(ctx):
-    ctx.obj = make_deploy_context(ctx)
-    ps_operation(ctx)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: port <service1> <service2>
-@click.pass_context
-def port(ctx, extra_args):
-    port_operation(ctx, extra_args)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: exec <service> <command>
-@click.pass_context
-def exec(ctx, extra_args):
-    ctx.obj = make_deploy_context(ctx)
-    exec_operation(ctx, extra_args)
-
-
-@command.command()
-@click.argument('extra_args', nargs=-1)  # help: command: logs <service1> <service2>
-@click.pass_context
-def logs(ctx, extra_args):
-    ctx.obj = make_deploy_context(ctx)
-    logs_operation(ctx, extra_args)
-
-
-@command.command()
-@click.pass_context
-def status(ctx):
-    print(f"Context: {ctx.parent.obj}")
-
-
-
-#from importlib import resources, util
-# TODO: figure out how to do this dynamically
-#stack = "mainnet-laconic"
-#module_name = "commands"
-#spec = util.spec_from_file_location(module_name, "./app/data/stacks/" + stack + "/deploy/commands.py")
-#imported_stack = util.module_from_spec(spec)
-#spec.loader.exec_module(imported_stack)
-#command.add_command(imported_stack.init)
-#command.add_command(imported_stack.create)

app/deployment_create.py

@@ -1,182 +0,0 @@
-# Copyright © 2022, 2023 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-import click
-import os
-from pathlib import Path
-from shutil import copyfile, copytree
-import sys
-import ruamel.yaml
-from .util import get_stack_file_path, get_parsed_deployment_spec, get_parsed_stack_config, global_options
-
-
-def _get_yaml():
-    # See: https://stackoverflow.com/a/45701840/1701505
-    yaml = ruamel.yaml.YAML()
-    yaml.preserve_quotes = True
-    yaml.indent(sequence=3, offset=1)
-    return yaml
-
-
-def _make_default_deployment_dir():
-    return "deployment-001"
-
-
-def _get_compose_file_dir():
-    # TODO: refactor to use common code with deploy command
-    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-    data_dir = Path(__file__).absolute().parent.joinpath("data")
-    source_compose_dir = data_dir.joinpath("compose")
-    return source_compose_dir
-
-
-def _get_named_volumes(stack):
-    # Parse the compose files looking for named volumes
-    named_volumes = []
-    parsed_stack = get_parsed_stack_config(stack)
-    pods = parsed_stack["pods"]
-    yaml = _get_yaml()
-    for pod in pods:
-        pod_file_path = os.path.join(_get_compose_file_dir(), f"docker-compose-{pod}.yml")
-        parsed_pod_file = yaml.load(open(pod_file_path, "r"))
-        if "volumes" in parsed_pod_file:
-            volumes = parsed_pod_file["volumes"]
-            for volume in volumes.keys():
-                # Volume definition looks like:
-                # 'laconicd-data': None
-                named_volumes.append(volume)
-    return named_volumes
-
-
-# If we're mounting a volume from a relatie path, then we
-# assume the directory doesn't exist yet and create it
-# so the deployment will start
-# Also warn if the path is absolute and doesn't exist
-def _create_bind_dir_if_relative(volume, path_string, compose_dir):
-    path = Path(path_string)
-    if not path.is_absolute():
-        absolute_path = Path(compose_dir).parent.joinpath(path)
-        absolute_path.mkdir(parents=True, exist_ok=True)
-    else:
-        if not path.exists():
-            print(f"WARNING: mount path for volume {volume} does not exist: {path_string}")
-
-
-# See: https://stackoverflow.com/questions/45699189/editing-docker-compose-yml-with-pyyaml
-def _fixup_pod_file(pod, spec, compose_dir):
-    # Fix up volumes
-    if "volumes" in spec:
-        spec_volumes = spec["volumes"]
-        if "volumes" in pod:
-            pod_volumes = pod["volumes"]
-            for volume in pod_volumes.keys():
-                if volume in spec_volumes:
-                    volume_spec = spec_volumes[volume]
-                    volume_spec_fixedup = volume_spec if Path(volume_spec).is_absolute() else f".{volume_spec}"
-                    _create_bind_dir_if_relative(volume, volume_spec, compose_dir)
-                    new_volume_spec = {"driver": "local",
-                                       "driver_opts": {
-                                           "type": "none",
-                                           "device": volume_spec_fixedup,
-                                           "o": "bind"
-                                        }
-                                       }
-                    pod["volumes"][volume] = new_volume_spec
-
-
-# Inspect the pod yaml to find config files referenced in subdirectories
-# other than the one associated with the pod
-def _find_extra_config_dirs(parsed_pod_file, pod):
-    config_dirs = set()
-    services = parsed_pod_file["services"]
-    for service in services:
-        service_info = services[service]
-        if "volumes" in service_info:
-            for volume in service_info["volumes"]:
-                if ":" in volume:
-                    host_path = volume.split(":")[0]
-                    if host_path.startswith("../config"):
-                        config_dir = host_path.split("/")[2]
-                        if config_dir != pod:
-                            config_dirs.add(config_dir)
-    return config_dirs
-
-
-@click.command()
-@click.option("--output", required=True, help="Write yaml spec file here")
-@click.pass_context
-def init(ctx, output):
-    yaml = _get_yaml()
-    stack = global_options(ctx).stack
-    verbose = global_options(ctx).verbose
-    spec_file_content = {"stack": stack}
-    if verbose:
-        print(f"Creating spec file for stack: {stack}")
-    named_volumes = _get_named_volumes(stack)
-    if named_volumes:
-        volume_descriptors = {}
-        for named_volume in named_volumes:
-            volume_descriptors[named_volume] = f"../data/{named_volume}"
-        spec_file_content["volumes"] = volume_descriptors
-    with open(output, "w") as output_file:
-        yaml.dump(spec_file_content, output_file)
-
-
-@click.command()
-@click.option("--spec-file", required=True, help="Spec file to use to create this deployment")
-@click.option("--deployment-dir", help="Create deployment files in this directory")
-@click.pass_context
-def create(ctx, spec_file, deployment_dir):
-    # This function fails with a useful error message if the file doens't exist
-    parsed_spec = get_parsed_deployment_spec(spec_file)
-    stack_name = parsed_spec['stack']
-    stack_file = get_stack_file_path(stack_name)
-    parsed_stack = get_parsed_stack_config(stack_name)
-    if global_options(ctx).debug:
-        print(f"parsed spec: {parsed_spec}")
-    if deployment_dir is None:
-        deployment_dir = _make_default_deployment_dir()
-    if os.path.exists(deployment_dir):
-        print(f"Error: {deployment_dir} already exists")
-        sys.exit(1)
-    os.mkdir(deployment_dir)
-    # Copy spec file and the stack file into the deployment dir
-    copyfile(spec_file, os.path.join(deployment_dir, os.path.basename(spec_file)))
-    copyfile(stack_file, os.path.join(deployment_dir, os.path.basename(stack_file)))
-    # Copy the pod files into the deployment dir, fixing up content
-    pods = parsed_stack['pods']
-    destination_compose_dir = os.path.join(deployment_dir, "compose")
-    os.mkdir(destination_compose_dir)
-    data_dir = Path(__file__).absolute().parent.joinpath("data")
-    yaml = _get_yaml()
-    for pod in pods:
-        pod_file_path = os.path.join(_get_compose_file_dir(), f"docker-compose-{pod}.yml")
-        parsed_pod_file = yaml.load(open(pod_file_path, "r"))
-        extra_config_dirs = _find_extra_config_dirs(parsed_pod_file, pod)
-        if global_options(ctx).debug:
-            print(f"extra config dirs: {extra_config_dirs}")
-        _fixup_pod_file(parsed_pod_file, parsed_spec, destination_compose_dir)
-        with open(os.path.join(destination_compose_dir, os.path.basename(pod_file_path)), "w") as output_file:
-            yaml.dump(parsed_pod_file, output_file)
-        # Copy the config files for the pod, if any
-        config_dirs = {pod}
-        config_dirs = config_dirs.union(extra_config_dirs)
-        for config_dir in config_dirs:
-            source_config_dir = data_dir.joinpath("config", config_dir)
-            if os.path.exists(source_config_dir):
-                destination_config_dir = os.path.join(deployment_dir, "config", config_dir)
-                # If the same config dir appears in multiple pods, it may already have been copied
-                if not os.path.exists(destination_config_dir):
-                    copytree(source_config_dir, destination_config_dir)

app/util.py

@@ -1,80 +0,0 @@
-# Copyright © 2022, 2023 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-import os.path
-import sys
-import yaml
-from pathlib import Path
-
-
-def include_exclude_check(s, include, exclude):
-    if include is None and exclude is None:
-        return True
-    if include is not None:
-        include_list = include.split(",")
-        return s in include_list
-    if exclude is not None:
-        exclude_list = exclude.split(",")
-        return s not in exclude_list
-
-
-def get_stack_file_path(stack):
-    # In order to be compatible with Python 3.8 we need to use this hack to get the path:
-    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-    stack_file_path = Path(__file__).absolute().parent.joinpath("data", "stacks", stack, "stack.yml")
-    return stack_file_path
-
-
-# Caller can pass either the name of a stack, or a path to a stack file
-def get_parsed_stack_config(stack):
-    stack_file_path = stack if isinstance(stack, os.PathLike) else get_stack_file_path(stack)
-    try:
-        with stack_file_path:
-            stack_config = yaml.safe_load(open(stack_file_path, "r"))
-            return stack_config
-    except FileNotFoundError as error:
-        # We try here to generate a useful diagnostic error
-        # First check if the stack directory is present
-        stack_directory = stack_file_path.parent
-        if os.path.exists(stack_directory):
-            print(f"Error: stack.yml file is missing from stack: {stack}")
-        else:
-            print(f"Error: stack: {stack} does not exist")
-        print(f"Exiting, error: {error}")
-        sys.exit(1)
-
-
-def get_parsed_deployment_spec(spec_file):
-    spec_file_path = Path(spec_file)
-    try:
-        with spec_file_path:
-            deploy_spec = yaml.safe_load(open(spec_file_path, "r"))
-            return deploy_spec
-    except FileNotFoundError as error:
-        # We try here to generate a useful diagnostic error
-        print(f"Error: spec file: {spec_file_path} does not exist")
-        print(f"Exiting, error: {error}")
-        sys.exit(1)
-
-
-# TODO: this is fragile wrt to the subcommand depth
-# See also: https://github.com/pallets/click/issues/108
-def global_options(ctx):
-    return ctx.parent.parent.obj
-
-
-# TODO: hack
-def global_options2(ctx):
-    return ctx.parent.obj

cli.py

@@ -1,61 +0,0 @@
-# Copyright © 2022 Cerc
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http:#www.gnu.org/licenses/>.
-
-import click
-from dataclasses import dataclass
-
-from app import setup_repositories
-from app import build_containers
-from app import build_npms
-from app import deploy
-from app import version
-from app import deployment
-
-CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
-
-
-@dataclass
-class Options:
-    stack: str
-    quiet: bool = False
-    verbose: bool = False
-    dry_run: bool = False
-    local_stack: bool = False
-    debug: bool = False
-    continue_on_error: bool = False
-
-
-@click.group(context_settings=CONTEXT_SETTINGS)
-@click.option('--stack', help="specify a stack to build/deploy")
-@click.option('--quiet', is_flag=True, default=False)
-@click.option('--verbose', is_flag=True, default=False)
-@click.option('--dry-run', is_flag=True, default=False)
-@click.option('--local-stack', is_flag=True, default=False)
-@click.option('--debug', is_flag=True, default=False)
-@click.option('--continue-on-error', is_flag=True, default=False)
-# See: https://click.palletsprojects.com/en/8.1.x/complex/#building-a-git-clone
-@click.pass_context
-def cli(ctx, stack, quiet, verbose, dry_run, local_stack, debug, continue_on_error):
-    """Laconic Stack Orchestrator"""
-    ctx.obj = Options(stack, quiet, verbose, dry_run, local_stack, debug, continue_on_error)
-
-
-cli.add_command(setup_repositories.command, "setup-repositories")
-cli.add_command(build_containers.command, "build-containers")
-cli.add_command(build_npms.command, "build-npms")
-cli.add_command(deploy.command, "deploy")  # deploy is an alias for deploy-system
-cli.add_command(deploy.command, "deploy-system")
-cli.add_command(deployment.command, "deployment")
-cli.add_command(version.command, "version")

docs/CONTRIBUTING.md

@@ -26,7 +26,7 @@ In addition to the pre-requisites listed in the [README](/README.md), the follow
 
 1. Clone this repository:
    ```
-   $ git clone https://github.com/cerc-io/stack-orchestrator.git
+   $ git clone https://git.vdb.to/cerc-io/stack-orchestrator.git
    ```
 
 2. Enter the project directory:

docs/README.md

@@ -0,0 +1,8 @@
+# Stack Orchestrator
+
+Here you will find information about the design of stack orchestrator, contributing to it, and deploying services/applications that combine two or more "stacks".
+
+Most "stacks" contain their own README which has plenty of information on deploying, but stacks can be combined in a variety of ways which are document here, for example:
+
+- [Gitea with Laconicd Fixturenet](./gitea-with-laconicd-fixturenet.md)
+- [Laconicd Registry with Console](./laconicd-with-console.md)

docs/adding-a-new-stack.md

@@ -0,0 +1,71 @@
+# Adding a new stack
+
+See [this PR](https://git.vdb.to/cerc-io/stack-orchestrator/pull/434) for an example of how to currently add a minimal stack to stack orchestrator. The [reth stack](https://git.vdb.to/cerc-io/stack-orchestrator/pull/435) is another good example.
+
+For external developers, we recommend forking this repo and adding your stack directly to your fork. This initially requires running in "developer mode" as described [here](/docs/CONTRIBUTING.md). Check out the [Namada stack](https://github.com/vknowable/stack-orchestrator/blob/main/app/data/stacks/public-namada/digitalocean_quickstart.md) from Knowable to see how that is done.
+
+Core to the feature completeness of stack orchestrator is to [decouple the tool functionality from payload](https://git.vdb.to/cerc-io/stack-orchestrator/issues/315) which will no longer require forking to add a stack.
+
+## Example
+
+- in `stack_orchestrator/data/stacks/my-new-stack/stack.yml` add:
+
+```yaml
+version: "0.1"
+name: my-new-stack
+repos:
+  - github.com/my-org/my-new-stack
+containers:
+  - cerc/my-new-stack
+pods:
+  - my-new-stack
+```
+
+- in `stack_orchestrator/data/container-build/cerc-my-new-stack/build.sh` add:
+
+```yaml
+#!/usr/bin/env bash
+# Build the my-new-stack image
+source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
+docker build -t cerc/my-new-stack:local -f ${CERC_REPO_BASE_DIR}/my-new-stack/Dockerfile ${build_command_args} ${CERC_REPO_BASE_DIR}/my-new-stack
+```
+
+- in `stack_orchestrator/data/compose/docker-compose-my-new-stack.yml` add:
+
+```yaml
+version: "3.2"
+
+services:
+  my-new-stack:
+    image: cerc/my-new-stack:local
+    restart: always
+    ports:
+      - "0.0.0.0:3000:3000"
+```
+
+- in `stack_orchestrator/data/repository-list.txt` add:
+
+```bash
+github.com/my-org/my-new-stack
+```
+whereby that repository contains your source code and a `Dockerfile`, and matches the `repos:` field in the `stack.yml`.
+
+- in `stack_orchestrator/data/container-image-list.txt` add:
+
+```bash
+cerc/my-new-stack
+```
+
+- in `stack_orchestrator/data/pod-list.txt` add:
+
+```bash
+my-new-stack
+```
+
+Now, the following commands will fetch, build, and deploy you app:
+
+```bash
+laconic-so --stack my-new-stack setup-repositories
+laconic-so --stack my-new-stack build-containers
+laconic-so --stack my-new-stack deploy-system up
+```

docs/cli.md

@@ -6,7 +6,7 @@ Sub-commands and flags
 
 Clone a single repository:
 ```
-$ laconic-so setup-repositories --include cerc-io/go-ethereum
+$ laconic-so setup-repositories --include github.com/cerc-io/go-ethereum
 ```
 Clone the repositories for a stack:
 ```
@@ -51,7 +51,7 @@ $ laconic-so build-npms --include <package-name>
 ```
 e.g.
 ```
-$ laconic-so build-npms --include laconic-sdk
+$ laconic-so build-npms --include registry-sdk
 ```
 Build the packages for a stack:
 ```
@@ -65,3 +65,71 @@ Force full rebuild of packages:
 ```
 $ laconic-so build-npms --include <package-name> --force-rebuild
 ```
+
+## deploy
+
+The `deploy` command group manages persistent deployments. The general workflow is `deploy init` to generate a spec file, then `deploy create` to create a deployment directory from the spec, then runtime commands like `deploy up` and `deploy down`.
+
+### deploy init
+
+Generate a deployment spec file from a stack definition:
+```
+$ laconic-so --stack <stack-name> deploy init --output <spec-file>
+```
+
+Options:
+- `--output` (required): write spec file here
+- `--config`: provide config variables for the deployment
+- `--config-file`: provide config variables in a file
+- `--kube-config`: provide a config file for a k8s deployment
+- `--image-registry`: provide a container image registry url for this k8s cluster
+- `--map-ports-to-host`: map ports to the host (`any-variable-random`, `localhost-same`, `any-same`, `localhost-fixed-random`, `any-fixed-random`)
+
+### deploy create
+
+Create a deployment directory from a spec file:
+```
+$ laconic-so --stack <stack-name> deploy create --spec-file <spec-file> --deployment-dir <dir>
+```
+
+Update an existing deployment in-place (preserving data volumes and env file):
+```
+$ laconic-so --stack <stack-name> deploy create --spec-file <spec-file> --deployment-dir <dir> --update
+```
+
+Options:
+- `--spec-file` (required): spec file to use
+- `--deployment-dir`: target directory for deployment files
+- `--update`: update an existing deployment directory, preserving data volumes and env file. Changed files are backed up with a `.bak` suffix. The deployment's `config.env` and `deployment.yml` are also preserved.
+- `--network-dir`: network configuration supplied in this directory
+- `--initial-peers`: initial set of persistent peers
+
+### deploy up
+
+Start a deployment:
+```
+$ laconic-so deployment --dir <deployment-dir> up
+```
+
+### deploy down
+
+Stop a deployment:
+```
+$ laconic-so deployment --dir <deployment-dir> down
+```
+Use `--delete-volumes` to also remove data volumes.
+
+### deploy ps
+
+Show running services:
+```
+$ laconic-so deployment --dir <deployment-dir> ps
+```
+
+### deploy logs
+
+View service logs:
+```
+$ laconic-so deployment --dir <deployment-dir> logs
+```
+Use `-f` to follow and `-n <count>` to tail.

docs/deployment_patterns.md

@@ -0,0 +1,202 @@
+# Deployment Patterns
+
+## GitOps Pattern
+
+For production deployments, we recommend a GitOps approach where your deployment configuration is tracked in version control.
+
+### Overview
+
+- **spec.yml is your source of truth**: Maintain it in your operator repository
+- **Don't regenerate on every restart**: Run `deploy init` once, then customize and commit
+- **Use restart for updates**: The restart command respects your git-tracked spec.yml
+
+### Workflow
+
+1. **Initial setup**: Run `deploy init` once to generate a spec.yml template
+2. **Customize and commit**: Edit spec.yml with your configuration (hostnames, resources, etc.) and commit to your operator repo
+3. **Deploy from git**: Use the committed spec.yml for deployments
+4. **Update via git**: Make changes in git, then restart to apply
+
+```bash
+# Initial setup (run once)
+laconic-so --stack my-stack deploy init --output spec.yml
+
+# Customize for your environment
+vim spec.yml  # Set hostname, resources, etc.
+
+# Commit to your operator repository
+git add spec.yml
+git commit -m "Add my-stack deployment configuration"
+git push
+
+# On deployment server: deploy from git-tracked spec
+laconic-so deploy create \
+  --spec-file /path/to/operator-repo/spec.yml \
+  --deployment-dir my-deployment
+
+laconic-so deployment --dir my-deployment start
+```
+
+### Updating Deployments
+
+When you need to update a deployment:
+
+```bash
+# 1. Make changes in your operator repo
+vim /path/to/operator-repo/spec.yml
+git commit -am "Update configuration"
+git push
+
+# 2. On deployment server: pull and restart
+cd /path/to/operator-repo && git pull
+laconic-so deployment --dir my-deployment restart
+```
+
+The `restart` command:
+- Pulls latest code from the stack repository
+- Uses your git-tracked spec.yml (does NOT regenerate from defaults)
+- Syncs the deployment directory
+- Restarts services
+
+### Anti-patterns
+
+**Don't do this:**
+```bash
+# BAD: Regenerating spec on every deployment
+laconic-so --stack my-stack deploy init --output spec.yml
+laconic-so deploy create --spec-file spec.yml ...
+```
+
+This overwrites your customizations with defaults from the stack's `commands.py`.
+
+**Do this instead:**
+```bash
+# GOOD: Use your git-tracked spec
+git pull  # Get latest spec.yml from your operator repo
+laconic-so deployment --dir my-deployment restart
+```
+
+## Private Registry Authentication
+
+For deployments using images from private container registries (e.g., GitHub Container Registry), configure authentication in your spec.yml:
+
+### Configuration
+
+Add a `registry-credentials` section to your spec.yml:
+
+```yaml
+registry-credentials:
+  server: ghcr.io
+  username: your-org-or-username
+  token-env: REGISTRY_TOKEN
+```
+
+**Fields:**
+- `server`: The registry hostname (e.g., `ghcr.io`, `docker.io`, `gcr.io`)
+- `username`: Registry username (for GHCR, use your GitHub username or org name)
+- `token-env`: Name of the environment variable containing your API token/PAT
+
+### Token Environment Variable
+
+The `token-env` pattern keeps credentials out of version control. Set the environment variable when running `deployment start`:
+
+```bash
+export REGISTRY_TOKEN="your-personal-access-token"
+laconic-so deployment --dir my-deployment start
+```
+
+For GHCR, create a Personal Access Token (PAT) with `read:packages` scope.
+
+### Ansible Integration
+
+When using Ansible for deployments, pass the token from a credentials file:
+
+```yaml
+- name: Start deployment
+  ansible.builtin.command:
+    cmd: laconic-so deployment --dir {{ deployment_dir }} start
+  environment:
+    REGISTRY_TOKEN: "{{ lookup('file', '~/.credentials/ghcr_token') }}"
+```
+
+### How It Works
+
+1. laconic-so reads the `registry-credentials` config from spec.yml
+2. Creates a Kubernetes `docker-registry` secret named `{deployment}-registry`
+3. The deployment's pods reference this secret for image pulls
+
+## Cluster and Volume Management
+
+### Stopping Deployments
+
+The `deployment stop` command has two important flags:
+
+```bash
+# Default: stops deployment, deletes cluster, PRESERVES volumes
+laconic-so deployment --dir my-deployment stop
+
+# Explicitly delete volumes (USE WITH CAUTION)
+laconic-so deployment --dir my-deployment stop --delete-volumes
+```
+
+### Volume Persistence
+
+Volumes persist across cluster deletion by design. This is important because:
+- **Data survives cluster recreation**: Ledger data, databases, and other state are preserved
+- **Faster recovery**: No need to re-sync or rebuild data after cluster issues
+- **Safe cluster upgrades**: Delete and recreate cluster without data loss
+
+**Only use `--delete-volumes` when:**
+- You explicitly want to start fresh with no data
+- The user specifically requests volume deletion
+- You're cleaning up a test/dev environment completely
+
+### Shared Cluster Architecture
+
+In kind deployments, multiple stacks share a single cluster:
+- First `deployment start` creates the cluster
+- Subsequent deployments reuse the existing cluster
+- `deployment stop` on ANY deployment deletes the shared cluster
+- Other deployments will fail until cluster is recreated
+
+To stop a single deployment without affecting the cluster:
+```bash
+laconic-so deployment --dir my-deployment stop --skip-cluster-management
+```
+
+## Volume Persistence in k8s-kind
+
+k8s-kind has 3 storage layers:
+
+- **Docker Host**: The physical server running Docker
+- **Kind Node**: A Docker container simulating a k8s node
+- **Pod Container**: Your workload
+
+For k8s-kind, volumes with paths are mounted from Docker Host → Kind Node → Pod via extraMounts.
+
+| spec.yml volume | Storage Location | Survives Pod Restart | Survives Cluster Restart |
+|-----------------|------------------|---------------------|-------------------------|
+| `vol:` (empty)  | Kind Node PVC    | ✅ | ❌ |
+| `vol: ./data/x` | Docker Host      | ✅ | ✅ |
+| `vol: /abs/path`| Docker Host      | ✅ | ✅ |
+
+**Recommendation**: Always use paths for data you want to keep. Relative paths
+(e.g., `./data/rpc-config`) resolve to `$DEPLOYMENT_DIR/data/rpc-config` on the
+Docker Host.
+
+### Example
+
+```yaml
+# In spec.yml
+volumes:
+  rpc-config: ./data/rpc-config  # Persists to $DEPLOYMENT_DIR/data/rpc-config
+  chain-data: ./data/chain       # Persists to $DEPLOYMENT_DIR/data/chain
+  temp-cache:                    # Empty = Kind Node PVC (lost on cluster delete)
+```
+
+### The Antipattern
+
+Empty-path volumes appear persistent because they survive pod restarts (data lives
+in Kind Node container). However, this data is lost when the kind cluster is
+recreated. This "false persistence" has caused data loss when operators assumed
+their data was safe.

docs/docker-compose-deployment.md

@@ -0,0 +1,550 @@
+# Docker Compose Deployment Guide
+
+## Introduction
+
+### What is a Deployer?
+
+In stack-orchestrator, a **deployer** provides a uniform interface for orchestrating containerized applications. This guide focuses on Docker Compose deployments, which is the default and recommended deployment mode.
+
+While stack-orchestrator also supports Kubernetes (`k8s`) and Kind (`k8s-kind`) deployments, those are out of scope for this guide. See the [Kubernetes Enhancements](./k8s-deployment-enhancements.md) documentation for advanced deployment options.
+
+## Prerequisites
+
+To deploy stacks using Docker Compose, you need:
+
+- Docker Engine (20.10+)
+- Docker Compose plugin (v2.0+)
+- Python 3.8+
+- stack-orchestrator installed (`laconic-so`)
+
+**That's it!** No additional infrastructure is required. If you have Docker installed, you're ready to deploy.
+
+## Deployment Workflow
+
+The typical deployment workflow consists of four main steps:
+
+1. **Setup repositories and build containers** (first time only)
+2. **Initialize deployment specification**
+3. **Create deployment directory**
+4. **Start and manage services**
+
+## Quick Start Example
+
+Here's a complete example using the built-in `test` stack:
+
+```bash
+# Step 1: Setup (first time only)
+laconic-so --stack test setup-repositories
+laconic-so --stack test build-containers
+
+# Step 2: Initialize deployment spec
+laconic-so --stack test deploy init --output test-spec.yml
+
+# Step 3: Create deployment directory
+laconic-so --stack test deploy create \
+  --spec-file test-spec.yml \
+  --deployment-dir test-deployment
+
+# Step 4: Start services
+laconic-so deployment --dir test-deployment start
+
+# View running services
+laconic-so deployment --dir test-deployment ps
+
+# View logs
+laconic-so deployment --dir test-deployment logs
+
+# Stop services (preserves data)
+laconic-so deployment --dir test-deployment stop
+```
+
+## Deployment Workflows
+
+Stack-orchestrator supports two deployment workflows:
+
+### 1. Deployment Directory Workflow (Recommended)
+
+This workflow creates a persistent deployment directory that contains all configuration and data.
+
+**When to use:**
+- Production deployments
+- When you need to preserve configuration
+- When you want to manage multiple deployments
+- When you need persistent volume data
+
+**Example:**
+
+```bash
+# Initialize deployment spec
+laconic-so --stack fixturenet-eth deploy init --output eth-spec.yml
+
+# Optionally edit eth-spec.yml to customize configuration
+
+# Create deployment directory
+laconic-so --stack fixturenet-eth deploy create \
+  --spec-file eth-spec.yml \
+  --deployment-dir my-eth-deployment
+
+# Start the deployment
+laconic-so deployment --dir my-eth-deployment start
+
+# Manage the deployment
+laconic-so deployment --dir my-eth-deployment ps
+laconic-so deployment --dir my-eth-deployment logs
+laconic-so deployment --dir my-eth-deployment stop
+```
+
+### 2. Quick Deploy Workflow
+
+This workflow deploys directly without creating a persistent deployment directory.
+
+**When to use:**
+- Quick testing
+- Temporary deployments
+- Simple stacks that don't require customization
+
+**Example:**
+
+```bash
+# Start the stack directly
+laconic-so --stack test deploy up
+
+# Check service status
+laconic-so --stack test deploy port test 80
+
+# View logs
+laconic-so --stack test deploy logs
+
+# Stop (preserves volumes)
+laconic-so --stack test deploy down
+
+# Stop and remove volumes
+laconic-so --stack test deploy down --delete-volumes
+```
+
+## Real-World Example: Ethereum Fixturenet
+
+Deploy a local Ethereum testnet with Geth and Lighthouse:
+
+```bash
+# Setup (first time only)
+laconic-so --stack fixturenet-eth setup-repositories
+laconic-so --stack fixturenet-eth build-containers
+
+# Initialize with default configuration
+laconic-so --stack fixturenet-eth deploy init --output eth-spec.yml
+
+# Create deployment
+laconic-so --stack fixturenet-eth deploy create \
+  --spec-file eth-spec.yml \
+  --deployment-dir fixturenet-eth-deployment
+
+# Start the network
+laconic-so deployment --dir fixturenet-eth-deployment start
+
+# Check status
+laconic-so deployment --dir fixturenet-eth-deployment ps
+
+# Access logs from specific service
+laconic-so deployment --dir fixturenet-eth-deployment logs fixturenet-eth-geth-1
+
+# Stop the network (preserves blockchain data)
+laconic-so deployment --dir fixturenet-eth-deployment stop
+
+# Start again - blockchain data is preserved
+laconic-so deployment --dir fixturenet-eth-deployment start
+
+# Clean up everything including data
+laconic-so deployment --dir fixturenet-eth-deployment stop --delete-volumes
+```
+
+## Configuration
+
+### Passing Configuration Parameters
+
+Configuration can be passed in three ways:
+
+**1. At init time via `--config` flag:**
+
+```bash
+laconic-so --stack test deploy init --output spec.yml \
+  --config PARAM1=value1,PARAM2=value2
+```
+
+**2. Edit the spec file after init:**
+
+```bash
+# Initialize
+laconic-so --stack test deploy init --output spec.yml
+
+# Edit spec.yml
+vim spec.yml
+```
+
+Example spec.yml:
+```yaml
+stack: test
+config:
+  PARAM1: value1
+  PARAM2: value2
+```
+
+**3. Docker Compose defaults:**
+
+Environment variables defined in the stack's `docker-compose-*.yml` files are used as defaults. Configuration from the spec file overrides these defaults.
+
+### Port Mapping
+
+By default, services are accessible on randomly assigned host ports. To find the mapped port:
+
+```bash
+# Find the host port for container port 80 on service 'webapp'
+laconic-so deployment --dir my-deployment port webapp 80
+
+# Output example: 0.0.0.0:32768
+```
+
+To configure fixed ports, edit the spec file before creating the deployment:
+
+```yaml
+network:
+  ports:
+    webapp:
+      - '8080:80'  # Maps host port 8080 to container port 80
+    api:
+      - '3000:3000'
+```
+
+Then create the deployment:
+
+```bash
+laconic-so --stack my-stack deploy create \
+  --spec-file spec.yml \
+  --deployment-dir my-deployment
+```
+
+### Volume Persistence
+
+Volumes are preserved between stop/start cycles by default:
+
+```bash
+# Stop but keep data
+laconic-so deployment --dir my-deployment stop
+
+# Start again - data is still there
+laconic-so deployment --dir my-deployment start
+```
+
+To completely remove all data:
+
+```bash
+# Stop and delete all volumes
+laconic-so deployment --dir my-deployment stop --delete-volumes
+```
+
+Volume data is stored in `<deployment-dir>/data/`.
+
+## Common Operations
+
+### Viewing Logs
+
+```bash
+# All services, continuous follow
+laconic-so deployment --dir my-deployment logs --follow
+
+# Last 100 lines from all services
+laconic-so deployment --dir my-deployment logs --tail 100
+
+# Specific service only
+laconic-so deployment --dir my-deployment logs webapp
+
+# Combine options
+laconic-so deployment --dir my-deployment logs --tail 50 --follow webapp
+```
+
+### Executing Commands in Containers
+
+```bash
+# Execute a command in a running service
+laconic-so deployment --dir my-deployment exec webapp ls -la
+
+# Interactive shell
+laconic-so deployment --dir my-deployment exec webapp /bin/bash
+
+# Run command with specific environment variables
+laconic-so deployment --dir my-deployment exec webapp env VAR=value command
+```
+
+### Checking Service Status
+
+```bash
+# List all running services
+laconic-so deployment --dir my-deployment ps
+
+# Check using Docker directly
+docker ps
+```
+
+### Updating a Running Deployment
+
+If you need to change configuration after deployment:
+
+```bash
+# 1. Edit the spec file
+vim my-deployment/spec.yml
+
+# 2. Regenerate configuration
+laconic-so deployment --dir my-deployment update
+
+# 3. Restart services to apply changes
+laconic-so deployment --dir my-deployment stop
+laconic-so deployment --dir my-deployment start
+```
+
+## Multi-Service Deployments
+
+Many stacks deploy multiple services that work together:
+
+```bash
+# Deploy a stack with multiple services
+laconic-so --stack laconicd-with-console deploy init --output spec.yml
+laconic-so --stack laconicd-with-console deploy create \
+  --spec-file spec.yml \
+  --deployment-dir laconicd-deployment
+
+laconic-so deployment --dir laconicd-deployment start
+
+# View all services
+laconic-so deployment --dir laconicd-deployment ps
+
+# View logs from specific services
+laconic-so deployment --dir laconicd-deployment logs laconicd
+laconic-so deployment --dir laconicd-deployment logs console
+```
+
+## ConfigMaps
+
+ConfigMaps allow you to mount configuration files into containers:
+
+```bash
+# 1. Create the config directory in your deployment
+mkdir -p my-deployment/data/my-config
+echo "database_url=postgres://localhost" > my-deployment/data/my-config/app.conf
+
+# 2. Reference in spec file
+vim my-deployment/spec.yml
+```
+
+Add to spec.yml:
+```yaml
+configmaps:
+  my-config: ./data/my-config
+```
+
+```bash
+# 3. Restart to apply
+laconic-so deployment --dir my-deployment stop
+laconic-so deployment --dir my-deployment start
+```
+
+The files will be mounted in the container at `/config/` (or as specified by the stack).
+
+## Deployment Directory Structure
+
+A typical deployment directory contains:
+
+```
+my-deployment/
+├── compose/
+│   └── docker-compose-*.yml    # Generated compose files
+├── config.env                   # Environment variables
+├── deployment.yml              # Deployment metadata
+├── spec.yml                    # Deployment specification
+└── data/                       # Volume mounts and configs
+    ├── service-data/           # Persistent service data
+    └── config-maps/            # ConfigMap files
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**Problem: "Cannot connect to Docker daemon"**
+
+```bash
+# Ensure Docker is running
+docker ps
+
+# Start Docker if needed (macOS)
+open -a Docker
+
+# Start Docker (Linux)
+sudo systemctl start docker
+```
+
+**Problem: "Port already in use"**
+
+```bash
+# Either stop the conflicting service or use different ports
+# Edit spec.yml before creating deployment:
+
+network:
+  ports:
+    webapp:
+      - '8081:80'  # Use 8081 instead of 8080
+```
+
+**Problem: "Image not found"**
+
+```bash
+# Build containers first
+laconic-so --stack your-stack build-containers
+```
+
+**Problem: Volumes not persisting**
+
+```bash
+# Check if you used --delete-volumes when stopping
+# Volume data is in: <deployment-dir>/data/
+
+# Don't use --delete-volumes if you want to keep data:
+laconic-so deployment --dir my-deployment stop
+
+# Only use --delete-volumes when you want to reset completely:
+laconic-so deployment --dir my-deployment stop --delete-volumes
+```
+
+**Problem: Services not starting**
+
+```bash
+# Check logs for errors
+laconic-so deployment --dir my-deployment logs
+
+# Check Docker container status
+docker ps -a
+
+# Try stopping and starting again
+laconic-so deployment --dir my-deployment stop
+laconic-so deployment --dir my-deployment start
+```
+
+### Inspecting Deployment State
+
+```bash
+# Check deployment directory structure
+ls -la my-deployment/
+
+# Check running containers
+docker ps
+
+# Check container details
+docker inspect <container-name>
+
+# Check networks
+docker network ls
+
+# Check volumes
+docker volume ls
+```
+
+## CLI Commands Reference
+
+### Stack Operations
+
+```bash
+# Clone required repositories
+laconic-so --stack <name> setup-repositories
+
+# Build container images
+laconic-so --stack <name> build-containers
+```
+
+### Deployment Initialization
+
+```bash
+# Initialize deployment spec with defaults
+laconic-so --stack <name> deploy init --output <spec-file>
+
+# Initialize with configuration
+laconic-so --stack <name> deploy init --output <spec-file> \
+  --config PARAM1=value1,PARAM2=value2
+```
+
+### Deployment Creation
+
+```bash
+# Create deployment directory from spec
+laconic-so --stack <name> deploy create \
+  --spec-file <spec-file> \
+  --deployment-dir <dir>
+```
+
+### Deployment Management
+
+```bash
+# Start all services
+laconic-so deployment --dir <dir> start
+
+# Stop services (preserves volumes)
+laconic-so deployment --dir <dir> stop
+
+# Stop and remove volumes
+laconic-so deployment --dir <dir> stop --delete-volumes
+
+# List running services
+laconic-so deployment --dir <dir> ps
+
+# View logs
+laconic-so deployment --dir <dir> logs [--tail N] [--follow] [service]
+
+# Show mapped port
+laconic-so deployment --dir <dir> port <service> <private-port>
+
+# Execute command in service
+laconic-so deployment --dir <dir> exec <service> <command>
+
+# Update configuration
+laconic-so deployment --dir <dir> update
+```
+
+### Quick Deploy Commands
+
+```bash
+# Start stack directly
+laconic-so --stack <name> deploy up
+
+# Stop stack
+laconic-so --stack <name> deploy down [--delete-volumes]
+
+# View logs
+laconic-so --stack <name> deploy logs
+
+# Show port mapping
+laconic-so --stack <name> deploy port <service> <port>
+```
+
+## Related Documentation
+
+- [CLI Reference](./cli.md) - Complete CLI command documentation
+- [Adding a New Stack](./adding-a-new-stack.md) - Creating custom stacks
+- [Specification](./spec.md) - Internal structure and design
+- [Kubernetes Enhancements](./k8s-deployment-enhancements.md) - Advanced K8s deployment options
+- [Web App Deployment](./webapp.md) - Deploying web applications
+
+## Examples
+
+For more examples, see the test scripts:
+- `scripts/quick-deploy-test.sh` - Quick deployment example
+- `tests/deploy/run-deploy-test.sh` - Comprehensive test showing all features
+
+## Summary
+
+- Docker Compose is the default and recommended deployment mode
+- Two workflows: deployment directory (recommended) or quick deploy
+- The standard workflow is: setup → build → init → create → start
+- Configuration is flexible with multiple override layers
+- Volume persistence is automatic unless explicitly deleted
+- All deployment state is contained in the deployment directory
+- For Kubernetes deployments, see separate K8s documentation
+
+You're now ready to deploy stacks using stack-orchestrator with Docker Compose!