Add a schedule for fixturenet-eth-plugeth-test

* Remove legacy docker config

* Trigger test run

.gitea/workflows/fixturenet-eth-plugeth-test.yml

@@ -0,0 +1,49 @@
+name: Fixturenet-Eth-Plugeth-Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-eth-plugeth-test'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '2 14 * * *'
+
+# Needed until we can incorporate docker startup into the executor container
+env:
+  DOCKER_HOST: unix:///var/run/dind.sock
+
+
+jobs:
+  test:
+    name: "Run an Ethereum plugeth fixturenet test"
+    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
+      - 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 fixturenet-eth tests"
+        run: ./tests/fixturenet-eth-plugeth/run-test.sh

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

@@ -0,0 +1,48 @@
+name: Fixturenet-Eth-Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-eth-test'
+
+# Needed until we can incorporate docker startup into the executor container
+env:
+  DOCKER_HOST: unix:///var/run/dind.sock
+
+
+jobs:
+  test:
+    name: "Run an Ethereum fixturenet test"
+    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
+      - 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 fixturenet-eth tests"
+        run: ./tests/fixturenet-eth/run-test.sh
+

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

@@ -0,0 +1,48 @@
+name: Fixturenet-Laconicd-Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-laconicd-test'
+  schedule:
+    - cron: '1 13 * * *'
+
+jobs:
+  test:
+    name: "Run an Laconicd fixturenet test"
+    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
+      - 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

.gitea/workflows/publish.yml

@@ -1,46 +1,56 @@
 name: Publish
 
 on:
-  pull_request:
-    branches: '*'
   push:
-    branches: '*'
-
-# Enable debug logging
-env:
-  ACTIONS_STEP_DEBUG: true
-  RUNNER_DEBUG: true
-  ACTIONS_RUNNER_DEBUG: true
+    branches:
+      - main
+      - publish-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
 jobs:
-  test:
-    name: "Build"
+  publish:
+    name: "Build and publish"
     runs-on: ubuntu-latest
     steps:
       - name: "Clone project repository"
         uses: actions/checkout@v3
-      - name: "Install Python"
-        uses: cerc-io/setup-python@v4
+      - name: "Get build info"
+        id: build-info
+        run: |
+          build_tag=$(./scripts/create_build_tag_file.sh)
+          echo "build-tag=v${build_tag}" >> $GITHUB_OUTPUT
+      # 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
-      - name: "Create release"
-        uses: cerc-io/action-gh-release@v1
-        # We haven't decided how to trigger this release job.
-        # It might be done on creation of a git tag
-        # Or it might be done on merge to a release branch
-        # Somehow by this point however we need to know the release version
-        with:
-          tag_name: "v1.2.4"
       - name: "Build local shiv package"
-        # Build has to be done after deciding on the version because
-        # we bundle the version into the build
-        run: ./scripts/build_shiv_package.sh
-      - name: "Upload release artifact"
-        uses: cerc-io/action-gh-release@v1
+        id: build
+        run: |
+          ./scripts/build_shiv_package.sh
+          result_code=$?
+          echo "package-file=$(ls ./package/*)" >> $GITHUB_OUTPUT
+          exit $result_code
+      - name: "Stage artifact file"
+        run: |
+          cp ${{ steps.build.outputs.package-file }} ./laconic-so
+      - name: "Create release"
+        uses: https://gitea.com/cerc-io/action-gh-release@gitea-v2
         with:
-          tag_name: "v1.2.4"
-          files: requirements.txt
+          tag_name: ${{ steps.build-info.outputs.build-tag }}
+          # On the publish test branch, mark our release as a draft
+          # Hack using endsWith to workaround Gitea sometimes sending "publish-test" vs "refs/heads/publish-test"
+          draft: ${{ endsWith('publish-test', github.ref ) }}
+          files: ./laconic-so

.gitea/workflows/test-deploy.yml

@@ -0,0 +1,49 @@
+name: Deploy Test
+
+on:
+  pull_request:
+    branches: '*'
+  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:
+    name: "Run deploy 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
+      - 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

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

@@ -0,0 +1,42 @@
+name: K8s Deploy Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-laconicd-test'
+
+jobs:
+  test:
+    name: "Run deploy test suite on kind/k8s"
+    runs-on: ubuntu-22.04-with-syn-ethdb
+    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
+      - 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 kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run k8s deployment test"
+        run: ./tests/k8s-deploy/run-deploy-test.sh

.gitea/workflows/test-webapp.yml

@@ -0,0 +1,51 @@
+name: Webapp Test
+
+on:
+  pull_request:
+    branches: '*'
+  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:
+    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
+      - 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: Start dockerd # Also needed until we can incorporate into the executor
+        run: |
+          dockerd -H $DOCKER_HOST --userland-proxy=false &
+          sleep 5
+      - name: "Run webapp tests"
+        run: ./tests/webapp-test/run-webapp-test.sh

.gitea/workflows/test.yml

@@ -1,10 +1,18 @@
-name: Test
+name: Smoke Test
 
 on:
   pull_request:
     branches: '*'
   push:
-    branches: '*'
+    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:
@@ -13,15 +21,31 @@ jobs:
     steps:
       - name: "Clone project repository"
         uses: actions/checkout@v3
-      - name: "Install Python"
-        uses: cerc-io/setup-python@v4
+      # 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
+      - 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
+
+

.gitea/workflows/triggers/fixturenet-eth-plugeth-test

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

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

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

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

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

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

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

.github/workflows/fixturenet-eth.yml

@@ -0,0 +1,30 @@
+name: Fixturenet-Eth Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.github/workflows/triggers/fixturenet-eth-test'
+
+jobs:
+  test:
+    name: "Run fixturenet-eth 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-eth tests"
+        run: ./tests/fixturenet-eth/run-test.sh

.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/publish.yml

@@ -0,0 +1,46 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - main
+      - publish-test
+
+jobs:
+  publish:
+    name: "Build and publish"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      - name: "Get build info"
+        id: build-info
+        run: |
+          build_tag=$(./scripts/create_build_tag_file.sh)
+          echo "build-tag=v${build_tag}" >> $GITHUB_OUTPUT
+      - 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: "Build local shiv package"
+        id: build
+        run: |
+          ./scripts/build_shiv_package.sh
+          result_code=$?
+          echo "package-file=$(ls ./package/*)" >> $GITHUB_OUTPUT
+          exit $result_code
+      - name: "Stage artifact file"
+        run: |
+          cp ${{ steps.build.outputs.package-file }} ./laconic-so
+      - name: "Create release"
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ steps.build-info.outputs.build-tag }}
+          # On the publish test branch, mark our release as a draft
+          # Hack using endsWith to workaround Gitea sometimes sending "publish-test" vs "refs/heads/publish-test"
+          draft: ${{ endsWith('publish-test', github.ref ) }}
+          files: ./laconic-so

.github/workflows/test-deploy.yml

@@ -0,0 +1,29 @@
+name: Deploy Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run deploy 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 deploy tests"
+        run: ./tests/deploy/run-deploy-test.sh

.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/test.yml

@@ -0,0 +1,29 @@
+name: Smoke Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run basic 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 smoke tests"
+        run: ./tests/smoke-test/run-smoke-test.sh

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

@@ -0,0 +1,2 @@
+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

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

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. :
 
@@ -35,58 +36,40 @@ curl -L -o ~/bin/laconic-so https://github.com/cerc-io/stack-orchestrator/releas
 ```
 
 Give it execute permissions:
+
 ```bash
 chmod +x ~/bin/laconic-so
 ```
 
 Ensure `laconic-so` is on the [`PATH`](https://unix.stackexchange.com/a/26059)
 
-Verify operation (your version will probably be different, just check here that you see some version outut and not an error):
+Verify operation (your version will probably be different, just check here that you see some version output and not an error):
 
 ```
 laconic-so version
-Version: v1.0.27-7831078
+Version: 1.1.0-7a607c2-202304260513
+```
+Save the distribution url to `~/.laconic-so/config.yml`:
+```bash
+mkdir ~/.laconic-so
+echo "distribution-url: https://github.com/cerc-io/stack-orchestrator/releases/latest/download/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
 
-Three sub-commands: `setup-repositories`, `build-containers` and `deploy-system` are generally run in order. The following is a slim example for standing up the `erc20-watcher`. Go further with the [erc20 watcher demo](/app/data/stacks/erc20) and other pieces of the stack, within the [`stacks` directory](/app/data/stacks).
+The various [stacks](/stack_orchestrator/data/stacks) each contain instructions for running different stacks based on your use case. For example:
 
-### Setup Repositories
-
-Clone the set of git repositories necessary to build a system:
-
-```bash
-laconic-so --stack erc20 setup-repositories
-```
-
-This will default to cloning git reposiories into: `~/cerc` or - if set - the environment variable `CERC_REPO_BASE_DIR`
-
-### Build Containers
-
-Build the set of docker container images required to run a system. It takes around 10 minutes to build all the containers from scratch.
-
-```bash
-laconic-so --stack erc20 build-containers
-```
-
-### Deploy System
-
-Uses `docker compose` to deploy a system (with most recently built container images).
-
-```bash
-laconic-so --stack erc20 deploy-system up
-```
-
-Check out he GraphQL playground here: [http://localhost:3002/graphql](http://localhost:3002/graphql)
-
-See the [erc20 watcher demo](/app/data/stacks/erc20) to continue further.
-
-### Cleanup
-
-```bash
-laconic-so --stack erc20 deploy-system down
-```
+- [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)
 
 ## Contributing
 
@@ -96,3 +79,4 @@ See the [CONTRIBUTING.md](/docs/CONTRIBUTING.md) for developer mode install.
 
 Native aarm64 is _not_ currently supported. x64 emulation on ARM64 macos should work (not yet tested).
 
+

app/build_containers.py

@@ -1,131 +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
-
-# 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.pass_context
-def command(ctx, include, exclude):
-    '''build the set of containers required for a complete stack'''
-
-    quiet = ctx.obj.quiet
-    verbose = ctx.obj.verbose
-    dry_run = ctx.obj.dry_run
-    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_URL": "http://gitea.local:3000/api/packages/cerc-io/npm/",
-        "CERC_NPM_AUTH_TOKEN": config("CERC_NPM_AUTH_TOKEN", default="<token-not-supplied>"),
-        "CERC_REPO_BASE_DIR": dev_root_path,
-        "CERC_HOST_UID": f"{os.getuid()}",
-        "CERC_HOST_GID": f"{os.getgid()}",
-        "DOCKER_BUILDKIT": "0"
-    }
-
-    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_dir 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-fixturenet-laconic-console.yml

@@ -1,6 +0,0 @@
-services:
-  laconic-console:
-    restart: unless-stopped
-    image: cerc/laconic-console-host:local
-    ports:
-      - "80"

app/data/compose/docker-compose-fixturenet-optimism.yml

@@ -1,116 +0,0 @@
-version: '3.7'
-
-services:
-  # Generates and funds the accounts required when setting up the L2 chain (outputs to volume l2_accounts)
-  # Creates / updates the configuration for L1 contracts deployment
-  # Deploys the L1 smart contracts (outputs to volume l1_deployment)
-  fixturenet-optimism-contracts:
-    hostname: fixturenet-optimism-contracts
-    image: cerc/optimism-contracts:local
-    env_file:
-      - ../config/fixturenet-optimism/l1-params.env
-    # Waits for L1 endpoint to be up before running the script
-    command: |
-      "./wait-for-it.sh -h $${L1_HOST} -p $${L1_PORT} -s -t 60 -- ./run.sh"
-    volumes:
-      - ../config/wait-for-it.sh:/app/packages/contracts-bedrock/wait-for-it.sh
-      - ../container-build/cerc-optimism-contracts/hardhat-tasks/verify-contract-deployment.ts:/app/packages/contracts-bedrock/tasks/verify-contract-deployment.ts
-      - ../container-build/cerc-optimism-contracts/hardhat-tasks/rekey-json.ts:/app/packages/contracts-bedrock/tasks/rekey-json.ts
-      - ../container-build/cerc-optimism-contracts/hardhat-tasks/send-balance.ts:/app/packages/contracts-bedrock/tasks/send-balance.ts
-      - ../config/fixturenet-optimism/optimism-contracts/update-config.js:/app/packages/contracts-bedrock/update-config.js
-      - ../config/fixturenet-optimism/optimism-contracts/run.sh:/app/packages/contracts-bedrock/run.sh
-      - fixturenet_geth_accounts:/geth-accounts:ro
-      - l2_accounts:/l2-accounts
-      - l1_deployment:/app/packages/contracts-bedrock
-    extra_hosts:
-    - "host.docker.internal:host-gateway"
-
-  # Generates the config files required for L2 (outputs to volume l2_config)
-  op-node-l2-config-gen:
-    image: cerc/optimism-op-node:local
-    depends_on:
-      fixturenet-optimism-contracts:
-        condition: service_completed_successfully
-    env_file:
-      - ../config/fixturenet-optimism/l1-params.env
-    volumes:
-      - ../config/fixturenet-optimism/generate-l2-config.sh:/app/generate-l2-config.sh
-      - l1_deployment:/contracts-bedrock:ro
-      - l2_config:/app
-    command: ["sh", "/app/generate-l2-config.sh"]
-    extra_hosts:
-    - "host.docker.internal:host-gateway"
-
-  # Initializes and runs the L2 execution client  (outputs to volume l2_geth_data)
-  op-geth:
-    image: cerc/optimism-l2geth:local
-    depends_on:
-      op-node-l2-config-gen:
-        condition: service_started
-    volumes:
-      - ../config/fixturenet-optimism/run-op-geth.sh:/run-op-geth.sh
-      - l2_config:/op-node:ro
-      - l2_accounts:/l2-accounts:ro
-      - l2_geth_data:/datadir
-    entrypoint: "sh"
-    command: "/run-op-geth.sh"
-    ports:
-      - "0.0.0.0:8545:8545"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost:8545"]
-      interval: 30s
-      timeout: 10s
-      retries: 10
-      start_period: 10s
-
-  # Runs the L2 consensus client (Sequencer node)
-  op-node:
-    env_file:
-      - ../config/fixturenet-optimism/l1-params.env
-    depends_on:
-      op-geth:
-        condition: service_healthy
-    image: cerc/optimism-op-node:local
-    volumes:
-      - ../config/fixturenet-optimism/run-op-node.sh:/app/run-op-node.sh
-      - l2_config:/op-node-data:ro
-      - l2_accounts:/l2-accounts:ro
-    command: ["sh", "/app/run-op-node.sh"]
-    ports:
-      - "0.0.0.0:8547:8547"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost:8547"]
-      interval: 30s
-      timeout: 10s
-      retries: 10
-      start_period: 10s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Runs the batcher (takes transactions from the Sequencer and publishes them to L1)
-  op-batcher:
-    env_file:
-      - ../config/fixturenet-optimism/l1-params.env
-    depends_on:
-      op-node:
-        condition: service_healthy
-      op-geth:
-        condition: service_healthy
-    image: cerc/optimism-op-batcher:local
-    volumes:
-      - ../config/wait-for-it.sh:/wait-for-it.sh
-      - ../config/fixturenet-optimism/run-op-batcher.sh:/run-op-batcher.sh
-      - l2_accounts:/l2-accounts:ro
-    entrypoint: ["sh", "-c"]
-    # Waits for L1 endpoint to be up before running the batcher
-    command: |
-      "/wait-for-it.sh -h $${L1_HOST} -p $${L1_PORT} -s -t 60 -- /run-op-batcher.sh"
-    extra_hosts:
-    - "host.docker.internal:host-gateway"
-
-volumes:
-  fixturenet_geth_accounts:
-  l1_deployment:
-  l2_accounts:
-  l2_config:
-  l2_geth_data:

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:
-      - "8080"
-      - "4001"
-      - "5001"

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

@@ -1,31 +0,0 @@
-version: '3.2'
-
-services:
-  # Builds and serves the MobyMask react-app
-  mobymask-app:
-    image: cerc/mobymask-ui:local
-    env_file:
-      - ../config/watcher-mobymask-v2/mobymask-params.env
-    # Waits for watcher server to be up before app build
-    # Required when running with watcher stack to get deployed contract address
-    command:
-      - sh
-      - -c
-      - ./wait-for-it.sh -h $${WATCHER_HOST} -p $${WATCHER_PORT} -s -t 0 -- ./mobymask-app-start.sh
-    volumes:
-      - ../config/wait-for-it.sh:/app/wait-for-it.sh
-      - ../config/watcher-mobymask-v2/mobymask-app-config.json:/app/src/mobymask-app-config.json
-      - ../config/watcher-mobymask-v2/mobymask-app-start.sh:/app/mobymask-app-start.sh
-      - mobymask_deployment:/server
-    ports:
-      - "0.0.0.0:3002:3000"
-    healthcheck:
-      test: ["CMD", "nc", "-v", "localhost", "3000"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 10s
-    shm_size: '1GB'
-
-volumes:
-  mobymask_deployment:

app/data/compose/docker-compose-peer-test-app.yml

@@ -1,21 +0,0 @@
-version: '3.2'
-
-services:
-  peer-test-app:
-    # Builds and serves the peer-test react-app
-    image: cerc/react-peer:local
-    working_dir: /app/packages/test-app
-    env_file:
-      - ../config/watcher-mobymask-v2/mobymask-params.env
-    command: ["sh", "./test-app-start.sh"]
-    volumes:
-      - ../config/watcher-mobymask-v2/test-app-config.json:/app/packages/test-app/src/test-app-config.json
-      - ../config/watcher-mobymask-v2/test-app-start.sh:/app/packages/test-app/test-app-start.sh
-    ports:
-      - "0.0.0.0:3003:3000"
-    healthcheck:
-      test: ["CMD", "nc", "-v", "localhost", "3000"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 10s

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

@@ -1,7 +0,0 @@
-version: "3.2"
-services:
-  test:
-    image: cerc/test-container:local
-    restart: always
-    ports:
-      - "80"

app/data/compose/docker-compose-watcher-mobymask-v2.yml

@@ -1,90 +0,0 @@
-version: '3.2'
-
-services:
-  # Starts the PostgreSQL database for watcher
-  mobymask-watcher-db:
-    restart: unless-stopped
-    image: postgres:14-alpine
-    environment:
-      - POSTGRES_USER=vdbm
-      - POSTGRES_MULTIPLE_DATABASES=mobymask-watcher,mobymask-watcher-job-queue
-      - POSTGRES_EXTENSION=mobymask-watcher-job-queue:pgcrypto
-      - POSTGRES_PASSWORD=password
-    volumes:
-      - ../config/postgresql/multiple-postgressql-databases.sh:/docker-entrypoint-initdb.d/multiple-postgressql-databases.sh
-      - mobymask_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
-
-  # Deploys MobyMask contract and generates an invite link
-  # Deployment is skipped if DEPLOYED_CONTRACT env is already set
-  mobymask:
-    image: cerc/mobymask:local
-    working_dir: /app/packages/server
-    env_file:
-      - ../config/watcher-mobymask-v2/optimism-params.env
-      - ../config/watcher-mobymask-v2/mobymask-params.env
-    environment:
-      - ENV=PROD
-    # Waits for L2 Optimism Geth and Node servers to be up before deploying contract
-    command:
-      - sh
-      - -c
-      - |
-        ./wait-for-it.sh -h $${L2_GETH_HOST} -p $${L2_GETH_PORT} -s -t 0 && \
-        ./wait-for-it.sh -h $${L2_NODE_HOST} -p $${L2_NODE_PORT} -s -t 0 && \
-        ./deploy-and-generate-invite.sh
-    volumes:
-      - ../config/wait-for-it.sh:/app/packages/server/wait-for-it.sh
-      - ../config/watcher-mobymask-v2/secrets-template.json:/app/packages/server/secrets-template.json
-      - ../config/watcher-mobymask-v2/deploy-and-generate-invite.sh:/app/packages/server/deploy-and-generate-invite.sh
-      - mobymask_deployment:/app/packages/server
-      - fixturenet_geth_accounts:/geth-accounts:ro
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the mobymask-v2-watcher server
-  mobymask-watcher-server:
-    restart: unless-stopped
-    depends_on:
-      mobymask-watcher-db:
-        condition: service_healthy
-      mobymask:
-        condition: service_completed_successfully
-    image: cerc/watcher-mobymask-v2:local
-    env_file:
-      - ../config/watcher-mobymask-v2/optimism-params.env
-      - ../config/watcher-mobymask-v2/mobymask-params.env
-    command: ["sh", "start-server.sh"]
-    volumes:
-      - ../config/watcher-mobymask-v2/watcher-config-template.toml:/app/packages/mobymask-v2-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-mobymask-v2/peer.env:/app/packages/peer/.env
-      - ../config/watcher-mobymask-v2/relay-id.json:/app/packages/mobymask-v2-watcher/relay-id.json
-      - ../config/watcher-mobymask-v2/peer-id.json:/app/packages/mobymask-v2-watcher/peer-id.json
-      - ../config/watcher-mobymask-v2/start-server.sh:/app/packages/mobymask-v2-watcher/start-server.sh
-      - mobymask_deployment:/server
-      - fixturenet_geth_accounts:/geth-accounts:ro
-    # Expose GQL, metrics and relay node ports
-    ports:
-      - "0.0.0.0:3001:3001"
-      - "0.0.0.0:9001:9001"
-      - "0.0.0.0:9090:9090"
-    healthcheck:
-      test: ["CMD", "busybox", "nc", "localhost", "9090"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-volumes:
-  mobymask_watcher_db_data:
-  mobymask_deployment:
-  fixturenet_geth_accounts:

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-optimism/generate-l2-config.sh

@@ -1,35 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-# 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 $L1_RPC
-
-openssl rand -hex 32 > /app/jwt.txt

app/data/config/fixturenet-optimism/l1-params.env

@@ -1,14 +0,0 @@
-# Change if pointing to an external L1 endpoint
-
-# L1 endpoint
-L1_CHAIN_ID=1212
-L1_RPC="http://fixturenet-eth-geth-1:8545"
-L1_HOST="fixturenet-eth-geth-1"
-L1_PORT=8545
-
-# Credentials for accounts on L1 to send balance to Optimism Proxy contract from
-# (enables them to do transactions on L2)
-L1_ADDRESS=
-L1_PRIV_KEY=
-L1_ADDRESS_2=
-L1_PRIV_KEY_2=

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

@@ -1,120 +0,0 @@
-#!/bin/bash
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-echo "Using L1 RPC endpoint ${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: $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')
-
-# Read the private key of L1 accounts
-if [ -f /geth-accounts/accounts.csv ]; then
-  echo "Using L1 account credentials from the mounted volume"
-  L1_ADDRESS=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 2)
-  L1_PRIV_KEY=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 3)
-  L1_ADDRESS_2=$(awk -F, 'NR==2{print $(NF-1)}' /geth-accounts/accounts.csv)
-  L1_PRIV_KEY_2=$(awk -F, 'NR==2{print $NF}' /geth-accounts/accounts.csv)
-else
-  echo "Using L1 account credentials from env"
-fi
-
-# Select a finalized L1 block as the starting point for roll ups
-until FINALIZED_BLOCK=$(cast block finalized --rpc-url "$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"
-
-# Send balances to the above L2 addresses
-yarn hardhat send-balance --to "${ADMIN_ADDRESS}" --amount 2 --private-key "${L1_PRIV_KEY}" --network getting-started
-yarn hardhat send-balance --to "${PROPOSER_ADDRESS}" --amount 5 --private-key "${L1_PRIV_KEY}" --network getting-started
-yarn hardhat send-balance --to "${BATCHER_ADDRESS}" --amount 1000 --private-key "${L1_PRIV_KEY}" --network getting-started
-
-echo "Balances sent to L2 accounts"
-
-# Update the deployment config
-sed -i 's/"l2OutputOracleStartingTimestamp": TIMESTAMP/"l2OutputOracleStartingTimestamp": '"$L1_BLOCKTIMESTAMP"'/g' deploy-config/getting-started.json
-jq --arg chainid "$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=$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
-
-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 "${L1_PRIV_KEY}" --network getting-started
-# Second account
-yarn hardhat send-balance --to "${PROXY_ADDRESS}" --amount 1 --private-key "${L1_PRIV_KEY_2}" --network getting-started
-
-echo "Balance sent to Proxy L2 contract"
-echo "Use following accounts for transactions in L2:"
-echo "${L1_ADDRESS}"
-echo "${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,77 +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}"
-
-# 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=full \
-  --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

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

@@ -1,23 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-# Get SEQUENCER KEY from keys.json
-SEQUENCER_KEY=$(jq -r '.Sequencer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-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=$L1_RPC \
-  --l1.rpckind=any

app/data/config/watcher-mobymask-v2/deploy-and-generate-invite.sh

@@ -1,66 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-echo "Using L2 RPC endpoint ${L2_GETH_RPC}"
-
-if [ -f /geth-accounts/accounts.csv ]; then
-  echo "Using L1 private key from the mounted volume"
-  # Read the private key of L1 account to deploy contract
-  PRIVATE_KEY_DEPLOYER=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 3)
-else
-  echo "Using PRIVATE_KEY_DEPLOYER from env"
-fi
-
-# Set the private key
-jq --arg privateKey "$PRIVATE_KEY_DEPLOYER" '.privateKey = $privateKey' secrets-template.json > secrets.json
-
-# Set the RPC URL
-jq --arg rpcUrl "$L2_GETH_RPC" '.rpcUrl = $rpcUrl' secrets.json > secrets_updated.json && mv secrets_updated.json secrets.json
-
-export RPC_URL="${L2_GETH_RPC}"
-
-# Check if DEPLOYED_CONTRACT environment variable set to skip contract deployment
-if [[ -n "$DEPLOYED_CONTRACT" ]]; then
-  echo "DEPLOYED_CONTRACT is set to '$DEPLOYED_CONTRACT'"
-  echo "Exiting without deploying contract"
-  exit 0
-fi
-
-# Check and exit if a deployment already exists (on restarts)
-if [ -f ./config.json ]; then
-  echo "config.json already exists, checking the contract deployment"
-
-  # Read JSON file
-  DEPLOYMENT_DETAILS=$(cat config.json)
-  CONTRACT_ADDRESS=$(echo "$DEPLOYMENT_DETAILS" | jq -r '.address')
-
-  cd ../hardhat
-  if yarn verifyDeployment --network optimism --contract "${CONTRACT_ADDRESS}"; then
-    echo "Deployment verfication successful"
-    cd ../server
-  else
-    echo "Deployment verfication failed, please clear MobyMask deployment volume before starting"
-    exit 1
-  fi
-fi
-
-# Wait until balance for deployer account is updated
-cd ../hardhat
-while true; do
-  ACCOUNT_BALANCE=$(yarn balance --network optimism "$PRIVATE_KEY_DEPLOYER" | grep ETH)
-
-  if [ "$ACCOUNT_BALANCE" != "0.0 ETH" ]; then
-    echo "Account balance updated: $ACCOUNT_BALANCE"
-    break # exit the loop
-  fi
-
-  echo "Account balance not updated: $ACCOUNT_BALANCE"
-  echo "Checking after 2 seconds"
-  sleep 2
-done
-
-cd ../server
-npm run deployAndGenerateInvite

app/data/config/watcher-mobymask-v2/mobymask-app-config.json

@@ -1,9 +0,0 @@
-{
-  "name": "MobyMask",
-  "relayNodes": [
-    "/ip4/127.0.0.1/tcp/9090/ws/p2p/12D3KooWSPCsVkHVyLQoCqhu2YRPvvM7o6r6NRYyLM5zeA6Uig5t"
-  ],
-  "peer": {
-    "enableDebugInfo": true
-  }
-}

app/data/config/watcher-mobymask-v2/mobymask-app-start.sh

@@ -1,25 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-# Use config from mounted volume if available (when running web-app along with watcher stack)
-if [ -f /server/config.json ]; then
-  echo "Merging config for deployed contract from mounted volume"
-  # Merging config files to get deployed contract address
-  jq -s '.[0] * .[1]' /app/src/mobymask-app-config.json /server/config.json > /app/src/config.json
-else
-  echo "Setting deployed contract details from env"
-
-  # Set config values from environment variables
-  jq --arg address "$DEPLOYED_CONTRACT" \
-    --argjson chainId $CHAIN_ID \
-    --argjson relayNodes "$RELAY_NODES" \
-    '.address = $address | .chainId = $chainId | .relayNodes = $relayNodes' \
-    /app/src/mobymask-app-config.json > /app/src/config.json
-fi
-
-REACT_APP_WATCHER_URI="$APP_WATCHER_URL/graphql" npm run build
-
-serve -s build

app/data/config/watcher-mobymask-v2/mobymask-params.env

@@ -1,14 +0,0 @@
-# Change if pointing web app to external watcher endpoint
-WATCHER_HOST="mobymask-watcher-server"
-WATCHER_PORT=3001
-APP_WATCHER_URL="http://localhost:3001"
-
-# Set deployed MobyMask contract address to avoid deploying contract in stack
-# mobymask-app will use this contract address in config if run separately
-DEPLOYED_CONTRACT=
-
-# Chain ID is used by mobymask web-app for txs
-CHAIN_ID=42069
-
-# Set relay nodes to be used by web-apps
-RELAY_NODES=["/ip4/127.0.0.1/tcp/9090/ws/p2p/12D3KooWSPCsVkHVyLQoCqhu2YRPvvM7o6r6NRYyLM5zeA6Uig5t"]

app/data/config/watcher-mobymask-v2/optimism-params.env

@@ -1,13 +0,0 @@
-# Change if pointing to an external optimism geth endpoint
-
-# L2 endpoints
-L2_GETH_RPC="http://op-geth:8545"
-L2_GETH_HOST="op-geth"
-L2_GETH_PORT=8545
-
-L2_NODE_HOST="op-node"
-L2_NODE_PORT=8547
-
-# Credentials for accounts to perform txs on L2
-PRIVATE_KEY_DEPLOYER=
-PRIVATE_KEY_PEER=

app/data/config/watcher-mobymask-v2/peer-id.json

@@ -1,5 +0,0 @@
-{
-  "id": "12D3KooWK6myjc8r1KBnfP9igp31qJkPaVfsKDjKrjoSefV5SDEo",
-  "privKey": "CAESQJMHbMaH+UEOtjGOzXYtoPO/cdHakCtN1hcnknIWzx/6ie1lxb+8kfzBjwt7apfj8fHlTCYSIVK8Q2AWu9a2h3g=",
-  "pubKey": "CAESIIntZcW/vJH8wY8Le2qX4/Hx5UwmEiFSvENgFrvWtod4"
-}

app/data/config/watcher-mobymask-v2/peer.env

@@ -1 +0,0 @@
-RELAY="/ip4/127.0.0.1/tcp/9090/ws/p2p/12D3KooWSPCsVkHVyLQoCqhu2YRPvvM7o6r6NRYyLM5zeA6Uig5t"

app/data/config/watcher-mobymask-v2/relay-id.json

@@ -1,5 +0,0 @@
-{
-  "id": "12D3KooWSPCsVkHVyLQoCqhu2YRPvvM7o6r6NRYyLM5zeA6Uig5t",
-  "privKey": "CAESQGsqG5o4VlWJZM9XlA3MjabyZOXWQ2MLZU5AhBQsjXGt9iSlGtTuNOrHX5xSRgLBxLuMoqWsjGxE/dDB9c46RI8=",
-  "pubKey": "CAESIPYkpRrU7jTqx1+cUkYCwcS7jKKlrIxsRP3QwfXOOkSP"
-}

app/data/config/watcher-mobymask-v2/start-server.sh

@@ -1,41 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-echo "Using L2 RPC endpoint ${L2_GETH_RPC}"
-
-# Use contract address from environment variable or set from config.json in mounted volume
-if [ -n "$DEPLOYED_CONTRACT" ]; then
-  CONTRACT_ADDRESS="${DEPLOYED_CONTRACT}"
-else
-  # Assign deployed contract address from server config (created by mobymask container after deploying contract)
-  CONTRACT_ADDRESS=$(jq -r '.address' /server/config.json | tr -d '"')
-fi
-
-if [ -f /geth-accounts/accounts.csv ]; then
-  echo "Using L1 private key from the mounted volume"
-  # Read the private key of L1 account for sending txs from peer
-  PRIVATE_KEY_PEER=$(awk -F, 'NR==2{print $NF}' /geth-accounts/accounts.csv)
-else
-  echo "Using PRIVATE_KEY_PEER from env"
-fi
-
-# Set private key and contract address for watcher peer txs to L2 only if PRIVATE_KEY_PEER variable is set
-if [ -n "$PRIVATE_KEY_PEER" ]; then
-  # Read in config template TOML file and modify it
-  CONTENT=$(cat environments/watcher-config-template.toml)
-  NEW_CONTENT=$(echo "$CONTENT" | sed -E "/\[metrics\]/i \\\n\n      [server.p2p.peer.l2TxConfig]\n        privateKey = \"${PRIVATE_KEY_PEER}\"\n        contractAddress = \"${CONTRACT_ADDRESS}\"\n")
-
-  # Write the modified content to a watcher config file
-  echo "$NEW_CONTENT" > environments/local.toml
-
-  sed -i 's|REPLACE_WITH_L2_GETH_RPC_ENDPOINT|'"${L2_GETH_RPC}"'|' environments/local.toml
-else
-  # Copy template config to watcher config without setting params for peer L2 txs
-  cp environments/watcher-config-template.toml environments/local.toml
-fi
-
-echo 'yarn server'
-yarn server

app/data/config/watcher-mobymask-v2/test-app-config.json

@@ -1,8 +0,0 @@
-{
-  "relayNodes": [
-    "/ip4/127.0.0.1/tcp/9090/ws/p2p/12D3KooWSPCsVkHVyLQoCqhu2YRPvvM7o6r6NRYyLM5zeA6Uig5t"
-  ],
-  "peer": {
-    "enableDebugInfo": true
-  }
-}

app/data/config/watcher-mobymask-v2/test-app-start.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-# Set relay nodes in config from RELAY_NODES environment variable
-jq --argjson relayNodes "$RELAY_NODES" \
-  '.relayNodes = $relayNodes' \
-  ./src/test-app-config.json > ./src/config.json
-
-yarn build
-
-serve -s build

app/data/container-build/cerc-act-runner-task-executor/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build a local version of the task executor for act-runner
-docker build -t cerc/act-runner-task-executor:local -f ${CERC_REPO_BASE_DIR}/act_runner/Dockerfile.task-executor ${CERC_REPO_BASE_DIR}/act_runner

app/data/container-build/cerc-act-runner/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build a local version of the act-runner image
-docker build -t cerc/act-runner:local -f ${CERC_REPO_BASE_DIR}/act_runner/Dockerfile ${CERC_REPO_BASE_DIR}/act_runner

app/data/container-build/cerc-eth-probe/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/eth-probe
-docker build -t cerc/eth-probe:local ${CERC_REPO_BASE_DIR}/eth-probe

app/data/container-build/cerc-eth-statediff-fill-service/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/eth-statediff-fill-service
-docker build -t cerc/eth-statediff-fill-service:local ${CERC_REPO_BASE_DIR}/eth-statediff-fill-service

app/data/container-build/cerc-eth-statediff-service/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/eth-statediff-service
-docker build -t cerc/eth-statediff-service:local ${CERC_REPO_BASE_DIR}/eth-statediff-service

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

@@ -1,27 +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:latest
-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 geth init /opt/testnet/build/el/geth.json && rm -f ~/.ethereum/geth/nodekey
-
-ENTRYPOINT ["/opt/testnet/run.sh"]

app/data/container-build/cerc-fixturenet-eth-lighthouse/genesis/cl/bootnode.sh

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-# See: https://github.com/sigp/lighthouse/blob/stable/scripts/local_testnet/bootnode.sh
-#
-# Starts a bootnode from the generated enr.
-#
-
-set -Eeuo pipefail
-
-source ./vars.env
-
-DEBUG_LEVEL=${1:-info}
-
-echo "Starting bootnode"
-
-if [ ! -f "$DATADIR/bootnode/enr.dat" ]; then
-  echo "Generating bootnode enr"
-  lcli \
-    generate-bootnode-enr \
-    --ip $ENR_IP \
-    --udp-port $BOOTNODE_PORT \
-    --tcp-port $BOOTNODE_PORT \
-    --genesis-fork-version $GENESIS_FORK_VERSION \
-    --output-dir $DATADIR/bootnode
-
-    bootnode_enr=`cat $DATADIR/bootnode/enr.dat`
-    echo "- $bootnode_enr" > $TESTNET_DIR/boot_enr.yaml
-    
-    echo "Generated bootnode enr and written to $TESTNET_DIR/boot_enr.yaml"
-fi
-
-exec lighthouse boot_node \
-    --testnet-dir $TESTNET_DIR \
-    --port $BOOTNODE_PORT \
-    --listen-address 0.0.0.0 \
-    --disable-packet-filter \
-    --network-dir $DATADIR/bootnode \

app/data/container-build/cerc-go-ethereum/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/go-ethereum
-docker build -t cerc/go-ethereum:local ${CERC_REPO_BASE_DIR}/go-ethereum

app/data/container-build/cerc-ipld-eth-beacon-db/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/ipld-eth-beacon-db
-docker build -t cerc/ipld-eth-beacon-db:local ${CERC_REPO_BASE_DIR}/ipld-eth-beacon-db

app/data/container-build/cerc-ipld-eth-beacon-indexer/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/ipld-eth-beacon-indexer
-docker build -t cerc/ipld-eth-beacon-indexer:local ${CERC_REPO_BASE_DIR}/ipld-eth-beacon-indexer

app/data/container-build/cerc-ipld-eth-db/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/ipld-eth-db
-docker build -t cerc/ipld-eth-db:local ${CERC_REPO_BASE_DIR}/ipld-eth-db

app/data/container-build/cerc-ipld-eth-server/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/ipld-eth-server
-docker build -t cerc/ipld-eth-server:local ${CERC_REPO_BASE_DIR}/ipld-eth-server

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

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/laconic-registry-cli
-
-# See: https://stackoverflow.com/a/246128/1701505
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-
-docker build -t cerc/laconic-console-host:local -f ${SCRIPT_DIR}/Dockerfile \
-  --add-host gitea.local:host-gateway \
-  --build-arg CERC_NPM_AUTH_TOKEN --build-arg CERC_NPM_URL ${SCRIPT_DIR}

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: 'http://localhost:9473/api'
-    webui: 'http://localhost:9473/console'

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

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/laconic-registry-cli
-
-# See: https://stackoverflow.com/a/246128/1701505
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-
-docker build -t cerc/laconic-registry-cli:local -f ${SCRIPT_DIR}/Dockerfile \
-  --add-host gitea.local:host-gateway \
-  --build-arg CERC_NPM_AUTH_TOKEN --build-arg CERC_NPM_URL ${SCRIPT_DIR}

app/data/container-build/cerc-laconicd/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/chiba-clonk
-docker build -t cerc/laconicd:local ${CERC_REPO_BASE_DIR}/laconicd

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

@@ -1,8 +0,0 @@
-FROM sigp/lighthouse:v3.2.1-modern
-
-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/Dockerfile

@@ -1,14 +0,0 @@
-FROM node:18.15.0-alpine3.16
-
-RUN apk --update --no-cache add make git jq bash
-
-WORKDIR /app
-
-COPY . .
-
-RUN npm install -g serve
-
-RUN echo "Building mobymask-ui" && \
-    npm install
-
-WORKDIR /app

app/data/container-build/cerc-optimism-l2geth/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/optimism-l2geth
-docker build -t cerc/optimism-l2geth:local ${CERC_REPO_BASE_DIR}/op-geth

app/data/container-build/cerc-react-peer/Dockerfile

@@ -1,14 +0,0 @@
-FROM node:18.15.0-alpine3.16
-
-RUN apk --update --no-cache add make git python3 jq
-
-WORKDIR /app
-
-COPY . .
-
-RUN yarn global add serve
-
-RUN echo "Building react-peer" && \
-    yarn install --ignore-scripts && yarn build --ignore @cerc-io/test-app
-
-WORKDIR /app

app/data/container-build/cerc-react-peer/build.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/react-peer
-
-# See: https://stackoverflow.com/a/246128/1701505
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-
-docker build -t cerc/react-peer:local -f ${SCRIPT_DIR}/Dockerfile ${CERC_REPO_BASE_DIR}/react-peer

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

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/test-contract
-docker build -t cerc/test-contract:local --build-arg ETH_ADDR=http://go-ethereum:8545 ${CERC_REPO_BASE_DIR}/ipld-eth-db-validator/test/contract

app/data/container-build/cerc-tx-spammer/build.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/tx-spammer
-docker build -t cerc/tx-spammer:local ${CERC_REPO_BASE_DIR}/tx-spammer

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/repository-list.txt

@@ -1,30 +0,0 @@
-cerc-io/ipld-eth-db
-cerc-io/go-ethereum
-cerc-io/ipld-eth-server
-cerc-io/eth-statediff-service
-cerc-io/eth-statediff-fill-service
-cerc-io/ipld-eth-db-validator
-cerc-io/ipld-eth-beacon-indexer
-cerc-io/ipld-eth-beacon-db
-cerc-io/laconicd
-cerc-io/laconic-sdk
-cerc-io/laconic-registry-cli
-cerc-io/laconic-console
-cerc-io/mobymask-watcher
-cerc-io/watcher-ts
-cerc-io/react-peer
-cerc-io/mobymask-ui
-cerc-io/MobyMask
-vulcanize/uniswap-watcher-ts
-vulcanize/uniswap-v3-info
-vulcanize/assemblyscript
-cerc-io/eth-probe
-cerc-io/tx-spammer
-dboreham/foundry
-lirewine/gem
-lirewine/debug
-lirewine/crypto
-lirewine/sdk
-telackey/act_runner
-ethereum-optimism/op-geth
-ethereum-optimism/optimism

app/data/stacks/build-support/stack.yml

@@ -1,6 +0,0 @@
-version: "1.1"
-name: build-support
-decription: "Build Support Components"
-containers:
-  - cerc/builder-js
-  - cerc/builder-gerbil

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 [l2-only](./l2-only.md) for the same.
-
-## Setup
-
-Clone required repositories:
-
-```bash
-laconic-so --stack fixturenet-optimism setup-repositories
-```
-
-Checkout to the required versions and branches in repos:
-
-```bash
-# Optimism
-cd ~/cerc/optimism
-git checkout @eth-optimism/sdk@0.0.0-20230329025055
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack fixturenet-optimism build-containers
-```
-
-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-batcher`
-* `cerc/optimism-op-node`
-
-## Deploy
-
-Deploy the stack:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy 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 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
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*fixturenet_geth_accounts|.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*fixturenet_geth_accounts|.*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:
-  * 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)
-    ```
-
-  * Reuse the deployment command used in [Deploy](#deploy) to restart the stopped containers
-
-## Known Issues
-
-* `fixturenet-eth` currently starts fresh on a restart
-* 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,87 +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 cerc-io/go-ethereum
-```
-
-Checkout to the required versions and branches in repos:
-
-```bash
-# Optimism
-cd ~/cerc/optimism
-git checkout @eth-optimism/sdk@0.0.0-20230329025055
-```
-
-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
-```
-
-This should create the required docker images in the local image registry:
-* `cerc/foundry`
-* `cerc/optimism-contracts`
-* `cerc/optimism-l2geth`
-* `cerc/optimism-op-batcher`
-* `cerc/optimism-op-node`
-
-## Deploy
-
-Update the [l1-params.env](../../config/fixturenet-optimism/l1-params.env) file with L1 endpoint (`L1_RPC`, `L1_HOST` and `L1_PORT`) and other params
-
-* NOTE:
-  * Stack Orchestrator needs to be run in [`dev`](/docs/CONTRIBUTING.md#install-developer-mode) mode to be able to edit the env file
-  * 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 up --include fixturenet-optimism
-```
-
-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 down --include fixturenet-optimism
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*fixturenet_geth_accounts|.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*fixturenet_geth_accounts|.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data")
-```
-
-## Troubleshooting
-
-See [Troubleshooting](./README.md#troubleshooting)

app/data/stacks/fixturenet-optimism/stack.yml

@@ -1,21 +0,0 @@
-version: "1.0"
-name: fixturenet-optimism
-decription: "Optimism Fixturenet"
-repos:
-  - cerc-io/go-ethereum
-  - dboreham/foundry
-  - ethereum-optimism/optimism
-  - ethereum-optimism/op-geth
-containers:
-  - cerc/go-ethereum
-  - cerc/lighthouse
-  - cerc/fixturenet-eth-geth
-  - cerc/fixturenet-eth-lighthouse
-  - cerc/foundry
-  - cerc/optimism-contracts
-  - cerc/optimism-op-node
-  - cerc/optimism-l2geth
-  - cerc/optimism-op-batcher
-pods:
-  - fixturenet-eth
-  - fixturenet-optimism

app/data/stacks/mobymask-v2/mobymask-only.md

@@ -1,85 +0,0 @@
-# MobyMask v2 watcher
-
-Instructions to setup and deploy MobyMask v2 watcher independently
-
-## Setup
-
-Prerequisite: L2 Optimism Geth and Node RPC endpoints
-
-Clone required repositories:
-
-```bash
-laconic-so --stack mobymask-v2 setup-repositories --include cerc-io/MobyMask,cerc-io/watcher-ts
-```
-
-Checkout to the required versions and branches in repos:
-
-```bash
-# watcher-ts
-cd ~/cerc/watcher-ts
-git checkout v0.2.34
-
-# MobyMask
-cd ~/cerc/MobyMask
-git checkout v0.1.2
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack mobymask-v2 build-containers --include cerc/watcher-mobymask-v2,cerc/mobymask
-```
-
-This should create the required docker images in the local image registry
-
-## Deploy
-
-### Configuration
-
-* In [mobymask-params.env](../../config/watcher-mobymask-v2/mobymask-params.env) file set `DEPLOYED_CONTRACT` to existing deployed mobymask contract address
-  * Setting `DEPLOYED_CONTRACT` will skip contract deployment when running stack
-* Update the [optimism-params.env](../../config/watcher-mobymask-v2/optimism-params.env) file with Optimism endpoints and other params for the Optimism running separately
-  * If `PRIVATE_KEY_PEER` is not set the inline watcher peer will not send txs to L2 on receiving P2P network messages
-* NOTE:
-  * Stack Orchestrator needs to be run in [`dev`](/docs/CONTRIBUTING.md#install-developer-mode) mode to be able to edit the env file
-  * If Optimism 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 mobymask-v2 deploy --include watcher-mobymask-v2 up
-```
-
-To list down and monitor the running containers:
-
-```bash
-laconic-so --stack mobymask-v2 deploy --include watcher-mobymask-v2 ps
-
-# With status
-docker ps
-
-# Check logs for a container
-docker logs -f <CONTAINER_ID>
-```
-
-## Tests
-
-See [Tests](./README.md#tests)
-
-## Clean up
-
-Stop all services running in the background:
-
-```bash
-laconic-so --stack mobymask-v2 deploy --include watcher-mobymask-v2 down
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*mobymask_watcher_db_data|.*mobymask_deployment|.*fixturenet_geth_accounts"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*mobymask_watcher_db_data|.*mobymask_deployment|.*fixturenet_geth_accounts")
-```

app/data/stacks/mobymask-v2/stack.yml

@@ -1,31 +0,0 @@
-version: "1.0"
-name: mobymask-v2
-repos:
-  - cerc-io/go-ethereum
-  - dboreham/foundry
-  - ethereum-optimism/optimism
-  - ethereum-optimism/op-geth
-  - cerc-io/watcher-ts
-  - cerc-io/react-peer
-  - cerc-io/mobymask-ui
-  - cerc-io/MobyMask
-containers:
-  - cerc/go-ethereum
-  - cerc/lighthouse
-  - cerc/fixturenet-eth-geth
-  - cerc/fixturenet-eth-lighthouse
-  - cerc/foundry
-  - cerc/optimism-contracts
-  - cerc/optimism-l2geth
-  - cerc/optimism-op-batcher
-  - cerc/optimism-op-node
-  - cerc/watcher-mobymask-v2
-  - cerc/react-peer
-  - cerc/mobymask-ui
-  - cerc/mobymask
-pods:
-  - fixturenet-eth
-  - fixturenet-optimism
-  - watcher-mobymask-v2
-  - mobymask-app
-  - peer-test-app

app/data/stacks/mobymask-v2/web-apps.md

@@ -1,91 +0,0 @@
-# Web Apps
-
-Instructions to setup and deploy MobyMask and Peer Test web apps
-
-## Setup
-
-Prerequisite: Watcher with GQL and relay node endpoints
-
-Clone required repositories:
-
-```bash
-laconic-so --stack mobymask-v2 setup-repositories --include cerc-io/react-peer,cerc-io/mobymask-ui
-```
-
-Checkout to the required versions and branches in repos:
-
-```bash
-# react-peer
-cd ~/cerc/react-peer
-git checkout v0.2.31
-
-# mobymask-ui
-cd ~/cerc/mobymask-ui
-git checkout laconic
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack mobymask-v2 build-containers --include cerc/react-peer-v2,cerc/mobymask-ui
-```
-
-This should create the required docker images in the local image registry
-
-## Deploy
-
-### Configuration
-
-* Update the [mobymask-params.env](../../config/watcher-mobymask-v2/mobymask-params.env) file with watcher endpoints and other params required by the web-apps
-  * `WATCHER_HOST` and `WATCHER_PORT` is used to check if watcher is up before building and deploying mobymask-app
-  * `APP_WATCHER_URL` is used by mobymask-app to make GQL queries
-  * `DEPLOYED_CONTRACT` and `CHAIN_ID` is used by mobymask-app in app config when creating messgaes for L2 txs
-  * `RELAY_NODES` is used by the web-apps to connect to the relay nodes (run in watcher)
-* NOTE:
-  * Stack Orchestrator needs to be run in [`dev`](/docs/CONTRIBUTING.md#install-developer-mode) mode to be able to edit the env file
-  * If watcher is running on the host machine, use `host.docker.internal` as the hostname to access the host port
-
-### Deploy the stack
-
-For running mobymask-app
-```bash
-laconic-so --stack mobymask-v2 deploy --include mobymask-app up
-```
-
-For running peer-test-app
-```bash
-laconic-so --stack mobymask-v2 deploy --include peer-test-app up
-```
-
-To list down and monitor the running containers:
-
-```bash
-docker ps
-
-# Check logs for a container
-docker logs -f <CONTAINER_ID>
-```
-
-## Clean up
-
-Stop all services running in the background:
-
-For mobymask-app
-```bash
-laconic-so --stack mobymask-v2 deploy --include mobymask-app down
-```
-
-For peer-test-app
-```bash
-laconic-so --stack mobymask-v2 deploy --include peer-test-app down
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*mobymask_deployment"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*mobymask_deployment")
-```

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 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/stack.yml

@@ -1,15 +0,0 @@
-version: "1.1"
-name: package-registry
-decription: "Local Package Registry"
-repos:
-  - cerc-io/hosting
-  - telackey/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/version.txt

@@ -1,2 +0,0 @@
-# This file should be re-generated running: scripts/update-version-file.sh script
-v1.0.36-2515878

app/deploy_system.py

@@ -1,332 +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
-import subprocess
-from python_on_whales import DockerClient, DockerException
-import click
-import importlib.resources
-from pathlib import Path
-from .util import include_exclude_check, get_parsed_stack_config
-
-
-@click.command()
-@click.option("--include", help="only start these components")
-@click.option("--exclude", help="don\'t start these components")
-@click.option("--cluster", help="specify a non-default cluster name")
-@click.argument('command', required=True)  # help: command: up|down|ps
-@click.argument('extra_args', nargs=-1)  # help: command: up|down|ps <service1> <service2>
-@click.pass_context
-def command(ctx, include, exclude, cluster, command, extra_args):
-    '''deploy a stack'''
-
-    # TODO: implement option exclusion and command value constraint lost with the move from argparse to click
-
-    debug = ctx.obj.debug
-    quiet = ctx.obj.quiet
-    verbose = ctx.obj.verbose
-    local_stack = ctx.obj.local_stack
-    dry_run = ctx.obj.dry_run
-    stack = ctx.obj.stack
-
-    cluster_context = _make_cluster_context(ctx.obj, include, exclude, cluster)
-
-    # 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)
-
-    extra_args_list = list(extra_args) or None
-
-    if not dry_run:
-        if command == "up":
-            container_exec_env = _make_runtime_env(ctx.obj)
-            for attr, value in container_exec_env.items():
-                os.environ[attr] = value
-            if verbose:
-                print(f"Running compose up with container_exec_env: {container_exec_env}, extra_args: {extra_args_list}")
-            for pre_start_command in cluster_context.pre_start_commands:
-                _run_command(ctx.obj, cluster_context.cluster, pre_start_command)
-            docker.compose.up(detach=True, services=extra_args_list)
-            for post_start_command in cluster_context.post_start_commands:
-                _run_command(ctx.obj, cluster_context.cluster, post_start_command)
-
-            _orchestrate_cluster_config(ctx.obj, cluster_context.config, docker, container_exec_env)
-
-        elif command == "down":
-            if verbose:
-                print("Running compose down")
-            docker.compose.down()
-        elif command == "exec":
-            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(ctx.obj)
-            if verbose:
-                print(f"Running compose exec {service_name} {command_to_exec}")
-            try:
-                docker.compose.execute(service_name, command_to_exec, envs=container_exec_env)
-            except DockerException as error:
-                print(f"container command returned error exit status")
-        elif command == "port":
-            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 verbose:
-                print(f"Running compose port {service_name} {exposed_port}")
-            mapped_port_data = docker.compose.port(service_name, exposed_port)
-            print(f"{mapped_port_data[0]}:{mapped_port_data[1]}")
-        elif command == "ps":
-            if verbose:
-                print("Running compose ps")
-            container_list = 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")
-        elif command == "logs":
-            if verbose:
-                print("Running compose logs")
-            logs_output = docker.compose.logs(services=extra_args_list if extra_args_list is not None else [])
-            print(logs_output)
-
-
-def get_stack_status(ctx, stack):
-
-    ctx_copy = copy.copy(ctx)
-    ctx_copy.stack = stack
-
-    cluster_context = _make_cluster_context(ctx_copy, 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
-
-
-def _make_cluster_context(ctx, include, exclude, cluster):
-
-    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"))
-
-    # 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},{ctx.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 importlib.resources.open_text(data, "pod-list.txt") as pod_list_file:
-        all_pods = pod_list_file.read().splitlines()
-
-    pods_in_scope = []
-    if ctx.stack:
-        stack_config = get_parsed_stack_config(ctx.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)
-
-
-class cluster_context:
-    def __init__(self, cluster, compose_files, pre_start_commands, post_start_commands, config) -> 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
-
-
-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
-                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}")

app/setup_repositories.py

@@ -1,178 +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/>.
-
-# env vars:
-# CERC_REPO_BASE_DIR defaults to ~/cerc
-
-import os
-import sys
-from decouple import config
-import git
-from tqdm import tqdm
-import click
-import importlib.resources
-from pathlib import Path
-import yaml
-from .util import include_exclude_check
-
-
-class GitProgress(git.RemoteProgress):
-    def __init__(self):
-        super().__init__()
-        self.pbar = tqdm(unit='B', ascii=True, unit_scale=True)
-
-    def update(self, op_code, cur_count, max_count=None, message=''):
-        self.pbar.total = max_count
-        self.pbar.n = cur_count
-        self.pbar.refresh()
-
-
-def is_git_repo(path):
-    try:
-        _ = git.Repo(path).git_dir
-        return True
-    except git.exc.InvalidGitRepositoryError:
-        return False
-
-# TODO: find a place for this in the context of click
-# parser = argparse.ArgumentParser(
-#    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 clone these repositories")
-@click.option("--exclude", help="don\'t clone these repositories")
-@click.option('--git-ssh', is_flag=True, default=False)
-@click.option('--check-only', is_flag=True, default=False)
-@click.option('--pull', is_flag=True, default=False)
-@click.option('--branches-file', help="checkout branches specified in this file")
-@click.pass_context
-def command(ctx, include, exclude, git_ssh, check_only, pull, branches_file):
-    '''git clone the set of repositories required to build the complete system from source'''
-
-    quiet = ctx.obj.quiet
-    verbose = ctx.obj.verbose
-    dry_run = ctx.obj.dry_run
-    stack = ctx.obj.stack
-
-    branches = []
-
-    # TODO: branches file needs to be re-worked in the context of stacks
-    if branches_file:
-        if verbose:
-            print(f"loading branches from: {branches_file}")
-        with open(branches_file) as branches_file_open:
-            branches = branches_file_open.read().splitlines()
-        if verbose:
-            print(f"Branches are: {branches}")
-
-    local_stack = ctx.obj.local_stack
-
-    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):
-        if not quiet:
-            print('Dev root directory doesn\'t exist, creating')
-        os.makedirs(dev_root_path)
-
-    # See: https://stackoverflow.com/a/20885799/1701505
-    from . import data
-    with importlib.resources.open_text(data, "repository-list.txt") as repository_list_file:
-        all_repos = repository_list_file.read().splitlines()
-
-    repos_in_scope = []
-    if 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")
-        with stack_file_path:
-            stack_config = yaml.safe_load(open(stack_file_path, "r"))
-            # TODO: syntax check the input here
-            repos_in_scope = stack_config['repos']
-    else:
-        repos_in_scope = all_repos
-
-    if verbose:
-        print(f"Repos: {repos_in_scope}")
-        if stack:
-            print(f"Stack: {stack}")
-
-    repos = []
-    for repo in repos_in_scope:
-        if include_exclude_check(repo, include, exclude):
-            repos.append(repo)
-        else:
-            if verbose:
-                print(f"Excluding: {repo}")
-
-    def process_repo(repo):
-        git_ssh_prefix = "git@github.com:"
-        git_http_prefix = "https://github.com/"
-        full_github_repo_path = f"{git_ssh_prefix if git_ssh else git_http_prefix}{repo}"
-        repoName = repo.split("/")[-1]
-        full_filesystem_repo_path = os.path.join(dev_root_path, repoName)
-        is_present = os.path.isdir(full_filesystem_repo_path)
-        if not quiet:
-            present_text = f"already exists active branch: {git.Repo(full_filesystem_repo_path).active_branch}" if is_present \
-                else 'Needs to be fetched'
-            print(f"Checking: {full_filesystem_repo_path}: {present_text}")
-        # Quick check that it's actually a repo
-        if is_present:
-            if not is_git_repo(full_filesystem_repo_path):
-                print(f"Error: {full_filesystem_repo_path} does not contain a valid git repository")
-                sys.exit(1)
-            else:
-                if pull:
-                    if verbose:
-                        print(f"Running git pull for {full_filesystem_repo_path}")
-                    if not check_only:
-                        git_repo = git.Repo(full_filesystem_repo_path)
-                        origin = git_repo.remotes.origin
-                        origin.pull(progress=None if quiet else GitProgress())
-                    else:
-                        print("(git pull skipped)")
-        if not is_present:
-            # Clone
-            if verbose:
-                print(f'Running git clone for {full_github_repo_path} into {full_filesystem_repo_path}')
-            if not dry_run:
-                git.Repo.clone_from(full_github_repo_path,
-                                    full_filesystem_repo_path,
-                                    progress=None if quiet else GitProgress())
-            else:
-                print("(git clone skipped)")
-        # Checkout the requested branch, if one was specified
-        if branches:
-            # Find the current repo in the branches list
-            for repo_branch in branches:
-                repo_branch_tuple = repo_branch.split(" ")
-                if repo_branch_tuple[0] == repo:
-                    # checkout specified branch
-                    branch_to_checkout = repo_branch_tuple[1]
-                    if verbose:
-                        print(f"checking out branch {branch_to_checkout} in repo {repo}")
-                        git_repo = git.Repo(full_filesystem_repo_path)
-                        git_repo.git.checkout(branch_to_checkout)
-
-    for repo in repos:
-        process_repo(repo)

app/util.py

@@ -1,50 +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_parsed_stack_config(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")
-    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)

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://github.com/cerc-io/stack-orchestrator.git
    ```
 
 2. Enter the project directory:
@@ -34,7 +34,9 @@ In addition to the pre-requisites listed in the [README](/README.md), the follow
    $ cd stack-orchestrator
    ```
 
-3. Create and activate a venv:
+3. (This and the next step can be done by running `source ./scripts/developer-mode-setup.sh`)
+
+   Create and activate a venv:
    ```
    $ python3 -m venv venv
    $ source ./venv/bin/activate
@@ -85,20 +87,27 @@ Use shiv to build a single file Python executable zip archive of laconic-so:
    ```
    $ cp stack-orchetrator/laconic-so ~/bin
    $ laconic-so
-      Usage: python -m laconic-so [OPTIONS] COMMAND [ARGS]...
+      Usage: laconic-so [OPTIONS] COMMAND [ARGS]...
 
       Laconic Stack Orchestrator
 
    Options:
+      --stack TEXT         specify a stack to build/deploy
       --quiet
       --verbose
       --dry-run
-      -h, --help  Show this message and exit.
+      --local-stack
+      --debug
+      --continue-on-error
+      -h, --help           Show this message and exit.
 
    Commands:
       build-containers    build the set of containers required for a complete...
+      build-npms          build the set of npm packages required for a...
+      deploy              deploy a stack
       deploy-system       deploy a stack
       setup-repositories  git clone the set of repositories required to build...
+      version             print tool version
    ```
 
 For cutting releases, use the [shiv build script](/scripts/build_shiv_package.sh).

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://github.com/cerc-io/stack-orchestrator/pull/434) for an example of how to currently add a minimal stack to stack orchestrator. The [reth stack](https://github.com/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://github.com/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

@@ -1,3 +1,67 @@
 # laconic-so
 
 Sub-commands and flags
+
+## setup-repositories
+
+Clone a single repository:
+```
+$ laconic-so setup-repositories --include github.com/cerc-io/go-ethereum
+```
+Clone the repositories for a stack:
+```
+$ laconic-so --stack fixturenet-eth setup-repositories
+```
+Pull latest commits from origin:
+```
+$ laconic-so --stack fixturenet-eth setup-repositories --pull
+```
+Use SSH rather than https:
+```
+$ laconic-so --stack fixturenet-eth setup-repositories --git-ssh
+```
+
+## build-containers
+
+Build a single container:
+```
+$ laconic-so build-containers --include <container-name>
+```
+e.g.
+```
+$ laconic-so build-containers --include cerc/go-ethereum
+```
+Build the containers for a stack:
+```
+$ laconic-so --stack <stack-name> build-containers
+```
+e.g.
+```
+$ laconic-so --stack fixturenet-eth build-containers
+```
+Force full rebuild of container images:
+```
+$ laconic-so build-containers --include <container-name> --force-rebuild
+```
+## build-npms
+
+Build a single package:
+```
+$ laconic-so build-npms --include <package-name>
+```
+e.g.
+```
+$ laconic-so build-npms --include laconic-sdk
+```
+Build the packages for a stack:
+```
+$ laconic-so --stack <stack-name> build-npms
+```
+e.g.
+```
+$ laconic-so --stack fixturenet-laconicd build-npms
+```
+Force full rebuild of packages:
+```
+$ laconic-so build-npms --include <package-name> --force-rebuild
+```

docs/gitea-with-laconicd-fixturenet.md

@@ -0,0 +1,80 @@
+# Gitea x NPMs X Laconicd
+
+Deploy a local Gitea server, publish NPM packages to it, then use those packages to build a Laconicd fixturenet. Demonstrates several components of the Laconic stack
+
+### Build and Deploy Gitea
+
+```bash
+laconic-so --stack build-support build-containers
+laconic-so --stack package-registry setup-repositories
+laconic-so --stack package-registry build-containers 
+laconic-so --stack package-registry deploy up
+```
+
+These commands can take awhile. Eventually, some instructions and a token will output. Set `CERC_NPM_AUTH_TOKEN`:
+
+```bash
+export CERC_NPM_AUTH_TOKEN=<your-token>
+```
+
+### Configure the hostname gitea.local
+
+How to do this depends on your operating system  but usually involves editing a `hosts` file. For example, on Linux add this line to the file `/etc/hosts` (needs sudo):
+
+```bash
+127.0.0.1       gitea.local
+```
+
+Test with:
+
+```bash
+ping gitea.local
+```
+
+```bash
+PING gitea.local (127.0.0.1) 56(84) bytes of data.
+64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.147 ms
+64 bytes from localhost (127.0.0.1): icmp_seq=2 ttl=64 time=0.033 ms
+```
+
+Although not necessary in order to build and publish packages, you can now access the Gitea web interface at: [http://gitea.local:3000](http://gitea.local:3000) using these credentials: `gitea_admin/admin1234` (Note: please properly secure Gitea if public internet access is allowed).
+
+### Build npm Packages
+
+Clone the required repositories:
+
+```bash
+laconic-so --stack fixturenet-laconicd setup-repositories
+```
+
+Build and publish the npm packages:
+
+```bash
+laconic-so --stack fixturenet-laconicd build-npms
+```
+
+Navigate to the Gitea console and switch to the `cerc-io` user then find the `Packages` tab to confirm that these two npm packages have been published:
+
+- `@cerc-io/laconic-registry-cli`
+- `@cerc-io/laconic-sdk`
+
+### Build and deploy fixturenet containers
+
+```bash
+laconic-so --stack fixturenet-laconicd build-containers
+laconic-so --stack fixturenet-laconicd deploy up
+```
+
+Check the logs:
+
+```bash
+laconic-so --stack fixturenet-laconicd deploy logs
+```
+
+### Test with the registry CLI
+
+```bash
+laconic-so --stack fixturenet-laconicd deploy exec cli "laconic cns status"
+```
+
+Try additional CLI commands, documented [here](https://github.com/cerc-io/laconic-registry-cli#operations).

docs/laconicd-with-console.md

@@ -0,0 +1,220 @@
+# Running a laconicd fixturenet with console
+
+The following tutorial explains the steps to run a laconicd fixturenet with CLI and web console that displays records in the registry. It is designed as an introduction to Stack Orchestrator and to showcase one component of the Laconic Stack. Prior to Stack Orchestrator, the following 4 repositories had to be cloned and setup manually:
+
+- https://git.vdb.to/cerc-io/laconicd
+- https://git.vdb.to/cerc-io/laconic-sdk
+- https://git.vdb.to/cerc-io/laconic-registry-cli
+- https://git.vdb.to/cerc-io/laconic-console
+
+Now, with Stack Orchestrator, it is a few quick commands. Additionally, the `docker` and `docker compose` integration on the back-end allows the stack to easily persist, facilitating workflows.
+
+## Setup laconic-so
+
+To avoid hiccups on Mac M1/M2 and any local machine nuances that may affect the user experience, this tutorial is focused on using a fresh Digital Ocean (DO) droplet with similar specs: 
+16 GB Memory / 8 Intel vCPUs / 160 GB Disk.
+
+1. Login to the droplet as root (either by SSH key or password set in the DO console)
+
+```
+ssh root@IP
+```
+
+2. Get the install script, give it executable permissions, and run it:
+
+```
+curl -o install.sh https://raw.githubusercontent.com/cerc-io/stack-orchestrator/main/scripts/quick-install-linux.sh
+```
+```
+chmod +x install.sh
+```
+```
+bash install.sh
+```
+
+3. Confirm docker was installed and activate the changes in `~/.profile`:
+
+```
+docker run hello-world
+```
+```
+source ~/.profile
+```
+
+4. Verify installation:
+
+```
+laconic-so version
+```
+
+## Setup the laconic fixturenet stack
+
+1. Get the repositories
+
+```
+laconic-so --stack fixturenet-laconic-loaded setup-repositories --include git.vdb.to/cerc-io/laconicd,git.vdb.to/cerc-io/laconic-sdk,git.vdb.to/cerc-io/laconic-registry-cli,git.vdb.to/cerc-io/laconic-console
+```
+
+2. Set this environment variable to the Laconic self-hosted Gitea instance:
+
+```
+export CERC_NPM_REGISTRY_URL=https://git.vdb.to/api/packages/cerc-io/npm/
+```
+
+3. Build the containers:
+
+```
+laconic-so --stack fixturenet-laconic-loaded build-containers
+```
+
+It's possible to run into an `ESOCKETTIMEDOUT` error, e.g., `error An unexpected error occurred: "https://registry.yarnpkg.com/@material-ui/icons/-/icons-4.11.3.tgz: ESOCKETTIMEDOUT"`. This may happen even if you have a great internet connection. In that case, re-run the `build-containers` command.
+
+4. Set this environment variable to your droplet's IP address:
+
+```
+export LACONIC_HOSTED_ENDPOINT=http://<your-IP>
+```
+
+5. Deploy the stack:
+
+```
+laconic-so --stack fixturenet-laconic-loaded deploy up
+```
+
+6. Check the logs:
+
+```
+laconic-so --stack fixturenet-laconic-loaded deploy logs
+```
+
+You'll see output from `laconicd` and the block height should be >1 to confirm it is running:
+
+```
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:29PM INF indexed block exents height=12 module=txindex server=node
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF Timed out dur=4976.960115 height=13 module=consensus round=0 server=node step=1
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF received proposal module=consensus proposal={"Type":32,"block_id":{"hash":"D26C088A711F912ADB97888C269F628DA33153795621967BE44DCB43C3D03CA4","parts":{"hash":"22411A20B7F14CDA33244420FBDDAF24450C0628C7A06034FF22DAC3699DDCC8","total":1}},"height":13,"pol_round":-1,"round":0,"signature":"DEuqnaQmvyYbUwckttJmgKdpRu6eVm9i+9rQ1pIrV2PidkMNdWRZBLdmNghkIrUzGbW8Xd7UVJxtLRmwRASgBg==","timestamp":"2023-04-18T21:30:01.49450663Z"} server=node
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF received complete proposal block hash=D26C088A711F912ADB97888C269F628DA33153795621967BE44DCB43C3D03CA4 height=13 module=consensus server=node
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF finalizing commit of block hash={} height=13 module=consensus num_txs=0 root=1A8CA1AF139CCC80EC007C6321D8A63A46A793386EE2EDF9A5CA0AB2C90728B7 server=node
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF minted coins from module account amount=2059730459416582643aphoton from=mint module=x/bank
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF executed block height=13 module=state num_invalid_txs=0 num_valid_txs=0 server=node
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF commit synced commit=436F6D6D697449447B5B363520313037203630203232372039352038352032303820313334203231392032303520313433203130372031343920313431203139203139322038362031323720362031383520323533203137362031333820313735203135392031383620323334203135382031323120313431203230342037335D3A447D
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF committed state app_hash=416B3CE35F55D086DBCD8F6B958D13C0567F06B9FDB08AAF9FBAEA9E798DCC49 height=13 module=state num_txs=0 server=node
+laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF indexed block exents height=13 module=txindex server=node
+```
+
+7. Confirm operation of the registry CLI:
+
+```
+laconic-so --stack fixturenet-laconic-loaded deploy exec cli "laconic cns status"
+```
+
+```
+{
+  "version": "0.3.0",
+  "node": {
+    "id": "4216af2ac9f68bda33a38803fc1b5c9559312c1d",
+    "network": "laconic_9000-1",
+    "moniker": "localtestnet"
+  },
+  "sync": {
+    "latest_block_hash": "1BDF4CB9AE2390DA65BCF997C83133C18014FCDDCAE03708488F0B56FCEEA429",
+    "latest_block_height": "5",
+    "latest_block_time": "2023-08-09 16:00:30.386903172 +0000 UTC",
+    "catching_up": false
+  },
+  "validator": {
+    "address": "651FBC700B747C76E90ACFC18CC9508C3D0905B9",
+    "voting_power": "1000000000000000"
+  },
+  "validators": [
+    {
+      "address": "651FBC700B747C76E90ACFC18CC9508C3D0905B9",
+      "voting_power": "1000000000000000",
+      "proposer_priority": "0"
+    }
+  ],
+  "num_peers": "0",
+  "peers": [],
+  "disk_usage": "292.0K"
+}
+```
+
+## Configure Digital Ocean firewall
+
+Let's open some ports.
+
+1. In the Digital Ocean web console, navigate to your droplet's main page. Select the "Networking" tab and scroll down to "Firewall".
+
+2. Get the port for the running console:
+
+```
+echo http://IP:$(laconic-so --stack fixturenet-laconic-loaded deploy port laconic-console 80 | cut -d ':' -f 2)
+```
+```
+http://IP:32778
+```
+
+3. Go back to the Digital Ocean web console and set an Inbound Rule for Custom TCP of the above port:
+
+- `32778` in this example, but yours will be different.
+- do the same for port `9473`
+
+Additional ports will need to be opened depending on your application. Ensure you add your droplet to this new Firewall and wait a minute or so for the update to propagate.
+
+4. Navigate to http://IP:port and ensure laconic-console is functioning as expected:
+
+- ensure you are connected to `laconicd`; no error message should pop up;
+- the wifi symbol in the bottom right should have a green check mark beside it
+- navigate to the status tab; it should display similar/identical information
+- navigate to the config tab, you'll see something like (with your IP):
+
+```
+wns
+  webui http://68.183.195.210:9473/console
+  server http://68.183.195.210:9473/api
+```
+
+## Publish and query a sample record to the registry
+
+1. The following command will create a bond and publish a record:
+
+```
+laconic-so --stack fixturenet-laconic-loaded deploy exec cli ./scripts/create-demo-records.sh
+```
+
+You'll get an output like:
+
+```
+Balance is: 99998999999999998999600000
+Created bond with id: dd88e8d6f9567b32b28e70552aea4419c5dd3307ebae85a284d1fe38904e301a
+Published demo-record-1.yml with id: bafyreierh3xnfivexlscdwubvczmddsnf46uytyfvrbdhkjzztvsz6ruly
+```
+
+The sample record we deployed looks like:
+
+```
+record:
+  type: WebsiteRegistrationRecord
+  url: 'https://cerc.io'
+  repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
+  build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
+  tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
+  version: 1.0.23
+```
+
+2. Return to the laconic-console
+
+- the published record should now be viewable
+- explore it for more information
+- click on the link that opens the GraphQL console
+- the query is pre-loaded, click the button to run it
+- inspect the output
+
+3. Try out additional CLI commands
+
+- these are documented [here](https://git.vdb.to/cerc-io/laconic-registry-cli#readme) and updates are forthcoming
+- e.g,:
+
+```
+laconic-so --stack fixturenet-laconic-loaded deploy exec cli "laconic cns record list"
+```

docs/spec.md

@@ -1,5 +1,6 @@
 # Specification
 
+Note: this page is out of date (but still useful) - it will no longer be useful once stacks are [decoupled from the tool functionality](https://github.com/cerc-io/stack-orchestrator/issues/315).
 
 ## Implementation
 

docs/webapp.md

@@ -0,0 +1,64 @@
+### Building and Running Webapps
+
+It is possible to build and run Next.js webapps using the `build-webapp` and `run-webapp` subcommands.
+
+To make it easier to build once and deploy into different environments and with different configuration,
+compilation and static page generation are separated in the `build-webapp` and `run-webapp` steps.
+
+This offers much more flexibilty than standard Next.js build methods, since any environment variables accessed
+via `process.env`, whether for pages or for API, will have values drawn from their runtime deployment environment,
+not their build environment. 
+
+## Building
+
+Building usually requires no additional configuration.  By default, the Next.js version specified in `package.json`
+is used, and either `yarn` or `npm` will be used automatically depending on which lock files are present.  These
+can be overidden with the build arguments `CERC_NEXT_VERSION` and `CERC_BUILD_TOOL` respectively.  For example: `--extra-build-args "--build-arg CERC_NEXT_VERSION=13.4.12"`
+
+**Example**:
+```
+$ cd ~/cerc
+$ git clone git@git.vdb.to:cerc-io/test-progressive-web-app.git
+$ laconic-so build-webapp --source-repo ~/cerc/test-progressive-web-app
+...
+
+Built host container for ~/cerc/test-progressive-web-app with tag:
+
+    cerc/test-progressive-web-app:local
+
+To test locally run:
+
+    laconic-so run-webapp --image cerc/test-progressive-web-app:local --env-file /path/to/environment.env
+
+```
+
+## Running
+
+With `run-webapp` a new container will be launched on the local machine, with runtime configuration provided by `--env-file` (if specified) and published on an available port.  Multiple instances can be launched with different configuration.
+
+**Example**:
+```
+# Production env
+$ laconic-so run-webapp --image cerc/test-progressive-web-app:local --env-file /path/to/environment/production.env
+
+Image: cerc/test-progressive-web-app:local
+ID: 4c6e893bf436b3e91a2b92ce37e30e499685131705700bd92a90d2eb14eefd05
+URL: http://localhost:32768
+
+# Dev env
+$ laconic-so run-webapp --image cerc/test-progressive-web-app:local --env-file /path/to/environment/dev.env
+
+Image: cerc/test-progressive-web-app:local
+ID: 9ab96494f563aafb6c057d88df58f9eca81b90f8721a4e068493a289a976051c
+URL: http://localhost:32769
+```
+
+## Deploying
+
+Use the subcommand `deploy-webapp create` to make a deployment directory that can be subsequently deployed to a Kubernetes cluster.
+Example commands are shown below, assuming that the webapp container image `cerc/test-progressive-web-app:local` has already been built:
+```
+$ laconic-so deploy-webapp create --kube-config ~/kubectl/k8s-kubeconfig.yaml --image-registry registry.digitalocean.com/laconic-registry --deployment-dir webapp-k8s-deployment --image cerc/test-progressive-web-app:local --url https://test-pwa-app.hosting.laconic.com/ --env-file test-webapp.env
+$ laconic-so deployment --dir webapp-k8s-deployment push-images
+$ laconic-so deployment --dir webapp-k8s-deployment start
+```

requirements.txt

@@ -1,6 +1,12 @@
-python-decouple>=3.6
-GitPython>=3.1.27
-tqdm>=4.64.0
-python-on-whales>=0.58.0
-click>=8.1.3
-pyyaml>=6.0
+python-decouple>=3.8
+python-dotenv==1.0.0
+GitPython>=3.1.32
+tqdm>=4.65.0
+python-on-whales>=0.64.0
+click>=8.1.6
+PyYAML>=6.0.1
+ruamel.yaml>=0.17.32
+pydantic==1.10.9
+tomli==2.0.1
+validators==0.22.0
+kubernetes>=28.1.0

scripts/build_shiv_package.sh

@@ -1,4 +1,4 @@
 # Builds the shiv "package" for distribution
 mkdir -p ./package
-version_string=$( ./scripts/update_version_file.sh)
+version_string=$( ./scripts/create_build_tag_file.sh )
 shiv -c laconic-so -o package/laconic-so-${version_string} .

scripts/cloud-init-dev-mode-install.yaml

@@ -0,0 +1,44 @@
+#cloud-config
+
+# Used for easily testing stacks-in-development on cloud platforms
+# Assumes Ubuntu, edit the last line if targeting a different OS
+
+# Once SSH'd into the server, run:
+# `$ cd stack-orchestrator`
+# `$ git checkout <branch>
+# `$ ./scripts/developer-mode-setup.sh`
+# `$ source ./venv/bin/activate`
+
+# Followed by the stack instructions.
+
+package_update: true
+package_upgrade: true
+
+groups:
+  - docker
+
+system_info:
+  default_user:
+    groups: [ docker ]
+
+packages:
+  - apt-transport-https
+  - ca-certificates
+  - curl
+  - jq
+  - git
+  - gnupg
+  - lsb-release
+  - unattended-upgrades
+  - python3.10-venv
+  - pip
+
+runcmd:
+  - mkdir -p /etc/apt/keyrings
+  - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+  - echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
+  - apt-get update
+  - apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+  - systemctl enable docker
+  - systemctl start docker
+  - git clone https://github.com/cerc-io/stack-orchestrator.git /home/ubuntu/stack-orchestrator

scripts/cloud-init-user-mode-install.yaml

@@ -0,0 +1,35 @@
+#cloud-config
+
+# Used for installing Stack Orchestrator on platforms that support `cloud-init`
+# Tested on Ubuntu
+
+package_update: true
+package_upgrade: true
+
+groups:
+  - docker
+
+system_info:
+  default_user:
+    groups: [ docker ]
+
+packages:
+  - apt-transport-https
+  - ca-certificates
+  - curl
+  - jq
+  - git
+  - gnupg
+  - lsb-release
+  - unattended-upgrades
+
+runcmd:
+  - mkdir -p /etc/apt/keyrings
+  - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+  - echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
+  - apt-get update
+  - apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+  - systemctl enable docker
+  - systemctl start docker
+  - curl -L -o /usr/local/bin/laconic-so https://github.com/cerc-io/stack-orchestrator/releases/latest/download/laconic-so
+  - chmod +x /usr/local/bin/laconic-so