Main restoration working

Improve restoration process, WIP
Support main restart
2024-01-29 14:15:26 +01:00 · 2024-01-29 10:36:30 +01:00 · 2024-01-26 12:12:34 +01:00 · 2024-01-26 11:45:41 +01:00 · 2024-01-26 11:23:38 +01:00 · 2024-01-26 09:34:43 +01:00
234 changed files with 4468 additions and 11569 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -6,7 +6,6 @@ Checks: '*,
         -altera-unroll-loops,
         -android-*,
         -cert-err58-cpp,
-         -cppcoreguidelines-avoid-do-while,
         -cppcoreguidelines-avoid-c-arrays,
         -cppcoreguidelines-avoid-goto,
         -cppcoreguidelines-avoid-magic-numbers,
@@ -61,7 +60,6 @@ Checks: '*,
         -readability-implicit-bool-conversion,
         -readability-magic-numbers,
         -readability-named-parameter,
-         -readability-identifier-length,
         -misc-no-recursion,
         -concurrency-mt-unsafe,
         -bugprone-easily-swappable-parameters'
--- a/.github/workflows/daily_benchmark.yaml
+++ b/.github/workflows/daily_benchmark.yaml
@@ -16,7 +16,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
--- a/.github/workflows/diff.yaml
+++ b/.github/workflows/diff.yaml
@@ -27,7 +27,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -65,7 +65,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -137,9 +137,9 @@ jobs:
          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu

      - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Code analysis)"
+          name: "Code coverage"
          path: tools/github/generated/code_coverage.tar.gz

      - name: Run clang-tidy
@@ -162,7 +162,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -208,9 +208,9 @@ jobs:
          ./cppcheck_and_clang_format diff

      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
          path: tools/github/cppcheck_and_clang_format.txt

  release_build:
@@ -223,7 +223,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -251,7 +251,7 @@ jobs:
          ./continuous_integration

      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: "GQL Behave Status"
          path: |
@@ -283,6 +283,7 @@ jobs:
          ./run.sh

      - name: Ensure Kafka and Pulsar are down
+        if: always()
        run: |
          cd tests/e2e/streams/kafka
          docker-compose down
@@ -322,16 +323,16 @@ jobs:
          cpack -G DEB --config ../CPackConfig.cmake

      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: "Enterprise DEB package"
          path: build/output/memgraph*.deb

      - name: Save test data
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: always()
        with:
-          name: "Test data(Release build)"
+          name: "Test data"
          path: |
            # multiple paths could be defined
            build/logs
@@ -346,7 +347,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -365,7 +366,6 @@ jobs:
          cd build
          ctest -R memgraph__unit --output-on-failure -j$THREADS
      - name: Run e2e tests
-        if: false
        run: |
          cd tests
          ./setup.sh /opt/toolchain-v4/activate
@@ -375,10 +375,74 @@ jobs:
          ./run.sh "Client initiated failover"
          ./run.sh "Uninitialized cluster"
      - name: Save test data
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: always()
        with:
-          name: "Test data(High availability build)"
+          name: "Test data"
+          path: |
+            # multiple paths could be defined
+            build/logs
+
+  experimental_build_mt:
+    name: "MultiTenancy replication build"
+    runs-on: [self-hosted, Linux, X64, Diff]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v3
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+
+      - name: Build release binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build MT replication experimental binaries.
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=Release -D MG_EXPERIMENTAL_REPLICATION_MULTITENANCY=ON ..
+          make -j$THREADS
+
+      - name: Run unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure -j$THREADS
+
+      - name: Run e2e tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          source ve3/bin/activate_e2e
+          cd e2e
+
+          # Just the replication based e2e tests
+          ./run.sh "Replicate multitenancy"
+          ./run.sh "Show"
+          ./run.sh "Show while creating invalid state"
+          ./run.sh "Delete edge replication"
+          ./run.sh "Read-write benchmark"
+          ./run.sh "Index replication"
+          ./run.sh "Constraints"
+
+      - name: Save test data
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: "Test data"
          path: |
            # multiple paths could be defined
            build/logs
@@ -394,7 +458,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -411,18 +475,13 @@ jobs:
          cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
          make -j$THREADS memgraph

-      - name: Refresh Jepsen Cluster
-        run: |
-          cd tests/jepsen
-          ./run.sh cluster-refresh
-
      - name: Run Jepsen tests
        run: |
          cd tests/jepsen
          ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs

      - name: Save Jepsen report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: ${{ always() }}
        with:
          name: "Jepsen Report"
@@ -438,7 +497,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
--- a/.github/workflows/full_clang_tidy.yaml
+++ b/.github/workflows/full_clang_tidy.yaml
@@ -14,7 +14,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
--- a/.github/workflows/package_memgraph.yaml
+++ b/.github/workflows/package_memgraph.yaml
@@ -42,14 +42,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package amzn-2 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: amzn-2
          path: build/output/amzn-2/memgraph*.rpm
@@ -60,14 +60,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package centos-7 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: centos-7
          path: build/output/centos-7/memgraph*.rpm
@@ -78,14 +78,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package centos-9 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: centos-9
          path: build/output/centos-9/memgraph*.rpm
@@ -96,14 +96,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package debian-10 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: debian-10
          path: build/output/debian-10/memgraph*.deb
@@ -114,14 +114,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package debian-11 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: debian-11
          path: build/output/debian-11/memgraph*.deb
@@ -132,14 +132,14 @@ jobs:
    timeout-minutes: 120
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package debian-11-arm ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: debian-11-aarch64
          path: build/output/debian-11-arm/memgraph*.deb
@@ -150,14 +150,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package debian-11 ${{ github.event.inputs.build_type }} --for-platform
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: debian-11-platform
          path: build/output/debian-11/memgraph*.deb
@@ -168,7 +168,7 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -177,7 +177,7 @@ jobs:
          ./run.sh package debian-11 ${{ github.event.inputs.build_type }} --for-docker
          ./run.sh docker
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: docker
          path: build/output/docker/memgraph*.tar.gz
@@ -188,14 +188,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package fedora-36 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: fedora-36
          path: build/output/fedora-36/memgraph*.rpm
@@ -206,14 +206,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package ubuntu-18.04 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: ubuntu-18.04
          path: build/output/ubuntu-18.04/memgraph*.deb
@@ -224,14 +224,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package ubuntu-20.04 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: ubuntu-20.04
          path: build/output/ubuntu-20.04/memgraph*.deb
@@ -242,14 +242,14 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package ubuntu-22.04 ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: ubuntu-22.04
          path: build/output/ubuntu-22.04/memgraph*.deb
@@ -260,14 +260,14 @@ jobs:
    timeout-minutes: 120
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
        run: |
          ./release/package/run.sh package ubuntu-22.04-arm ${{ github.event.inputs.build_type }}
      - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: ubuntu-22.04-aarch64
          path: build/output/ubuntu-22.04-arm/memgraph*.deb
@@ -279,7 +279,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Download artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v3
        with:
          # name: # if name input parameter is not provided, all artifacts are downloaded
                  # and put in directories named after each one.
--- a/.github/workflows/performance_benchmarks.yaml
+++ b/.github/workflows/performance_benchmarks.yaml
@@ -14,7 +14,7 @@ jobs:

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
--- a/.github/workflows/release_debian10.yaml
+++ b/.github/workflows/release_debian10.yaml
@@ -1,7 +1,4 @@
 name: Release Debian 10
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true

 on:
  workflow_dispatch:
@@ -13,30 +10,23 @@ on:
        options:
          - Release
          - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
  schedule:
    - cron: "0 22 * * *"

-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
 jobs:
  community_build:
    name: "Community build"
    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -50,6 +40,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build community binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
@@ -71,11 +65,10 @@ jobs:
      THREADS: 24
      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-    timeout-minutes: 60

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -117,19 +110,22 @@ jobs:
          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu

      - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Coverage build)"
+          name: "Code coverage"
          path: tools/github/generated/code_coverage.tar.gz

  debug_build:
    name: "Debug build"
    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -161,6 +157,10 @@ jobs:
        run: |
          ./tests/drivers/run.sh

+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
      - name: Run cppcheck and clang-format
        run: |
          # Activate toolchain.
@@ -171,49 +171,23 @@ jobs:
          ./cppcheck_and_clang_format diff

      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
          path: tools/github/cppcheck_and_clang_format.txt

-  debug_integration_test:
-    name: "Debug integration tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run integration tests
-        run: |
-          tests/integration/run.sh
-
  release_build:
    name: "Release build"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    runs-on: [self-hosted, Linux, X64, Debian10, BigMemory]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -227,6 +201,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build release binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
@@ -248,60 +226,11 @@ jobs:
          cpack -G DEB --config ../CPackConfig.cmake

      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: "Enterprise DEB package"
          path: build/output/memgraph*.deb

-      - name: Run GQL Behave tests
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          cd gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-  release_benchmark_tests:
-    name: "Release Benchmark Tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run micro benchmark tests
        run: |
          # Activate toolchain.
@@ -328,31 +257,29 @@ jobs:
            --num-database-workers 9 --num-clients-workers 30 \
            --no-strict

-  release_e2e_test:
-    if: false
-    name: "Release End-to-end Test"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration

-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html

-      - name: Build release binaries
+      - name: Run unit tests
        run: |
          # Activate toolchain.
          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init

-          # Build release binaries
+          # Run unit tests.
          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
+          ctest -R memgraph__unit --output-on-failure

      - name: Ensure Kafka and Pulsar are up
        run: |
@@ -377,32 +304,6 @@ jobs:
          cd ../pulsar
          docker-compose down

-  release_durability_stress_tests:
-    name: "Release durability and stress tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run stress test (plain)
        run: |
          cd tests/stress
@@ -413,6 +314,11 @@ jobs:
          cd tests/stress
          ./continuous_integration --use-ssl

+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
      - name: Run durability test (plain)
        run: |
          cd tests/stress
@@ -428,11 +334,15 @@ jobs:
  release_jepsen_test:
    name: "Release Jepsen Test"
    runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
    timeout-minutes: 60

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -445,23 +355,22 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build only memgraph release binary.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
          make -j$THREADS memgraph

-      - name: Refresh Jepsen Cluster
-        run: |
-          cd tests/jepsen
-          ./run.sh cluster-refresh
-
      - name: Run Jepsen tests
        run: |
          cd tests/jepsen
          ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs

      - name: Save Jepsen report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: ${{ always() }}
        with:
          name: "Jepsen Report"
--- a/.github/workflows/release_docker.yaml
+++ b/.github/workflows/release_docker.yaml
@@ -19,7 +19,7 @@ jobs:
      DOCKER_REPOSITORY_NAME: memgraph
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v2
--- a/.github/workflows/release_mgbench_client.yaml
+++ b/.github/workflows/release_mgbench_client.yaml
@@ -20,7 +20,7 @@ jobs:

    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v2
--- a/.github/workflows/release_ubuntu2004.yaml
+++ b/.github/workflows/release_ubuntu2004.yaml
@@ -1,7 +1,4 @@
 name: Release Ubuntu 20.04
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true

 on:
  workflow_dispatch:
@@ -13,30 +10,23 @@ on:
        options:
          - Release
          - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
  schedule:
    - cron: "0 22 * * *"

-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
 jobs:
  community_build:
    name: "Community build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -50,6 +40,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build community binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
@@ -67,11 +61,14 @@ jobs:
  coverage_build:
    name: "Coverage build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -113,19 +110,22 @@ jobs:
          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu

      - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Coverage build)"
+          name: "Code coverage"
          path: tools/github/generated/code_coverage.tar.gz

  debug_build:
    name: "Debug build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -157,6 +157,10 @@ jobs:
        run: |
          ./tests/drivers/run.sh

+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
      - name: Run cppcheck and clang-format
        run: |
          # Activate toolchain.
@@ -167,49 +171,23 @@ jobs:
          ./cppcheck_and_clang_format diff

      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
          path: tools/github/cppcheck_and_clang_format.txt

-  debug_integration_test:
-    name: "Debug integration tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run integration tests
-        run: |
-          tests/integration/run.sh
-
  release_build:
    name: "Release build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -223,6 +201,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build release binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
@@ -244,60 +226,11 @@ jobs:
          cpack -G DEB --config ../CPackConfig.cmake

      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: "Enterprise DEB package"
          path: build/output/memgraph*.deb

-      - name: Run GQL Behave tests
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          cd gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-  release_benchmark_tests:
-    name: "Release Benchmark Tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run micro benchmark tests
        run: |
          # Activate toolchain.
@@ -324,31 +257,29 @@ jobs:
            --num-database-workers 9 --num-clients-workers 30 \
            --no-strict

-  release_e2e_test:
-    if: false
-    name: "Release End-to-end Test"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration

-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html

-      - name: Build release binaries
+      - name: Run unit tests
        run: |
          # Activate toolchain.
          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init

-          # Build release binaries
+          # Run unit tests.
          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
+          ctest -R memgraph__unit --output-on-failure

      - name: Ensure Kafka and Pulsar are up
        run: |
@@ -373,32 +304,6 @@ jobs:
          cd ../pulsar
          docker-compose down

-  release_durability_stress_tests:
-    name: "Release durability and stress tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run stress test (plain)
        run: |
          cd tests/stress
@@ -409,6 +314,11 @@ jobs:
          cd tests/stress
          ./continuous_integration --use-ssl

+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
      - name: Run durability test (plain)
        run: |
          cd tests/stress
--- a/.github/workflows/stress_test_large.yaml
+++ b/.github/workflows/stress_test_large.yaml
@@ -1,68 +0,0 @@
-name: Stress test large
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
-
-on:
-  workflow_dispatch:
-    inputs:
-      build_type:
-        type: choice
-        description: "Memgraph Build type. Default value is Release."
-        default: 'Release'
-        options:
-          - Release
-          - RelWithDebInfo
-  push:
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
-  schedule:
-    - cron: "0 22 * * *"
-
-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
-jobs:
-  stress_test_large:
-    name: "Stress test large"
-    timeout-minutes: 720
-    strategy:
-      matrix:
-        os: [Debian10, Ubuntu20.04]
-        extra: [BigMemory, Gen8]
-        exclude:
-          - os: Debian10
-            extra: Gen8
-          - os: Ubuntu20.04
-            extra: BigMemory
-    runs-on: [self-hosted, Linux, X64, "${{ matrix.os }}", "${{ matrix.extra }}"]
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
--- a/.github/workflows/upload_to_s3.yaml
+++ b/.github/workflows/upload_to_s3.yaml
@@ -15,7 +15,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Download artifacts
-        uses: dawidd6/action-download-artifact@v4
+        uses: dawidd6/action-download-artifact@v2
        with:
          workflow: package_all.yaml
          workflow_conclusion: success
--- a/ADRs/003_rocksdb.md
+++ b/ADRs/003_rocksdb.md
@@ -1,38 +0,0 @@
-# RocksDB ADR
-
-**Author**
-Marko Budiselic (github.com/gitbuda)
-
-**Status**
-ACCEPTED
-
-**Date**
-January 23, 2024
-
-**Problem**
-
-Interacting with data (reads and writes) on disk in a concurrent, safe, and
-fast way is a challenging task. Implementing all low-level primitives to
-interact with various disk hardware efficiently consumes significant
-engineering people. Whenever Memgraph has to store data on disk (or any
-other colder than RAM storage system), the problem is how to do that in the
-least amount of development time while satisfying all functional requirements
-(often performance).
-
-**Criteria**
-
- working efficiently in a highly concurrent environment
- easy integration with Memgraph's C++ codebase
- providing low-level key-value API
- heavily tested in production environments
- providing abstractions for the storage hardware (even for cloud-based
-  storages like S3)
-
-**Decision**
-
-There are a few robust key-value stores, but finding one that is
-production-ready and compatible with Memgraph's C++ codebase is challenging.
-**We select [RocksDB](https://github.com/facebook/rocksdb)** because it
-delivers robust API to manage data on disk; it's battle-tested in many
-production environments (many databases systems are embedding RocksDB), and
-it's the most compatible one.
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -275,7 +275,7 @@ option(MG_EXPERIMENTAL_HIGH_AVAILABILITY "Feature flag for experimental high ava

 if (NOT MG_ENTERPRISE AND MG_EXPERIMENTAL_HIGH_AVAILABILITY)
    set(MG_EXPERIMENTAL_HIGH_AVAILABILITY OFF)
-    message(FATAL_ERROR "MG_EXPERIMENTAL_HIGH_AVAILABILITY can only be used with enterpise version of the code.")
+    message(FATAL_ERROR "MG_EXPERIMENTAL_HIGH_AVAILABILITY must be used with enterpise version of the code.")
 endif ()

 if (MG_EXPERIMENTAL_HIGH_AVAILABILITY)
@@ -291,6 +291,16 @@ option(TSAN "Build with Thread Sanitizer. To get a reasonable performance option
 option(UBSAN "Build with Undefined Behaviour Sanitizer" OFF)

 # Build feature flags
+option(MG_EXPERIMENTAL_REPLICATION_MULTITENANCY "Feature flag for experimental replicaition of multitenacy" OFF)
+
+if (NOT MG_ENTERPRISE AND MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+    set(MG_EXPERIMENTAL_REPLICATION_MULTITENANCY OFF)
+    message(FATAL_ERROR "MG_EXPERIMENTAL_REPLICATION_MULTITENANCY with community edition build isn't possible")
+endif ()
+
+if (MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+    add_compile_definitions(MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+endif ()

 if (TEST_COVERAGE)
  string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -294,10 +294,3 @@ set_path_external_library(jemalloc STATIC
  ${CMAKE_CURRENT_SOURCE_DIR}/jemalloc/include/)

 import_header_library(rangev3 ${CMAKE_CURRENT_SOURCE_DIR}/rangev3/include)
-
-# Setup NuRaft
-import_external_library(nuraft STATIC
-  ${CMAKE_CURRENT_SOURCE_DIR}/nuraft/lib/libnuraft.a
-  ${CMAKE_CURRENT_SOURCE_DIR}/nuraft/include/)
-find_package(OpenSSL REQUIRED)
-target_link_libraries(nuraft INTERFACE ${OPENSSL_LIBRARIES})
--- a/libs/setup.sh
+++ b/libs/setup.sh
@@ -123,10 +123,9 @@ declare -A primary_urls=(
  ["pulsar"]="http://$local_cache_host/git/pulsar.git"
  ["librdtsc"]="http://$local_cache_host/git/librdtsc.git"
  ["ctre"]="http://$local_cache_host/file/hanickadot/compile-time-regular-expressions/v3.7.2/single-header/ctre.hpp"
-  ["absl"]="http://$local_cache_host/git/abseil-cpp.git"
-  ["jemalloc"]="http://$local_cache_host/git/jemalloc.git"
-  ["range-v3"]="http://$local_cache_host/git/range-v3.git"
-  ["nuraft"]="http://$local_cache_host/git/NuRaft.git"
+  ["absl"]="https://$local_cache_host/git/abseil-cpp.git"
+  ["jemalloc"]="https://$local_cache_host/git/jemalloc.git"
+  ["range-v3"]="https://$local_cache_host/git/ericniebler/range-v3.git"
 )

 # The goal of secondary urls is to have links to the "source of truth" of
@@ -156,7 +155,6 @@ declare -A secondary_urls=(
  ["absl"]="https://github.com/abseil/abseil-cpp.git"
  ["jemalloc"]="https://github.com/jemalloc/jemalloc.git"
  ["range-v3"]="https://github.com/ericniebler/range-v3.git"
-  ["nuraft"]="https://github.com/eBay/NuRaft.git"
 )

 # antlr
@@ -270,8 +268,6 @@ pushd jemalloc
 MALLOC_CONF="retain:false,percpu_arena:percpu,oversize_threshold:0,muzzy_decay_ms:5000,dirty_decay_ms:5000" \
 ./configure \
  --disable-cxx \
-  --with-lg-page=12 \
-  --with-lg-hugepage=21 \
  --enable-shared=no --prefix=$working_dir \
  --with-malloc-conf="retain:false,percpu_arena:percpu,oversize_threshold:0,muzzy_decay_ms:5000,dirty_decay_ms:5000"

@@ -281,10 +277,3 @@ popd
 #range-v3 release-0.12.0
 range_v3_ref="release-0.12.0"
 repo_clone_try_double "${primary_urls[range-v3]}" "${secondary_urls[range-v3]}" "rangev3" "$range_v3_ref"
-
-# NuRaft
-nuraft_tag="v2.1.0"
-repo_clone_try_double "${primary_urls[nuraft]}" "${secondary_urls[nuraft]}" "nuraft" "$nuraft_tag" true
-pushd nuraft
-./prepare.sh
-popd
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -22,10 +22,8 @@ add_subdirectory(dbms)
 add_subdirectory(flags)
 add_subdirectory(distributed)
 add_subdirectory(replication)
-add_subdirectory(replication_handler)
 add_subdirectory(coordination)
 add_subdirectory(replication_coordination_glue)
-add_subdirectory(system)

 string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)

@@ -45,10 +43,10 @@ set(mg_single_node_v2_sources
 add_executable(memgraph ${mg_single_node_v2_sources})
 target_include_directories(memgraph PUBLIC ${CMAKE_SOURCE_DIR}/include)
 target_link_libraries(memgraph stdc++fs Threads::Threads
-        mg-telemetry mg-communication mg-communication-metrics mg-memory mg-utils mg-license mg-settings mg-glue mg-flags mg::system mg::replication_handler)
+        mg-telemetry mg-communication mg-communication-metrics mg-memory mg-utils mg-license mg-settings mg-glue mg-flags)

 # NOTE: `include/mg_procedure.syms` describes a pattern match for symbols which
-# should be dynamically exported, so that `dlopen` can correctly link th
+# should be dynamically exported, so that `dlopen` can correctly link the
 # symbols in custom procedure module libraries.
 target_link_libraries(memgraph "-Wl,--dynamic-list=${CMAKE_SOURCE_DIR}/include/mg_procedure.syms")
 set_target_properties(memgraph PROPERTIES
--- a/src/auth/CMakeLists.txt
+++ b/src/auth/CMakeLists.txt
@@ -2,9 +2,7 @@ set(auth_src_files
    auth.cpp
    crypto.cpp
    models.cpp
-    module.cpp
-    rpc.cpp
-    replication_handlers.cpp)
+    module.cpp)

 find_package(Seccomp REQUIRED)
 find_package(fmt REQUIRED)
@@ -13,7 +11,7 @@ find_package(gflags REQUIRED)

 add_library(mg-auth STATIC ${auth_src_files})
 target_link_libraries(mg-auth json libbcrypt gflags fmt::fmt)
-target_link_libraries(mg-auth mg-utils mg-kvstore mg-license mg::system mg-replication)
+target_link_libraries(mg-auth mg-utils mg-kvstore mg-license )

 target_link_libraries(mg-auth ${Seccomp_LIBRARIES})
 target_include_directories(mg-auth SYSTEM PRIVATE ${Seccomp_INCLUDE_DIRS})
--- a/src/auth/auth.cpp
+++ b/src/auth/auth.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -8,18 +8,17 @@

 #include "auth/auth.hpp"

+#include <cstring>
 #include <iostream>
-#include <optional>
+#include <limits>
 #include <utility>

 #include <fmt/format.h>

-#include "auth/crypto.hpp"
 #include "auth/exceptions.hpp"
-#include "auth/rpc.hpp"
 #include "license/license.hpp"
-#include "system/transaction.hpp"
 #include "utils/flag_validation.hpp"
+#include "utils/logging.hpp"
 #include "utils/message.hpp"
 #include "utils/settings.hpp"
 #include "utils/string.hpp"
@@ -44,89 +43,9 @@ DEFINE_VALIDATED_int32(auth_module_timeout_ms, 10000,
                       FLAG_IN_RANGE(100, 1800000));

 namespace memgraph::auth {
-
-namespace {
-#ifdef MG_ENTERPRISE
-/**
- * REPLICATION SYSTEM ACTION IMPLEMENTATIONS
- */
-struct UpdateAuthData : memgraph::system::ISystemAction {
-  explicit UpdateAuthData(User user) : user_{std::move(user)}, role_{std::nullopt} {}
-  explicit UpdateAuthData(Role role) : user_{std::nullopt}, role_{std::move(role)} {}
-
-  void DoDurability() override { /* Done during Auth execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const replication::UpdateAuthDataRes &response) { return response.success; };
-    if (user_) {
-      return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-          *user_);
-    }
-    if (role_) {
-      return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-          *role_);
-    }
-    // Should never get here
-    MG_ASSERT(false, "Trying to update auth data that is not a user nor a role");
-    return {};
-  }
-
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  std::optional<User> user_;
-  std::optional<Role> role_;
-};
-
-struct DropAuthData : memgraph::system::ISystemAction {
-  enum class AuthDataType { USER, ROLE };
-
-  explicit DropAuthData(AuthDataType type, std::string_view name) : type_{type}, name_{name} {}
-
-  void DoDurability() override { /* Done during Auth execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const replication::DropAuthDataRes &response) { return response.success; };
-
-    memgraph::replication::DropAuthDataReq::DataType type{};
-    switch (type_) {
-      case AuthDataType::USER:
-        type = memgraph::replication::DropAuthDataReq::DataType::USER;
-        break;
-      case AuthDataType::ROLE:
-        type = memgraph::replication::DropAuthDataReq::DataType::ROLE;
-        break;
-    }
-    return client.SteamAndFinalizeDelta<replication::DropAuthDataRpc>(
-        check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-        type, name_);
-  }
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  AuthDataType type_;
-  std::string name_;
-};
-#endif
-
-/**
- * CONSTANTS
- */
 const std::string kUserPrefix = "user:";
 const std::string kRolePrefix = "role:";
 const std::string kLinkPrefix = "link:";
-const std::string kVersion = "version";
-
-static constexpr auto kVersionV1 = "V1";
-}  // namespace

 /**
 * All data stored in the `Auth` storage is stored in an underlying
@@ -145,59 +64,7 @@ static constexpr auto kVersionV1 = "V1";
 * key="link:<username>", value="<rolename>"
 */

-namespace {
-void MigrateVersions(kvstore::KVStore &store) {
-  static constexpr auto kPasswordHashV0V1 = "password_hash";
-  auto version_str = store.Get(kVersion);
-
-  if (!version_str) {
-    using namespace std::string_literals;
-
-    // pre versioning, add version to the store
-    auto puts = std::map<std::string, std::string>{{kVersion, kVersionV1}};
-
-    // also add hash kind into durability
-
-    auto it = store.begin(kUserPrefix);
-    auto const e = store.end(kUserPrefix);
-
-    if (it != e) {
-      const auto hash_algo = CurrentHashAlgorithm();
-      spdlog::info("Updating auth durability, assuming previously stored as {}", AsString(hash_algo));
-
-      for (; it != e; ++it) {
-        auto const &[key, value] = *it;
-        try {
-          auto user_data = nlohmann::json::parse(value);
-
-          auto password_hash = user_data[kPasswordHashV0V1];
-          if (!password_hash.is_string()) {
-            throw AuthException("Couldn't load user data!");
-          }
-          // upgrade the password_hash to include the hash algortihm
-          if (password_hash.empty()) {
-            user_data[kPasswordHashV0V1] = nullptr;
-          } else {
-            user_data[kPasswordHashV0V1] = HashedPassword{hash_algo, password_hash};
-          }
-          puts.emplace(key, user_data.dump());
-        } catch (const nlohmann::json::parse_error &e) {
-          throw AuthException("Couldn't load user data!");
-        }
-      }
-    }
-
-    // Perform migration to V1
-    store.PutMultiple(puts);
-    version_str = kVersionV1;
-  }
-}
-};  // namespace
-
-Auth::Auth(std::string storage_directory, Config config)
-    : storage_(std::move(storage_directory)), module_(FLAGS_auth_module_executable), config_{std::move(config)} {
-  MigrateVersions(storage_);
-}
+Auth::Auth(const std::string &storage_directory) : storage_(storage_directory), module_(FLAGS_auth_module_executable) {}

 std::optional<User> Auth::Authenticate(const std::string &username, const std::string &password) {
  if (module_.IsUsed()) {
@@ -228,12 +95,6 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
    // Authenticate the user.
    if (!is_authenticated) return std::nullopt;

-    /**
-     * TODO
-     * The auth module should not update auth data.
-     * There is now way to replicate it and we should not be storing sensitive data if we don't have to.
-     */
-
    // Find or create the user and return it.
    auto user = GetUser(username);
    if (!user) {
@@ -252,7 +113,7 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
        return std::nullopt;
      }
    } else {
-      UpdatePassword(*user, password);
+      user->UpdatePassword(password);
    }
    if (FLAGS_auth_module_manage_roles) {
      if (!rolename.empty()) {
@@ -294,10 +155,6 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
                                          username, "https://memgr.ph/auth"));
      return std::nullopt;
    }
-    if (user->UpgradeHash(password)) {
-      SaveUser(*user);
-    }
-
    return user;
  }
 }
@@ -326,7 +183,7 @@ std::optional<User> Auth::GetUser(const std::string &username_orig) const {
  return user;
 }

-void Auth::SaveUser(const User &user, system::Transaction *system_tx) {
+void Auth::SaveUser(const User &user) {
  bool success = false;
  if (const auto *role = user.role(); role != nullptr) {
    success = storage_.PutMultiple(
@@ -338,72 +195,26 @@ void Auth::SaveUser(const User &user, system::Transaction *system_tx) {
  if (!success) {
    throw AuthException("Couldn't save user '{}'!", user.username());
  }
-  // All changes to the user end up calling this function, so no need to add a delta anywhere else
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<UpdateAuthData>(user);
-#endif
-  }
 }

-void Auth::UpdatePassword(auth::User &user, const std::optional<std::string> &password) {
-  // Check if null
-  if (!password) {
-    if (!config_.password_permit_null) {
-      throw AuthException("Null passwords aren't permitted!");
-    }
-  } else {
-    // Check if compliant with our filter
-    if (config_.custom_password_regex) {
-      if (const auto license_check_result = license::global_license_checker.IsEnterpriseValid(utils::global_settings);
-          license_check_result.HasError()) {
-        throw AuthException(
-            "Custom password regex is a Memgraph Enterprise feature. Please set the config "
-            "(\"--auth-password-strength-regex\") to its default value (\"{}\") or remove the flag.\n{}",
-            glue::kDefaultPasswordRegex,
-            license::LicenseCheckErrorToString(license_check_result.GetError(), "password regex"));
-      }
-    }
-    if (!std::regex_match(*password, config_.password_regex)) {
-      throw AuthException(
-          "The user password doesn't conform to the required strength! Regex: "
-          "\"{}\"",
-          config_.password_regex_str);
-    }
-  }
-
-  // All checks passed; update
-  user.UpdatePassword(password);
-}
-
-std::optional<User> Auth::AddUser(const std::string &username, const std::optional<std::string> &password,
-                                  system::Transaction *system_tx) {
-  if (!NameRegexMatch(username)) {
-    throw AuthException("Invalid user name.");
-  }
+std::optional<User> Auth::AddUser(const std::string &username, const std::optional<std::string> &password) {
  auto existing_user = GetUser(username);
  if (existing_user) return std::nullopt;
  auto existing_role = GetRole(username);
  if (existing_role) return std::nullopt;
  auto new_user = User(username);
-  UpdatePassword(new_user, password);
-  SaveUser(new_user, system_tx);
+  new_user.UpdatePassword(password);
+  SaveUser(new_user);
  return new_user;
 }

-bool Auth::RemoveUser(const std::string &username_orig, system::Transaction *system_tx) {
+bool Auth::RemoveUser(const std::string &username_orig) {
  auto username = utils::ToLowerCase(username_orig);
  if (!storage_.Get(kUserPrefix + username)) return false;
  std::vector<std::string> keys({kLinkPrefix + username, kUserPrefix + username});
  if (!storage_.DeleteMultiple(keys)) {
    throw AuthException("Couldn't remove user '{}'!", username);
  }
-  // Handling drop user delta
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<DropAuthData>(DropAuthData::AuthDataType::USER, username);
-#endif
-  }
  return true;
 }

@@ -420,19 +231,6 @@ std::vector<auth::User> Auth::AllUsers() const {
  return ret;
 }

-std::vector<std::string> Auth::AllUsernames() const {
-  std::vector<std::string> ret;
-  for (auto it = storage_.begin(kUserPrefix); it != storage_.end(kUserPrefix); ++it) {
-    auto username = it->first.substr(kUserPrefix.size());
-    if (username != utils::ToLowerCase(username)) continue;
-    auto user = GetUser(username);
-    if (user) {
-      ret.push_back(username);
-    }
-  }
-  return ret;
-}
-
 bool Auth::HasUsers() const { return storage_.begin(kUserPrefix) != storage_.end(kUserPrefix); }

 std::optional<Role> Auth::GetRole(const std::string &rolename_orig) const {
@@ -450,30 +248,21 @@ std::optional<Role> Auth::GetRole(const std::string &rolename_orig) const {
  return Role::Deserialize(data);
 }

-void Auth::SaveRole(const Role &role, system::Transaction *system_tx) {
+void Auth::SaveRole(const Role &role) {
  if (!storage_.Put(kRolePrefix + role.rolename(), role.Serialize().dump())) {
    throw AuthException("Couldn't save role '{}'!", role.rolename());
  }
-  // All changes to the role end up calling this function, so no need to add a delta anywhere else
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<UpdateAuthData>(role);
-#endif
-  }
 }

-std::optional<Role> Auth::AddRole(const std::string &rolename, system::Transaction *system_tx) {
-  if (!NameRegexMatch(rolename)) {
-    throw AuthException("Invalid role name.");
-  }
+std::optional<Role> Auth::AddRole(const std::string &rolename) {
  if (auto existing_role = GetRole(rolename)) return std::nullopt;
  if (auto existing_user = GetUser(rolename)) return std::nullopt;
  auto new_role = Role(rolename);
-  SaveRole(new_role, system_tx);
+  SaveRole(new_role);
  return new_role;
 }

-bool Auth::RemoveRole(const std::string &rolename_orig, system::Transaction *system_tx) {
+bool Auth::RemoveRole(const std::string &rolename_orig) {
  auto rolename = utils::ToLowerCase(rolename_orig);
  if (!storage_.Get(kRolePrefix + rolename)) return false;
  std::vector<std::string> keys;
@@ -486,12 +275,6 @@ bool Auth::RemoveRole(const std::string &rolename_orig, system::Transaction *sys
  if (!storage_.DeleteMultiple(keys)) {
    throw AuthException("Couldn't remove role '{}'!", rolename);
  }
-  // Handling drop role delta
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<DropAuthData>(DropAuthData::AuthDataType::ROLE, rolename);
-#endif
-  }
  return true;
 }

@@ -509,18 +292,6 @@ std::vector<auth::Role> Auth::AllRoles() const {
  return ret;
 }

-std::vector<std::string> Auth::AllRolenames() const {
-  std::vector<std::string> ret;
-  for (auto it = storage_.begin(kRolePrefix); it != storage_.end(kRolePrefix); ++it) {
-    auto rolename = it->first.substr(kRolePrefix.size());
-    if (rolename != utils::ToLowerCase(rolename)) continue;
-    if (auto role = GetRole(rolename)) {
-      ret.push_back(rolename);
-    }
-  }
-  return ret;
-}
-
 std::vector<auth::User> Auth::AllUsersForRole(const std::string &rolename_orig) const {
  const auto rolename = utils::ToLowerCase(rolename_orig);
  std::vector<auth::User> ret;
@@ -540,67 +311,52 @@ std::vector<auth::User> Auth::AllUsersForRole(const std::string &rolename_orig)
 }

 #ifdef MG_ENTERPRISE
-bool Auth::GrantDatabaseToUser(const std::string &db, const std::string &name, system::Transaction *system_tx) {
+bool Auth::GrantDatabaseToUser(const std::string &db, const std::string &name) {
  if (auto user = GetUser(name)) {
    if (db == kAllDatabases) {
      user->db_access().GrantAll();
    } else {
      user->db_access().Add(db);
    }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
    return true;
  }
  return false;
 }

-bool Auth::RevokeDatabaseFromUser(const std::string &db, const std::string &name, system::Transaction *system_tx) {
+bool Auth::RevokeDatabaseFromUser(const std::string &db, const std::string &name) {
  if (auto user = GetUser(name)) {
    if (db == kAllDatabases) {
      user->db_access().DenyAll();
    } else {
      user->db_access().Remove(db);
    }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
    return true;
  }
  return false;
 }

-void Auth::DeleteDatabase(const std::string &db, system::Transaction *system_tx) {
+void Auth::DeleteDatabase(const std::string &db) {
  for (auto it = storage_.begin(kUserPrefix); it != storage_.end(kUserPrefix); ++it) {
    auto username = it->first.substr(kUserPrefix.size());
    if (auto user = GetUser(username)) {
      user->db_access().Delete(db);
-      SaveUser(*user, system_tx);
+      SaveUser(*user);
    }
  }
 }

-bool Auth::SetMainDatabase(std::string_view db, const std::string &name, system::Transaction *system_tx) {
+bool Auth::SetMainDatabase(std::string_view db, const std::string &name) {
  if (auto user = GetUser(name)) {
    if (!user->db_access().SetDefault(db)) {
      throw AuthException("Couldn't set default database '{}' for user '{}'!", db, name);
    }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
    return true;
  }
  return false;
 }
 #endif

-bool Auth::NameRegexMatch(const std::string &user_or_role) const {
-  if (config_.custom_name_regex) {
-    if (const auto license_check_result =
-            memgraph::license::global_license_checker.IsEnterpriseValid(memgraph::utils::global_settings);
-        license_check_result.HasError()) {
-      throw memgraph::auth::AuthException(
-          "Custom user/role regex is a Memgraph Enterprise feature. Please set the config "
-          "(\"--auth-user-or-role-name-regex\") to its default value (\"{}\") or remove the flag.\n{}",
-          glue::kDefaultUserRoleRegex,
-          memgraph::license::LicenseCheckErrorToString(license_check_result.GetError(), "user/role regex"));
-    }
-  }
-  return std::regex_match(user_or_role, config_.name_regex);
-}
-
 }  // namespace memgraph::auth
--- a/src/auth/auth.hpp
+++ b/src/auth/auth.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -10,23 +10,16 @@

 #include <mutex>
 #include <optional>
-#include <regex>
 #include <vector>

 #include "auth/exceptions.hpp"
 #include "auth/models.hpp"
 #include "auth/module.hpp"
-#include "glue/auth_global.hpp"
 #include "kvstore/kvstore.hpp"
-#include "system/action.hpp"
 #include "utils/settings.hpp"
-#include "utils/synchronized.hpp"

 namespace memgraph::auth {

-class Auth;
-using SynchedAuth = memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock>;
-
 static const constexpr char *const kAllDatabases = "*";

 /**
@@ -38,47 +31,7 @@ static const constexpr char *const kAllDatabases = "*";
 */
 class Auth final {
 public:
-  struct Config {
-    Config() {}
-    Config(std::string name_regex, std::string password_regex, bool password_permit_null)
-        : name_regex_str{std::move(name_regex)},
-          password_regex_str{std::move(password_regex)},
-          password_permit_null{password_permit_null},
-          custom_name_regex{name_regex_str != glue::kDefaultUserRoleRegex},
-          name_regex{name_regex_str},
-          custom_password_regex{password_regex_str != glue::kDefaultPasswordRegex},
-          password_regex{password_regex_str} {}
-
-    std::string name_regex_str{glue::kDefaultUserRoleRegex};
-    std::string password_regex_str{glue::kDefaultPasswordRegex};
-    bool password_permit_null{true};
-
-   private:
-    friend class Auth;
-    bool custom_name_regex{false};
-    std::regex name_regex{name_regex_str};
-    bool custom_password_regex{false};
-    std::regex password_regex{password_regex_str};
-  };
-
-  explicit Auth(std::string storage_directory, Config config);
-
-  /**
-   * @brief Set the Config object
-   *
-   * @param config
-   */
-  void SetConfig(Config config) {
-    // NOTE: The Auth class itself is not thread-safe, higher-level code needs to synchronize it when using it.
-    config_ = std::move(config);
-  }
-
-  /**
-   * @brief
-   *
-   * @return Config
-   */
-  Config GetConfig() const { return config_; }
+  explicit Auth(const std::string &storage_directory);

  /**
   * Authenticates a user using his username and password.
@@ -108,7 +61,7 @@ class Auth final {
   *
   * @throw AuthException if unable to save the user.
   */
-  void SaveUser(const User &user, system::Transaction *system_tx = nullptr);
+  void SaveUser(const User &user);

  /**
   * Creates a user if the user doesn't exist.
@@ -119,8 +72,7 @@ class Auth final {
   * @return a user when the user is created, nullopt if the user exists
   * @throw AuthException if unable to save the user.
   */
-  std::optional<User> AddUser(const std::string &username, const std::optional<std::string> &password = std::nullopt,
-                              system::Transaction *system_tx = nullptr);
+  std::optional<User> AddUser(const std::string &username, const std::optional<std::string> &password = std::nullopt);

  /**
   * Removes a user from the storage.
@@ -131,15 +83,7 @@ class Auth final {
   *         doesn't exist
   * @throw AuthException if unable to remove the user.
   */
-  bool RemoveUser(const std::string &username, system::Transaction *system_tx = nullptr);
-
-  /**
-   * @brief
-   *
-   * @param user
-   * @param password
-   */
-  void UpdatePassword(auth::User &user, const std::optional<std::string> &password);
+  bool RemoveUser(const std::string &username);

  /**
   * Gets all users from the storage.
@@ -149,13 +93,6 @@ class Auth final {
   */
  std::vector<User> AllUsers() const;

-  /**
-   * @brief
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> AllUsernames() const;
-
  /**
   * Returns whether there are users in the storage.
   *
@@ -180,7 +117,7 @@ class Auth final {
   *
   * @throw AuthException if unable to save the role.
   */
-  void SaveRole(const Role &role, system::Transaction *system_tx = nullptr);
+  void SaveRole(const Role &role);

  /**
   * Creates a role if the role doesn't exist.
@@ -190,7 +127,7 @@ class Auth final {
   * @return a role when the role is created, nullopt if the role exists
   * @throw AuthException if unable to save the role.
   */
-  std::optional<Role> AddRole(const std::string &rolename, system::Transaction *system_tx = nullptr);
+  std::optional<Role> AddRole(const std::string &rolename);

  /**
   * Removes a role from the storage.
@@ -201,7 +138,7 @@ class Auth final {
   *         doesn't exist
   * @throw AuthException if unable to remove the role.
   */
-  bool RemoveRole(const std::string &rolename, system::Transaction *system_tx = nullptr);
+  bool RemoveRole(const std::string &rolename);

  /**
   * Gets all roles from the storage.
@@ -211,13 +148,6 @@ class Auth final {
   */
  std::vector<Role> AllRoles() const;

-  /**
-   * @brief
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> AllRolenames() const;
-
  /**
   * Gets all users for a role from the storage.
   *
@@ -237,7 +167,7 @@ class Auth final {
   * @return true on success
   * @throw AuthException if unable to find or update the user
   */
-  bool RevokeDatabaseFromUser(const std::string &db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool RevokeDatabaseFromUser(const std::string &db, const std::string &name);

  /**
   * @brief Grant access to individual database for a user.
@@ -247,7 +177,7 @@ class Auth final {
   * @return true on success
   * @throw AuthException if unable to find or update the user
   */
-  bool GrantDatabaseToUser(const std::string &db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool GrantDatabaseToUser(const std::string &db, const std::string &name);

  /**
   * @brief Delete a database from all users.
@@ -255,7 +185,7 @@ class Auth final {
   * @param db name of the database to delete
   * @throw AuthException if unable to read data
   */
-  void DeleteDatabase(const std::string &db, system::Transaction *system_tx = nullptr);
+  void DeleteDatabase(const std::string &db);

  /**
   * @brief Set main database for an individual user.
@@ -265,24 +195,14 @@ class Auth final {
   * @return true on success
   * @throw AuthException if unable to find or update the user
   */
-  bool SetMainDatabase(std::string_view db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool SetMainDatabase(std::string_view db, const std::string &name);
 #endif

 private:
-  /**
-   * @brief
-   *
-   * @param user_or_role
-   * @return true
-   * @return false
-   */
-  bool NameRegexMatch(const std::string &user_or_role) const;
-
  // Even though the `kvstore::KVStore` class is guaranteed to be thread-safe,
  // Auth is not thread-safe because modifying users and roles might require
  // more than one operation on the storage.
  kvstore::KVStore storage_;
  auth::Module module_;
-  Config config_;
 };
 }  // namespace memgraph::auth
--- a/src/auth/crypto.cpp
+++ b/src/auth/crypto.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -22,14 +22,10 @@

 namespace {
 using namespace std::literals;
-
-constexpr auto kHashAlgo = "hash_algo";
-constexpr auto kPasswordHash = "password_hash";
-
-inline constexpr std::array password_hash_mappings{
-    std::pair{"bcrypt"sv, memgraph::auth::PasswordHashAlgorithm::BCRYPT},
-    std::pair{"sha256"sv, memgraph::auth::PasswordHashAlgorithm::SHA256},
-    std::pair{"sha256-multiple"sv, memgraph::auth::PasswordHashAlgorithm::SHA256_MULTIPLE}};
+inline constexpr std::array password_encryption_mappings{
+    std::pair{"bcrypt"sv, memgraph::auth::PasswordEncryptionAlgorithm::BCRYPT},
+    std::pair{"sha256"sv, memgraph::auth::PasswordEncryptionAlgorithm::SHA256},
+    std::pair{"sha256-multiple"sv, memgraph::auth::PasswordEncryptionAlgorithm::SHA256_MULTIPLE}};

 inline constexpr uint64_t ONE_SHA_ITERATION = 1;
 inline constexpr uint64_t MULTIPLE_SHA_ITERATIONS = 1024;
@@ -39,7 +35,7 @@ inline constexpr uint64_t MULTIPLE_SHA_ITERATIONS = 1024;
 DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",
                        "The password encryption algorithm used for authentication.", {
                          if (const auto result =
-                                  memgraph::utils::IsValidEnumValueString(value, password_hash_mappings);
+                                  memgraph::utils::IsValidEnumValueString(value, password_encryption_mappings);
                              result.HasError()) {
                            const auto error = result.GetError();
                            switch (error) {
@@ -49,7 +45,7 @@ DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",
                              }
                              case memgraph::utils::ValidationError::InvalidValue: {
                                std::cout << "Invalid value for password encryption algorithm. Allowed values: "
-                                          << memgraph::utils::GetAllowedEnumValuesString(password_hash_mappings)
+                                          << memgraph::utils::GetAllowedEnumValuesString(password_encryption_mappings)
                                          << std::endl;
                                break;
                              }
@@ -62,7 +58,7 @@ DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",

 namespace memgraph::auth {
 namespace BCrypt {
-std::string HashPassword(const std::string &password) {
+std::string EncryptPassword(const std::string &password) {
  char salt[BCRYPT_HASHSIZE];
  char hash[BCRYPT_HASHSIZE];

@@ -90,30 +86,16 @@ bool VerifyPassword(const std::string &password, const std::string &hash) {
 }  // namespace BCrypt

 namespace SHA {
-
-namespace {
-
-constexpr auto SHA_LENGTH = 64U;
-constexpr auto SALT_SIZE = 16U;
-constexpr auto SALT_SIZE_DURABLE = SALT_SIZE * 2;
-
 #if OPENSSL_VERSION_MAJOR >= 3
-std::string HashPasswordOpenSSL3(std::string_view password, const uint64_t number_of_iterations,
-                                 std::string_view salt) {
+std::string EncryptPasswordOpenSSL3(const std::string &password, const uint64_t number_of_iterations) {
  unsigned char hash[SHA256_DIGEST_LENGTH];

  EVP_MD_CTX *ctx = EVP_MD_CTX_new();
  EVP_MD *md = EVP_MD_fetch(nullptr, "SHA2-256", nullptr);

  EVP_DigestInit_ex(ctx, md, nullptr);
-
-  if (!salt.empty()) {
-    DMG_ASSERT(salt.size() == SALT_SIZE);
-    EVP_DigestUpdate(ctx, salt.data(), salt.size());
-  }
-
  for (auto i = 0; i < number_of_iterations; i++) {
-    EVP_DigestUpdate(ctx, password.data(), password.size());
+    EVP_DigestUpdate(ctx, password.c_str(), password.size());
  }
  EVP_DigestFinal_ex(ctx, hash, nullptr);

@@ -121,11 +103,6 @@ std::string HashPasswordOpenSSL3(std::string_view password, const uint64_t numbe
  EVP_MD_CTX_free(ctx);

  std::stringstream result_stream;
-
-  for (unsigned char salt_char : salt) {
-    result_stream << std::hex << std::setw(2) << std::setfill('0') << (((unsigned int)salt_char) & 0xFFU);
-  }
-
  for (auto hash_char : hash) {
    result_stream << std::hex << std::setw(2) << std::setfill('0') << (int)hash_char;
  }
@@ -133,27 +110,17 @@ std::string HashPasswordOpenSSL3(std::string_view password, const uint64_t numbe
  return result_stream.str();
 }
 #else
-std::string HashPasswordOpenSSL1_1(std::string_view password, const uint64_t number_of_iterations,
-                                   std::string_view salt) {
+std::string EncryptPasswordOpenSSL1_1(const std::string &password, const uint64_t number_of_iterations) {
  unsigned char hash[SHA256_DIGEST_LENGTH];

  SHA256_CTX sha256;
  SHA256_Init(&sha256);
-
-  if (!salt.empty()) {
-    DMG_ASSERT(salt.size() == SALT_SIZE);
-    SHA256_Update(&sha256, salt.data(), salt.size());
-  }
-
  for (auto i = 0; i < number_of_iterations; i++) {
-    SHA256_Update(&sha256, password.data(), password.size());
+    SHA256_Update(&sha256, password.c_str(), password.size());
  }
  SHA256_Final(hash, &sha256);

  std::stringstream ss;
-  for (unsigned char salt_char : salt) {
-    ss << std::hex << std::setw(2) << std::setfill('0') << (((unsigned int)salt_char) & 0xFFU);
-  }
  for (auto hash_char : hash) {
    ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash_char;
  }
@@ -162,144 +129,55 @@ std::string HashPasswordOpenSSL1_1(std::string_view password, const uint64_t num
 }
 #endif

-std::string HashPassword(std::string_view password, const uint64_t number_of_iterations, std::string_view salt) {
+std::string EncryptPassword(const std::string &password, const uint64_t number_of_iterations) {
 #if OPENSSL_VERSION_MAJOR >= 3
-  return HashPasswordOpenSSL3(password, number_of_iterations, salt);
+  return EncryptPasswordOpenSSL3(password, number_of_iterations);
 #else
-  return HashPasswordOpenSSL1_1(password, number_of_iterations, salt);
+  return EncryptPasswordOpenSSL1_1(password, number_of_iterations);
 #endif
 }

-auto ExtractSalt(std::string_view salt_durable) -> std::array<char, SALT_SIZE> {
-  static_assert(SALT_SIZE_DURABLE % 2 == 0);
-  static_assert(SALT_SIZE_DURABLE / 2 == SALT_SIZE);
-
-  MG_ASSERT(salt_durable.size() == SALT_SIZE_DURABLE);
-  auto const *b = salt_durable.cbegin();
-  auto const *const e = salt_durable.cend();
-
-  auto salt = std::array<char, SALT_SIZE>{};
-  auto *inserter = salt.begin();
-
-  auto const toval = [](char a) -> uint8_t {
-    if ('0' <= a && a <= '9') {
-      return a - '0';
-    }
-    if ('a' <= a && a <= 'f') {
-      return 10 + (a - 'a');
-    }
-    MG_ASSERT(false, "Currupt hash, can't extract salt");
-    __builtin_unreachable();
-  };
-
-  for (; b != e; b += 2, ++inserter) {
-    *inserter = static_cast<char>(static_cast<uint8_t>(toval(b[0]) << 4U) | toval(b[1]));
-  }
-  return salt;
-}
-
-bool IsSalted(std::string_view hash) { return hash.size() == SHA_LENGTH + SALT_SIZE_DURABLE; }
-
-bool VerifyPassword(std::string_view password, std::string_view hash, const uint64_t number_of_iterations) {
-  auto password_hash = std::invoke([&] {
-    if (hash.size() == SHA_LENGTH) [[unlikely]] {
-      // Just SHA256
-      return HashPassword(password, number_of_iterations, {});
-    } else {
-      // SHA256 + SALT
-      MG_ASSERT(IsSalted(hash));
-      auto const salt_durable = std::string_view{hash.data(), SALT_SIZE_DURABLE};
-      std::array<char, SALT_SIZE> salt = ExtractSalt(salt_durable);
-      return HashPassword(password, number_of_iterations, {salt.data(), salt.size()});
-    }
-  });
+bool VerifyPassword(const std::string &password, const std::string &hash, const uint64_t number_of_iterations) {
+  auto password_hash = EncryptPassword(password, number_of_iterations);
  return password_hash == hash;
 }
-
-}  // namespace
-
 }  // namespace SHA

-HashedPassword HashPassword(const std::string &password, std::optional<PasswordHashAlgorithm> override_algo) {
-  auto const hash_algo = override_algo.value_or(CurrentHashAlgorithm());
-  auto password_hash = std::invoke([&] {
-    switch (hash_algo) {
-      case PasswordHashAlgorithm::BCRYPT: {
-        return BCrypt::HashPassword(password);
-      }
-      case PasswordHashAlgorithm::SHA256:
-      case PasswordHashAlgorithm::SHA256_MULTIPLE: {
-        auto gen = std::mt19937(std::random_device{}());
-        auto salt = std::array<char, SHA::SALT_SIZE>{};
-        auto dis = std::uniform_int_distribution<unsigned char>(0, 255);
-        std::generate(salt.begin(), salt.end(), [&]() { return dis(gen); });
-        auto iterations = (hash_algo == PasswordHashAlgorithm::SHA256) ? ONE_SHA_ITERATION : MULTIPLE_SHA_ITERATIONS;
-        return SHA::HashPassword(password, iterations, {salt.data(), salt.size()});
-      }
-    }
-  });
-  return HashedPassword{hash_algo, std::move(password_hash)};
-};
+bool VerifyPassword(const std::string &password, const std::string &hash) {
+  const auto password_encryption_algorithm = utils::StringToEnum<PasswordEncryptionAlgorithm>(
+      FLAGS_password_encryption_algorithm, password_encryption_mappings);

-namespace {
-
-auto InternalParseHashAlgorithm(std::string_view algo) -> PasswordHashAlgorithm {
-  auto maybe_parsed = utils::StringToEnum<PasswordHashAlgorithm>(algo, password_hash_mappings);
-  if (!maybe_parsed) {
-    throw AuthException("Invalid password encryption '{}'!", algo);
+  if (!password_encryption_algorithm.has_value()) {
+    throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
  }
-  return *maybe_parsed;
-}

-PasswordHashAlgorithm &InternalCurrentHashAlgorithm() {
-  static auto current = PasswordHashAlgorithm::BCRYPT;
-  static std::once_flag flag;
-  std::call_once(flag, [] { current = InternalParseHashAlgorithm(FLAGS_password_encryption_algorithm); });
-  return current;
-}
-}  // namespace
-
-auto CurrentHashAlgorithm() -> PasswordHashAlgorithm { return InternalCurrentHashAlgorithm(); }
-
-void SetHashAlgorithm(std::string_view algo) {
-  auto &current = InternalCurrentHashAlgorithm();
-  current = InternalParseHashAlgorithm(algo);
-}
-
-auto AsString(PasswordHashAlgorithm hash_algo) -> std::string_view {
-  return *utils::EnumToString<PasswordHashAlgorithm>(hash_algo, password_hash_mappings);
-}
-
-bool HashedPassword::VerifyPassword(const std::string &password) {
-  switch (hash_algo) {
-    case PasswordHashAlgorithm::BCRYPT:
-      return BCrypt::VerifyPassword(password, password_hash);
-    case PasswordHashAlgorithm::SHA256:
-      return SHA::VerifyPassword(password, password_hash, ONE_SHA_ITERATION);
-    case PasswordHashAlgorithm::SHA256_MULTIPLE:
-      return SHA::VerifyPassword(password, password_hash, MULTIPLE_SHA_ITERATIONS);
+  switch (password_encryption_algorithm.value()) {
+    case PasswordEncryptionAlgorithm::BCRYPT:
+      return BCrypt::VerifyPassword(password, hash);
+    case PasswordEncryptionAlgorithm::SHA256:
+      return SHA::VerifyPassword(password, hash, ONE_SHA_ITERATION);
+    case PasswordEncryptionAlgorithm::SHA256_MULTIPLE:
+      return SHA::VerifyPassword(password, hash, MULTIPLE_SHA_ITERATIONS);
  }
+
+  throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
 }

-void to_json(nlohmann::json &j, const HashedPassword &p) {
-  j = nlohmann::json{{kHashAlgo, p.hash_algo}, {kPasswordHash, p.password_hash}};
-}
+std::string EncryptPassword(const std::string &password) {
+  const auto password_encryption_algorithm = utils::StringToEnum<PasswordEncryptionAlgorithm>(
+      FLAGS_password_encryption_algorithm, password_encryption_mappings);

-void from_json(const nlohmann::json &j, HashedPassword &p) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  PasswordHashAlgorithm hash_algo;
-  j.at(kHashAlgo).get_to(hash_algo);
-  auto password_hash = j.value(kPasswordHash, std::string());
-  p = HashedPassword{hash_algo, std::move(password_hash)};
-}
+  if (!password_encryption_algorithm.has_value()) {
+    throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
+  }

-bool HashedPassword::IsSalted() const {
-  switch (hash_algo) {
-    case PasswordHashAlgorithm::BCRYPT:
-      return true;
-    case PasswordHashAlgorithm::SHA256:
-    case PasswordHashAlgorithm::SHA256_MULTIPLE:
-      return SHA::IsSalted(password_hash);
+  switch (password_encryption_algorithm.value()) {
+    case PasswordEncryptionAlgorithm::BCRYPT:
+      return BCrypt::EncryptPassword(password);
+    case PasswordEncryptionAlgorithm::SHA256:
+      return SHA::EncryptPassword(password, ONE_SHA_ITERATION);
+    case PasswordEncryptionAlgorithm::SHA256_MULTIPLE:
+      return SHA::EncryptPassword(password, MULTIPLE_SHA_ITERATIONS);
  }
 }

--- a/src/auth/crypto.hpp
+++ b/src/auth/crypto.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -8,45 +8,14 @@

 #pragma once

-#include <json/json.hpp>
-#include <optional>
 #include <string>

 namespace memgraph::auth {
-/// Need to be stable, auth durability depends on this
-enum class PasswordHashAlgorithm : uint8_t { BCRYPT = 0, SHA256 = 1, SHA256_MULTIPLE = 2 };
+enum class PasswordEncryptionAlgorithm : uint8_t { BCRYPT, SHA256, SHA256_MULTIPLE };

-void SetHashAlgorithm(std::string_view algo);
+/// @throw AuthException if unable to encrypt the password.
+std::string EncryptPassword(const std::string &password);

-auto CurrentHashAlgorithm() -> PasswordHashAlgorithm;
-
-auto AsString(PasswordHashAlgorithm hash_algo) -> std::string_view;
-
-struct HashedPassword {
-  HashedPassword() = default;
-  HashedPassword(PasswordHashAlgorithm hash_algo, std::string password_hash)
-      : hash_algo{hash_algo}, password_hash{std::move(password_hash)} {}
-  HashedPassword(HashedPassword const &) = default;
-  HashedPassword(HashedPassword &&) = default;
-  HashedPassword &operator=(HashedPassword const &) = default;
-  HashedPassword &operator=(HashedPassword &&) = default;
-
-  friend bool operator==(HashedPassword const &, HashedPassword const &) = default;
-
-  bool VerifyPassword(const std::string &password);
-
-  bool IsSalted() const;
-
-  auto HashAlgo() const -> PasswordHashAlgorithm { return hash_algo; }
-
-  friend void to_json(nlohmann::json &j, const HashedPassword &p);
-  friend void from_json(const nlohmann::json &j, HashedPassword &p);
-
- private:
-  PasswordHashAlgorithm hash_algo{PasswordHashAlgorithm::BCRYPT};
-  std::string password_hash{};
-};
-
-/// @throw AuthException if unable to hash the password.
-HashedPassword HashPassword(const std::string &password, std::optional<PasswordHashAlgorithm> override_algo = {});
+/// @throw AuthException if unable to verify the password.
+bool VerifyPassword(const std::string &password, const std::string &hash);
 }  // namespace memgraph::auth
--- a/src/auth/models.cpp
+++ b/src/auth/models.cpp
@@ -9,6 +9,7 @@
 #include "auth/models.hpp"

 #include <cstdint>
+#include <regex>
 #include <utility>

 #include <gflags/gflags.h>
@@ -20,26 +21,22 @@
 #include "query/constants.hpp"
 #include "spdlog/spdlog.h"
 #include "utils/cast.hpp"
+#include "utils/logging.hpp"
+#include "utils/settings.hpp"
 #include "utils/string.hpp"

+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(auth_password_permit_null, true, "Set to false to disable null passwords.");
+
+inline constexpr std::string_view default_password_regex = ".+";
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(auth_password_strength_regex, default_password_regex.data(),
+              "The regular expression that should be used to match the entire "
+              "entered password to ensure its strength.");
+
 namespace memgraph::auth {
 namespace {

-constexpr auto kRoleName = "rolename";
-constexpr auto kPermissions = "permissions";
-constexpr auto kGrants = "grants";
-constexpr auto kDenies = "denies";
-constexpr auto kUsername = "username";
-constexpr auto kPasswordHash = "password_hash";
-
-#ifdef MG_ENTERPRISE
-constexpr auto kGlobalPermission = "global_permission";
-constexpr auto kFineGrainedAccessHandler = "fine_grained_access_handler";
-constexpr auto kAllowAll = "allow_all";
-constexpr auto kDefault = "default";
-constexpr auto kDatabases = "databases";
-#endif
-
 // Constant list of all available permissions.
 const std::vector<Permission> kPermissionsAll = {Permission::MATCH,
                                                 Permission::CREATE,
@@ -248,9 +245,8 @@ std::vector<Permission> Permissions::GetDenies() const {

 nlohmann::json Permissions::Serialize() const {
  nlohmann::json data = nlohmann::json::object();
-
-  data[kGrants] = grants_;
-  data[kDenies] = denies_;
+  data["grants"] = grants_;
+  data["denies"] = denies_;
  return data;
 }

@@ -258,10 +254,10 @@ Permissions Permissions::Deserialize(const nlohmann::json &data) {
  if (!data.is_object()) {
    throw AuthException("Couldn't load permissions data!");
  }
-  if (!data[kGrants].is_number_unsigned() || !data[kDenies].is_number_unsigned()) {
+  if (!data["grants"].is_number_unsigned() || !data["denies"].is_number_unsigned()) {
    throw AuthException("Couldn't load permissions data!");
  }
-  return Permissions{data[kGrants], data[kDenies]};
+  return Permissions{data["grants"], data["denies"]};
 }

 uint64_t Permissions::grants() const { return grants_; }
@@ -323,8 +319,8 @@ nlohmann::json FineGrainedAccessPermissions::Serialize() const {
    return {};
  }
  nlohmann::json data = nlohmann::json::object();
-  data[kPermissions] = permissions_;
-  data[kGlobalPermission] = global_permission_.has_value() ? global_permission_.value() : -1;
+  data["permissions"] = permissions_;
+  data["global_permission"] = global_permission_.has_value() ? global_permission_.value() : -1;
  return data;
 }

@@ -337,13 +333,13 @@ FineGrainedAccessPermissions FineGrainedAccessPermissions::Deserialize(const nlo
  }
  std::optional<uint64_t> global_permission;

-  if (data[kGlobalPermission].empty() || data[kGlobalPermission] == -1) {
+  if (data["global_permission"].empty() || data["global_permission"] == -1) {
    global_permission = std::nullopt;
  } else {
-    global_permission = data[kGlobalPermission];
+    global_permission = data["global_permission"];
  }

-  return FineGrainedAccessPermissions(data[kPermissions], global_permission);
+  return FineGrainedAccessPermissions(data["permissions"], global_permission);
 }

 const std::unordered_map<std::string, uint64_t> &FineGrainedAccessPermissions::GetPermissions() const {
@@ -449,13 +445,13 @@ const FineGrainedAccessPermissions &Role::GetFineGrainedAccessEdgeTypePermission

 nlohmann::json Role::Serialize() const {
  nlohmann::json data = nlohmann::json::object();
-  data[kRoleName] = rolename_;
-  data[kPermissions] = permissions_.Serialize();
+  data["rolename"] = rolename_;
+  data["permissions"] = permissions_.Serialize();
 #ifdef MG_ENTERPRISE
  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    data[kFineGrainedAccessHandler] = fine_grained_access_handler_.Serialize();
+    data["fine_grained_access_handler"] = fine_grained_access_handler_.Serialize();
  } else {
-    data[kFineGrainedAccessHandler] = {};
+    data["fine_grained_access_handler"] = {};
  }
 #endif
  return data;
@@ -465,21 +461,21 @@ Role Role::Deserialize(const nlohmann::json &data) {
  if (!data.is_object()) {
    throw AuthException("Couldn't load role data!");
  }
-  if (!data[kRoleName].is_string() || !data[kPermissions].is_object()) {
+  if (!data["rolename"].is_string() || !data["permissions"].is_object()) {
    throw AuthException("Couldn't load role data!");
  }
-  auto permissions = Permissions::Deserialize(data[kPermissions]);
+  auto permissions = Permissions::Deserialize(data["permissions"]);
 #ifdef MG_ENTERPRISE
  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
    FineGrainedAccessHandler fine_grained_access_handler;
    // We can have an empty fine_grained if the user was created without a valid license
-    if (data[kFineGrainedAccessHandler].is_object()) {
-      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data[kFineGrainedAccessHandler]);
+    if (data["fine_grained_access_handler"].is_object()) {
+      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data["fine_grained_access_handler"]);
    }
-    return {data[kRoleName], permissions, std::move(fine_grained_access_handler)};
+    return {data["rolename"], permissions, std::move(fine_grained_access_handler)};
  }
 #endif
-  return {data[kRoleName], permissions};
+  return {data["rolename"], permissions};
 }

 bool operator==(const Role &first, const Role &second) {
@@ -549,10 +545,10 @@ const std::string &Databases::GetDefault() const {

 nlohmann::json Databases::Serialize() const {
  nlohmann::json data = nlohmann::json::object();
-  data[kGrants] = grants_dbs_;
-  data[kDenies] = denies_dbs_;
-  data[kAllowAll] = allow_all_;
-  data[kDefault] = default_db_;
+  data["grants"] = grants_dbs_;
+  data["denies"] = denies_dbs_;
+  data["allow_all"] = allow_all_;
+  data["default"] = default_db_;
  return data;
 }

@@ -560,22 +556,22 @@ Databases Databases::Deserialize(const nlohmann::json &data) {
  if (!data.is_object()) {
    throw AuthException("Couldn't load database data!");
  }
-  if (!data[kGrants].is_structured() || !data[kDenies].is_structured() || !data[kAllowAll].is_boolean() ||
-      !data[kDefault].is_string()) {
+  if (!data["grants"].is_structured() || !data["denies"].is_structured() || !data["allow_all"].is_boolean() ||
+      !data["default"].is_string()) {
    throw AuthException("Couldn't load database data!");
  }
-  return {data[kAllowAll], data[kGrants], data[kDenies], data[kDefault]};
+  return {data["allow_all"], data["grants"], data["denies"], data["default"]};
 }
 #endif

 User::User() = default;

 User::User(const std::string &username) : username_(utils::ToLowerCase(username)) {}
-User::User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions)
+User::User(const std::string &username, std::string password_hash, const Permissions &permissions)
    : username_(utils::ToLowerCase(username)), password_hash_(std::move(password_hash)), permissions_(permissions) {}

 #ifdef MG_ENTERPRISE
-User::User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions,
+User::User(const std::string &username, std::string password_hash, const Permissions &permissions,
           FineGrainedAccessHandler fine_grained_access_handler, Databases db_access)
    : username_(utils::ToLowerCase(username)),
      password_hash_(std::move(password_hash)),
@@ -585,16 +581,38 @@ User::User(const std::string &username, std::optional<HashedPassword> password_h
 #endif

 bool User::CheckPassword(const std::string &password) {
-  return password_hash_ ? password_hash_->VerifyPassword(password) : true;
+  if (password_hash_.empty()) return true;
+  return VerifyPassword(password, password_hash_);
 }

-void User::UpdatePassword(const std::optional<std::string> &password,
-                          std::optional<PasswordHashAlgorithm> algo_override) {
+void User::UpdatePassword(const std::optional<std::string> &password) {
  if (!password) {
-    password_hash_.reset();
+    if (!FLAGS_auth_password_permit_null) {
+      throw AuthException("Null passwords aren't permitted!");
+    }
+    password_hash_ = "";
    return;
  }
-  password_hash_ = HashPassword(*password, algo_override);
+
+  if (FLAGS_auth_password_strength_regex != default_password_regex) {
+    if (const auto license_check_result = license::global_license_checker.IsEnterpriseValid(utils::global_settings);
+        license_check_result.HasError()) {
+      throw AuthException(
+          "Custom password regex is a Memgraph Enterprise feature. Please set the config "
+          "(\"--auth-password-strength-regex\") to its default value (\"{}\") or remove the flag.\n{}",
+          default_password_regex,
+          license::LicenseCheckErrorToString(license_check_result.GetError(), "password regex"));
+    }
+  }
+  std::regex re(FLAGS_auth_password_strength_regex);
+  if (!std::regex_match(*password, re)) {
+    throw AuthException(
+        "The user password doesn't conform to the required strength! Regex: "
+        "\"{}\"",
+        FLAGS_auth_password_strength_regex);
+  }
+
+  password_hash_ = EncryptPassword(*password);
 }

 void User::SetRole(const Role &role) { role_.emplace(role); }
@@ -611,49 +629,27 @@ Permissions User::GetPermissions() const {

 #ifdef MG_ENTERPRISE
 FineGrainedAccessPermissions User::GetFineGrainedAccessLabelPermissions() const {
-  return Merge(GetUserFineGrainedAccessLabelPermissions(), GetRoleFineGrainedAccessLabelPermissions());
-}
-
-FineGrainedAccessPermissions User::GetFineGrainedAccessEdgeTypePermissions() const {
-  return Merge(GetUserFineGrainedAccessEdgeTypePermissions(), GetRoleFineGrainedAccessEdgeTypePermissions());
-}
-
-FineGrainedAccessPermissions User::GetUserFineGrainedAccessEdgeTypePermissions() const {
  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
    return FineGrainedAccessPermissions{};
  }

-  return fine_grained_access_handler_.edge_type_permissions();
-}
-
-FineGrainedAccessPermissions User::GetUserFineGrainedAccessLabelPermissions() const {
-  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    return FineGrainedAccessPermissions{};
+  if (role_) {
+    return Merge(role()->fine_grained_access_handler().label_permissions(),
+                 fine_grained_access_handler_.label_permissions());
  }

  return fine_grained_access_handler_.label_permissions();
 }

-FineGrainedAccessPermissions User::GetRoleFineGrainedAccessEdgeTypePermissions() const {
+FineGrainedAccessPermissions User::GetFineGrainedAccessEdgeTypePermissions() const {
  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
    return FineGrainedAccessPermissions{};
  }
-
  if (role_) {
-    return role()->fine_grained_access_handler().edge_type_permissions();
+    return Merge(role()->fine_grained_access_handler().edge_type_permissions(),
+                 fine_grained_access_handler_.edge_type_permissions());
  }
-  return FineGrainedAccessPermissions{};
-}
-
-FineGrainedAccessPermissions User::GetRoleFineGrainedAccessLabelPermissions() const {
-  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    return FineGrainedAccessPermissions{};
-  }
-
-  if (role_) {
-    return role()->fine_grained_access_handler().label_permissions();
-  }
-  return FineGrainedAccessPermissions{};
+  return fine_grained_access_handler_.edge_type_permissions();
 }
 #endif

@@ -675,20 +671,16 @@ const Role *User::role() const {

 nlohmann::json User::Serialize() const {
  nlohmann::json data = nlohmann::json::object();
-  data[kUsername] = username_;
-  if (password_hash_.has_value()) {
-    data[kPasswordHash] = *password_hash_;
-  } else {
-    data[kPasswordHash] = nullptr;
-  }
-  data[kPermissions] = permissions_.Serialize();
+  data["username"] = username_;
+  data["password_hash"] = password_hash_;
+  data["permissions"] = permissions_.Serialize();
 #ifdef MG_ENTERPRISE
  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    data[kFineGrainedAccessHandler] = fine_grained_access_handler_.Serialize();
-    data[kDatabases] = database_access_.Serialize();
+    data["fine_grained_access_handler"] = fine_grained_access_handler_.Serialize();
+    data["databases"] = database_access_.Serialize();
  } else {
-    data[kFineGrainedAccessHandler] = {};
-    data[kDatabases] = {};
+    data["fine_grained_access_handler"] = {};
+    data["databases"] = {};
  }
 #endif
  // The role shouldn't be serialized here, it is stored as a foreign key.
@@ -699,23 +691,15 @@ User User::Deserialize(const nlohmann::json &data) {
  if (!data.is_object()) {
    throw AuthException("Couldn't load user data!");
  }
-  auto password_hash_json = data[kPasswordHash];
-  if (!data[kUsername].is_string() || !(password_hash_json.is_object() || password_hash_json.is_null()) ||
-      !data[kPermissions].is_object()) {
+  if (!data["username"].is_string() || !data["password_hash"].is_string() || !data["permissions"].is_object()) {
    throw AuthException("Couldn't load user data!");
  }
-
-  std::optional<HashedPassword> password_hash{};
-  if (password_hash_json.is_object()) {
-    password_hash = password_hash_json.get<HashedPassword>();
-  }
-
-  auto permissions = Permissions::Deserialize(data[kPermissions]);
+  auto permissions = Permissions::Deserialize(data["permissions"]);
 #ifdef MG_ENTERPRISE
  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
    Databases db_access;
-    if (data[kDatabases].is_structured()) {
-      db_access = Databases::Deserialize(data[kDatabases]);
+    if (data["databases"].is_structured()) {
+      db_access = Databases::Deserialize(data["databases"]);
    } else {
      // Back-compatibility
      spdlog::warn("User without specified database access. Given access to the default database.");
@@ -724,13 +708,13 @@ User User::Deserialize(const nlohmann::json &data) {
    }
    FineGrainedAccessHandler fine_grained_access_handler;
    // We can have an empty fine_grained if the user was created without a valid license
-    if (data[kFineGrainedAccessHandler].is_object()) {
-      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data[kFineGrainedAccessHandler]);
+    if (data["fine_grained_access_handler"].is_object()) {
+      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data["fine_grained_access_handler"]);
    }
-    return {data[kUsername], std::move(password_hash), permissions, std::move(fine_grained_access_handler), db_access};
+    return {data["username"], data["password_hash"], permissions, std::move(fine_grained_access_handler), db_access};
  }
 #endif
-  return {data[kUsername], std::move(password_hash), permissions};
+  return {data["username"], data["password_hash"], permissions};
 }

 bool operator==(const User &first, const User &second) {
--- a/src/auth/models.hpp
+++ b/src/auth/models.hpp
@@ -15,7 +15,6 @@

 #include <json/json.hpp>
 #include <utility>
-#include "crypto.hpp"
 #include "dbms/constants.hpp"
 #include "utils/logging.hpp"

@@ -207,8 +206,6 @@ bool operator==(const FineGrainedAccessHandler &first, const FineGrainedAccessHa

 class Role final {
 public:
-  Role() = default;
-
  explicit Role(const std::string &rolename);
  Role(const std::string &rolename, const Permissions &permissions);
 #ifdef MG_ENTERPRISE
@@ -335,9 +332,9 @@ class User final {
  User();

  explicit User(const std::string &username);
-  User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions);
+  User(const std::string &username, std::string password_hash, const Permissions &permissions);
 #ifdef MG_ENTERPRISE
-  User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions,
+  User(const std::string &username, std::string password_hash, const Permissions &permissions,
       FineGrainedAccessHandler fine_grained_access_handler, Databases db_access = {});
 #endif
  User(const User &) = default;
@@ -349,18 +346,8 @@ class User final {
  /// @throw AuthException if unable to verify the password.
  bool CheckPassword(const std::string &password);

-  bool UpgradeHash(const std::string password) {
-    if (!password_hash_) return false;
-    if (password_hash_->IsSalted()) return false;
-
-    auto const algo = password_hash_->HashAlgo();
-    UpdatePassword(password, algo);
-    return true;
-  }
-
  /// @throw AuthException if unable to set the password.
-  void UpdatePassword(const std::optional<std::string> &password = {},
-                      std::optional<PasswordHashAlgorithm> algo_override = std::nullopt);
+  void UpdatePassword(const std::optional<std::string> &password = std::nullopt);

  void SetRole(const Role &role);

@@ -371,10 +358,6 @@ class User final {
 #ifdef MG_ENTERPRISE
  FineGrainedAccessPermissions GetFineGrainedAccessLabelPermissions() const;
  FineGrainedAccessPermissions GetFineGrainedAccessEdgeTypePermissions() const;
-  FineGrainedAccessPermissions GetUserFineGrainedAccessLabelPermissions() const;
-  FineGrainedAccessPermissions GetUserFineGrainedAccessEdgeTypePermissions() const;
-  FineGrainedAccessPermissions GetRoleFineGrainedAccessLabelPermissions() const;
-  FineGrainedAccessPermissions GetRoleFineGrainedAccessEdgeTypePermissions() const;
  const FineGrainedAccessHandler &fine_grained_access_handler() const;
  FineGrainedAccessHandler &fine_grained_access_handler();
 #endif
@@ -399,7 +382,7 @@ class User final {

 private:
  std::string username_;
-  std::optional<HashedPassword> password_hash_;
+  std::string password_hash_;
  Permissions permissions_;
 #ifdef MG_ENTERPRISE
  FineGrainedAccessHandler fine_grained_access_handler_;
--- a/src/auth/replication_handlers.cpp
+++ b/src/auth/replication_handlers.cpp
@@ -1,190 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "auth/replication_handlers.hpp"
-
-#include "auth/auth.hpp"
-#include "auth/rpc.hpp"
-#include "license/license.hpp"
-
-namespace memgraph::auth {
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req) {
-  spdlog::error(fmt::format("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                            current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : ""));
-}
-
-#ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                           slk::Reader *req_reader, slk::Builder *res_builder) {
-  replication::UpdateAuthDataReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  using memgraph::replication::UpdateAuthDataRes;
-  UpdateAuthDataRes res(false);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, replication::UpdateAuthDataReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("UpdateAuthDataHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Update
-    if (req.user) auth->SaveUser(*req.user);
-    if (req.role) auth->SaveRole(*req.role);
-    // Success
-    system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-    res = UpdateAuthDataRes(true);
-    spdlog::debug("UpdateAuthDataHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-  } catch (const auth::AuthException & /* not used */) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-void DropAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                         slk::Reader *req_reader, slk::Builder *res_builder) {
-  replication::DropAuthDataReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  using memgraph::replication::DropAuthDataRes;
-  DropAuthDataRes res(false);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, replication::DropAuthDataRes::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("DropAuthDataHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Remove
-    switch (req.type) {
-      case replication::DropAuthDataReq::DataType::USER:
-        auth->RemoveUser(req.name);
-        break;
-      case replication::DropAuthDataReq::DataType::ROLE:
-        auth->RemoveRole(req.name);
-        break;
-    }
-    // Success
-    system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-    res = DropAuthDataRes(true);
-    spdlog::debug("DropAuthDataHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-  } catch (const auth::AuthException & /* not used */) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,
-                           const std::vector<auth::User> &users, const std::vector<auth::Role> &roles) {
-  return auth.WithLock([&](auto &locked_auth) {
-    // Update config
-    locked_auth.SetConfig(std::move(auth_config));
-    // Get all current users
-    auto old_users = locked_auth.AllUsernames();
-    // Save incoming users
-    for (const auto &user : users) {
-      // Missing users
-      try {
-        locked_auth.SaveUser(user);
-      } catch (const auth::AuthException &) {
-        spdlog::debug("SystemRecoveryHandler: Failed to save user");
-        return false;
-      }
-      const auto it = std::find(old_users.begin(), old_users.end(), user.username());
-      if (it != old_users.end()) old_users.erase(it);
-    }
-    // Delete all the leftover users
-    for (const auto &user : old_users) {
-      if (!locked_auth.RemoveUser(user)) {
-        spdlog::debug("SystemRecoveryHandler: Failed to remove user \"{}\".", user);
-        return false;
-      }
-    }
-
-    // Roles are only supported with a license
-    if (license::global_license_checker.IsEnterpriseValidFast()) {
-      // Get all current roles
-      auto old_roles = locked_auth.AllRolenames();
-      // Save incoming users
-      for (const auto &role : roles) {
-        // Missing users
-        try {
-          locked_auth.SaveRole(role);
-        } catch (const auth::AuthException &) {
-          spdlog::debug("SystemRecoveryHandler: Failed to save user");
-          return false;
-        }
-        const auto it = std::find(old_roles.begin(), old_roles.end(), role.rolename());
-        if (it != old_roles.end()) old_roles.erase(it);
-      }
-      // Delete all the leftover users
-      for (const auto &role : old_roles) {
-        if (!locked_auth.RemoveRole(role)) {
-          spdlog::debug("SystemRecoveryHandler: Failed to remove user \"{}\".", role);
-          return false;
-        }
-      }
-    }
-
-    // Success
-    return true;
-  });
-}
-
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              auth::SynchedAuth &auth) {
-  // NOTE: Register even without license as the user could add a license at run-time
-  data.server->rpc_server_.Register<replication::UpdateAuthDataRpc>(
-      [&data, system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received UpdateAuthDataRpc");
-        UpdateAuthDataHandler(system_state_access, data.uuid_, auth, req_reader, res_builder);
-      });
-  data.server->rpc_server_.Register<replication::DropAuthDataRpc>(
-      [&data, system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received DropAuthDataRpc");
-        DropAuthDataHandler(system_state_access, data.uuid_, auth, req_reader, res_builder);
-      });
-}
-#endif
-
-}  // namespace memgraph::auth
--- a/src/auth/replication_handlers.hpp
+++ b/src/auth/replication_handlers.hpp
@@ -1,37 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "auth/auth.hpp"
-#include "replication/state.hpp"
-#include "slk/streams.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::auth {
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req);
-
-#ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                           slk::Reader *req_reader, slk::Builder *res_builder);
-void DropAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                         slk::Reader *req_reader, slk::Builder *res_builder);
-
-bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,
-                           const std::vector<auth::User> &users, const std::vector<auth::Role> &roles);
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              auth::SynchedAuth &auth);
-#endif
-}  // namespace memgraph::auth
--- a/src/auth/rpc.cpp
+++ b/src/auth/rpc.cpp
@@ -1,182 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "auth/rpc.hpp"
-
-#include <json/json.hpp>
-#include "auth/auth.hpp"
-#include "slk/serialization.hpp"
-#include "slk/streams.hpp"
-#include "utils/enum.hpp"
-
-namespace memgraph::slk {
-
-// Serialize code for auth::Role
-void Save(const auth::Role &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.Serialize().dump(), builder);
-}
-namespace {
-auth::Role LoadAuthRole(memgraph::slk::Reader *reader) {
-  std::string tmp;
-  memgraph::slk::Load(&tmp, reader);
-  const auto json = nlohmann::json::parse(tmp);
-  return memgraph::auth::Role::Deserialize(json);
-}
-}  // namespace
-// Deserialize code for auth::Role
-void Load(auth::Role *self, memgraph::slk::Reader *reader) { *self = LoadAuthRole(reader); }
-// Special case for optional<Role>
-template <>
-inline void Load<auth::Role>(std::optional<auth::Role> *obj, Reader *reader) {
-  bool exists = false;
-  Load(&exists, reader);
-  if (exists) {
-    obj->emplace(LoadAuthRole(reader));
-  } else {
-    *obj = std::nullopt;
-  }
-}
-
-// Serialize code for auth::User
-void Save(const auth::User &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.Serialize().dump(), builder);
-  std::optional<auth::Role> role{};
-  if (const auto *role_ptr = self.role(); role_ptr) {
-    role.emplace(*role_ptr);
-  }
-  memgraph::slk::Save(role, builder);
-}
-// Deserialize code for auth::User
-void Load(auth::User *self, memgraph::slk::Reader *reader) {
-  std::string tmp;
-  memgraph::slk::Load(&tmp, reader);
-  const auto json = nlohmann::json::parse(tmp);
-  *self = memgraph::auth::User::Deserialize(json);
-  std::optional<auth::Role> role{};
-  memgraph::slk::Load(&role, reader);
-  if (role)
-    self->SetRole(*role);
-  else
-    self->ClearRole();
-}
-
-// Serialize code for auth::Auth::Config
-void Save(const auth::Auth::Config &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.name_regex_str, builder);
-  memgraph::slk::Save(self.password_regex_str, builder);
-  memgraph::slk::Save(self.password_permit_null, builder);
-}
-// Deserialize code for auth::Auth::Config
-void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader) {
-  std::string name_regex_str{};
-  std::string password_regex_str{};
-  bool password_permit_null{};
-
-  memgraph::slk::Load(&name_regex_str, reader);
-  memgraph::slk::Load(&password_regex_str, reader);
-  memgraph::slk::Load(&password_permit_null, reader);
-
-  *self = auth::Auth::Config{std::move(name_regex_str), std::move(password_regex_str), password_permit_null};
-}
-
-// Serialize code for UpdateAuthDataReq
-void Save(const memgraph::replication::UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.user, builder);
-  memgraph::slk::Save(self.role, builder);
-}
-void Load(memgraph::replication::UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->user, reader);
-  memgraph::slk::Load(&self->role, reader);
-}
-
-// Serialize code for UpdateAuthDataRes
-void Save(const memgraph::replication::UpdateAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-// Serialize code for DropAuthDataReq
-void Save(const memgraph::replication::DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(utils::EnumToNum<2, uint8_t>(self.type), builder);
-  memgraph::slk::Save(self.name, builder);
-}
-void Load(memgraph::replication::DropAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  uint8_t type_tmp = 0;
-  memgraph::slk::Load(&type_tmp, reader);
-  if (!utils::NumToEnum<2>(type_tmp, self->type)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-  memgraph::slk::Load(&self->name, reader);
-}
-
-// Serialize code for DropAuthDataRes
-void Save(const memgraph::replication::DropAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-void Load(memgraph::replication::DropAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-}  // namespace memgraph::slk
-
-namespace memgraph::replication {
-
-constexpr utils::TypeInfo UpdateAuthDataReq::kType{utils::TypeId::REP_UPDATE_AUTH_DATA_REQ, "UpdateAuthDataReq",
-                                                   nullptr};
-
-constexpr utils::TypeInfo UpdateAuthDataRes::kType{utils::TypeId::REP_UPDATE_AUTH_DATA_RES, "UpdateAuthDataRes",
-                                                   nullptr};
-
-constexpr utils::TypeInfo DropAuthDataReq::kType{utils::TypeId::REP_DROP_AUTH_DATA_REQ, "DropAuthDataReq", nullptr};
-
-constexpr utils::TypeInfo DropAuthDataRes::kType{utils::TypeId::REP_DROP_AUTH_DATA_RES, "DropAuthDataRes", nullptr};
-
-void UpdateAuthDataReq::Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void UpdateAuthDataReq::Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void UpdateAuthDataRes::Save(const UpdateAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void UpdateAuthDataRes::Load(UpdateAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void DropAuthDataReq::Save(const DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropAuthDataReq::Load(DropAuthDataReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-void DropAuthDataRes::Save(const DropAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropAuthDataRes::Load(DropAuthDataRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-
-}  // namespace memgraph::replication
--- a/src/auth/rpc.hpp
+++ b/src/auth/rpc.hpp
@@ -1,127 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <optional>
-
-#include "auth/auth.hpp"
-#include "auth/models.hpp"
-#include "rpc/messages.hpp"
-#include "slk/streams.hpp"
-
-namespace memgraph::replication {
-
-struct UpdateAuthDataReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader);
-  static void Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder);
-  UpdateAuthDataReq() = default;
-  UpdateAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                    auth::User user)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        user{std::move(user)} {}
-  UpdateAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                    auth::Role role)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        role{std::move(role)} {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  std::optional<auth::User> user;
-  std::optional<auth::Role> role;
-};
-
-struct UpdateAuthDataRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UpdateAuthDataRes *self, memgraph::slk::Reader *reader);
-  static void Save(const UpdateAuthDataRes &self, memgraph::slk::Builder *builder);
-  UpdateAuthDataRes() = default;
-  explicit UpdateAuthDataRes(bool success) : success{success} {}
-
-  bool success;
-};
-
-using UpdateAuthDataRpc = rpc::RequestResponse<UpdateAuthDataReq, UpdateAuthDataRes>;
-
-struct DropAuthDataReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropAuthDataReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DropAuthDataReq &self, memgraph::slk::Builder *builder);
-  DropAuthDataReq() = default;
-
-  enum class DataType { USER, ROLE };
-
-  DropAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                  DataType type, std::string_view name)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        type{type},
-        name{name} {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  DataType type;
-  std::string name;
-};
-
-struct DropAuthDataRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropAuthDataRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DropAuthDataRes &self, memgraph::slk::Builder *builder);
-  DropAuthDataRes() = default;
-  explicit DropAuthDataRes(bool success) : success{success} {}
-
-  bool success;
-};
-
-using DropAuthDataRpc = rpc::RequestResponse<DropAuthDataReq, DropAuthDataRes>;
-
-}  // namespace memgraph::replication
-
-namespace memgraph::slk {
-
-void Save(const auth::Role &self, memgraph::slk::Builder *builder);
-void Load(auth::Role *self, memgraph::slk::Reader *reader);
-void Save(const auth::User &self, memgraph::slk::Builder *builder);
-void Load(auth::User *self, memgraph::slk::Reader *reader);
-void Save(const auth::Auth::Config &self, memgraph::slk::Builder *builder);
-void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::replication::UpdateAuthDataRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::replication::UpdateAuthDataReq & /*self*/, memgraph::slk::Builder * /*builder*/);
-void Load(memgraph::replication::UpdateAuthDataReq * /*self*/, memgraph::slk::Reader * /*reader*/);
-void Save(const memgraph::replication::DropAuthDataRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::replication::DropAuthDataRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::replication::DropAuthDataReq & /*self*/, memgraph::slk::Builder * /*builder*/);
-void Load(memgraph::replication::DropAuthDataReq * /*self*/, memgraph::slk::Reader * /*reader*/);
-}  // namespace memgraph::slk
--- a/src/communication/websocket/auth.hpp
+++ b/src/communication/websocket/auth.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -14,6 +14,8 @@
 #include <string>

 #include "auth/auth.hpp"
+#include "utils/spin_lock.hpp"
+#include "utils/synchronized.hpp"

 namespace memgraph::communication::websocket {

@@ -28,7 +30,7 @@ class AuthenticationInterface {

 class SafeAuth : public AuthenticationInterface {
 public:
-  explicit SafeAuth(auth::SynchedAuth *auth) : auth_{auth} {}
+  explicit SafeAuth(utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock> *auth) : auth_{auth} {}

  bool Authenticate(const std::string &username, const std::string &password) const override;

@@ -37,6 +39,6 @@ class SafeAuth : public AuthenticationInterface {
  bool HasAnyUsers() const override;

 private:
-  auth::SynchedAuth *auth_;
+  utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock> *auth_;
 };
 }  // namespace memgraph::communication::websocket
--- a/src/coordination/CMakeLists.txt
+++ b/src/coordination/CMakeLists.txt
@@ -8,34 +8,23 @@ target_sources(mg-coordination
        include/coordination/coordinator_server.hpp
        include/coordination/coordinator_config.hpp
        include/coordination/coordinator_exceptions.hpp
-        include/coordination/coordinator_slk.hpp
        include/coordination/coordinator_instance.hpp
-        include/coordination/coordinator_handlers.hpp
+        include/coordination/coordinator_slk.hpp
+        include/coordination/coordinator_data.hpp
        include/coordination/constants.hpp
-        include/coordination/instance_status.hpp
-        include/coordination/replication_instance.hpp
-        include/coordination/raft_state.hpp
-
-        include/nuraft/coordinator_log_store.hpp
-        include/nuraft/coordinator_state_machine.hpp
-        include/nuraft/coordinator_state_manager.hpp
+        include/coordination/failover_status.hpp
+        include/coordination/coordinator_cluster_config.hpp

        PRIVATE
        coordinator_client.cpp
        coordinator_state.cpp
        coordinator_rpc.cpp
        coordinator_server.cpp
-        coordinator_handlers.cpp
+        coordinator_data.cpp
        coordinator_instance.cpp
-        replication_instance.cpp
-        raft_state.cpp
-
-        coordinator_log_store.cpp
-        coordinator_state_machine.cpp
-        coordinator_state_manager.cpp
 )
 target_include_directories(mg-coordination PUBLIC include)

 target_link_libraries(mg-coordination
-    PUBLIC mg::utils mg::rpc mg::slk mg::io mg::repl_coord_glue lib::rangev3 nuraft mg-replication_handler
+    PUBLIC mg::utils mg::rpc mg::slk mg::io mg::repl_coord_glue lib::rangev3
 )
--- a/src/coordination/coordinator_client.cpp
+++ b/src/coordination/coordinator_client.cpp
@@ -9,7 +9,6 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.

-#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE

 #include "coordination/coordinator_client.hpp"
@@ -21,51 +20,40 @@
 namespace memgraph::coordination {

 namespace {
-auto CreateClientContext(memgraph::coordination::CoordinatorClientConfig const &config)
+auto CreateClientContext(const memgraph::coordination::CoordinatorClientConfig &config)
    -> communication::ClientContext {
  return (config.ssl) ? communication::ClientContext{config.ssl->key_file, config.ssl->cert_file}
                      : communication::ClientContext{};
 }
 }  // namespace

-CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
+CoordinatorClient::CoordinatorClient(CoordinatorData *coord_data, CoordinatorClientConfig config,
                                     HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
    : rpc_context_{CreateClientContext(config)},
      rpc_client_{io::network::Endpoint(io::network::Endpoint::needs_resolving, config.ip_address, config.port),
                  &rpc_context_},
      config_{std::move(config)},
-      coord_instance_{coord_instance},
+      coord_data_{coord_data},
      succ_cb_{std::move(succ_cb)},
      fail_cb_{std::move(fail_cb)} {}

 auto CoordinatorClient::InstanceName() const -> std::string { return config_.instance_name; }
 auto CoordinatorClient::SocketAddress() const -> std::string { return rpc_client_.Endpoint().SocketAddress(); }

-auto CoordinatorClient::InstanceDownTimeoutSec() const -> std::chrono::seconds {
-  return config_.instance_down_timeout_sec;
-}
-
 void CoordinatorClient::StartFrequentCheck() {
-  if (instance_checker_.IsRunning()) {
-    return;
-  }
-
-  MG_ASSERT(config_.instance_health_check_frequency_sec > std::chrono::seconds(0),
+  MG_ASSERT(config_.health_check_frequency_sec > std::chrono::seconds(0),
            "Health check frequency must be greater than 0");

  instance_checker_.Run(
-      config_.instance_name, config_.instance_health_check_frequency_sec,
-      [this, instance_name = config_.instance_name] {
+      config_.instance_name, config_.health_check_frequency_sec, [this, instance_name = config_.instance_name] {
        try {
          spdlog::trace("Sending frequent heartbeat to machine {} on {}", instance_name,
                        rpc_client_.Endpoint().SocketAddress());
-          {  // NOTE: This is intentionally scoped so that stream lock could get released.
-            auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
-            stream.AwaitResponse();
-          }
-          succ_cb_(coord_instance_, instance_name);
-        } catch (rpc::RpcFailedException const &) {
-          fail_cb_(coord_instance_, instance_name);
+          auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
+          stream.AwaitResponse();
+          succ_cb_(coord_data_, instance_name);
+        } catch (const rpc::RpcFailedException &) {
+          fail_cb_(coord_data_, instance_name);
        }
      });
 }
@@ -79,77 +67,37 @@ auto CoordinatorClient::SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCal
  fail_cb_ = std::move(fail_cb);
 }

-auto CoordinatorClient::ReplicationClientInfo() const -> ReplClientInfo { return config_.replication_client_info; }
+auto CoordinatorClient::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
+  return config_.replication_client_info;
+}

-auto CoordinatorClient::SendPromoteReplicaToMainRpc(const utils::UUID &uuid,
-                                                    ReplicationClientsInfo replication_clients_info) const -> bool {
+auto CoordinatorClient::SendPromoteReplicaToMainRpc(
+    std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info) const -> bool {
  try {
-    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(uuid, std::move(replication_clients_info))};
+    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(std::move(replication_clients_info))};
    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful PromoteReplicaToMainRpc response!");
+      spdlog::error("Failed to receive successful RPC failover response!");
      return false;
    }
    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("RPC error occurred while sending PromoteReplicaToMainRpc!");
+  } catch (const rpc::RpcFailedException &) {
+    spdlog::error("RPC error occurred while sending failover RPC!");
  }
  return false;
 }

 auto CoordinatorClient::DemoteToReplica() const -> bool {
-  auto const &instance_name = config_.instance_name;
+  const auto instance_name = config_.instance_name;
  try {
-    auto stream{rpc_client_.Stream<DemoteMainToReplicaRpc>(config_.replication_client_info)};
+    auto stream{rpc_client_.Stream<SetMainToReplicaRpc>(config_.replication_client_info)};
    if (!stream.AwaitResponse().success) {
      spdlog::error("Failed to receive successful RPC response for setting instance {} to replica!", instance_name);
      return false;
    }
    spdlog::info("Sent request RPC from coordinator to instance to set it as replica!");
    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to set instance {} to replica!", instance_name);
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<replication_coordination_glue::SwapMainUUIDRpc>(uuid)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC swapping of uuid response!");
-      return false;
-    }
-    return true;
  } catch (const rpc::RpcFailedException &) {
-    spdlog::error("RPC error occurred while sending swapping uuid RPC!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<UnregisterReplicaRpc>(instance_name)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for unregistering replica!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to unregister replica!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendEnableWritingOnMainRpc() const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<EnableWritingOnMainRpc>()};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for enabling writing on main!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to enable writing on main!");
+    spdlog::error("Failed to set instance {} to replica!", instance_name);
  }
  return false;
 }
--- a/src/coordination/coordinator_data.cpp
+++ b/src/coordination/coordinator_data.cpp
@@ -0,0 +1,224 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "coordination/coordinator_instance.hpp"
+#include "coordination/register_main_replica_coordinator_status.hpp"
+#ifdef MG_ENTERPRISE
+
+#include "coordination/coordinator_data.hpp"
+
+#include <range/v3/view.hpp>
+#include <shared_mutex>
+
+namespace memgraph::coordination {
+
+CoordinatorData::CoordinatorData() {
+  auto find_instance = [](CoordinatorData *coord_data, std::string_view instance_name) -> CoordinatorInstance & {
+    auto instance = std::ranges::find_if(
+        coord_data->registered_instances_,
+        [instance_name](const CoordinatorInstance &instance) { return instance.InstanceName() == instance_name; });
+
+    MG_ASSERT(instance != coord_data->registered_instances_.end(), "Instance {} not found during callback!",
+              instance_name);
+    return *instance;
+  };
+
+  replica_succ_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing replica successful callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    instance.OnSuccessPing();
+  };
+
+  replica_fail_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing replica failure callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    instance.OnFailPing();
+  };
+
+  main_succ_cb_ = [this, find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing main successful callback", instance_name);
+
+    auto &instance = find_instance(coord_data, instance_name);
+
+    if (instance.IsAlive()) {
+      instance.OnSuccessPing();
+    } else {
+      auto const new_role = coord_data->ClusterHasAliveMain() ? replication_coordination_glue::ReplicationRole::REPLICA
+                                                              : replication_coordination_glue::ReplicationRole::MAIN;
+      if (new_role == replication_coordination_glue::ReplicationRole::REPLICA) {
+        thread_pool_.AddTask([&instance, coord_data, instance_name]() {
+          auto lock = std::lock_guard{coord_data->coord_data_lock_};
+          spdlog::info("Demoting instance {} to replica", instance_name);
+          instance.PauseFrequentCheck();
+          utils::OnScopeExit scope_exit{[&instance] { instance.ResumeFrequentCheck(); }};
+          auto const status = instance.DemoteToReplica(coord_data->replica_succ_cb_, coord_data->replica_fail_cb_);
+          if (!status) {
+            spdlog::error("Instance {} failed to demote to replica", instance_name);
+          } else {
+            spdlog::info("Instance {} demoted to replica", instance_name);
+            instance.OnSuccessPing();
+          }
+        });
+      } else {
+        instance.OnSuccessPing();
+      }
+    }
+  };
+
+  main_fail_cb_ = [this, find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing main failure callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    instance.OnFailPing();
+
+    if (!ClusterHasAliveMain()) {
+      spdlog::info("Cluster without main instance, starting automatic failover");
+      switch (auto failover_status = DoFailover(); failover_status) {
+        using enum DoFailoverStatus;
+        case ALL_REPLICAS_DOWN:
+          spdlog::warn("Failover aborted since all replicas are down!");
+          break;
+        case MAIN_ALIVE:
+          spdlog::warn("Failover aborted since main is alive!");
+          break;
+        case RPC_FAILED:
+          spdlog::warn("Failover aborted since promoting replica to main failed!");
+          break;
+        case SUCCESS:
+          break;
+      }
+    }
+  };
+}
+
+auto CoordinatorData::ClusterHasAliveMain() const -> bool {
+  auto const alive_main = [](const CoordinatorInstance &instance) { return instance.IsMain() && instance.IsAlive(); };
+  return std::ranges::any_of(registered_instances_, alive_main);
+}
+
+auto CoordinatorData::DoFailover() -> DoFailoverStatus {
+  auto replica_instances = registered_instances_ | ranges::views::filter(&CoordinatorInstance::IsReplica);
+
+  auto chosen_replica_instance = std::ranges::find_if(replica_instances, &CoordinatorInstance::IsAlive);
+  if (chosen_replica_instance == replica_instances.end()) {
+    return DoFailoverStatus::ALL_REPLICAS_DOWN;
+  }
+
+  chosen_replica_instance->PauseFrequentCheck();
+  utils::OnScopeExit scope_exit{[&chosen_replica_instance] { chosen_replica_instance->ResumeFrequentCheck(); }};
+
+  std::vector<ReplClientInfo> repl_clients_info;
+  repl_clients_info.reserve(std::ranges::distance(replica_instances));
+
+  auto const not_chosen_replica_instance = [&chosen_replica_instance](const CoordinatorInstance &instance) {
+    return instance != *chosen_replica_instance;
+  };
+
+  std::ranges::transform(replica_instances | ranges::views::filter(not_chosen_replica_instance),
+                         std::back_inserter(repl_clients_info),
+                         [](const CoordinatorInstance &instance) { return instance.ReplicationClientInfo(); });
+
+  if (!chosen_replica_instance->PromoteToMain(std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
+    return DoFailoverStatus::RPC_FAILED;
+  }
+  return DoFailoverStatus::SUCCESS;
+}
+
+auto CoordinatorData::ShowInstances() const -> std::vector<CoordinatorInstanceStatus> {
+  std::vector<CoordinatorInstanceStatus> instances_status;
+  instances_status.reserve(registered_instances_.size());
+
+  auto const stringify_repl_role = [](const CoordinatorInstance &instance) -> std::string {
+    if (!instance.IsAlive()) return "unknown";
+    if (instance.IsMain()) return "main";
+    return "replica";
+  };
+
+  auto const instance_to_status =
+      [&stringify_repl_role](const CoordinatorInstance &instance) -> CoordinatorInstanceStatus {
+    return {.instance_name = instance.InstanceName(),
+            .socket_address = instance.SocketAddress(),
+            .replication_role = stringify_repl_role(instance),
+            .is_alive = instance.IsAlive()};
+  };
+
+  {
+    auto lock = std::shared_lock{coord_data_lock_};
+    std::ranges::transform(registered_instances_, std::back_inserter(instances_status), instance_to_status);
+  }
+
+  return instances_status;
+}
+
+auto CoordinatorData::SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
+  auto lock = std::lock_guard{coord_data_lock_};
+
+  auto const is_new_main = [&instance_name](const CoordinatorInstance &instance) {
+    return instance.InstanceName() == instance_name;
+  };
+  auto new_main = std::ranges::find_if(registered_instances_, is_new_main);
+
+  if (new_main == registered_instances_.end()) {
+    spdlog::error("Instance {} not registered. Please register it using REGISTER INSTANCE {}", instance_name,
+                  instance_name);
+    return SetInstanceToMainCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+  }
+
+  new_main->PauseFrequentCheck();
+  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
+
+  std::vector<CoordinatorClientConfig::ReplicationClientInfo> repl_clients_info;
+  repl_clients_info.reserve(registered_instances_.size() - 1);
+
+  auto const is_not_new_main = [&instance_name](const CoordinatorInstance &instance) {
+    return instance.InstanceName() != instance_name;
+  };
+  std::ranges::transform(registered_instances_ | ranges::views::filter(is_not_new_main),
+                         std::back_inserter(repl_clients_info),
+                         [](const CoordinatorInstance &instance) { return instance.ReplicationClientInfo(); });
+
+  if (!new_main->PromoteToMain(std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
+    return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
+  }
+
+  spdlog::info("Instance {} promoted to main", instance_name);
+  return SetInstanceToMainCoordinatorStatus::SUCCESS;
+}
+
+auto CoordinatorData::RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus {
+  auto lock = std::lock_guard{coord_data_lock_};
+  if (std::ranges::any_of(registered_instances_, [&config](const CoordinatorInstance &instance) {
+        return instance.InstanceName() == config.instance_name;
+      })) {
+    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
+  }
+
+  if (std::ranges::any_of(registered_instances_, [&config](const CoordinatorInstance &instance) {
+        return instance.SocketAddress() == config.SocketAddress();
+      })) {
+    return RegisterInstanceCoordinatorStatus::END_POINT_EXISTS;
+  }
+
+  try {
+    registered_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_);
+    return RegisterInstanceCoordinatorStatus::SUCCESS;
+
+  } catch (CoordinatorRegisterInstanceException const &) {
+    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
+  }
+}
+
+}  // namespace memgraph::coordination
+
+#endif
--- a/src/coordination/coordinator_handlers.cpp
+++ b/src/coordination/coordinator_handlers.cpp
@@ -1,211 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-#include "coordination/coordinator_handlers.hpp"
-
-#include <range/v3/view.hpp>
-
-#include "coordination/coordinator_rpc.hpp"
-#include "coordination/include/coordination/coordinator_server.hpp"
-#include "replication/state.hpp"
-
-namespace memgraph::dbms {
-
-void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &server,
-                                   replication::ReplicationHandler &replication_handler) {
-  server.Register<coordination::PromoteReplicaToMainRpc>(
-      [&](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received PromoteReplicaToMainRpc");
-        CoordinatorHandlers::PromoteReplicaToMainHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::DemoteMainToReplicaRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received DemoteMainToReplicaRpc from coordinator server");
-        CoordinatorHandlers::DemoteMainToReplicaHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<replication_coordination_glue::SwapMainUUIDRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received SwapMainUUIDRPC on coordinator server");
-        CoordinatorHandlers::SwapMainUUIDHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::UnregisterReplicaRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received UnregisterReplicaRpc on coordinator server");
-        CoordinatorHandlers::UnregisterReplicaHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::EnableWritingOnMainRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received EnableWritingOnMainRpc on coordinator server");
-        CoordinatorHandlers::EnableWritingOnMainHandler(replication_handler, req_reader, res_builder);
-      });
-}
-
-void CoordinatorHandlers::SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler,
-                                              slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsReplica()) {
-    spdlog::error("Setting main uuid must be performed on replica.");
-    slk::Save(replication_coordination_glue::SwapMainUUIDRes{false}, res_builder);
-    return;
-  }
-
-  replication_coordination_glue::SwapMainUUIDReq req;
-  slk::Load(&req, req_reader);
-  spdlog::info(fmt::format("Set replica data UUID  to main uuid {}", std::string(req.uuid)));
-  std::get<memgraph::replication::RoleReplicaData>(replication_handler.GetReplState().ReplicationData()).uuid_ =
-      req.uuid;
-
-  slk::Save(replication_coordination_glue::SwapMainUUIDRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader *req_reader, slk::Builder *res_builder) {
-  spdlog::info("Executing DemoteMainToReplicaHandler");
-
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Setting to replica must be performed on main.");
-    slk::Save(coordination::DemoteMainToReplicaRes{false}, res_builder);
-    return;
-  }
-
-  coordination::DemoteMainToReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  const replication::ReplicationServerConfig clients_config{
-      .ip_address = req.replication_client_info.replication_ip_address,
-      .port = req.replication_client_info.replication_port};
-
-  if (!replication_handler.SetReplicationRoleReplica(clients_config, std::nullopt)) {
-    spdlog::error("Demoting main to replica failed!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-
-  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHandler &replication_handler,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsReplica()) {
-    spdlog::error("Failover must be performed on replica!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-  coordination::PromoteReplicaToMainReq req;
-  slk::Load(&req, req_reader);
-
-  // This can fail because of disk. If it does, the cluster state could get inconsistent.
-  // We don't handle disk issues.
-  if (const bool success = replication_handler.DoReplicaToMainPromotion(req.main_uuid_); !success) {
-    spdlog::error("Promoting replica to main failed!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-
-  auto const converter = [](const auto &repl_info_config) {
-    return replication::ReplicationClientConfig{
-        .name = repl_info_config.instance_name,
-        .mode = repl_info_config.replication_mode,
-        .ip_address = repl_info_config.replication_ip_address,
-        .port = repl_info_config.replication_port,
-    };
-  };
-
-  // registering replicas
-  for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
-    auto instance_client = replication_handler.RegisterReplica(config, false);
-    if (instance_client.HasError()) {
-      using enum memgraph::replication::RegisterReplicaError;
-      switch (instance_client.GetError()) {
-        // Can't happen, checked on the coordinator side
-        case memgraph::query::RegisterReplicaError::NAME_EXISTS:
-          spdlog::error("Replica with the same name already exists!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        // Can't happen, checked on the coordinator side
-        case memgraph::query::RegisterReplicaError::ENDPOINT_EXISTS:
-          spdlog::error("Replica with the same endpoint already exists!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        // We don't handle disk issues
-        case memgraph::query::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
-          spdlog::error("Registered replica could not be persisted!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        case memgraph::query::RegisterReplicaError::ERROR_ACCEPTING_MAIN:
-          spdlog::error("Replica didn't accept change of main!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        case memgraph::query::RegisterReplicaError::CONNECTION_FAILED:
-          // Connection failure is not a fatal error
-          break;
-      }
-    }
-  }
-  spdlog::info("Promote replica to main was success {}", std::string(req.main_uuid_));
-  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Unregistering replica must be performed on main.");
-    slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-    return;
-  }
-
-  coordination::UnregisterReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  auto res = replication_handler.UnregisterReplica(req.instance_name);
-  switch (res) {
-    using enum memgraph::query::UnregisterReplicaResult;
-    case SUCCESS:
-      slk::Save(coordination::UnregisterReplicaRes{true}, res_builder);
-      break;
-    case NOT_MAIN:
-      spdlog::error("Unregistering replica must be performed on main.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case CAN_NOT_UNREGISTER:
-      spdlog::error("Could not unregister replica.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case COULD_NOT_BE_PERSISTED:
-      spdlog::error("Could not persist replica unregistration.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-  }
-}
-
-void CoordinatorHandlers::EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Enable writing on main must be performed on main!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  if (!replication_handler.GetReplState().EnableWritingOnMain()) {
-    spdlog::error("Enabling writing on main failed!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  slk::Save(coordination::EnableWritingOnMainRes{true}, res_builder);
-}
-
-}  // namespace memgraph::dbms
-#endif
--- a/src/coordination/coordinator_instance.cpp
+++ b/src/coordination/coordinator_instance.cpp
@@ -13,337 +13,72 @@

 #include "coordination/coordinator_instance.hpp"

-#include "coordination/coordinator_exceptions.hpp"
-#include "nuraft/coordinator_state_machine.hpp"
-#include "nuraft/coordinator_state_manager.hpp"
-#include "utils/counter.hpp"
-#include "utils/functional.hpp"
-
-#include <range/v3/view.hpp>
-#include <shared_mutex>
-
 namespace memgraph::coordination {

-using nuraft::ptr;
-using nuraft::srv_config;
-
-CoordinatorInstance::CoordinatorInstance()
-    : raft_state_(RaftState::MakeRaftState(
-          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StartFrequentCheck); },
-          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StopFrequentCheck); })) {
-  auto find_repl_instance = [](CoordinatorInstance *self,
-                               std::string_view repl_instance_name) -> ReplicationInstance & {
-    auto repl_instance =
-        std::ranges::find_if(self->repl_instances_, [repl_instance_name](ReplicationInstance const &instance) {
-          return instance.InstanceName() == repl_instance_name;
-        });
-
-    MG_ASSERT(repl_instance != self->repl_instances_.end(), "Instance {} not found during callback!",
-              repl_instance_name);
-    return *repl_instance;
-  };
-
-  replica_succ_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing replica successful callback", repl_instance_name);
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-
-    if (!repl_instance.EnsureReplicaHasCorrectMainUUID(self->GetMainUUID())) {
-      spdlog::error(
-          fmt::format("Failed to swap uuid for replica instance {} which is alive", repl_instance.InstanceName()));
-      return;
-    }
-
-    repl_instance.OnSuccessPing();
-  };
-
-  replica_fail_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing replica failure callback", repl_instance_name);
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-    repl_instance.OnFailPing();
-    // We need to restart main uuid from instance since it was "down" at least a second
-    // There is slight delay, if we choose to use isAlive, instance can be down and back up in less than
-    // our isAlive time difference, which would lead to instance setting UUID to nullopt and stopping accepting any
-    // incoming RPCs from valid main
-    // TODO(antoniofilipovic) this needs here more complex logic
-    // We need to get id of main replica is listening to on successful ping
-    // and swap it to correct uuid if it failed
-    repl_instance.ResetMainUUID();
-  };
-
-  main_succ_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing main successful callback", repl_instance_name);
-
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-
-    if (repl_instance.IsAlive()) {
-      repl_instance.OnSuccessPing();
-      return;
-    }
-
-    const auto &repl_instance_uuid = repl_instance.GetMainUUID();
-    MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set.");
-
-    auto const curr_main_uuid = self->GetMainUUID();
-    if (curr_main_uuid == repl_instance_uuid.value()) {
-      if (!repl_instance.EnableWritingOnMain()) {
-        spdlog::error("Failed to enable writing on main instance {}", repl_instance_name);
-        return;
-      }
-
-      repl_instance.OnSuccessPing();
-      return;
-    }
-
-    // TODO(antoniof) make demoteToReplica idempotent since main can be demoted to replica but
-    // swapUUID can fail
-    if (repl_instance.DemoteToReplica(self->replica_succ_cb_, self->replica_fail_cb_)) {
-      repl_instance.OnSuccessPing();
-      spdlog::info("Instance {} demoted to replica", repl_instance_name);
-    } else {
-      spdlog::error("Instance {} failed to become replica", repl_instance_name);
-      return;
-    }
-
-    if (!repl_instance.SendSwapAndUpdateUUID(curr_main_uuid)) {
-      spdlog::error(fmt::format("Failed to swap uuid for demoted main instance {}", repl_instance.InstanceName()));
-      return;
-    }
-  };
-
-  main_fail_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing main failure callback", repl_instance_name);
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-    repl_instance.OnFailPing();
-    const auto &repl_instance_uuid = repl_instance.GetMainUUID();
-    MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set");
-
-    if (!repl_instance.IsAlive() && self->GetMainUUID() == repl_instance_uuid.value()) {
-      spdlog::info("Cluster without main instance, trying automatic failover");
-      self->TryFailover();  // TODO: (andi) Initiate failover
-    }
-  };
+CoordinatorInstance::CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config,
+                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
+    : client_(data, std::move(config), std::move(succ_cb), std::move(fail_cb)),
+      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA),
+      is_alive_(true) {
+  if (!client_.DemoteToReplica()) {
+    throw CoordinatorRegisterInstanceException("Failed to demote instance {} to replica", client_.InstanceName());
+  }
+  client_.StartFrequentCheck();
 }

-auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
-  auto const coord_instances = raft_state_.GetAllCoordinators();
-
-  auto const stringify_repl_role = [](ReplicationInstance const &instance) -> std::string {
-    if (!instance.IsAlive()) return "unknown";
-    if (instance.IsMain()) return "main";
-    return "replica";
-  };
-
-  auto const repl_instance_to_status = [&stringify_repl_role](ReplicationInstance const &instance) -> InstanceStatus {
-    return {.instance_name = instance.InstanceName(),
-            .coord_socket_address = instance.SocketAddress(),
-            .cluster_role = stringify_repl_role(instance),
-            .is_alive = instance.IsAlive()};
-  };
-
-  auto const coord_instance_to_status = [](ptr<srv_config> const &instance) -> InstanceStatus {
-    return {.instance_name = "coordinator_" + std::to_string(instance->get_id()),
-            .raft_socket_address = instance->get_endpoint(),
-            .cluster_role = "coordinator",
-            .is_alive = true};  // TODO: (andi) Get this info from RAFT and test it or when we will move
-                                // CoordinatorState to every instance, we can be smarter about this using our RPC.
-  };
-
-  auto instances_status = utils::fmap(coord_instance_to_status, coord_instances);
-  {
-    auto lock = std::shared_lock{coord_instance_lock_};
-    std::ranges::transform(repl_instances_, std::back_inserter(instances_status), repl_instance_to_status);
-  }
-
-  return instances_status;
+auto CoordinatorInstance::OnSuccessPing() -> void {
+  last_response_time_ = std::chrono::system_clock::now();
+  is_alive_ = true;
 }

-auto CoordinatorInstance::TryFailover() -> void {
-  auto alive_replicas = repl_instances_ | ranges::views::filter(&ReplicationInstance::IsReplica) |
-                        ranges::views::filter(&ReplicationInstance::IsAlive);
-
-  if (ranges::empty(alive_replicas)) {
-    spdlog::warn("Failover failed since all replicas are down!");
-    return;
-  }
-
-  // TODO: Smarter choice
-  auto new_main = ranges::begin(alive_replicas);
-
-  new_main->PauseFrequentCheck();
-  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
-
-  auto const is_not_new_main = [&new_main](ReplicationInstance &instance) {
-    return instance.InstanceName() != new_main->InstanceName();
-  };
-
-  auto const new_main_uuid = utils::UUID{};
-  // If for some replicas swap fails, for others on successful ping we will revert back on next change
-  // or we will do failover first again and then it will be consistent again
-  for (auto &other_replica_instance : alive_replicas | ranges::views::filter(is_not_new_main)) {
-    if (!other_replica_instance.SendSwapAndUpdateUUID(new_main_uuid)) {
-      spdlog::error(fmt::format("Failed to swap uuid for instance {} which is alive, aborting failover",
-                                other_replica_instance.InstanceName()));
-      return;
-    }
-  }
-
-  // TODO: (andi) fmap compliant
-  ReplicationClientsInfo repl_clients_info;
-  repl_clients_info.reserve(repl_instances_.size() - 1);
-  std::ranges::transform(repl_instances_ | ranges::views::filter(is_not_new_main),
-                         std::back_inserter(repl_clients_info), &ReplicationInstance::ReplicationClientInfo);
-
-  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
-    spdlog::warn("Failover failed since promoting replica to main failed!");
-    return;
-  }
-  // TODO: (andi) This should be replicated across all coordinator instances with Raft log
-  SetMainUUID(new_main_uuid);
-  spdlog::info("Failover successful! Instance {} promoted to main.", new_main->InstanceName());
+auto CoordinatorInstance::OnFailPing() -> bool {
+  is_alive_ =
+      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_response_time_).count() <
+      CoordinatorClusterConfig::alive_response_time_difference_sec_;
+  return is_alive_;
 }

-// TODO: (andi) Make sure you cannot put coordinator instance to the main
-auto CoordinatorInstance::SetReplicationInstanceToMain(std::string instance_name)
-    -> SetInstanceToMainCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
+auto CoordinatorInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
+auto CoordinatorInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
+auto CoordinatorInstance::IsAlive() const -> bool { return is_alive_; }

-  auto const is_new_main = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-  auto new_main = std::ranges::find_if(repl_instances_, is_new_main);
-
-  if (new_main == repl_instances_.end()) {
-    spdlog::error("Instance {} not registered. Please register it using REGISTER INSTANCE {}", instance_name,
-                  instance_name);
-    return SetInstanceToMainCoordinatorStatus::NO_INSTANCE_WITH_NAME;
-  }
-
-  new_main->PauseFrequentCheck();
-  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
-
-  auto const is_not_new_main = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() != instance_name;
-  };
-
-  auto const new_main_uuid = utils::UUID{};
-
-  for (auto &other_instance : repl_instances_ | ranges::views::filter(is_not_new_main)) {
-    if (!other_instance.SendSwapAndUpdateUUID(new_main_uuid)) {
-      spdlog::error(
-          fmt::format("Failed to swap uuid for instance {}, aborting failover", other_instance.InstanceName()));
-      return SetInstanceToMainCoordinatorStatus::SWAP_UUID_FAILED;
-    }
-  }
-
-  ReplicationClientsInfo repl_clients_info;
-  repl_clients_info.reserve(repl_instances_.size() - 1);
-  std::ranges::transform(repl_instances_ | ranges::views::filter(is_not_new_main),
-                         std::back_inserter(repl_clients_info), &ReplicationInstance::ReplicationClientInfo);
-
-  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
-    return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
-  }
-
-  // TODO: (andi) This should be replicated across all coordinator instances with Raft log
-  SetMainUUID(new_main_uuid);
-  spdlog::info("Instance {} promoted to main", instance_name);
-  return SetInstanceToMainCoordinatorStatus::SUCCESS;
+auto CoordinatorInstance::IsReplica() const -> bool {
+  return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
+}
+auto CoordinatorInstance::IsMain() const -> bool {
+  return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
 }

-auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig config)
-    -> RegisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  auto instance_name = config.instance_name;
-
-  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-
-  if (std::ranges::any_of(repl_instances_, name_matches)) {
-    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
+auto CoordinatorInstance::PromoteToMain(ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
+                                        HealthCheckCallback main_fail_cb) -> bool {
+  if (!client_.SendPromoteReplicaToMainRpc(std::move(repl_clients_info))) {
+    return false;
  }

-  auto const socket_address_matches = [&config](ReplicationInstance const &instance) {
-    return instance.SocketAddress() == config.SocketAddress();
-  };
+  replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
+  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));

-  if (std::ranges::any_of(repl_instances_, socket_address_matches)) {
-    return RegisterInstanceCoordinatorStatus::ENDPOINT_EXISTS;
-  }
-
-  if (!raft_state_.RequestLeadership()) {
-    return RegisterInstanceCoordinatorStatus::NOT_LEADER;
-  }
-
-  auto const res = raft_state_.AppendRegisterReplicationInstance(instance_name);
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for registering instance {}. Most likely the reason is that the instance is not "
-        "the "
-        "leader.",
-        config.instance_name);
-    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_ACCEPT;
-  }
-
-  spdlog::info("Request for registering instance {} accepted", instance_name);
-  try {
-    repl_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_);
-  } catch (CoordinatorRegisterInstanceException const &) {
-    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to register instance {} with error code {}", instance_name, res->get_result_code());
-    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_APPEND;
-  }
-
-  spdlog::info("Instance {} registered", instance_name);
-  return RegisterInstanceCoordinatorStatus::SUCCESS;
+  return true;
 }

-auto CoordinatorInstance::UnregisterReplicationInstance(std::string instance_name)
-    -> UnregisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-
-  auto inst_to_remove = std::ranges::find_if(repl_instances_, name_matches);
-  if (inst_to_remove == repl_instances_.end()) {
-    return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+auto CoordinatorInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
+    -> bool {
+  if (!client_.DemoteToReplica()) {
+    return false;
  }

-  if (inst_to_remove->IsMain() && inst_to_remove->IsAlive()) {
-    return UnregisterInstanceCoordinatorStatus::IS_MAIN;
-  }
+  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
+  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));

-  inst_to_remove->StopFrequentCheck();
-  auto curr_main = std::ranges::find_if(repl_instances_, &ReplicationInstance::IsMain);
-  MG_ASSERT(curr_main != repl_instances_.end(), "There must be a main instance when unregistering a replica");
-  if (!curr_main->SendUnregisterReplicaRpc(instance_name)) {
-    inst_to_remove->StartFrequentCheck();
-    return UnregisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-  std::erase_if(repl_instances_, name_matches);
-
-  return UnregisterInstanceCoordinatorStatus::SUCCESS;
+  return true;
 }

-auto CoordinatorInstance::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
-    -> void {
-  raft_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
+auto CoordinatorInstance::PauseFrequentCheck() -> void { client_.PauseFrequentCheck(); }
+auto CoordinatorInstance::ResumeFrequentCheck() -> void { client_.ResumeFrequentCheck(); }
+
+auto CoordinatorInstance::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
+  return client_.ReplicationClientInfo();
 }

-auto CoordinatorInstance::GetMainUUID() const -> utils::UUID { return main_uuid_; }
-
-// TODO: (andi) Add to the RAFT log.
-auto CoordinatorInstance::SetMainUUID(utils::UUID new_uuid) -> void { main_uuid_ = new_uuid; }
-
 }  // namespace memgraph::coordination
 #endif
--- a/src/coordination/coordinator_log_store.cpp
+++ b/src/coordination/coordinator_log_store.cpp
@@ -1,201 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_log_store.hpp"
-
-#include "coordination/coordinator_exceptions.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::cs_new;
-
-namespace {
-
-ptr<log_entry> MakeClone(const ptr<log_entry> &entry) {
-  return cs_new<log_entry>(entry->get_term(), buffer::clone(entry->get_buf()), entry->get_val_type(),
-                           entry->get_timestamp());
-}
-
-}  // namespace
-
-CoordinatorLogStore::CoordinatorLogStore() : start_idx_(1) {
-  ptr<buffer> buf = buffer::alloc(sizeof(uint64_t));
-  logs_[0] = cs_new<log_entry>(0, buf);
-}
-
-CoordinatorLogStore::~CoordinatorLogStore() {}
-
-auto CoordinatorLogStore::FindOrDefault_(uint64_t index) const -> ptr<log_entry> {
-  auto entry = logs_.find(index);
-  if (entry == logs_.end()) {
-    entry = logs_.find(0);
-  }
-  return entry->second;
-}
-
-uint64_t CoordinatorLogStore::next_slot() const {
-  auto lock = std::lock_guard{logs_lock_};
-  return start_idx_ + logs_.size() - 1;
-}
-
-uint64_t CoordinatorLogStore::start_index() const { return start_idx_; }
-
-ptr<log_entry> CoordinatorLogStore::last_entry() const {
-  auto lock = std::lock_guard{logs_lock_};
-
-  uint64_t const last_idx = start_idx_ + logs_.size() - 1;
-  auto const last_src = FindOrDefault_(last_idx - 1);
-
-  return MakeClone(last_src);
-}
-
-uint64_t CoordinatorLogStore::append(ptr<log_entry> &entry) {
-  ptr<log_entry> clone = MakeClone(entry);
-  uint64_t next_slot{0};
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    next_slot = start_idx_ + logs_.size() - 1;
-    logs_[next_slot] = clone;
-  }
-  return next_slot;
-}
-
-void CoordinatorLogStore::write_at(uint64_t index, ptr<log_entry> &entry) {
-  ptr<log_entry> clone = MakeClone(entry);
-
-  // Discard all logs equal to or greater than `index.
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    auto itr = logs_.lower_bound(index);
-    while (itr != logs_.end()) {
-      itr = logs_.erase(itr);
-    }
-    logs_[index] = clone;
-  }
-}
-
-ptr<std::vector<ptr<log_entry>>> CoordinatorLogStore::log_entries(uint64_t start, uint64_t end) {
-  auto ret = cs_new<std::vector<ptr<log_entry>>>();
-  ret->resize(end - start);
-
-  for (uint64_t i = start, curr_index = 0; i < end; ++i, ++curr_index) {
-    ptr<log_entry> src = nullptr;
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      if (auto const entry = logs_.find(i); entry != logs_.end()) {
-        src = entry->second;
-      } else {
-        throw RaftCouldNotFindEntryException("Could not find entry at index {}", i);
-      }
-    }
-    (*ret)[curr_index] = MakeClone(src);
-  }
-  return ret;
-}
-
-ptr<log_entry> CoordinatorLogStore::entry_at(uint64_t index) {
-  ptr<log_entry> src = nullptr;
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    src = FindOrDefault_(index);
-  }
-  return MakeClone(src);
-}
-
-uint64_t CoordinatorLogStore::term_at(uint64_t index) {
-  uint64_t term = 0;
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    term = FindOrDefault_(index)->get_term();
-  }
-  return term;
-}
-
-ptr<buffer> CoordinatorLogStore::pack(uint64_t index, int32 cnt) {
-  std::vector<ptr<buffer>> logs;
-
-  size_t size_total = 0;
-  uint64_t const end_index = index + cnt;
-  for (uint64_t i = index; i < end_index; ++i) {
-    ptr<log_entry> le = nullptr;
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      le = logs_[i];
-    }
-    MG_ASSERT(le.get(), "Could not find log entry at index {}", i);
-    auto buf = le->serialize();
-    size_total += buf->size();
-    logs.push_back(buf);
-  }
-
-  auto buf_out = buffer::alloc(sizeof(int32) + cnt * sizeof(int32) + size_total);
-  buf_out->pos(0);
-  buf_out->put((int32)cnt);
-
-  for (auto &entry : logs) {
-    buf_out->put(static_cast<int32>(entry->size()));
-    buf_out->put(*entry);
-  }
-  return buf_out;
-}
-
-void CoordinatorLogStore::apply_pack(uint64_t index, buffer &pack) {
-  pack.pos(0);
-  int32 const num_logs = pack.get_int();
-
-  for (int32 i = 0; i < num_logs; ++i) {
-    uint64_t cur_idx = index + i;
-    int32 buf_size = pack.get_int();
-
-    ptr<buffer> buf_local = buffer::alloc(buf_size);
-    pack.get(buf_local);
-
-    ptr<log_entry> le = log_entry::deserialize(*buf_local);
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      logs_[cur_idx] = le;
-    }
-  }
-
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    auto const entry = logs_.upper_bound(0);
-    if (entry != logs_.end()) {
-      start_idx_ = entry->first;
-    } else {
-      start_idx_ = 1;
-    }
-  }
-}
-
-// NOTE: Remove all logs up to given 'last_log_index' (inclusive).
-bool CoordinatorLogStore::compact(uint64_t last_log_index) {
-  auto lock = std::lock_guard{logs_lock_};
-  for (uint64_t ii = start_idx_; ii <= last_log_index; ++ii) {
-    auto const entry = logs_.find(ii);
-    if (entry != logs_.end()) {
-      logs_.erase(entry);
-    }
-  }
-
-  if (start_idx_ <= last_log_index) {
-    start_idx_ = last_log_index + 1;
-  }
-  return true;
-}
-
-bool CoordinatorLogStore::flush() { return true; }
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/coordinator_rpc.cpp
+++ b/src/coordination/coordinator_rpc.cpp
@@ -36,50 +36,22 @@ void PromoteReplicaToMainRes::Load(PromoteReplicaToMainRes *self, memgraph::slk:
  memgraph::slk::Load(self, reader);
 }

-void DemoteMainToReplicaReq::Save(const DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
+void SetMainToReplicaReq::Save(const SetMainToReplicaReq &self, memgraph::slk::Builder *builder) {
  memgraph::slk::Save(self, builder);
 }

-void DemoteMainToReplicaReq::Load(DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader) {
+void SetMainToReplicaReq::Load(SetMainToReplicaReq *self, memgraph::slk::Reader *reader) {
  memgraph::slk::Load(self, reader);
 }

-void DemoteMainToReplicaRes::Save(const DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder) {
+void SetMainToReplicaRes::Save(const SetMainToReplicaRes &self, memgraph::slk::Builder *builder) {
  memgraph::slk::Save(self, builder);
 }

-void DemoteMainToReplicaRes::Load(DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader) {
+void SetMainToReplicaRes::Load(SetMainToReplicaRes *self, memgraph::slk::Reader *reader) {
  memgraph::slk::Load(self, reader);
 }

-void UnregisterReplicaReq::Save(UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void UnregisterReplicaReq::Load(UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void UnregisterReplicaRes::Save(UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void UnregisterReplicaRes::Load(UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void EnableWritingOnMainRes::Save(EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void EnableWritingOnMainRes::Load(EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void EnableWritingOnMainReq::Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder) {}
-
-void EnableWritingOnMainReq::Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader) {}
-
 }  // namespace coordination

 constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::TypeId::COORD_FAILOVER_REQ,
@@ -88,24 +60,11 @@ constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::Ty
 constexpr utils::TypeInfo coordination::PromoteReplicaToMainRes::kType{utils::TypeId::COORD_FAILOVER_RES,
                                                                       "CoordPromoteReplicaToMainRes", nullptr};

-constexpr utils::TypeInfo coordination::DemoteMainToReplicaReq::kType{utils::TypeId::COORD_SET_REPL_MAIN_REQ,
-                                                                      "CoordDemoteToReplicaReq", nullptr};
+constexpr utils::TypeInfo coordination::SetMainToReplicaReq::kType{utils::TypeId::COORD_SET_REPL_MAIN_REQ,
+                                                                   "CoordDemoteToReplicaReq", nullptr};

-constexpr utils::TypeInfo coordination::DemoteMainToReplicaRes::kType{utils::TypeId::COORD_SET_REPL_MAIN_RES,
-
-                                                                      "CoordDemoteToReplicaRes", nullptr};
-
-constexpr utils::TypeInfo coordination::UnregisterReplicaReq::kType{utils::TypeId::COORD_UNREGISTER_REPLICA_REQ,
-                                                                    "UnregisterReplicaReq", nullptr};
-
-constexpr utils::TypeInfo coordination::UnregisterReplicaRes::kType{utils::TypeId::COORD_UNREGISTER_REPLICA_RES,
-                                                                    "UnregisterReplicaRes", nullptr};
-
-constexpr utils::TypeInfo coordination::EnableWritingOnMainReq::kType{utils::TypeId::COORD_ENABLE_WRITING_ON_MAIN_REQ,
-                                                                      "CoordEnableWritingOnMainReq", nullptr};
-
-constexpr utils::TypeInfo coordination::EnableWritingOnMainRes::kType{utils::TypeId::COORD_ENABLE_WRITING_ON_MAIN_RES,
-                                                                      "CoordEnableWritingOnMainRes", nullptr};
+constexpr utils::TypeInfo coordination::SetMainToReplicaRes::kType{utils::TypeId::COORD_SET_REPL_MAIN_RES,
+                                                                   "CoordDemoteToReplicaRes", nullptr};

 namespace slk {

@@ -118,52 +77,26 @@ void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::
 }

 void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid_, builder);
  memgraph::slk::Save(self.replication_clients_info, builder);
 }

 void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid_, reader);
  memgraph::slk::Load(&self->replication_clients_info, reader);
 }

-void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
+void Save(const memgraph::coordination::SetMainToReplicaReq &self, memgraph::slk::Builder *builder) {
  memgraph::slk::Save(self.replication_client_info, builder);
 }

-void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader) {
+void Load(memgraph::coordination::SetMainToReplicaReq *self, memgraph::slk::Reader *reader) {
  memgraph::slk::Load(&self->replication_client_info, reader);
 }

-void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder) {
+void Save(const memgraph::coordination::SetMainToReplicaRes &self, memgraph::slk::Builder *builder) {
  memgraph::slk::Save(self.success, builder);
 }

-void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.instance_name, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->instance_name, reader);
-}
-
-void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
+void Load(memgraph::coordination::SetMainToReplicaRes *self, memgraph::slk::Reader *reader) {
  memgraph::slk::Load(&self->success, reader);
 }

--- a/src/coordination/coordinator_server.cpp
+++ b/src/coordination/coordinator_server.cpp
@@ -12,7 +12,7 @@
 #ifdef MG_ENTERPRISE

 #include "coordination/coordinator_server.hpp"
-#include "replication_coordination_glue/handler.hpp"
+#include "replication_coordination_glue/messages.hpp"

 namespace memgraph::coordination {

--- a/src/coordination/coordinator_state.cpp
+++ b/src/coordination/coordinator_state.cpp
@@ -25,7 +25,7 @@
 namespace memgraph::coordination {

 CoordinatorState::CoordinatorState() {
-  MG_ASSERT(!(FLAGS_raft_server_id && FLAGS_coordinator_server_port),
+  MG_ASSERT(!(FLAGS_coordinator && FLAGS_coordinator_server_port),
            "Instance cannot be a coordinator and have registered coordinator server.");

  spdlog::info("Executing coordinator constructor");
@@ -41,53 +41,43 @@ CoordinatorState::CoordinatorState() {
  }
 }

-auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig config)
-    -> RegisterInstanceCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
+auto CoordinatorState::RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
            "Coordinator cannot register replica since variant holds wrong alternative");

  return std::visit(
-      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-                                    return RegisterInstanceCoordinatorStatus::NOT_COORDINATOR;
-                                  },
-                                  [config](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.RegisterReplicationInstance(config);
-                                  }},
+      memgraph::utils::Overloaded{
+          [](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
+            return RegisterInstanceCoordinatorStatus::NOT_COORDINATOR;
+          },
+          [config](CoordinatorData &coordinator_data) { return coordinator_data.RegisterInstance(config); }},
      data_);
 }

-auto CoordinatorState::UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
-            "Coordinator cannot unregister instance since variant holds wrong alternative");
-
-  return std::visit(
-      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-                                    return UnregisterInstanceCoordinatorStatus::NOT_COORDINATOR;
-                                  },
-                                  [&instance_name](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.UnregisterReplicationInstance(instance_name);
-                                  }},
-      data_);
-}
-
-auto CoordinatorState::SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
+auto CoordinatorState::SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
            "Coordinator cannot register replica since variant holds wrong alternative");

  return std::visit(
      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
                                    return SetInstanceToMainCoordinatorStatus::NOT_COORDINATOR;
                                  },
-                                  [&instance_name](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.SetReplicationInstanceToMain(instance_name);
+                                  [&instance_name](CoordinatorData &coordinator_data) {
+                                    return coordinator_data.SetInstanceToMain(instance_name);
                                  }},
      data_);
 }

-auto CoordinatorState::ShowInstances() const -> std::vector<InstanceStatus> {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
+auto CoordinatorState::ShowInstances() const -> std::vector<CoordinatorInstanceStatus> {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
            "Can't call show instances on data_, as variant holds wrong alternative");
-  return std::get<CoordinatorInstance>(data_).ShowInstances();
+  return std::get<CoordinatorData>(data_).ShowInstances();
+}
+
+[[nodiscard]] auto CoordinatorState::DoFailover() -> DoFailoverStatus {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_), "Cannot do failover since variant holds wrong alternative");
+  auto &coord_state = std::get<CoordinatorData>(data_);
+  return coord_state.DoFailover();
 }

 auto CoordinatorState::GetCoordinatorServer() const -> CoordinatorServer & {
@@ -95,13 +85,5 @@ auto CoordinatorState::GetCoordinatorServer() const -> CoordinatorServer & {
            "Cannot get coordinator server since variant holds wrong alternative");
  return *std::get<CoordinatorMainReplicaData>(data_).coordinator_server_;
 }
-
-auto CoordinatorState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
-    -> void {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
-            "Coordinator cannot register replica since variant holds wrong alternative");
-  return std::get<CoordinatorInstance>(data_).AddCoordinatorInstance(raft_server_id, raft_port, raft_address);
-}
-
 }  // namespace memgraph::coordination
 #endif
--- a/src/coordination/coordinator_state_machine.cpp
+++ b/src/coordination/coordinator_state_machine.cpp
@@ -1,111 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_state_machine.hpp"
-
-namespace memgraph::coordination {
-
-auto CoordinatorStateMachine::EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer> {
-  std::string str_log = name + "_replica";
-  ptr<buffer> log = buffer::alloc(sizeof(uint32_t) + str_log.size());
-  buffer_serializer bs(log);
-  bs.put_str(str_log);
-  return log;
-}
-
-auto CoordinatorStateMachine::DecodeRegisterReplicationInstance(buffer &data) -> std::string {
-  buffer_serializer bs(data);
-  return bs.get_str();
-}
-
-auto CoordinatorStateMachine::pre_commit(ulong const log_idx, buffer &data) -> ptr<buffer> {
-  buffer_serializer bs(data);
-  std::string str = bs.get_str();
-
-  spdlog::info("pre_commit {} : {}", log_idx, str);
-  return nullptr;
-}
-
-auto CoordinatorStateMachine::commit(ulong const log_idx, buffer &data) -> ptr<buffer> {
-  buffer_serializer bs(data);
-  std::string str = bs.get_str();
-
-  spdlog::info("commit {} : {}", log_idx, str);
-
-  last_committed_idx_ = log_idx;
-  return nullptr;
-}
-
-auto CoordinatorStateMachine::commit_config(ulong const log_idx, ptr<cluster_config> & /*new_conf*/) -> void {
-  last_committed_idx_ = log_idx;
-}
-
-auto CoordinatorStateMachine::rollback(ulong const log_idx, buffer &data) -> void {
-  buffer_serializer bs(data);
-  std::string str = bs.get_str();
-
-  spdlog::info("rollback {} : {}", log_idx, str);
-}
-
-auto CoordinatorStateMachine::read_logical_snp_obj(snapshot & /*snapshot*/, void *& /*user_snp_ctx*/, ulong /*obj_id*/,
-                                                   ptr<buffer> &data_out, bool &is_last_obj) -> int {
-  // Put dummy data.
-  data_out = buffer::alloc(sizeof(int32));
-  buffer_serializer bs(data_out);
-  bs.put_i32(0);
-
-  is_last_obj = true;
-  return 0;
-}
-
-auto CoordinatorStateMachine::save_logical_snp_obj(snapshot &s, ulong &obj_id, buffer & /*data*/, bool /*is_first_obj*/,
-                                                   bool /*is_last_obj*/) -> void {
-  spdlog::info("save snapshot {} term {} object ID", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
-  // Request next object.
-  obj_id++;
-}
-
-auto CoordinatorStateMachine::apply_snapshot(snapshot &s) -> bool {
-  spdlog::info("apply snapshot {} term {}", s.get_last_log_idx(), s.get_last_log_term());
-  {
-    auto lock = std::lock_guard{last_snapshot_lock_};
-    ptr<buffer> snp_buf = s.serialize();
-    last_snapshot_ = snapshot::deserialize(*snp_buf);
-  }
-  return true;
-}
-
-auto CoordinatorStateMachine::free_user_snp_ctx(void *&user_snp_ctx) -> void {}
-
-auto CoordinatorStateMachine::last_snapshot() -> ptr<snapshot> {
-  auto lock = std::lock_guard{last_snapshot_lock_};
-  return last_snapshot_;
-}
-
-auto CoordinatorStateMachine::last_commit_index() -> ulong { return last_committed_idx_; }
-
-auto CoordinatorStateMachine::create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void {
-  spdlog::info("create snapshot {} term {}", s.get_last_log_idx(), s.get_last_log_term());
-  // Clone snapshot from `s`.
-  {
-    auto lock = std::lock_guard{last_snapshot_lock_};
-    ptr<buffer> snp_buf = s.serialize();
-    last_snapshot_ = snapshot::deserialize(*snp_buf);
-  }
-  ptr<std::exception> except(nullptr);
-  bool ret = true;
-  when_done(ret, except);
-}
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/coordinator_state_manager.cpp
+++ b/src/coordination/coordinator_state_manager.cpp
@@ -1,68 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_state_manager.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::cluster_config;
-using nuraft::cs_new;
-using nuraft::srv_config;
-using nuraft::srv_state;
-using nuraft::state_mgr;
-
-CoordinatorStateManager::CoordinatorStateManager(int srv_id, std::string const &endpoint)
-    : my_id_(srv_id), my_endpoint_(endpoint), cur_log_store_(cs_new<CoordinatorLogStore>()) {
-  my_srv_config_ = cs_new<srv_config>(srv_id, endpoint);
-
-  // Initial cluster config: contains only one server (myself).
-  cluster_config_ = cs_new<cluster_config>();
-  cluster_config_->get_servers().push_back(my_srv_config_);
-}
-
-auto CoordinatorStateManager::load_config() -> ptr<cluster_config> {
-  // Just return in-memory data in this example.
-  // May require reading from disk here, if it has been written to disk.
-  return cluster_config_;
-}
-
-auto CoordinatorStateManager::save_config(cluster_config const &config) -> void {
-  // Just keep in memory in this example.
-  // Need to write to disk here, if want to make it durable.
-  ptr<buffer> buf = config.serialize();
-  cluster_config_ = cluster_config::deserialize(*buf);
-}
-
-auto CoordinatorStateManager::save_state(srv_state const &state) -> void {
-  // Just keep in memory in this example.
-  // Need to write to disk here, if want to make it durable.
-  ptr<buffer> buf = state.serialize();
-  saved_state_ = srv_state::deserialize(*buf);
-}
-
-auto CoordinatorStateManager::read_state() -> ptr<srv_state> {
-  // Just return in-memory data in this example.
-  // May require reading from disk here, if it has been written to disk.
-  return saved_state_;
-}
-
-auto CoordinatorStateManager::load_log_store() -> ptr<log_store> { return cur_log_store_; }
-
-auto CoordinatorStateManager::server_id() -> int32 { return my_id_; }
-
-auto CoordinatorStateManager::system_exit(int const exit_code) -> void {}
-
-auto CoordinatorStateManager::GetSrvConfig() const -> ptr<srv_config> { return my_srv_config_; }
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/include/coordination/coordinator_client.hpp
+++ b/src/coordination/include/coordination/coordinator_client.hpp
@@ -16,18 +16,17 @@
 #include "coordination/coordinator_config.hpp"
 #include "rpc/client.hpp"
 #include "utils/scheduler.hpp"
-#include "utils/uuid.hpp"

 namespace memgraph::coordination {

-class CoordinatorInstance;
-using HealthCheckCallback = std::function<void(CoordinatorInstance *, std::string_view)>;
+class CoordinatorData;
+using HealthCheckCallback = std::function<void(CoordinatorData *, std::string_view)>;
 using ReplicationClientsInfo = std::vector<ReplClientInfo>;

 class CoordinatorClient {
 public:
-  explicit CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
-                             HealthCheckCallback succ_cb, HealthCheckCallback fail_cb);
+  explicit CoordinatorClient(CoordinatorData *coord_data_, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                             HealthCheckCallback fail_cb);

  ~CoordinatorClient() = default;

@@ -45,25 +44,13 @@ class CoordinatorClient {
  auto InstanceName() const -> std::string;
  auto SocketAddress() const -> std::string;

+  [[nodiscard]] auto SendPromoteReplicaToMainRpc(ReplicationClientsInfo replication_clients_info) const -> bool;
  [[nodiscard]] auto DemoteToReplica() const -> bool;
-  // TODO: (andi) Consistent naming
-  auto SendPromoteReplicaToMainRpc(const utils::UUID &uuid, ReplicationClientsInfo replication_clients_info) const
-      -> bool;
-
-  auto SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool;
-
-  auto SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool;
-
-  auto SendEnableWritingOnMainRpc() const -> bool;

  auto ReplicationClientInfo() const -> ReplClientInfo;

  auto SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void;

-  auto RpcClient() -> rpc::Client & { return rpc_client_; }
-
-  auto InstanceDownTimeoutSec() const -> std::chrono::seconds;
-
  friend bool operator==(CoordinatorClient const &first, CoordinatorClient const &second) {
    return first.config_ == second.config_;
  }
@@ -76,7 +63,7 @@ class CoordinatorClient {
  mutable rpc::Client rpc_client_;

  CoordinatorClientConfig config_;
-  CoordinatorInstance *coord_instance_;
+  CoordinatorData *coord_data_;
  HealthCheckCallback succ_cb_;
  HealthCheckCallback fail_cb_;
 };
--- a/src/coordination/include/coordination/coordinator_cluster_config.hpp
+++ b/src/coordination/include/coordination/coordinator_cluster_config.hpp
@@ -8,4 +8,15 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
-#include "system/include/system/transaction.hpp"
+
+#pragma once
+
+#ifdef MG_ENTERPRISE
+namespace memgraph::coordination {
+
+struct CoordinatorClusterConfig {
+  static constexpr int alive_response_time_difference_sec_{5};
+};
+
+}  // namespace memgraph::coordination
+#endif
--- a/src/coordination/include/coordination/coordinator_config.hpp
+++ b/src/coordination/include/coordination/coordinator_config.hpp
@@ -28,8 +28,7 @@ struct CoordinatorClientConfig {
  std::string instance_name;
  std::string ip_address;
  uint16_t port{};
-  std::chrono::seconds instance_health_check_frequency_sec{1};
-  std::chrono::seconds instance_down_timeout_sec{5};
+  std::chrono::seconds health_check_frequency_sec{1};

  auto SocketAddress() const -> std::string { return ip_address + ":" + std::to_string(port); }

--- a/src/coordination/include/coordination/coordinator_data.hpp
+++ b/src/coordination/include/coordination/coordinator_data.hpp
@@ -0,0 +1,53 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#ifdef MG_ENTERPRISE
+
+#include "coordination/coordinator_instance.hpp"
+#include "coordination/coordinator_instance_status.hpp"
+#include "coordination/coordinator_server.hpp"
+#include "coordination/failover_status.hpp"
+#include "coordination/register_main_replica_coordinator_status.hpp"
+#include "utils/rw_lock.hpp"
+#include "utils/thread_pool.hpp"
+
+#include <list>
+
+namespace memgraph::coordination {
+class CoordinatorData {
+ public:
+  CoordinatorData();
+
+  [[nodiscard]] auto DoFailover() -> DoFailoverStatus;
+
+  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+
+  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;
+
+ private:
+  auto ClusterHasAliveMain() const -> bool;
+
+  mutable utils::RWLock coord_data_lock_{utils::RWLock::Priority::READ};
+  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
+  // Must be std::list because we rely on pointer stability
+  std::list<CoordinatorInstance> registered_instances_;
+  utils::ThreadPool thread_pool_{1};
+};
+
+struct CoordinatorMainReplicaData {
+  std::unique_ptr<CoordinatorServer> coordinator_server_;
+};
+
+}  // namespace memgraph::coordination
+#endif
--- a/src/coordination/include/coordination/coordinator_exceptions.hpp
+++ b/src/coordination/include/coordination/coordinator_exceptions.hpp
@@ -28,60 +28,5 @@ class CoordinatorRegisterInstanceException final : public utils::BasicException
  SPECIALIZE_GET_EXCEPTION_NAME(CoordinatorRegisterInstanceException)
 };

-class RaftServerStartException final : public utils::BasicException {
- public:
-  explicit RaftServerStartException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftServerStartException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftServerStartException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftServerStartException)
-};
-
-class RaftAddServerException final : public utils::BasicException {
- public:
-  explicit RaftAddServerException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftAddServerException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftAddServerException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftAddServerException)
-};
-
-class RaftBecomeLeaderException final : public utils::BasicException {
- public:
-  explicit RaftBecomeLeaderException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftBecomeLeaderException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftBecomeLeaderException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftBecomeLeaderException)
-};
-
-class RaftCouldNotFindEntryException final : public utils::BasicException {
- public:
-  explicit RaftCouldNotFindEntryException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftCouldNotFindEntryException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftCouldNotFindEntryException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftCouldNotFindEntryException)
-};
-
-class RaftCouldNotParseFlagsException final : public utils::BasicException {
- public:
-  explicit RaftCouldNotParseFlagsException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftCouldNotParseFlagsException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftCouldNotParseFlagsException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftCouldNotParseFlagsException)
-};
-
 }  // namespace memgraph::coordination
 #endif
--- a/src/coordination/include/coordination/coordinator_handlers.hpp
+++ b/src/coordination/include/coordination/coordinator_handlers.hpp
@@ -1,45 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_server.hpp"
-#include "replication_handler/replication_handler.hpp"
-#include "slk/streams.hpp"
-
-namespace memgraph::dbms {
-
-class DbmsHandler;
-
-class CoordinatorHandlers {
- public:
-  static void Register(memgraph::coordination::CoordinatorServer &server,
-                       replication::ReplicationHandler &replication_handler);
-
- private:
-  static void PromoteReplicaToMainHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                          slk::Builder *res_builder);
-  static void DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                         slk::Builder *res_builder);
-  static void SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                  slk::Builder *res_builder);
-
-  static void UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                       slk::Builder *res_builder);
-  static void EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                         slk::Builder *res_builder);
-};
-
-}  // namespace memgraph::dbms
-
-#endif
--- a/src/coordination/include/coordination/coordinator_instance.hpp
+++ b/src/coordination/include/coordination/coordinator_instance.hpp
@@ -13,47 +13,55 @@

 #ifdef MG_ENTERPRISE

-#include "coordination/coordinator_server.hpp"
-#include "coordination/instance_status.hpp"
-#include "coordination/raft_state.hpp"
-#include "coordination/register_main_replica_coordinator_status.hpp"
-#include "coordination/replication_instance.hpp"
-#include "utils/rw_lock.hpp"
-#include "utils/thread_pool.hpp"
-
-#include <list>
+#include "coordination/coordinator_client.hpp"
+#include "coordination/coordinator_cluster_config.hpp"
+#include "coordination/coordinator_exceptions.hpp"
+#include "replication_coordination_glue/role.hpp"

 namespace memgraph::coordination {

+class CoordinatorData;
+
 class CoordinatorInstance {
 public:
-  CoordinatorInstance();
+  CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                      HealthCheckCallback fail_cb);

-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
+  CoordinatorInstance(CoordinatorInstance const &other) = delete;
+  CoordinatorInstance &operator=(CoordinatorInstance const &other) = delete;
+  CoordinatorInstance(CoordinatorInstance &&other) noexcept = delete;
+  CoordinatorInstance &operator=(CoordinatorInstance &&other) noexcept = delete;
+  ~CoordinatorInstance() = default;

-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+  auto OnSuccessPing() -> void;
+  auto OnFailPing() -> bool;

-  auto ShowInstances() const -> std::vector<InstanceStatus>;
+  auto IsAlive() const -> bool;

-  auto TryFailover() -> void;
+  auto InstanceName() const -> std::string;
+  auto SocketAddress() const -> std::string;

-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
+  auto IsReplica() const -> bool;
+  auto IsMain() const -> bool;

-  auto GetMainUUID() const -> utils::UUID;
+  auto PromoteToMain(ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
+                     HealthCheckCallback main_fail_cb) -> bool;
+  auto DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb) -> bool;

-  auto SetMainUUID(utils::UUID new_uuid) -> void;
+  auto PauseFrequentCheck() -> void;
+  auto ResumeFrequentCheck() -> void;
+
+  auto ReplicationClientInfo() const -> ReplClientInfo;

 private:
-  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
+  CoordinatorClient client_;
+  replication_coordination_glue::ReplicationRole replication_role_;
+  std::chrono::system_clock::time_point last_response_time_{};
+  bool is_alive_{false};

-  // NOTE: Must be std::list because we rely on pointer stability
-  std::list<ReplicationInstance> repl_instances_;
-  mutable utils::RWLock coord_instance_lock_{utils::RWLock::Priority::READ};
-
-  utils::UUID main_uuid_;
-
-  RaftState raft_state_;
+  friend bool operator==(CoordinatorInstance const &first, CoordinatorInstance const &second) {
+    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
+  }
 };

 }  // namespace memgraph::coordination
--- a/src/coordination/include/coordination/coordinator_instance_status.hpp
+++ b/src/coordination/include/coordination/coordinator_instance_status.hpp
@@ -19,13 +19,10 @@

 namespace memgraph::coordination {

-// TODO: (andi) For phase IV. Some instances won't have raft_socket_address, coord_socket_address, replication_role and
-// cluster role... At the end, all instances will have everything.
-struct InstanceStatus {
+struct CoordinatorInstanceStatus {
  std::string instance_name;
-  std::string raft_socket_address;
-  std::string coord_socket_address;
-  std::string cluster_role;
+  std::string socket_address;
+  std::string replication_role;
  bool is_alive;
 };

--- a/src/coordination/include/coordination/coordinator_rpc.hpp
+++ b/src/coordination/include/coordination/coordinator_rpc.hpp
@@ -11,7 +11,6 @@

 #pragma once

-#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE

 #include "coordination/coordinator_config.hpp"
@@ -27,13 +26,10 @@ struct PromoteReplicaToMainReq {
  static void Load(PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
  static void Save(const PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);

-  explicit PromoteReplicaToMainReq(const utils::UUID &uuid,
-                                   std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
-      : main_uuid_(uuid), replication_clients_info(std::move(replication_clients_info)) {}
+  explicit PromoteReplicaToMainReq(std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
+      : replication_clients_info(std::move(replication_clients_info)) {}
  PromoteReplicaToMainReq() = default;

-  // get uuid here
-  utils::UUID main_uuid_;
  std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info;
 };

@@ -52,115 +48,56 @@ struct PromoteReplicaToMainRes {

 using PromoteReplicaToMainRpc = rpc::RequestResponse<PromoteReplicaToMainReq, PromoteReplicaToMainRes>;

-struct DemoteMainToReplicaReq {
+struct SetMainToReplicaReq {
  static const utils::TypeInfo kType;
  static const utils::TypeInfo &GetTypeInfo() { return kType; }

-  static void Load(DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
+  static void Load(SetMainToReplicaReq *self, memgraph::slk::Reader *reader);
+  static void Save(const SetMainToReplicaReq &self, memgraph::slk::Builder *builder);

-  explicit DemoteMainToReplicaReq(CoordinatorClientConfig::ReplicationClientInfo replication_client_info)
+  explicit SetMainToReplicaReq(CoordinatorClientConfig::ReplicationClientInfo replication_client_info)
      : replication_client_info(std::move(replication_client_info)) {}

-  DemoteMainToReplicaReq() = default;
+  SetMainToReplicaReq() = default;

  CoordinatorClientConfig::ReplicationClientInfo replication_client_info;
 };

-struct DemoteMainToReplicaRes {
+struct SetMainToReplicaRes {
  static const utils::TypeInfo kType;
  static const utils::TypeInfo &GetTypeInfo() { return kType; }

-  static void Load(DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
+  static void Load(SetMainToReplicaRes *self, memgraph::slk::Reader *reader);
+  static void Save(const SetMainToReplicaRes &self, memgraph::slk::Builder *builder);

-  explicit DemoteMainToReplicaRes(bool success) : success(success) {}
-  DemoteMainToReplicaRes() = default;
+  explicit SetMainToReplicaRes(bool success) : success(success) {}
+  SetMainToReplicaRes() = default;

  bool success;
 };

-using DemoteMainToReplicaRpc = rpc::RequestResponse<DemoteMainToReplicaReq, DemoteMainToReplicaRes>;
-
-struct UnregisterReplicaReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UnregisterReplicaReq *self, memgraph::slk::Reader *reader);
-  static void Save(UnregisterReplicaReq const &self, memgraph::slk::Builder *builder);
-
-  explicit UnregisterReplicaReq(std::string instance_name) : instance_name(std::move(instance_name)) {}
-
-  UnregisterReplicaReq() = default;
-
-  std::string instance_name;
-};
-
-struct UnregisterReplicaRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UnregisterReplicaRes *self, memgraph::slk::Reader *reader);
-  static void Save(const UnregisterReplicaRes &self, memgraph::slk::Builder *builder);
-
-  explicit UnregisterReplicaRes(bool success) : success(success) {}
-  UnregisterReplicaRes() = default;
-
-  bool success;
-};
-
-using UnregisterReplicaRpc = rpc::RequestResponse<UnregisterReplicaReq, UnregisterReplicaRes>;
-
-struct EnableWritingOnMainReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader);
-  static void Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder);
-
-  EnableWritingOnMainReq() = default;
-};
-
-struct EnableWritingOnMainRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
-  static void Save(EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
-
-  explicit EnableWritingOnMainRes(bool success) : success(success) {}
-  EnableWritingOnMainRes() = default;
-
-  bool success;
-};
-
-using EnableWritingOnMainRpc = rpc::RequestResponse<EnableWritingOnMainReq, EnableWritingOnMainRes>;
+using SetMainToReplicaRpc = rpc::RequestResponse<SetMainToReplicaReq, SetMainToReplicaRes>;

 }  // namespace memgraph::coordination

 // SLK serialization declarations
 namespace memgraph::slk {

-// PromoteReplicaToMainRpc
 void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader);
+
 void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);

-// DemoteMainToReplicaRpc
-void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
+void Save(const memgraph::coordination::SetMainToReplicaRes &self, memgraph::slk::Builder *builder);

-// UnregisterReplicaRpc
-void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader);
-void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader);
+void Load(memgraph::coordination::SetMainToReplicaRes *self, memgraph::slk::Reader *reader);

-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
+void Save(const memgraph::coordination::SetMainToReplicaReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::coordination::SetMainToReplicaReq *self, memgraph::slk::Reader *reader);

 }  // namespace memgraph::slk

--- a/src/coordination/include/coordination/coordinator_state.hpp
+++ b/src/coordination/include/coordination/coordinator_state.hpp
@@ -13,9 +13,10 @@

 #ifdef MG_ENTERPRISE

-#include "coordination/coordinator_instance.hpp"
+#include "coordination/coordinator_data.hpp"
+#include "coordination/coordinator_instance_status.hpp"
 #include "coordination/coordinator_server.hpp"
-#include "coordination/instance_status.hpp"
+#include "coordination/failover_status.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"

 #include <variant>
@@ -27,30 +28,25 @@ class CoordinatorState {
  CoordinatorState();
  ~CoordinatorState() = default;

-  CoordinatorState(CoordinatorState const &) = delete;
-  CoordinatorState &operator=(CoordinatorState const &) = delete;
+  CoordinatorState(const CoordinatorState &) = delete;
+  CoordinatorState &operator=(const CoordinatorState &) = delete;

  CoordinatorState(CoordinatorState &&) noexcept = delete;
  CoordinatorState &operator=(CoordinatorState &&) noexcept = delete;

-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;

-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;

-  auto ShowInstances() const -> std::vector<InstanceStatus>;
+  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;

-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
-
-  // NOTE: The client code must check that the server exists before calling this method.
+  // The client code must check that the server exists before calling this method.
  auto GetCoordinatorServer() const -> CoordinatorServer &;

- private:
-  struct CoordinatorMainReplicaData {
-    std::unique_ptr<CoordinatorServer> coordinator_server_;
-  };
+  [[nodiscard]] auto DoFailover() -> DoFailoverStatus;

-  std::variant<CoordinatorInstance, CoordinatorMainReplicaData> data_;
+ private:
+  std::variant<CoordinatorData, CoordinatorMainReplicaData> data_;
 };

 }  // namespace memgraph::coordination
--- a/src/coordination/include/coordination/failover_status.hpp
+++ b/src/coordination/include/coordination/failover_status.hpp
@@ -8,4 +8,14 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
-#include "system/include/system/system.hpp"
+
+#pragma once
+
+#ifdef MG_ENTERPRISE
+
+#include <cstdint>
+
+namespace memgraph::coordination {
+enum class DoFailoverStatus : uint8_t { SUCCESS, ALL_REPLICAS_DOWN, MAIN_ALIVE, RPC_FAILED };
+}  // namespace memgraph::coordination
+#endif
--- a/src/coordination/include/coordination/raft_state.hpp
+++ b/src/coordination/include/coordination/raft_state.hpp
@@ -1,79 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <flags/replication.hpp>
-
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using BecomeLeaderCb = std::function<void()>;
-using BecomeFollowerCb = std::function<void()>;
-
-using nuraft::buffer;
-using nuraft::logger;
-using nuraft::ptr;
-using nuraft::raft_launcher;
-using nuraft::raft_server;
-using nuraft::srv_config;
-using nuraft::state_machine;
-using nuraft::state_mgr;
-using raft_result = nuraft::cmd_result<ptr<buffer>>;
-
-class RaftState {
- private:
-  explicit RaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb, uint32_t raft_server_id,
-                     uint32_t raft_port, std::string raft_address);
-
-  auto InitRaftServer() -> void;
-
- public:
-  RaftState() = delete;
-  RaftState(RaftState const &other) = default;
-  RaftState &operator=(RaftState const &other) = default;
-  RaftState(RaftState &&other) noexcept = default;
-  RaftState &operator=(RaftState &&other) noexcept = default;
-  ~RaftState();
-
-  static auto MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState;
-
-  auto InstanceName() const -> std::string;
-  auto RaftSocketAddress() const -> std::string;
-
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
-  auto GetAllCoordinators() const -> std::vector<ptr<srv_config>>;
-
-  auto RequestLeadership() -> bool;
-  auto IsLeader() const -> bool;
-
-  auto AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result>;
-
-  // TODO: (andi) I think variables below can be abstracted
-  uint32_t raft_server_id_;
-  uint32_t raft_port_;
-  std::string raft_address_;
-
-  ptr<state_machine> state_machine_;
-  ptr<state_mgr> state_manager_;
-  ptr<raft_server> raft_server_;
-  ptr<logger> logger_;
-  raft_launcher launcher_;
-
-  BecomeLeaderCb become_leader_cb_;
-  BecomeFollowerCb become_follower_cb_;
-};
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/include/coordination/register_main_replica_coordinator_status.hpp
+++ b/src/coordination/include/coordination/register_main_replica_coordinator_status.hpp
@@ -19,30 +19,17 @@ namespace memgraph::coordination {

 enum class RegisterInstanceCoordinatorStatus : uint8_t {
  NAME_EXISTS,
-  ENDPOINT_EXISTS,
+  END_POINT_EXISTS,
  NOT_COORDINATOR,
  RPC_FAILED,
-  NOT_LEADER,
-  RAFT_COULD_NOT_ACCEPT,
-  RAFT_COULD_NOT_APPEND,
  SUCCESS
 };

-enum class UnregisterInstanceCoordinatorStatus : uint8_t {
-  NO_INSTANCE_WITH_NAME,
-  IS_MAIN,
-  NOT_COORDINATOR,
-  NOT_LEADER,
-  RPC_FAILED,
-  SUCCESS,
-};
-
 enum class SetInstanceToMainCoordinatorStatus : uint8_t {
  NO_INSTANCE_WITH_NAME,
  NOT_COORDINATOR,
  SUCCESS,
  COULD_NOT_PROMOTE_TO_MAIN,
-  SWAP_UUID_FAILED
 };

 }  // namespace memgraph::coordination
--- a/src/coordination/include/coordination/replication_instance.hpp
+++ b/src/coordination/include/coordination/replication_instance.hpp
@@ -1,93 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_client.hpp"
-#include "coordination/coordinator_exceptions.hpp"
-#include "replication_coordination_glue/role.hpp"
-
-#include <libnuraft/nuraft.hxx>
-#include "utils/uuid.hpp"
-
-namespace memgraph::coordination {
-
-class CoordinatorInstance;
-
-class ReplicationInstance {
- public:
-  ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
-                      HealthCheckCallback fail_cb);
-
-  ReplicationInstance(ReplicationInstance const &other) = delete;
-  ReplicationInstance &operator=(ReplicationInstance const &other) = delete;
-  ReplicationInstance(ReplicationInstance &&other) noexcept = delete;
-  ReplicationInstance &operator=(ReplicationInstance &&other) noexcept = delete;
-  ~ReplicationInstance() = default;
-
-  auto OnSuccessPing() -> void;
-  auto OnFailPing() -> bool;
-
-  auto IsAlive() const -> bool;
-
-  auto InstanceName() const -> std::string;
-  auto SocketAddress() const -> std::string;
-
-  auto IsReplica() const -> bool;
-  auto IsMain() const -> bool;
-
-  auto PromoteToMain(utils::UUID uuid, ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
-                     HealthCheckCallback main_fail_cb) -> bool;
-  auto DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb) -> bool;
-
-  auto StartFrequentCheck() -> void;
-  auto StopFrequentCheck() -> void;
-  auto PauseFrequentCheck() -> void;
-  auto ResumeFrequentCheck() -> void;
-
-  auto ReplicationClientInfo() const -> ReplClientInfo;
-
-  auto EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool;
-
-  auto SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool;
-  auto SendUnregisterReplicaRpc(std::string const &instance_name) -> bool;
-
-  // TODO: (andi) Inconsistent API
-  auto GetClient() -> CoordinatorClient &;
-
-  auto EnableWritingOnMain() -> bool;
-
-  auto SetNewMainUUID(utils::UUID const &main_uuid) -> void;
-  auto ResetMainUUID() -> void;
-  auto GetMainUUID() const -> const std::optional<utils::UUID> &;
-
- private:
-  CoordinatorClient client_;
-  replication_coordination_glue::ReplicationRole replication_role_;
-  std::chrono::system_clock::time_point last_response_time_{};
-  bool is_alive_{false};
-
-  // for replica this is main uuid of current main
-  // for "main" main this same as in CoordinatorData
-  // it is set to nullopt when replica is down
-  // TLDR; when replica is down and comes back up we reset uuid of main replica is listening to
-  // so we need to send swap uuid again
-  std::optional<utils::UUID> main_uuid_;
-
-  friend bool operator==(ReplicationInstance const &first, ReplicationInstance const &second) {
-    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
-  }
-};
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/include/nuraft/coordinator_log_store.hpp
+++ b/src/coordination/include/nuraft/coordinator_log_store.hpp
@@ -1,70 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::buffer;
-using nuraft::int32;
-using nuraft::int64;
-using nuraft::log_entry;
-using nuraft::log_store;
-using nuraft::ptr;
-using nuraft::raft_server;
-
-class CoordinatorLogStore : public log_store {
- public:
-  CoordinatorLogStore();
-  CoordinatorLogStore(CoordinatorLogStore const &) = delete;
-  CoordinatorLogStore &operator=(CoordinatorLogStore const &) = delete;
-  CoordinatorLogStore(CoordinatorLogStore &&) = delete;
-  CoordinatorLogStore &operator=(CoordinatorLogStore &&) = delete;
-  ~CoordinatorLogStore() override;
-
-  ulong next_slot() const override;
-
-  ulong start_index() const override;
-
-  ptr<log_entry> last_entry() const override;
-
-  ulong append(ptr<log_entry> &entry) override;
-
-  void write_at(ulong index, ptr<log_entry> &entry) override;
-
-  ptr<std::vector<ptr<log_entry>>> log_entries(ulong start, ulong end) override;
-
-  ptr<log_entry> entry_at(ulong index) override;
-
-  ulong term_at(ulong index) override;
-
-  ptr<buffer> pack(ulong index, int32 cnt) override;
-
-  void apply_pack(ulong index, buffer &pack) override;
-
-  bool compact(ulong last_log_index) override;
-
-  bool flush() override;
-
- private:
-  auto FindOrDefault_(ulong index) const -> ptr<log_entry>;
-
-  std::map<ulong, ptr<log_entry>> logs_;
-  mutable std::mutex logs_lock_;
-  std::atomic<ulong> start_idx_;
-};
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/include/nuraft/coordinator_state_machine.hpp
+++ b/src/coordination/include/nuraft/coordinator_state_machine.hpp
@@ -1,76 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <spdlog/spdlog.h>
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::async_result;
-using nuraft::buffer;
-using nuraft::buffer_serializer;
-using nuraft::cluster_config;
-using nuraft::int32;
-using nuraft::ptr;
-using nuraft::snapshot;
-using nuraft::state_machine;
-
-class CoordinatorStateMachine : public state_machine {
- public:
-  CoordinatorStateMachine() = default;
-  CoordinatorStateMachine(CoordinatorStateMachine const &) = delete;
-  CoordinatorStateMachine &operator=(CoordinatorStateMachine const &) = delete;
-  CoordinatorStateMachine(CoordinatorStateMachine &&) = delete;
-  CoordinatorStateMachine &operator=(CoordinatorStateMachine &&) = delete;
-  ~CoordinatorStateMachine() override {}
-
-  static auto EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer>;
-
-  static auto DecodeRegisterReplicationInstance(buffer &data) -> std::string;
-
-  auto pre_commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
-
-  auto commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
-
-  auto commit_config(ulong log_idx, ptr<cluster_config> & /*new_conf*/) -> void override;
-
-  auto rollback(ulong log_idx, buffer &data) -> void override;
-
-  auto read_logical_snp_obj(snapshot & /*snapshot*/, void *& /*user_snp_ctx*/, ulong /*obj_id*/, ptr<buffer> &data_out,
-                            bool &is_last_obj) -> int override;
-
-  auto save_logical_snp_obj(snapshot &s, ulong &obj_id, buffer & /*data*/, bool /*is_first_obj*/, bool /*is_last_obj*/)
-      -> void override;
-
-  auto apply_snapshot(snapshot &s) -> bool override;
-
-  auto free_user_snp_ctx(void *&user_snp_ctx) -> void override;
-
-  auto last_snapshot() -> ptr<snapshot> override;
-
-  auto last_commit_index() -> ulong override;
-
-  auto create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void override;
-
- private:
-  std::atomic<uint64_t> last_committed_idx_{0};
-
-  ptr<snapshot> last_snapshot_;
-
-  std::mutex last_snapshot_lock_;
-};
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/include/nuraft/coordinator_state_manager.hpp
+++ b/src/coordination/include/nuraft/coordinator_state_manager.hpp
@@ -1,66 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_log_store.hpp"
-
-#include <spdlog/spdlog.h>
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::cluster_config;
-using nuraft::cs_new;
-using nuraft::srv_config;
-using nuraft::srv_state;
-using nuraft::state_mgr;
-
-class CoordinatorStateManager : public state_mgr {
- public:
-  explicit CoordinatorStateManager(int srv_id, std::string const &endpoint);
-
-  CoordinatorStateManager(CoordinatorStateManager const &) = delete;
-  CoordinatorStateManager &operator=(CoordinatorStateManager const &) = delete;
-  CoordinatorStateManager(CoordinatorStateManager &&) = delete;
-  CoordinatorStateManager &operator=(CoordinatorStateManager &&) = delete;
-
-  ~CoordinatorStateManager() override = default;
-
-  auto load_config() -> ptr<cluster_config> override;
-
-  auto save_config(cluster_config const &config) -> void override;
-
-  auto save_state(srv_state const &state) -> void override;
-
-  auto read_state() -> ptr<srv_state> override;
-
-  auto load_log_store() -> ptr<log_store> override;
-
-  auto server_id() -> int32 override;
-
-  auto system_exit(int exit_code) -> void override;
-
-  auto GetSrvConfig() const -> ptr<srv_config>;
-
- private:
-  int my_id_;
-  std::string my_endpoint_;
-  ptr<CoordinatorLogStore> cur_log_store_;
-  ptr<srv_config> my_srv_config_;
-  ptr<cluster_config> cluster_config_;
-  ptr<srv_state> saved_state_;
-};
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/raft_state.cpp
+++ b/src/coordination/raft_state.cpp
@@ -1,140 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/raft_state.hpp"
-
-#include "coordination/coordinator_exceptions.hpp"
-#include "nuraft/coordinator_state_machine.hpp"
-#include "nuraft/coordinator_state_manager.hpp"
-#include "utils/counter.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::asio_service;
-using nuraft::cb_func;
-using nuraft::CbReturnCode;
-using nuraft::cmd_result;
-using nuraft::cs_new;
-using nuraft::ptr;
-using nuraft::raft_params;
-using nuraft::raft_server;
-using nuraft::srv_config;
-using raft_result = cmd_result<ptr<buffer>>;
-
-RaftState::RaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb, uint32_t raft_server_id,
-                     uint32_t raft_port, std::string raft_address)
-    : raft_server_id_(raft_server_id),
-      raft_port_(raft_port),
-      raft_address_(std::move(raft_address)),
-      state_machine_(cs_new<CoordinatorStateMachine>()),
-      state_manager_(
-          cs_new<CoordinatorStateManager>(raft_server_id_, raft_address_ + ":" + std::to_string(raft_port_))),
-      logger_(nullptr),
-      become_leader_cb_(std::move(become_leader_cb)),
-      become_follower_cb_(std::move(become_follower_cb)) {}
-
-auto RaftState::InitRaftServer() -> void {
-  asio_service::options asio_opts;
-  asio_opts.thread_pool_size_ = 1;  // TODO: (andi) Improve this
-
-  raft_params params;
-  params.heart_beat_interval_ = 100;
-  params.election_timeout_lower_bound_ = 200;
-  params.election_timeout_upper_bound_ = 400;
-  // 5 logs are preserved before the last snapshot
-  params.reserved_log_items_ = 5;
-  // Create snapshot for every 5 log appends
-  params.snapshot_distance_ = 5;
-  params.client_req_timeout_ = 3000;
-  params.return_method_ = raft_params::blocking;
-
-  raft_server::init_options init_opts;
-  init_opts.raft_callback_ = [this](cb_func::Type event_type, cb_func::Param *param) -> nuraft::CbReturnCode {
-    if (event_type == cb_func::BecomeLeader) {
-      spdlog::info("Node {} became leader", param->leaderId);
-      become_leader_cb_();
-    } else if (event_type == cb_func::BecomeFollower) {
-      spdlog::info("Node {} became follower", param->myId);
-      become_follower_cb_();
-    }
-    return CbReturnCode::Ok;
-  };
-
-  raft_launcher launcher;
-
-  raft_server_ = launcher.init(state_machine_, state_manager_, logger_, static_cast<int>(raft_port_), asio_opts, params,
-                               init_opts);
-
-  if (!raft_server_) {
-    throw RaftServerStartException("Failed to launch raft server on {}:{}", raft_address_, raft_port_);
-  }
-
-  auto maybe_stop = utils::ResettableCounter<20>();
-  do {
-    if (raft_server_->is_initialized()) {
-      return;
-    }
-    std::this_thread::sleep_for(std::chrono::milliseconds(250));
-  } while (!maybe_stop());
-
-  throw RaftServerStartException("Failed to initialize raft server on {}:{}", raft_address_, raft_port_);
-}
-
-auto RaftState::MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState {
-  uint32_t raft_server_id{0};
-  uint32_t raft_port{0};
-  try {
-    raft_server_id = FLAGS_raft_server_id;
-    raft_port = FLAGS_raft_server_port;
-  } catch (std::exception const &e) {
-    throw RaftCouldNotParseFlagsException("Failed to parse flags: {}", e.what());
-  }
-
-  auto raft_state =
-      RaftState(std::move(become_leader_cb), std::move(become_follower_cb), raft_server_id, raft_port, "127.0.0.1");
-  raft_state.InitRaftServer();
-  return raft_state;
-}
-
-RaftState::~RaftState() { launcher_.shutdown(); }
-
-auto RaftState::InstanceName() const -> std::string { return "coordinator_" + std::to_string(raft_server_id_); }
-
-auto RaftState::RaftSocketAddress() const -> std::string { return raft_address_ + ":" + std::to_string(raft_port_); }
-
-auto RaftState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void {
-  auto const endpoint = raft_address + ":" + std::to_string(raft_port);
-  srv_config const srv_config_to_add(static_cast<int>(raft_server_id), endpoint);
-  if (!raft_server_->add_srv(srv_config_to_add)->get_accepted()) {
-    throw RaftAddServerException("Failed to add server {} to the cluster", endpoint);
-  }
-  spdlog::info("Request to add server {} to the cluster accepted", endpoint);
-}
-
-auto RaftState::GetAllCoordinators() const -> std::vector<ptr<srv_config>> {
-  std::vector<ptr<srv_config>> all_srv_configs;
-  raft_server_->get_srv_config_all(all_srv_configs);
-  return all_srv_configs;
-}
-
-auto RaftState::IsLeader() const -> bool { return raft_server_->is_leader(); }
-
-auto RaftState::RequestLeadership() -> bool { return raft_server_->is_leader() || raft_server_->request_leadership(); }
-
-auto RaftState::AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result> {
-  auto new_log = CoordinatorStateMachine::EncodeRegisterReplicationInstance(instance);
-  return raft_server_->append_entries({new_log});
-}
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/coordination/replication_instance.cpp
+++ b/src/coordination/replication_instance.cpp
@@ -1,115 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/replication_instance.hpp"
-
-#include "replication_coordination_glue/handler.hpp"
-
-namespace memgraph::coordination {
-
-ReplicationInstance::ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config,
-                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
-    : client_(peer, std::move(config), std::move(succ_cb), std::move(fail_cb)),
-      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA) {
-  if (!client_.DemoteToReplica()) {
-    throw CoordinatorRegisterInstanceException("Failed to demote instance {} to replica", client_.InstanceName());
-  }
-
-  client_.StartFrequentCheck();
-}
-
-auto ReplicationInstance::OnSuccessPing() -> void {
-  last_response_time_ = std::chrono::system_clock::now();
-  is_alive_ = true;
-}
-
-auto ReplicationInstance::OnFailPing() -> bool {
-  auto elapsed_time = std::chrono::system_clock::now() - last_response_time_;
-  is_alive_ = elapsed_time < client_.InstanceDownTimeoutSec();
-  return is_alive_;
-}
-
-auto ReplicationInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
-auto ReplicationInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
-auto ReplicationInstance::IsAlive() const -> bool { return is_alive_; }
-
-auto ReplicationInstance::IsReplica() const -> bool {
-  return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
-}
-auto ReplicationInstance::IsMain() const -> bool {
-  return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
-}
-
-auto ReplicationInstance::PromoteToMain(utils::UUID new_uuid, ReplicationClientsInfo repl_clients_info,
-                                        HealthCheckCallback main_succ_cb, HealthCheckCallback main_fail_cb) -> bool {
-  if (!client_.SendPromoteReplicaToMainRpc(new_uuid, std::move(repl_clients_info))) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
-  main_uuid_ = new_uuid;
-  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));
-
-  return true;
-}
-
-auto ReplicationInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
-    -> bool {
-  if (!client_.DemoteToReplica()) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
-  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));
-
-  return true;
-}
-
-auto ReplicationInstance::StartFrequentCheck() -> void { client_.StartFrequentCheck(); }
-auto ReplicationInstance::StopFrequentCheck() -> void { client_.StopFrequentCheck(); }
-auto ReplicationInstance::PauseFrequentCheck() -> void { client_.PauseFrequentCheck(); }
-auto ReplicationInstance::ResumeFrequentCheck() -> void { client_.ResumeFrequentCheck(); }
-
-auto ReplicationInstance::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
-  return client_.ReplicationClientInfo();
-}
-
-auto ReplicationInstance::GetClient() -> CoordinatorClient & { return client_; }
-
-auto ReplicationInstance::SetNewMainUUID(utils::UUID const &main_uuid) -> void { main_uuid_ = main_uuid; }
-auto ReplicationInstance::ResetMainUUID() -> void { main_uuid_ = std::nullopt; }
-auto ReplicationInstance::GetMainUUID() const -> std::optional<utils::UUID> const & { return main_uuid_; }
-
-auto ReplicationInstance::EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool {
-  if (!main_uuid_ || *main_uuid_ != curr_main_uuid) {
-    return SendSwapAndUpdateUUID(curr_main_uuid);
-  }
-  return true;
-}
-
-auto ReplicationInstance::SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool {
-  if (!replication_coordination_glue::SendSwapMainUUIDRpc(client_.RpcClient(), new_main_uuid)) {
-    return false;
-  }
-  SetNewMainUUID(new_main_uuid);
-  return true;
-}
-
-auto ReplicationInstance::SendUnregisterReplicaRpc(std::string const &instance_name) -> bool {
-  return client_.SendUnregisterReplicaRpc(instance_name);
-}
-
-auto ReplicationInstance::EnableWritingOnMain() -> bool { return client_.SendEnableWritingOnMainRpc(); }
-
-}  // namespace memgraph::coordination
-#endif
--- a/src/dbms/CMakeLists.txt
+++ b/src/dbms/CMakeLists.txt
@@ -1,10 +1,2 @@
-add_library(mg-dbms STATIC
-        dbms_handler.cpp
-        database.cpp
-        coordinator_handler.cpp
-        inmemory/replication_handlers.cpp
-        replication_handlers.cpp
-        rpc.cpp
-
-)
-target_link_libraries(mg-dbms mg-utils mg-storage-v2 mg-query mg-auth mg-replication mg-coordination)
+add_library(mg-dbms STATIC dbms_handler.cpp database.cpp replication_handler.cpp coordinator_handler.cpp replication_client.cpp inmemory/replication_handlers.cpp coordinator_handlers.cpp)
+target_link_libraries(mg-dbms mg-utils mg-storage-v2 mg-query mg-replication mg-coordination)
--- a/src/dbms/constants.hpp
+++ b/src/dbms/constants.hpp
@@ -16,4 +16,10 @@ namespace memgraph::dbms {
 constexpr std::string_view kDefaultDB = "memgraph";        //!< Name of the default database
 constexpr std::string_view kMultiTenantDir = "databases";  //!< Name of the multi-tenant directory

+#ifdef MG_EXPERIMENTAL_REPLICATION_MULTITENANCY
+constexpr bool allow_mt_repl = true;
+#else
+constexpr bool allow_mt_repl = false;
+#endif
+
 }  // namespace memgraph::dbms
--- a/src/dbms/coordinator_handler.cpp
+++ b/src/dbms/coordinator_handler.cpp
@@ -9,41 +9,30 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.

+#include "coordination/register_main_replica_coordinator_status.hpp"
 #ifdef MG_ENTERPRISE

 #include "dbms/coordinator_handler.hpp"

-#include "coordination/register_main_replica_coordinator_status.hpp"
+#include "dbms/dbms_handler.hpp"

 namespace memgraph::dbms {

-CoordinatorHandler::CoordinatorHandler(coordination::CoordinatorState &coordinator_state)
-    : coordinator_state_(coordinator_state) {}
+CoordinatorHandler::CoordinatorHandler(DbmsHandler &dbms_handler) : dbms_handler_(dbms_handler) {}

-auto CoordinatorHandler::RegisterReplicationInstance(memgraph::coordination::CoordinatorClientConfig config)
+auto CoordinatorHandler::RegisterInstance(memgraph::coordination::CoordinatorClientConfig config)
    -> coordination::RegisterInstanceCoordinatorStatus {
-  return coordinator_state_.RegisterReplicationInstance(config);
+  return dbms_handler_.CoordinatorState().RegisterInstance(config);
 }

-auto CoordinatorHandler::UnregisterReplicationInstance(std::string instance_name)
-    -> coordination::UnregisterInstanceCoordinatorStatus {
-  return coordinator_state_.UnregisterReplicationInstance(std::move(instance_name));
-}
-
-auto CoordinatorHandler::SetReplicationInstanceToMain(std::string instance_name)
+auto CoordinatorHandler::SetInstanceToMain(std::string instance_name)
    -> coordination::SetInstanceToMainCoordinatorStatus {
-  return coordinator_state_.SetReplicationInstanceToMain(std::move(instance_name));
+  return dbms_handler_.CoordinatorState().SetInstanceToMain(std::move(instance_name));
 }

-auto CoordinatorHandler::ShowInstances() const -> std::vector<coordination::InstanceStatus> {
-  return coordinator_state_.ShowInstances();
+auto CoordinatorHandler::ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus> {
+  return dbms_handler_.CoordinatorState().ShowInstances();
 }
-
-auto CoordinatorHandler::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
-    -> void {
-  coordinator_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
-}
-
 }  // namespace memgraph::dbms

 #endif
--- a/src/dbms/coordinator_handler.hpp
+++ b/src/dbms/coordinator_handler.hpp
@@ -13,11 +13,15 @@

 #ifdef MG_ENTERPRISE

+#include "utils/result.hpp"
+
 #include "coordination/coordinator_config.hpp"
-#include "coordination/coordinator_state.hpp"
-#include "coordination/instance_status.hpp"
+#include "coordination/coordinator_instance_status.hpp"
+#include "coordination/failover_status.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"

+#include <cstdint>
+#include <optional>
 #include <vector>

 namespace memgraph::dbms {
@@ -26,23 +30,17 @@ class DbmsHandler;

 class CoordinatorHandler {
 public:
-  explicit CoordinatorHandler(coordination::CoordinatorState &coordinator_state);
+  explicit CoordinatorHandler(DbmsHandler &dbms_handler);

-  // TODO: (andi) When moving coordinator state on same instances, rename from RegisterReplicationInstance to
-  // RegisterInstance
-  auto RegisterReplicationInstance(coordination::CoordinatorClientConfig config)
+  auto RegisterInstance(coordination::CoordinatorClientConfig config)
      -> coordination::RegisterInstanceCoordinatorStatus;

-  auto UnregisterReplicationInstance(std::string instance_name) -> coordination::UnregisterInstanceCoordinatorStatus;
+  auto SetInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;

-  auto SetReplicationInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
-
-  auto ShowInstances() const -> std::vector<coordination::InstanceStatus>;
-
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
+  auto ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus>;

 private:
-  coordination::CoordinatorState &coordinator_state_;
+  DbmsHandler &dbms_handler_;
 };

 }  // namespace memgraph::dbms
--- a/src/dbms/coordinator_handlers.cpp
+++ b/src/dbms/coordinator_handlers.cpp
@@ -0,0 +1,155 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#ifdef MG_ENTERPRISE
+
+#include "dbms/coordinator_handlers.hpp"
+#include "dbms/utils.hpp"
+
+#include "coordination/coordinator_exceptions.hpp"
+#include "coordination/coordinator_rpc.hpp"
+#include "dbms/dbms_handler.hpp"
+#include "dbms/replication_client.hpp"
+
+#include "range/v3/view.hpp"
+
+namespace memgraph::dbms {
+
+void CoordinatorHandlers::Register(DbmsHandler &dbms_handler) {
+  auto &server = dbms_handler.CoordinatorState().GetCoordinatorServer();
+
+  server.Register<coordination::PromoteReplicaToMainRpc>(
+      [&dbms_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
+        spdlog::info("Received PromoteReplicaToMainRpc");
+        CoordinatorHandlers::PromoteReplicaToMainHandler(dbms_handler, req_reader, res_builder);
+      });
+
+  server.Register<coordination::SetMainToReplicaRpc>(
+      [&dbms_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
+        spdlog::info("Received SetMainToReplicaRpc from coordinator server");
+        CoordinatorHandlers::SetMainToReplicaHandler(dbms_handler, req_reader, res_builder);
+      });
+}
+
+void CoordinatorHandlers::SetMainToReplicaHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader,
+                                                  slk::Builder *res_builder) {
+  auto &repl_state = dbms_handler.ReplicationState();
+  spdlog::info("Executing SetMainToReplicaHandler");
+
+  if (repl_state.IsReplica()) {
+    spdlog::error("Setting to replica must be performed on main.");
+    slk::Save(coordination::SetMainToReplicaRes{false}, res_builder);
+    return;
+  }
+
+  coordination::SetMainToReplicaReq req;
+  slk::Load(&req, req_reader);
+
+  const replication::ReplicationServerConfig clients_config{
+      .ip_address = req.replication_client_info.replication_ip_address,
+      .port = req.replication_client_info.replication_port};
+
+  if (bool success = memgraph::dbms::SetReplicationRoleReplica(dbms_handler, clients_config); !success) {
+    spdlog::error("Setting main to replica failed!");
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+    return;
+  }
+
+  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
+}
+
+void CoordinatorHandlers::PromoteReplicaToMainHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader,
+                                                      slk::Builder *res_builder) {
+  auto &repl_state = dbms_handler.ReplicationState();
+
+  if (!repl_state.IsReplica()) {
+    spdlog::error("Only replica can be promoted to main!");
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+    return;
+  }
+
+  auto repl_server_config = std::get<replication::RoleReplicaData>(repl_state.ReplicationData()).config;
+
+  // This can fail because of disk. If it does, the cluster state could get inconsistent.
+  // We don't handle disk issues.
+  if (bool success = memgraph::dbms::DoReplicaToMainPromotion(dbms_handler); !success) {
+    spdlog::error("Promoting replica to main failed!");
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+    return;
+  }
+
+  coordination::PromoteReplicaToMainReq req;
+  slk::Load(&req, req_reader);
+
+  auto const converter = [](const auto &repl_info_config) {
+    return replication::ReplicationClientConfig{
+        .name = repl_info_config.instance_name,
+        .mode = repl_info_config.replication_mode,
+        .ip_address = repl_info_config.replication_ip_address,
+        .port = repl_info_config.replication_port,
+    };
+  };
+
+  MG_ASSERT(
+      std::get<replication::RoleMainData>(repl_state.ReplicationData()).registered_replicas_.empty(),
+      "No replicas should be registered after promoting replica to main and before registering replication clients!");
+
+  // registering replicas
+  for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
+    auto instance_client = repl_state.RegisterReplica(config);
+    if (instance_client.HasError()) {
+      switch (instance_client.GetError()) {
+        // Can't happen, we are already replica
+        case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+          spdlog::error("Failover must be performed to main!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        // Can't happen, checked on the coordinator side
+        case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
+          spdlog::error("Replica with the same name already exists!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        // Can't happen, checked on the coordinator side
+        case memgraph::replication::RegisterReplicaError::ENDPOINT_EXISTS:
+          spdlog::error("Replica with the same endpoint already exists!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        // We don't handle disk issues
+        case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+          spdlog::error("Registered replica could not be persisted!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        case memgraph::replication::RegisterReplicaError::SUCCESS:
+          break;
+      }
+    }
+    if (!allow_mt_repl && dbms_handler.All().size() > 1) {
+      spdlog::warn("Multi-tenant replication is currently not supported!");
+    }
+
+    auto &instance_client_ref = *instance_client.GetValue();
+
+    // Update system before enabling individual storage <-> replica clients
+    dbms_handler.SystemRestore(instance_client_ref);
+
+    // TODO: (andi) Policy for register all databases
+    // Will be resolved after deciding about choosing new replica
+    const bool all_clients_good = memgraph::dbms::RegisterAllDatabasesClients(dbms_handler, instance_client_ref);
+    MG_ASSERT(all_clients_good, "Failed to register one or more databases to the REPLICA \"{}\".", config.name);
+
+    StartReplicaClient(dbms_handler, instance_client_ref);
+  }
+
+  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
+}
+
+}  // namespace memgraph::dbms
+#endif
--- a/src/dbms/coordinator_handlers.hpp
+++ b/src/dbms/coordinator_handlers.hpp
@@ -11,22 +11,24 @@

 #pragma once

-#include "gflags/gflags.h"
+#ifdef MG_ENTERPRISE

-// Short help flag.
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_string(experimental_enabled);
+#include "slk/serialization.hpp"

-namespace memgraph::flags {
+namespace memgraph::dbms {

-// Each bit is an enabled experiment
-// old experiments can be reused once code cleanup has happened
-enum class Experiments : uint8_t {
-  SYSTEM_REPLICATION = 1 << 0,
+class DbmsHandler;
+
+class CoordinatorHandlers {
+ public:
+  static void Register(DbmsHandler &dbms_handler);
+
+ private:
+  static void PromoteReplicaToMainHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader,
+                                          slk::Builder *res_builder);
+  static void SetMainToReplicaHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 };

-bool AreExperimentsEnabled(Experiments experiments);
+}  // namespace memgraph::dbms

-void InitializeExperimental();
-
-}  // namespace memgraph::flags
+#endif
--- a/src/dbms/database.cpp
+++ b/src/dbms/database.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -11,7 +11,10 @@

 #include "dbms/database.hpp"
 #include "dbms/inmemory/storage_helper.hpp"
+#include "dbms/replication_handler.hpp"
+#include "flags/storage_mode.hpp"
 #include "storage/v2/disk/storage.hpp"
+#include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/storage_mode.hpp"

 template struct memgraph::utils::Gatekeeper<memgraph::dbms::Database>;
--- a/src/dbms/dbms_handler.cpp
+++ b/src/dbms/dbms_handler.cpp
@@ -11,76 +11,29 @@

 #include "dbms/dbms_handler.hpp"

+#include "dbms/coordinator_handlers.hpp"
+#include "flags/replication.hpp"
+
 #include <cstdint>
 #include <filesystem>

 #include "dbms/constants.hpp"
 #include "dbms/global.hpp"
-#include "flags/experimental.hpp"
+#include "dbms/replication_client.hpp"
 #include "spdlog/spdlog.h"
-#include "system/include/system/system.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/logging.hpp"
 #include "utils/uuid.hpp"

 namespace memgraph::dbms {

+#ifdef MG_ENTERPRISE
+
 namespace {
-constexpr std::string_view kDBPrefix = "database:";  // Key prefix for database durability
-
-std::string RegisterReplicaErrorToString(query::RegisterReplicaError error) {
-  switch (error) {
-    using enum query::RegisterReplicaError;
-    case NAME_EXISTS:
-      return "NAME_EXISTS";
-    case ENDPOINT_EXISTS:
-      return "ENDPOINT_EXISTS";
-    case CONNECTION_FAILED:
-      return "CONNECTION_FAILED";
-    case COULD_NOT_BE_PERSISTED:
-      return "COULD_NOT_BE_PERSISTED";
-    case ERROR_ACCEPTING_MAIN:
-      return "ERROR_ACCEPTING_MAIN";
-  }
-}
-
-// Per storage
-// NOTE Storage will connect to all replicas. Future work might change this
-void RestoreReplication(replication::RoleMainData &mainData, DatabaseAccess db_acc) {
-  spdlog::info("Restoring replication role.");
-
-  // Each individual client has already been restored and started. Here we just go through each database and start its
-  // client
-  for (auto &instance_client : mainData.registered_replicas_) {
-    spdlog::info("Replica {} restoration started for {}.", instance_client.name_, db_acc->name());
-    const auto &ret = db_acc->storage()->repl_storage_state_.replication_clients_.WithLock(
-        [&, db_acc](auto &storage_clients) mutable -> utils::BasicResult<query::RegisterReplicaError> {
-          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client, mainData.uuid_);
-          auto *storage = db_acc->storage();
-          client->Start(storage, std::move(db_acc));
-          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
-          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
-          // Failed to start due to branching of MAIN and REPLICA
-          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
-            spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
-                         instance_client.name_);
-          }
-          storage_clients.push_back(std::move(client));
-          return {};
-        });
-
-    if (ret.HasError()) {
-      MG_ASSERT(query::RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
-      LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
-                RegisterReplicaErrorToString(ret.GetError()));
-    }
-    spdlog::info("Replica {} restored for {}.", instance_client.name_, db_acc->name());
-  }
-  spdlog::info("Replication role restored to MAIN.");
-}
+constexpr std::string_view kDBPrefix = "database:";                               // Key prefix for database durability
+constexpr std::string_view kLastCommitedSystemTsKey = "last_commited_system_ts";  // Key for timestamp durability
 }  // namespace

-#ifdef MG_ENTERPRISE
 struct Durability {
  enum class DurabilityVersion : uint8_t {
    V0 = 0,
@@ -159,9 +112,11 @@ struct Durability {
  }
 };

-DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &repl_state, auth::SynchedAuth &auth,
-                         bool recovery_on_startup)
-    : default_config_{std::move(config)}, auth_{auth}, repl_state_{repl_state} {
+DbmsHandler::DbmsHandler(
+    storage::Config config,
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+    bool recovery_on_startup)
+    : default_config_{std::move(config)}, repl_state_{ReplicationStateRootPath(default_config_)} {
  // TODO: Decouple storage config from dbms config
  // TODO: Save individual db configs inside the kvstore and restore from there

@@ -195,13 +150,19 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
      const auto uuid = json.at("uuid").get<utils::UUID>();
      const auto rel_dir = json.at("rel_dir").get<std::filesystem::path>();
      spdlog::info("Restoring database {} at {}.", name, rel_dir);
-      auto new_db = New_(name, uuid, nullptr, rel_dir);
+      auto new_db = New_(name, uuid, rel_dir);
      MG_ASSERT(!new_db.HasError(), "Failed while creating database {}.", name);
      directories.emplace(rel_dir.filename());
      spdlog::info("Database {} restored.", name);
    }
+    // Read the last timestamp
+    auto lcst = durability_->Get(kLastCommitedSystemTsKey);
+    if (lcst) {
+      last_commited_system_timestamp_ = std::stoul(*lcst);
+      system_timestamp_ = last_commited_system_timestamp_;
+    }
  } else {  // Clear databases from the durability list and auth
-    auto locked_auth = auth_.Lock();
+    auto locked_auth = auth->Lock();
    auto it = durability_->begin(std::string{kDBPrefix});
    auto end = durability_->end(std::string{kDBPrefix});
    for (; it != end; ++it) {
@@ -211,6 +172,8 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
      locked_auth->DeleteDatabase(name);
      durability_->Delete(key);
    }
+    // Delete the last timestamp
+    durability_->Delete(kLastCommitedSystemTsKey);
  }

  /*
@@ -235,31 +198,45 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
   */
  // Setup the default DB
  SetupDefault_();
+
+  /*
+   * REPLICATION RECOVERY AND STARTUP
+   */
+  // Startup replication state (if recovered at startup)
+  auto replica = [this](replication::RoleReplicaData const &data) { return StartRpcServer(*this, data); };
+  // Replication recovery and frequent check start
+  auto main = [this](replication::RoleMainData &data) {
+    for (auto &client : data.registered_replicas_) {
+      SystemRestore(client);
+    }
+    ForEach([this](DatabaseAccess db) { RecoverReplication(db); });
+    for (auto &client : data.registered_replicas_) {
+      StartReplicaClient(*this, client);
+    }
+    return true;
+  };
+  // Startup proccess for main/replica
+  MG_ASSERT(std::visit(memgraph::utils::Overloaded{replica, main}, repl_state_.ReplicationData()),
+            "Replica recovery failure!");
+
+  // Warning
+  if (default_config_.durability.snapshot_wal_mode == storage::Config::Durability::SnapshotWalMode::DISABLED &&
+      repl_state_.IsMain()) {
+    spdlog::warn(
+        "The instance has the MAIN replication role, but durability logs and snapshots are disabled. Please "
+        "consider "
+        "enabling durability by using --storage-snapshot-interval-sec and --storage-wal-enabled flags because "
+        "without write-ahead logs this instance is not replicating any data.");
+  }
+
+  // MAIN or REPLICA instance
+  if (FLAGS_coordinator_server_port) {
+    CoordinatorHandlers::Register(*this);
+    MG_ASSERT(coordinator_state_.GetCoordinatorServer().Start(), "Failed to start coordinator server!");
+  }
 }

-struct DropDatabase : memgraph::system::ISystemAction {
-  explicit DropDatabase(utils::UUID uuid) : uuid_{uuid} {}
-  void DoDurability() override { /* Done during DBMS execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const storage::replication::DropDatabaseRes &response) {
-      return response.result != storage::replication::DropDatabaseRes::Result::FAILURE;
-    };
-
-    return client.SteamAndFinalizeDelta<storage::replication::DropDatabaseRpc>(
-        check_response, main_uuid, std::string(epoch.id()), txn.last_committed_system_timestamp(), txn.timestamp(),
-        uuid_);
-  }
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  utils::UUID uuid_;
-};
-
-DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name, system::Transaction *transaction) {
+DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name) {
  std::lock_guard<LockT> wr(lock_);
  if (db_name == kDefaultDB) {
    // MSG cannot delete the default db
@@ -296,10 +273,9 @@ DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name, syste

  // Success
  // Save delta
-  if (transaction) {
-    transaction->AddAction<DropDatabase>(uuid);
+  if (system_transaction_) {
+    system_transaction_->delta.emplace(SystemTransaction::Delta::drop_database, uuid);
  }
-
  return {};
 }

@@ -320,50 +296,18 @@ DbmsHandler::DeleteResult DbmsHandler::Delete(utils::UUID uuid) {
  return Delete_(db_name);
 }

-struct CreateDatabase : memgraph::system::ISystemAction {
-  explicit CreateDatabase(storage::SalientConfig config, DatabaseAccess db_acc)
-      : config_{std::move(config)}, db_acc(db_acc) {}
-
-  void DoDurability() override {
-    // Done during dbms execution
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const storage::replication::CreateDatabaseRes &response) {
-      return response.result != storage::replication::CreateDatabaseRes::Result::FAILURE;
-    };
-
-    return client.SteamAndFinalizeDelta<storage::replication::CreateDatabaseRpc>(
-        check_response, main_uuid, std::string(epoch.id()), txn.last_committed_system_timestamp(), txn.timestamp(),
-        config_);
-  }
-
-  void PostReplication(replication::RoleMainData &mainData) const override {
-    // Sync database with REPLICAs
-    // NOTE: The function bellow is used to create ReplicationStorageClient, so it must be called on a new storage
-    // We don't need to have it here, since the function won't fail even if the replication client fails to
-    // connect We will just have everything ready, for recovery at some point.
-    dbms::DbmsHandler::RecoverStorageReplication(db_acc, mainData);
-  }
-
- private:
-  storage::SalientConfig config_;
-  DatabaseAccess db_acc;
-};
-
-DbmsHandler::NewResultT DbmsHandler::New_(storage::Config storage_config, system::Transaction *txn) {
+DbmsHandler::NewResultT DbmsHandler::New_(storage::Config storage_config) {
  auto new_db = db_handler_.New(storage_config, repl_state_);

  if (new_db.HasValue()) {  // Success
                            // Save delta
-    UpdateDurability(storage_config);
-    if (txn) {
-      txn->AddAction<CreateDatabase>(storage_config.salient, new_db.GetValue());
+    if (system_transaction_) {
+      system_transaction_->delta.emplace(SystemTransaction::Delta::create_database, storage_config.salient);
    }
+    UpdateDurability(storage_config);
+    return new_db.GetValue();
  }
-  return new_db;
+  return new_db.GetError();
 }

 DbmsHandler::DeleteResult DbmsHandler::Delete_(std::string_view db_name) {
@@ -417,19 +361,89 @@ void DbmsHandler::UpdateDurability(const storage::Config &config, std::optional<
  durability_->Put(key, val);
 }

-#endif
+AllSyncReplicaStatus DbmsHandler::Commit() {
+  if (system_transaction_ == std::nullopt || system_transaction_->delta == std::nullopt)
+    return AllSyncReplicaStatus::AllCommitsConfirmed;  // Nothing to commit
+  const auto &delta = *system_transaction_->delta;

-void DbmsHandler::RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data) {
-  using enum memgraph::flags::Experiments;
-  auto const is_enterprise = license::global_license_checker.IsEnterpriseValidFast();
-  auto experimental_system_replication = flags::AreExperimentsEnabled(SYSTEM_REPLICATION);
-  if ((is_enterprise && experimental_system_replication) || db_acc->name() == dbms::kDefaultDB) {
-    // Handle global replication state
-    spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
-    // RECOVER REPLICA CONNECTIONS
-    memgraph::dbms::RestoreReplication(role_main_data, db_acc);
-  } else if (!role_main_data.registered_replicas_.empty()) {
-    spdlog::warn("Multi-tenant replication is currently not supported!");
+  auto sync_status = AllSyncReplicaStatus::AllCommitsConfirmed;
+  // TODO Create a system client that can handle all of this automatically
+  switch (delta.action) {
+    using enum SystemTransaction::Delta::Action;
+    case CREATE_DATABASE: {
+      // Replication
+      auto main_handler = [&](memgraph::replication::RoleMainData &main_data) {
+        // TODO: data race issue? registered_replicas_ access not protected
+        // This is sync in any case, as this is the startup
+        for (auto &client : main_data.registered_replicas_) {
+          bool completed = SteamAndFinalizeDelta<storage::replication::CreateDatabaseRpc>(
+              client,
+              [](const storage::replication::CreateDatabaseRes &response) {
+                return response.result != storage::replication::CreateDatabaseRes::Result::FAILURE;
+              },
+              std::string(main_data.epoch_.id()), last_commited_system_timestamp_,
+              system_transaction_->system_timestamp, delta.config);
+          // TODO: reduce duplicate code
+          if (!completed && client.mode_ == replication_coordination_glue::ReplicationMode::SYNC) {
+            sync_status = AllSyncReplicaStatus::SomeCommitsUnconfirmed;
+          }
+        }
+        // Sync database with REPLICAs
+        RecoverReplication(Get_(delta.config.name));
+      };
+      auto replica_handler = [](memgraph::replication::RoleReplicaData &) { /* Nothing to do */ };
+      std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
+    } break;
+    case DROP_DATABASE: {
+      // Replication
+      auto main_handler = [&](memgraph::replication::RoleMainData &main_data) {
+        // TODO: data race issue? registered_replicas_ access not protected
+        // This is sync in any case, as this is the startup
+        for (auto &client : main_data.registered_replicas_) {
+          bool completed = SteamAndFinalizeDelta<storage::replication::DropDatabaseRpc>(
+              client,
+              [](const storage::replication::DropDatabaseRes &response) {
+                return response.result != storage::replication::DropDatabaseRes::Result::FAILURE;
+              },
+              std::string(main_data.epoch_.id()), last_commited_system_timestamp_,
+              system_transaction_->system_timestamp, delta.uuid);
+          // TODO: reduce duplicate code
+          if (!completed && client.mode_ == replication_coordination_glue::ReplicationMode::SYNC) {
+            sync_status = AllSyncReplicaStatus::SomeCommitsUnconfirmed;
+          }
+        }
+      };
+      auto replica_handler = [](memgraph::replication::RoleReplicaData &) { /* Nothing to do */ };
+      std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
+    } break;
  }
+
+  durability_->Put(kLastCommitedSystemTsKey, std::to_string(system_transaction_->system_timestamp));
+  last_commited_system_timestamp_ = system_transaction_->system_timestamp;
+  ResetSystemTransaction();
+  return sync_status;
 }
+
+#else  // not MG_ENTERPRISE
+
+AllSyncReplicaStatus DbmsHandler::Commit() {
+  if (system_transaction_ == std::nullopt || system_transaction_->delta == std::nullopt) {
+    return AllSyncReplicaStatus::AllCommitsConfirmed;  // Nothing to commit
+  }
+  const auto &delta = *system_transaction_->delta;
+
+  switch (delta.action) {
+    using enum SystemTransaction::Delta::Action;
+    case CREATE_DATABASE:
+    case DROP_DATABASE:
+      /* Community edition doesn't support multi-tenant replication */
+      break;
+  }
+
+  last_commited_system_timestamp_ = system_transaction_->system_timestamp;
+  ResetSystemTransaction();
+  return AllSyncReplicaStatus::AllCommitsConfirmed;
+}
+
+#endif
 }  // namespace memgraph::dbms
--- a/src/dbms/dbms_handler.hpp
+++ b/src/dbms/dbms_handler.hpp
@@ -25,25 +25,24 @@
 #include "constants.hpp"
 #include "dbms/database.hpp"
 #include "dbms/inmemory/replication_handlers.hpp"
-#include "dbms/rpc.hpp"
+#include "dbms/replication_handler.hpp"
 #include "kvstore/kvstore.hpp"
-#include "license/license.hpp"
 #include "replication/replication_client.hpp"
-#include "replication_coordination_glue/handler.hpp"
 #include "storage/v2/config.hpp"
+#include "storage/v2/replication/enums.hpp"
+#include "storage/v2/replication/rpc.hpp"
 #include "storage/v2/transaction.hpp"
-#include "system/system.hpp"
 #include "utils/thread_pool.hpp"
 #ifdef MG_ENTERPRISE
 #include "coordination/coordinator_state.hpp"
 #include "dbms/database_handler.hpp"
 #endif
+#include "dbms/transaction.hpp"
 #include "global.hpp"
 #include "query/config.hpp"
 #include "query/interpreter_context.hpp"
 #include "spdlog/spdlog.h"
 #include "storage/v2/isolation_level.hpp"
-#include "system/system.hpp"
 #include "utils/logging.hpp"
 #include "utils/result.hpp"
 #include "utils/rw_lock.hpp"
@@ -52,6 +51,11 @@

 namespace memgraph::dbms {

+enum class AllSyncReplicaStatus {
+  AllCommitsConfirmed,
+  SomeCommitsUnconfirmed,
+};
+
 struct Statistics {
  uint64_t num_vertex;           //!< Sum of vertexes in every database
  uint64_t num_edges;            //!< Sum of edges in every database
@@ -107,7 +111,8 @@ class DbmsHandler {
   * @param auth pointer to the global authenticator
   * @param recovery_on_startup restore databases (and its content) and authentication data
   */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state, auth::SynchedAuth &auth,
+  DbmsHandler(storage::Config config,
+              memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
              bool recovery_on_startup);  // TODO If more arguments are added use a config struct
 #else
  /**
@@ -115,13 +120,15 @@ class DbmsHandler {
   *
   * @param configs storage configuration
   */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state)
-      : repl_state_{repl_state},
+  DbmsHandler(storage::Config config)
+      : repl_state_{ReplicationStateRootPath(config)},
        db_gatekeeper_{[&] {
                         config.salient.name = kDefaultDB;
                         return std::move(config);
                       }(),
-                       repl_state_} {}
+                       repl_state_} {
+    RecoverReplication(Get());
+  }
 #endif

 #ifdef MG_ENTERPRISE
@@ -131,10 +138,10 @@ class DbmsHandler {
   * @param name name of the database
   * @return NewResultT context on success, error on failure
   */
-  NewResultT New(const std::string &name, system::Transaction *txn = nullptr) {
+  NewResultT New(const std::string &name) {
    std::lock_guard<LockT> wr(lock_);
    const auto uuid = utils::UUID{};
-    return New_(name, uuid, txn);
+    return New_(name, uuid);
  }

  /**
@@ -227,7 +234,7 @@ class DbmsHandler {
   * @param db_name database name
   * @return DeleteResult error on failure
   */
-  DeleteResult TryDelete(std::string_view db_name, system::Transaction *transaction = nullptr);
+  DeleteResult TryDelete(std::string_view db_name);

  /**
   * @brief Delete or defer deletion of database.
@@ -267,29 +274,16 @@ class DbmsHandler {
  bool IsReplica() const { return repl_state_.IsReplica(); }

 #ifdef MG_ENTERPRISE
-  // coordination::CoordinatorState &CoordinatorState() { return coordinator_state_; }
+  coordination::CoordinatorState &CoordinatorState() { return coordinator_state_; }
 #endif

-  /**
-   * @brief Return all active databases.
-   *
-   * @return std::vector<std::string>
-   */
-  auto Count() const -> std::size_t {
-#ifdef MG_ENTERPRISE
-    std::shared_lock<LockT> rd(lock_);
-    return db_handler_.size();
-#else
-    return 1;
-#endif
-  }
-
  /**
   * @brief Return the statistics all databases.
   *
   * @return Statistics
   */
-  Statistics Stats(memgraph::replication_coordination_glue::ReplicationRole replication_role) {
+  Statistics Stats() {
+    auto const replication_role = repl_state_.GetRole();
    Statistics stats{};
    // TODO: Handle overflow?
 #ifdef MG_ENTERPRISE
@@ -325,7 +319,8 @@ class DbmsHandler {
   *
   * @return std::vector<DatabaseInfo>
   */
-  std::vector<DatabaseInfo> Info(memgraph::replication_coordination_glue::ReplicationRole replication_role) {
+  std::vector<DatabaseInfo> Info() {
+    auto const replication_role = repl_state_.GetRole();
    std::vector<DatabaseInfo> res;
 #ifdef MG_ENTERPRISE
    std::shared_lock<LockT> rd(lock_);
@@ -412,18 +407,99 @@ class DbmsHandler {
    }
  }

-  static void RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data);
-
-  auto default_config() const -> storage::Config const & {
-#ifdef MG_ENTERPRISE
-    return default_config_;
-#else
-    const auto acc = db_gatekeeper_.access();
-    MG_ASSERT(acc, "Failed to get default database!");
-    return acc->get()->config();
-#endif
+  void NewSystemTransaction() {
+    DMG_ASSERT(!system_transaction_, "Already running a system transaction");
+    system_transaction_.emplace(++system_timestamp_);
  }

+  void ResetSystemTransaction() { system_transaction_.reset(); }
+
+  //! \tparam RPC An rpc::RequestResponse
+  //! \tparam Args the args type
+  //! \param client the client to use for rpc communication
+  //! \param check predicate to check response is ok
+  //! \param args arguments to forward to the rpc request
+  //! \return If replica stream is completed or enqueued
+  template <typename RPC, typename... Args>
+  bool SteamAndFinalizeDelta(auto &client, auto &&check, Args &&...args) {
+    try {
+      auto stream = client.rpc_client_.template Stream<RPC>(std::forward<Args>(args)...);
+      auto task = [&client, check = std::forward<decltype(check)>(check), stream = std::move(stream)]() mutable {
+        if (stream.IsDefunct()) {
+          client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+          return false;
+        }
+        try {
+          if (check(stream.AwaitResponse())) {
+            return true;
+          }
+        } catch (memgraph::rpc::GenericRpcFailedException const &e) {
+          // swallow error, fallthrough to error handling
+        }
+        // This replica needs SYSTEM recovery
+        client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+        return false;
+      };
+
+      if (client.mode_ == memgraph::replication_coordination_glue::ReplicationMode::ASYNC) {
+        client.thread_pool_.AddTask([task = utils::CopyMovableFunctionWrapper{std::move(task)}]() mutable { task(); });
+        return true;
+      }
+
+      return task();
+    } catch (memgraph::rpc::GenericRpcFailedException const &e) {
+      // This replica needs SYSTEM recovery
+      client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+      return false;
+    }
+  };
+
+  AllSyncReplicaStatus Commit();
+
+  auto LastCommitedTS() const -> uint64_t { return last_commited_system_timestamp_; }
+  void SetLastCommitedTS(uint64_t new_ts) { last_commited_system_timestamp_.store(new_ts); }
+
+#ifdef MG_ENTERPRISE
+  // When being called by intepreter no need to gain lock, it should already be under a system transaction
+  // But concurrently the FrequentCheck is running and will need to lock before reading last_commited_system_timestamp_
+  template <bool REQUIRE_LOCK = false>
+  void SystemRestore(replication::ReplicationClient &client) {
+    // Check if system is up to date
+    if (client.state_.WithLock(
+            [](auto &state) { return state == memgraph::replication::ReplicationClient::State::READY; }))
+      return;
+
+    // Try to recover...
+    {
+      auto [database_configs, last_commited_system_timestamp] = std::invoke([&] {
+        auto sys_guard =
+            std::unique_lock{system_lock_, std::defer_lock};  // ensure no other system transaction in progress
+        if constexpr (REQUIRE_LOCK) {
+          sys_guard.lock();
+        }
+        auto configs = std::vector<storage::SalientConfig>{};
+        ForEach([&configs](DatabaseAccess acc) { configs.emplace_back(acc->config().salient); });
+        return std::pair{configs, last_commited_system_timestamp_.load()};
+      });
+      try {
+        auto stream = client.rpc_client_.Stream<storage::replication::SystemRecoveryRpc>(last_commited_system_timestamp,
+                                                                                         std::move(database_configs));
+        const auto response = stream.AwaitResponse();
+        if (response.result == storage::replication::SystemRecoveryRes::Result::FAILURE) {
+          client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+          return;
+        }
+      } catch (memgraph::rpc::GenericRpcFailedException const &e) {
+        client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+        return;
+      }
+    }
+
+    // Successfully recovered
+    client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::READY; });
+  }
+#endif
+
 private:
 #ifdef MG_ENTERPRISE
  /**
@@ -448,8 +524,7 @@ class DbmsHandler {
   * @param uuid undelying RocksDB directory
   * @return NewResultT context on success, error on failure
   */
-  NewResultT New_(std::string_view name, utils::UUID uuid, system::Transaction *txn = nullptr,
-                  std::optional<std::filesystem::path> rel_dir = {}) {
+  NewResultT New_(std::string_view name, utils::UUID uuid, std::optional<std::filesystem::path> rel_dir = {}) {
    auto config_copy = default_config_;
    config_copy.salient.name = name;
    config_copy.salient.uuid = uuid;
@@ -460,7 +535,7 @@ class DbmsHandler {
      storage::UpdatePaths(config_copy,
                           default_config_.durability.storage_directory / kMultiTenantDir / std::string{uuid});
    }
-    return New_(std::move(config_copy), txn);
+    return New_(std::move(config_copy));
  }

  /**
@@ -469,11 +544,11 @@ class DbmsHandler {
   * @param config configuration to be used
   * @return NewResultT context on success, error on failure
   */
-  NewResultT New_(const storage::SalientConfig &config, system::Transaction *txn = nullptr) {
+  NewResultT New_(const storage::SalientConfig &config) {
    auto config_copy = default_config_;
    config_copy.salient = config;  // name, uuid, mode, etc
    UpdatePaths(config_copy, config_copy.durability.storage_directory / kMultiTenantDir / std::string{config.uuid});
-    return New_(std::move(config_copy), txn);
+    return New_(std::move(config_copy));
  }

  /**
@@ -482,7 +557,7 @@ class DbmsHandler {
   * @param storage_config storage configuration
   * @return NewResultT context on success, error on failure
   */
-  DbmsHandler::NewResultT New_(storage::Config storage_config, system::Transaction *txn = nullptr);
+  NewResultT New_(storage::Config storage_config);

  // TODO: new overload of Delete_ with DatabaseAccess
  DeleteResult Delete_(std::string_view db_name);
@@ -497,8 +572,7 @@ class DbmsHandler {
      Get(kDefaultDB);
    } catch (const UnknownDatabaseException &) {
      // No default DB restored, create it
-      MG_ASSERT(New_(kDefaultDB, {/* random UUID */}, nullptr, ".").HasValue(),
-                "Failed while creating the default database");
+      MG_ASSERT(New_(kDefaultDB, {/* random UUID */}, ".").HasValue(), "Failed while creating the default database");
    }

    // For back-compatibility...
@@ -585,21 +659,35 @@ class DbmsHandler {
  }
 #endif

+  void RecoverReplication(DatabaseAccess db_acc) {
+    if (allow_mt_repl || db_acc->name() == dbms::kDefaultDB) {
+      // Handle global replication state
+      spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
+      // RECOVER REPLICA CONNECTIONS
+      memgraph::dbms::RestoreReplication(repl_state_, std::move(db_acc));
+    } else if (const ::memgraph::replication::RoleMainData *data =
+                   std::get_if<::memgraph::replication::RoleMainData>(&repl_state_.ReplicationData());
+               data && !data->registered_replicas_.empty()) {
+      spdlog::warn("Multi-tenant replication is currently not supported!");
+    }
+  }
+
 #ifdef MG_ENTERPRISE
  mutable LockT lock_{utils::RWLock::Priority::READ};  //!< protective lock
  storage::Config default_config_;                     //!< Storage configuration used when creating new databases
  DatabaseHandler db_handler_;                         //!< multi-tenancy storage handler
-  // TODO: move to be common
-  std::unique_ptr<kvstore::KVStore> durability_;  //!< list of active dbs (pointer so we can postpone its creation)
-  auth::SynchedAuth &auth_;                       //!< Synchronized auth::Auth
+  std::unique_ptr<kvstore::KVStore> durability_;       //!< list of active dbs (pointer so we can postpone its creation)
+  coordination::CoordinatorState coordinator_state_;  //!< Replication coordinator
 #endif
+  // TODO: Make an api
+ public:
+  utils::ResourceLock system_lock_{};  //!> Ensure exclusive access for system queries
 private:
-  // NOTE: atm the only reason this exists here, is because we pass it into the construction of New Database's
-  //       Database only uses it as a convience to make the correct Access without out needing to be told the
-  //       current replication role. TODO: make Database Access explicit about the role and remove this from
-  //       dbms stuff
-  replication::ReplicationState &repl_state_;  //!< Ref to global replication state
-
+  std::optional<SystemTransaction> system_transaction_;      //!< Current system transaction (only one at a time)
+  uint64_t system_timestamp_{storage::kTimestampInitialId};  //!< System timestamp
+  std::atomic_uint64_t last_commited_system_timestamp_{
+      storage::kTimestampInitialId};          //!< Last commited system timestamp
+  replication::ReplicationState repl_state_;  //!< Global replication state
 #ifndef MG_ENTERPRISE
  mutable utils::Gatekeeper<Database> db_gatekeeper_;  //!< Single databases gatekeeper
 #endif
--- a/src/dbms/handler.hpp
+++ b/src/dbms/handler.hpp
@@ -144,8 +144,6 @@ class Handler {
  auto cbegin() const { return items_.cbegin(); }
  auto cend() const { return items_.cend(); }

-  auto size() const { return items_.size(); }
-
  struct string_hash {
    using is_transparent = void;
    [[nodiscard]] size_t operator()(const char *s) const { return std::hash<std::string_view>{}(s); }
--- a/src/dbms/inmemory/replication_handlers.cpp
+++ b/src/dbms/inmemory/replication_handlers.cpp
@@ -76,110 +76,58 @@ std::optional<DatabaseAccess> GetDatabaseAccessor(dbms::DbmsHandler *dbms_handle
    return std::nullopt;
  }
 }
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req) {
-  spdlog::error("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : "");
-}
 }  // namespace

-void InMemoryReplicationHandlers::Register(dbms::DbmsHandler *dbms_handler, replication::RoleReplicaData &data) {
-  auto &server = *data.server;
-  server.rpc_server_.Register<storage::replication::HeartbeatRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received HeartbeatRpc");
-        InMemoryReplicationHandlers::HeartbeatHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
+void InMemoryReplicationHandlers::Register(dbms::DbmsHandler *dbms_handler, replication::ReplicationServer &server) {
+  server.rpc_server_.Register<storage::replication::HeartbeatRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received HeartbeatRpc");
+    InMemoryReplicationHandlers::HeartbeatHandler(dbms_handler, req_reader, res_builder);
+  });
  server.rpc_server_.Register<storage::replication::AppendDeltasRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
+      [dbms_handler](auto *req_reader, auto *res_builder) {
        spdlog::debug("Received AppendDeltasRpc");
-        InMemoryReplicationHandlers::AppendDeltasHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::SnapshotRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received SnapshotRpc");
-        InMemoryReplicationHandlers::SnapshotHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::WalFilesRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received WalFilesRpc");
-        InMemoryReplicationHandlers::WalFilesHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::CurrentWalRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received CurrentWalRpc");
-        InMemoryReplicationHandlers::CurrentWalHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::TimestampRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received TimestampRpc");
-        InMemoryReplicationHandlers::TimestampHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<replication_coordination_glue::SwapMainUUIDRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received SwapMainUUIDHandler");
-        InMemoryReplicationHandlers::SwapMainUUIDHandler(dbms_handler, data, req_reader, res_builder);
+        InMemoryReplicationHandlers::AppendDeltasHandler(dbms_handler, req_reader, res_builder);
      });
+  server.rpc_server_.Register<storage::replication::SnapshotRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received SnapshotRpc");
+    InMemoryReplicationHandlers::SnapshotHandler(dbms_handler, req_reader, res_builder);
+  });
+  server.rpc_server_.Register<storage::replication::WalFilesRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received WalFilesRpc");
+    InMemoryReplicationHandlers::WalFilesHandler(dbms_handler, req_reader, res_builder);
+  });
+  server.rpc_server_.Register<storage::replication::CurrentWalRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received CurrentWalRpc");
+    InMemoryReplicationHandlers::CurrentWalHandler(dbms_handler, req_reader, res_builder);
+  });
+  server.rpc_server_.Register<storage::replication::TimestampRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received TimestampRpc");
+    InMemoryReplicationHandlers::TimestampHandler(dbms_handler, req_reader, res_builder);
+  });
 }

-void InMemoryReplicationHandlers::SwapMainUUIDHandler(dbms::DbmsHandler *dbms_handler,
-                                                      replication::RoleReplicaData &role_replica_data,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!dbms_handler->IsReplica()) {
-    spdlog::error("Setting main uuid must be performed on replica.");
-    slk::Save(replication_coordination_glue::SwapMainUUIDRes{false}, res_builder);
-    return;
-  }
-
-  replication_coordination_glue::SwapMainUUIDReq req;
-  slk::Load(&req, req_reader);
-  spdlog::info(fmt::format("Set replica data UUID  to main uuid {}", std::string(req.uuid)));
-  dbms_handler->ReplicationState().TryPersistRoleReplica(role_replica_data.config, req.uuid);
-  role_replica_data.uuid_ = req.uuid;
-
-  slk::Save(replication_coordination_glue::SwapMainUUIDRes{true}, res_builder);
-}
-
-void InMemoryReplicationHandlers::HeartbeatHandler(dbms::DbmsHandler *dbms_handler,
-                                                   const std::optional<utils::UUID> &current_main_uuid,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::HeartbeatHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                   slk::Builder *res_builder) {
  storage::replication::HeartbeatReq req;
  slk::Load(&req, req_reader);
  auto const db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
+  if (!db_acc) {
+    storage::replication::HeartbeatRes res{false, 0, ""};
+    slk::Save(res, res_builder);
+    return;
+  }

-  if (!current_main_uuid.has_value() || req.main_uuid != *current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::HeartbeatReq::kType.name);
-    storage::replication::HeartbeatRes res{false, 0, ""};
-    slk::Save(res, res_builder);
-    return;
-  }
  // TODO: this handler is agnostic of InMemory, move to be reused by on-disk
-  if (!db_acc.has_value()) {
-    spdlog::warn("No database accessor");
-    storage::replication::HeartbeatRes res{false, 0, ""};
-    slk::Save(res, res_builder);
-    return;
-  }
  auto const *storage = db_acc->get()->storage();
  storage::replication::HeartbeatRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load(),
                                         std::string{storage->repl_storage_state_.epoch_.id()}};
  slk::Save(res, res_builder);
 }

-void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_handler,
-                                                      const std::optional<utils::UUID> &current_main_uuid,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                      slk::Builder *res_builder) {
  storage::replication::AppendDeltasReq req;
  slk::Load(&req, req_reader);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::AppendDeltasReq::kType.name);
-    storage::replication::AppendDeltasRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
-
  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
  if (!db_acc) {
    storage::replication::AppendDeltasRes res{false, 0};
@@ -239,9 +187,8 @@ void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_ha
  spdlog::debug("Replication recovery from append deltas finished, replica is now up to date!");
 }

-void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handler,
-                                                  const std::optional<utils::UUID> &current_main_uuid,
-                                                  slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                  slk::Builder *res_builder) {
  storage::replication::SnapshotReq req;
  slk::Load(&req, req_reader);
  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -250,12 +197,6 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
    slk::Save(res, res_builder);
    return;
  }
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::SnapshotReq::kType.name);
-    storage::replication::SnapshotRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }

  storage::replication::Decoder decoder(req_reader);

@@ -329,9 +270,8 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
  spdlog::debug("Replication recovery from snapshot finished!");
 }

-void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handler,
-                                                  const std::optional<utils::UUID> &current_main_uuid,
-                                                  slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                  slk::Builder *res_builder) {
  storage::replication::WalFilesReq req;
  slk::Load(&req, req_reader);
  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -340,12 +280,6 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
    slk::Save(res, res_builder);
    return;
  }
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::WalFilesReq::kType.name);
-    storage::replication::WalFilesRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }

  const auto wal_file_number = req.file_number;
  spdlog::debug("Received WAL files: {}", wal_file_number);
@@ -364,9 +298,8 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
  spdlog::debug("Replication recovery from WAL files ended successfully, replica is now up to date!");
 }

-void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_handler,
-                                                    const std::optional<utils::UUID> &current_main_uuid,
-                                                    slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                    slk::Builder *res_builder) {
  storage::replication::CurrentWalReq req;
  slk::Load(&req, req_reader);
  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -376,13 +309,6 @@ void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_hand
    return;
  }

-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::CurrentWalReq::kType.name);
-    storage::replication::CurrentWalRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
-
  storage::replication::Decoder decoder(req_reader);

  auto *storage = static_cast<storage::InMemoryStorage *>(db_acc->get()->storage());
@@ -444,9 +370,8 @@ void InMemoryReplicationHandlers::LoadWal(storage::InMemoryStorage *storage, sto
  }
 }

-void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handler,
-                                                   const std::optional<utils::UUID> &current_main_uuid,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                   slk::Builder *res_builder) {
  storage::replication::TimestampReq req;
  slk::Load(&req, req_reader);
  auto const db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -456,13 +381,6 @@ void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handl
    return;
  }

-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::TimestampReq::kType.name);
-    storage::replication::CurrentWalRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
-
  // TODO: this handler is agnostic of InMemory, move to be reused by on-disk
  auto const *storage = db_acc->get()->storage();
  storage::replication::TimestampRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load()};
--- a/src/dbms/inmemory/replication_handlers.hpp
+++ b/src/dbms/inmemory/replication_handlers.hpp
@@ -12,7 +12,6 @@
 #pragma once

 #include "replication/replication_server.hpp"
-#include "replication/state.hpp"
 #include "storage/v2/replication/serialization.hpp"

 namespace memgraph::storage {
@@ -24,30 +23,21 @@ class DbmsHandler;

 class InMemoryReplicationHandlers {
 public:
-  static void Register(dbms::DbmsHandler *dbms_handler, replication::RoleReplicaData &data);
+  static void Register(dbms::DbmsHandler *dbms_handler, replication::ReplicationServer &server);

 private:
  // RPC handlers
-  static void HeartbeatHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                               slk::Reader *req_reader, slk::Builder *res_builder);
+  static void HeartbeatHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);

-  static void AppendDeltasHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                                  slk::Reader *req_reader, slk::Builder *res_builder);
+  static void AppendDeltasHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);

-  static void SnapshotHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                              slk::Reader *req_reader, slk::Builder *res_builder);
+  static void SnapshotHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);

-  static void WalFilesHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                              slk::Reader *req_reader, slk::Builder *res_builder);
+  static void WalFilesHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);

-  static void CurrentWalHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                                slk::Reader *req_reader, slk::Builder *res_builder);
+  static void CurrentWalHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);

-  static void TimestampHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                               slk::Reader *req_reader, slk::Builder *res_builder);
-
-  static void SwapMainUUIDHandler(dbms::DbmsHandler *dbms_handler, replication::RoleReplicaData &role_replica_data,
-                                  slk::Reader *req_reader, slk::Builder *res_builder);
+  static void TimestampHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);

  static void LoadWal(storage::InMemoryStorage *storage, storage::replication::Decoder *decoder);

--- a/src/dbms/inmemory/storage_helper.hpp
+++ b/src/dbms/inmemory/storage_helper.hpp
@@ -11,6 +11,10 @@

 #pragma once

+#include <variant>
+
+#include "dbms/constants.hpp"
+#include "dbms/replication_handler.hpp"
 #include "replication/state.hpp"
 #include "storage/v2/config.hpp"
 #include "storage/v2/inmemory/storage.hpp"
--- a/src/dbms/replication_client.cpp
+++ b/src/dbms/replication_client.cpp
@@ -0,0 +1,43 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "dbms/replication_client.hpp"
+#include "replication/replication_client.hpp"
+
+namespace memgraph::dbms {
+
+void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client) {
+  // No client error, start instance level client
+  auto const &endpoint = client.rpc_client_.Endpoint();
+  spdlog::trace("Replication client started at: {}:{}", endpoint.address, endpoint.port);
+  client.StartFrequentCheck([&dbms_handler](bool reconnect, replication::ReplicationClient &client) {
+    // Working connection
+    // Check if system needs restoration
+    if (reconnect) {
+      client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+    }
+#ifdef MG_ENTERPRISE
+    dbms_handler.SystemRestore<true>(client);
+#endif
+    // Check if any database has been left behind
+    dbms_handler.ForEach([&name = client.name_, reconnect](dbms::DatabaseAccess db_acc) {
+      // Specific database <-> replica client
+      db_acc->storage()->repl_storage_state_.WithClient(name, [&](storage::ReplicationStorageClient *client) {
+        if (reconnect || client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+          // Database <-> replica might be behind, check and recover
+          client->TryCheckReplicaStateAsync(db_acc->storage(), db_acc);
+        }
+      });
+    });
+  });
+}  // namespace memgraph::dbms
+
+}  // namespace memgraph::dbms
--- a/src/dbms/replication_client.hpp
+++ b/src/dbms/replication_client.hpp
@@ -8,4 +8,14 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
-#include "system/include/system/action.hpp"
+
+#pragma once
+
+#include "dbms/dbms_handler.hpp"
+#include "replication/replication_client.hpp"
+
+namespace memgraph::dbms {
+
+void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client);
+
+}  // namespace memgraph::dbms
--- a/src/dbms/replication_handler.cpp
+++ b/src/dbms/replication_handler.cpp
@@ -0,0 +1,400 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "dbms/replication_handler.hpp"
+
+#include <algorithm>
+
+#include "dbms/constants.hpp"
+#include "dbms/dbms_handler.hpp"
+#include "dbms/global.hpp"
+#include "dbms/inmemory/replication_handlers.hpp"
+#include "dbms/replication_client.hpp"
+#include "dbms/utils.hpp"
+#include "replication/messages.hpp"
+#include "replication/state.hpp"
+#include "spdlog/spdlog.h"
+#include "storage/v2/config.hpp"
+#include "storage/v2/replication/rpc.hpp"
+#include "utils/on_scope_exit.hpp"
+
+using memgraph::replication::RoleMainData;
+using memgraph::replication::RoleReplicaData;
+
+namespace memgraph::dbms {
+
+namespace {
+
+std::string RegisterReplicaErrorToString(RegisterReplicaError error) {
+  switch (error) {
+    using enum RegisterReplicaError;
+    case NAME_EXISTS:
+      return "NAME_EXISTS";
+    case ENDPOINT_EXISTS:
+      return "ENDPOINT_EXISTS";
+    case CONNECTION_FAILED:
+      return "CONNECTION_FAILED";
+    case COULD_NOT_BE_PERSISTED:
+      return "COULD_NOT_BE_PERSISTED";
+  }
+}
+}  // namespace
+
+ReplicationHandler::ReplicationHandler(DbmsHandler &dbms_handler) : dbms_handler_(dbms_handler) {}
+
+bool ReplicationHandler::SetReplicationRoleMain() {
+  auto const main_handler = [](RoleMainData &) {
+    // If we are already MAIN, we don't want to change anything
+    return false;
+  };
+
+  auto const replica_handler = [this](RoleReplicaData const &) {
+    return memgraph::dbms::DoReplicaToMainPromotion(dbms_handler_);
+  };
+
+  // TODO: under lock
+  return std::visit(utils::Overloaded{main_handler, replica_handler},
+                    dbms_handler_.ReplicationState().ReplicationData());
+}
+
+bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config) {
+  // We don't want to restart the server if we're already a REPLICA
+  if (dbms_handler_.ReplicationState().IsReplica()) {
+    return false;
+  }
+
+  // TODO StorageState needs to be synched. Could have a dangling reference if someone adds a database as we are
+  //      deleting the replica.
+  // Remove database specific clients
+  dbms_handler_.ForEach([&](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    storage->repl_storage_state_.replication_clients_.WithLock([](auto &clients) { clients.clear(); });
+  });
+  // Remove instance level clients
+  std::get<RoleMainData>(dbms_handler_.ReplicationState().ReplicationData()).registered_replicas_.clear();
+
+  // Creates the server
+  dbms_handler_.ReplicationState().SetReplicationRoleReplica(config);
+
+  // Start
+  const auto success =
+      std::visit(utils::Overloaded{[](RoleMainData const &) {
+                                     // ASSERT
+                                     return false;
+                                   },
+                                   [this](RoleReplicaData const &data) { return StartRpcServer(dbms_handler_, data); }},
+                 dbms_handler_.ReplicationState().ReplicationData());
+  // TODO Handle error (restore to main?)
+  return success;
+}
+
+auto ReplicationHandler::RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+    -> memgraph::utils::BasicResult<RegisterReplicaError> {
+  MG_ASSERT(dbms_handler_.ReplicationState().IsMain(), "Only main instance can register a replica!");
+
+  auto maybe_client = dbms_handler_.ReplicationState().RegisterReplica(config);
+  if (maybe_client.HasError()) {
+    switch (maybe_client.GetError()) {
+      case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+        MG_ASSERT(false, "Only main instance can register a replica!");
+        return {};
+      case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
+        return memgraph::dbms::RegisterReplicaError::NAME_EXISTS;
+      case memgraph::replication::RegisterReplicaError::ENDPOINT_EXISTS:
+        return memgraph::dbms::RegisterReplicaError::ENDPOINT_EXISTS;
+      case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+        return memgraph::dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+      case memgraph::replication::RegisterReplicaError::SUCCESS:
+        break;
+    }
+  }
+
+  if (!allow_mt_repl && dbms_handler_.All().size() > 1) {
+    spdlog::warn("Multi-tenant replication is currently not supported!");
+  }
+
+#ifdef MG_ENTERPRISE
+  // Update system before enabling individual storage <-> replica clients
+  dbms_handler_.SystemRestore(*maybe_client.GetValue());
+#endif
+
+  const auto dbms_error = memgraph::dbms::HandleRegisterReplicaStatus(maybe_client);
+  if (dbms_error.has_value()) {
+    return *dbms_error;
+  }
+  auto &instance_client_ptr = maybe_client.GetValue();
+  const bool all_clients_good = memgraph::dbms::RegisterAllDatabasesClients(dbms_handler_, *instance_client_ptr);
+
+  // NOTE Currently if any databases fails, we revert back
+  if (!all_clients_good) {
+    spdlog::error("Failed to register all databases on the REPLICA \"{}\"", config.name);
+    UnregisterReplica(config.name);
+    return RegisterReplicaError::CONNECTION_FAILED;
+  }
+
+  // No client error, start instance level client
+  StartReplicaClient(dbms_handler_, *instance_client_ptr);
+  return {};
+}
+
+auto ReplicationHandler::UnregisterReplica(std::string_view name) -> UnregisterReplicaResult {
+  auto const replica_handler = [](RoleReplicaData const &) -> UnregisterReplicaResult {
+    return UnregisterReplicaResult::NOT_MAIN;
+  };
+  auto const main_handler = [this, name](RoleMainData &mainData) -> UnregisterReplicaResult {
+    if (!dbms_handler_.ReplicationState().TryPersistUnregisterReplica(name)) {
+      return UnregisterReplicaResult::COULD_NOT_BE_PERSISTED;
+    }
+    // Remove database specific clients
+    dbms_handler_.ForEach([name](DatabaseAccess db_acc) {
+      db_acc->storage()->repl_storage_state_.replication_clients_.WithLock([&name](auto &clients) {
+        std::erase_if(clients, [name](const auto &client) { return client->Name() == name; });
+      });
+    });
+    // Remove instance level clients
+    auto const n_unregistered =
+        std::erase_if(mainData.registered_replicas_, [name](auto const &client) { return client.name_ == name; });
+    return n_unregistered != 0 ? UnregisterReplicaResult::SUCCESS : UnregisterReplicaResult::CAN_NOT_UNREGISTER;
+  };
+
+  return std::visit(utils::Overloaded{main_handler, replica_handler},
+                    dbms_handler_.ReplicationState().ReplicationData());
+}
+
+auto ReplicationHandler::GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole {
+  return dbms_handler_.ReplicationState().GetRole();
+}
+
+bool ReplicationHandler::IsMain() const { return dbms_handler_.ReplicationState().IsMain(); }
+
+bool ReplicationHandler::IsReplica() const { return dbms_handler_.ReplicationState().IsReplica(); }
+
+// Per storage
+// NOTE Storage will connect to all replicas. Future work might change this
+void RestoreReplication(replication::ReplicationState &repl_state, DatabaseAccess db_acc) {
+  spdlog::info("Restoring replication role.");
+
+  /// MAIN
+  auto const recover_main = [db_acc = std::move(db_acc)](RoleMainData &mainData) mutable {  // NOLINT
+    // Each individual client has already been restored and started. Here we just go through each database and start its
+    // client
+    for (auto &instance_client : mainData.registered_replicas_) {
+      spdlog::info("Replica {} restoration started for {}.", instance_client.name_, db_acc->name());
+      const auto &ret = db_acc->storage()->repl_storage_state_.replication_clients_.WithLock(
+          [&, db_acc](auto &storage_clients) mutable -> utils::BasicResult<RegisterReplicaError> {
+            auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
+            auto *storage = db_acc->storage();
+            client->Start(storage, std::move(db_acc));
+            // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
+            // MAYBE_BEHIND isn't a statement of the current state, this is the default value
+            // Failed to start due to branching of MAIN and REPLICA
+            if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+              spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
+                           instance_client.name_);
+            }
+            storage_clients.push_back(std::move(client));
+            return {};
+          });
+
+      if (ret.HasError()) {
+        MG_ASSERT(RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
+        LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
+                  RegisterReplicaErrorToString(ret.GetError()));
+      }
+      spdlog::info("Replica {} restored for {}.", instance_client.name_, db_acc->name());
+    }
+    spdlog::info("Replication role restored to MAIN.");
+  };
+
+  /// REPLICA
+  auto const recover_replica = [](RoleReplicaData const &data) { /*nothing to do*/ };
+
+  std::visit(
+      utils::Overloaded{
+          recover_main,
+          recover_replica,
+      },
+      repl_state.ReplicationData());
+}
+
+namespace system_replication {
+#ifdef MG_ENTERPRISE
+void SystemHeartbeatHandler(const uint64_t ts, slk::Reader *req_reader, slk::Builder *res_builder) {
+  replication::SystemHeartbeatReq req;
+  replication::SystemHeartbeatReq::Load(&req, req_reader);
+
+  replication::SystemHeartbeatRes res(ts);
+  memgraph::slk::Save(res, res_builder);
+}
+
+void CreateDatabaseHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
+  memgraph::storage::replication::CreateDatabaseReq req;
+  memgraph::slk::Load(&req, req_reader);
+
+  using memgraph::storage::replication::CreateDatabaseRes;
+  CreateDatabaseRes res(CreateDatabaseRes::Result::FAILURE);
+
+  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
+  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
+  //       If MAIN has changed we need to check this new group_timestamp is consistent with
+  //       what we have so far.
+
+  if (req.expected_group_timestamp != dbms_handler.LastCommitedTS()) {
+    spdlog::debug("CreateDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
+                  dbms_handler.LastCommitedTS());
+    memgraph::slk::Save(res, res_builder);
+    return;
+  }
+
+  try {
+    // Create new
+    auto new_db = dbms_handler.Update(req.config);
+    if (new_db.HasValue()) {
+      // Successfully create db
+      dbms_handler.SetLastCommitedTS(req.new_group_timestamp);
+      res = CreateDatabaseRes(CreateDatabaseRes::Result::SUCCESS);
+      spdlog::debug("CreateDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
+    }
+  } catch (...) {
+    // Failure
+  }
+
+  memgraph::slk::Save(res, res_builder);
+}
+
+void DropDatabaseHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
+  memgraph::storage::replication::DropDatabaseReq req;
+  memgraph::slk::Load(&req, req_reader);
+
+  using memgraph::storage::replication::DropDatabaseRes;
+  DropDatabaseRes res(DropDatabaseRes::Result::FAILURE);
+
+  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
+  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
+  //       If MAIN has changed we need to check this new group_timestamp is consistent with
+  //       what we have so far.
+
+  if (req.expected_group_timestamp != dbms_handler.LastCommitedTS()) {
+    spdlog::debug("DropDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
+                  dbms_handler.LastCommitedTS());
+    memgraph::slk::Save(res, res_builder);
+    return;
+  }
+
+  try {
+    // NOTE: Single communication channel can exist at a time, no other database can be deleted/created at the moment.
+    auto new_db = dbms_handler.Delete(req.uuid);
+    if (new_db.HasError()) {
+      if (new_db.GetError() == DeleteError::NON_EXISTENT) {
+        // Nothing to drop
+        dbms_handler.SetLastCommitedTS(req.new_group_timestamp);
+        res = DropDatabaseRes(DropDatabaseRes::Result::NO_NEED);
+      }
+    } else {
+      // Successfully drop db
+      dbms_handler.SetLastCommitedTS(req.new_group_timestamp);
+      res = DropDatabaseRes(DropDatabaseRes::Result::SUCCESS);
+      spdlog::debug("DropDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
+    }
+  } catch (...) {
+    // Failure
+  }
+
+  memgraph::slk::Save(res, res_builder);
+}
+
+void SystemRecoveryHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
+  // TODO Speed up
+  memgraph::storage::replication::SystemRecoveryReq req;
+  memgraph::slk::Load(&req, req_reader);
+
+  using memgraph::storage::replication::SystemRecoveryRes;
+  SystemRecoveryRes res(SystemRecoveryRes::Result::FAILURE);
+
+  utils::OnScopeExit send_on_exit([&]() { memgraph::slk::Save(res, res_builder); });
+
+  // Get all current dbs
+  auto old = dbms_handler.All();
+
+  // Check/create the incoming dbs
+  for (const auto &config : req.database_configs) {
+    // Missing db
+    try {
+      if (dbms_handler.Update(config).HasError()) {
+        spdlog::debug("SystemRecoveryHandler: Failed to update database \"{}\".", config.name);
+        return;  // Send failure on exit
+      }
+    } catch (const UnknownDatabaseException &) {
+      spdlog::debug("SystemRecoveryHandler: UnknownDatabaseException");
+      return;  // Send failure on exit
+    }
+    const auto it = std::find(old.begin(), old.end(), config.name);
+    if (it != old.end()) old.erase(it);
+  }
+
+  // Delete all the leftover old dbs
+  for (const auto &remove_db : old) {
+    const auto del = dbms_handler.Delete(remove_db);
+    if (del.HasError()) {
+      // Some errors are not terminal
+      if (del.GetError() == DeleteError::DEFAULT_DB || del.GetError() == DeleteError::NON_EXISTENT) {
+        spdlog::debug("SystemRecoveryHandler: Dropped database \"{}\".", remove_db);
+        continue;
+      }
+      spdlog::debug("SystemRecoveryHandler: Failed to drop database \"{}\".", remove_db);
+      return;  // Send failure on exit
+    }
+  }
+  // Successfully recovered
+  dbms_handler.SetLastCommitedTS(req.forced_group_timestamp);
+  spdlog::debug("SystemRecoveryHandler: SUCCESS updated LCTS to {}", req.forced_group_timestamp);
+  res = SystemRecoveryRes(SystemRecoveryRes::Result::SUCCESS);
+}
+#endif
+
+void Register(replication::RoleReplicaData const &data, dbms::DbmsHandler &dbms_handler) {
+#ifdef MG_ENTERPRISE
+  data.server->rpc_server_.Register<replication::SystemHeartbeatRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received SystemHeartbeatRpc");
+        SystemHeartbeatHandler(dbms_handler.LastCommitedTS(), req_reader, res_builder);
+      });
+  data.server->rpc_server_.Register<storage::replication::CreateDatabaseRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received CreateDatabaseRpc");
+        CreateDatabaseHandler(dbms_handler, req_reader, res_builder);
+      });
+  data.server->rpc_server_.Register<storage::replication::DropDatabaseRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received DropDatabaseRpc");
+        DropDatabaseHandler(dbms_handler, req_reader, res_builder);
+      });
+  data.server->rpc_server_.Register<storage::replication::SystemRecoveryRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received SystemRecoveryRpc");
+        SystemRecoveryHandler(dbms_handler, req_reader, res_builder);
+      });
+#endif
+}
+}  // namespace system_replication
+
+bool StartRpcServer(DbmsHandler &dbms_handler, const replication::RoleReplicaData &data) {
+  // Register handlers
+  InMemoryReplicationHandlers::Register(&dbms_handler, *data.server);
+  system_replication::Register(data, dbms_handler);
+  // Start server
+  if (!data.server->Start()) {
+    spdlog::error("Unable to start the replication server.");
+    return false;
+  }
+  return true;
+}
+}  // namespace memgraph::dbms
--- a/src/dbms/replication_handler.hpp
+++ b/src/dbms/replication_handler.hpp
@@ -0,0 +1,82 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "replication_coordination_glue/role.hpp"
+#include "dbms/database.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::replication {
+struct ReplicationState;
+struct ReplicationServerConfig;
+struct ReplicationClientConfig;
+}  // namespace memgraph::replication
+
+namespace memgraph::dbms {
+
+class DbmsHandler;
+
+enum class RegisterReplicaError : uint8_t { NAME_EXISTS, ENDPOINT_EXISTS, CONNECTION_FAILED, COULD_NOT_BE_PERSISTED };
+
+enum class UnregisterReplicaResult : uint8_t {
+  NOT_MAIN,
+  COULD_NOT_BE_PERSISTED,
+  CAN_NOT_UNREGISTER,
+  SUCCESS,
+};
+
+/// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
+/// TODO: extend to do multiple storages
+struct ReplicationHandler {
+  explicit ReplicationHandler(DbmsHandler &dbms_handler);
+
+  // as REPLICA, become MAIN
+  bool SetReplicationRoleMain();
+
+  // as MAIN, become REPLICA
+  bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config);
+
+  // as MAIN, define and connect to REPLICAs
+  auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+      -> utils::BasicResult<RegisterReplicaError>;
+
+  // as MAIN, remove a REPLICA connection
+  auto UnregisterReplica(std::string_view name) -> UnregisterReplicaResult;
+
+  // Helper pass-through (TODO: remove)
+  auto GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole;
+  bool IsMain() const;
+  bool IsReplica() const;
+
+ private:
+  DbmsHandler &dbms_handler_;
+};
+
+/// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
+/// TODO: extend to do multiple storages
+void RestoreReplication(replication::ReplicationState &repl_state, DatabaseAccess db_acc);
+
+namespace system_replication {
+// System handlers
+#ifdef MG_ENTERPRISE
+void CreateDatabaseHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
+void SystemHeartbeatHandler(uint64_t ts, slk::Reader *req_reader, slk::Builder *res_builder);
+void SystemRecoveryHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
+#endif
+
+/// Register all DBMS level RPC handlers
+void Register(replication::RoleReplicaData const &data, DbmsHandler &dbms_handler);
+}  // namespace system_replication
+
+bool StartRpcServer(DbmsHandler &dbms_handler, const replication::RoleReplicaData &data);
+
+}  // namespace memgraph::dbms
--- a/src/dbms/replication_handlers.cpp
+++ b/src/dbms/replication_handlers.cpp
@@ -1,205 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "dbms/replication_handlers.hpp"
-
-#include "dbms/database.hpp"
-#include "dbms/dbms_handler.hpp"
-#include "storage/v2/storage.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::dbms {
-
-#ifdef MG_ENTERPRISE
-
-void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                           slk::Reader *req_reader, slk::Builder *res_builder) {
-  using memgraph::storage::replication::CreateDatabaseRes;
-  CreateDatabaseRes res(CreateDatabaseRes::Result::FAILURE);
-
-  // Ignore if no license
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    spdlog::error("Handling CreateDatabase, an enterprise RPC message, without license.");
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  memgraph::storage::replication::CreateDatabaseReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, memgraph::storage::replication::CreateDatabaseReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("CreateDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Create new
-    auto new_db = dbms_handler.Update(req.config);
-    if (new_db.HasValue()) {
-      // Successfully create db
-      system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-      res = CreateDatabaseRes(CreateDatabaseRes::Result::SUCCESS);
-      spdlog::debug("CreateDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-    }
-  } catch (...) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                         slk::Reader *req_reader, slk::Builder *res_builder) {
-  using memgraph::storage::replication::DropDatabaseRes;
-  DropDatabaseRes res(DropDatabaseRes::Result::FAILURE);
-
-  // Ignore if no license
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    spdlog::error("Handling DropDatabase, an enterprise RPC message, without license.");
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  memgraph::storage::replication::DropDatabaseReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, memgraph::storage::replication::DropDatabaseReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("DropDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // NOTE: Single communication channel can exist at a time, no other database can be deleted/created at the moment.
-    auto new_db = dbms_handler.Delete(req.uuid);
-    if (new_db.HasError()) {
-      if (new_db.GetError() == DeleteError::NON_EXISTENT) {
-        // Nothing to drop
-        system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-        res = DropDatabaseRes(DropDatabaseRes::Result::NO_NEED);
-      }
-    } else {
-      // Successfully drop db
-      system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-      res = DropDatabaseRes(DropDatabaseRes::Result::SUCCESS);
-      spdlog::debug("DropDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-    }
-  } catch (...) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-bool SystemRecoveryHandler(DbmsHandler &dbms_handler, const std::vector<storage::SalientConfig> &database_configs) {
-  /*
-   * NO LICENSE
-   */
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    spdlog::error("Handling SystemRecovery, an enterprise RPC message, without license.");
-    for (const auto &config : database_configs) {
-      // Only handle default DB
-      if (config.name != kDefaultDB) continue;
-      try {
-        if (dbms_handler.Update(config).HasError()) {
-          return false;
-        }
-      } catch (const UnknownDatabaseException &) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /*
-   * MULTI-TENANCY
-   */
-  // Get all current dbs
-  auto old = dbms_handler.All();
-  // Check/create the incoming dbs
-  for (const auto &config : database_configs) {
-    // Missing db
-    try {
-      if (dbms_handler.Update(config).HasError()) {
-        spdlog::debug("SystemRecoveryHandler: Failed to update database \"{}\".", config.name);
-        return false;
-      }
-    } catch (const UnknownDatabaseException &) {
-      spdlog::debug("SystemRecoveryHandler: UnknownDatabaseException");
-      return false;
-    }
-    const auto it = std::find(old.begin(), old.end(), config.name);
-    if (it != old.end()) old.erase(it);
-  }
-
-  // Delete all the leftover old dbs
-  for (const auto &remove_db : old) {
-    const auto del = dbms_handler.Delete(remove_db);
-    if (del.HasError()) {
-      // Some errors are not terminal
-      if (del.GetError() == DeleteError::DEFAULT_DB || del.GetError() == DeleteError::NON_EXISTENT) {
-        spdlog::debug("SystemRecoveryHandler: Dropped database \"{}\".", remove_db);
-        continue;
-      }
-      spdlog::debug("SystemRecoveryHandler: Failed to drop database \"{}\".", remove_db);
-      return false;
-    }
-  }
-
-  /*
-   * SUCCESS
-   */
-  return true;
-}
-
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              dbms::DbmsHandler &dbms_handler) {
-  // NOTE: Register even without license as the user could add a license at run-time
-  data.server->rpc_server_.Register<storage::replication::CreateDatabaseRpc>(
-      [&data, system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received CreateDatabaseRpc");
-        CreateDatabaseHandler(system_state_access, data.uuid_, dbms_handler, req_reader, res_builder);
-      });
-  data.server->rpc_server_.Register<storage::replication::DropDatabaseRpc>(
-      [&data, system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received DropDatabaseRpc");
-        DropDatabaseHandler(system_state_access, data.uuid_, dbms_handler, req_reader, res_builder);
-      });
-}
-#endif
-}  // namespace memgraph::dbms
--- a/src/dbms/replication_handlers.hpp
+++ b/src/dbms/replication_handlers.hpp
@@ -1,42 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "dbms/dbms_handler.hpp"
-#include "replication/state.hpp"
-#include "slk/streams.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::dbms {
-
-#ifdef MG_ENTERPRISE
-
-inline void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                         std::string_view rpc_req) {
-  spdlog::error("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : "");
-}
-
-// RPC handlers
-void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                           slk::Reader *req_reader, slk::Builder *res_builder);
-void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                         slk::Reader *req_reader, slk::Builder *res_builder);
-bool SystemRecoveryHandler(DbmsHandler &dbms_handler, const std::vector<storage::SalientConfig> &database_configs);
-
-// RPC registration
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              dbms::DbmsHandler &dbms_handler);
-#endif
-}  // namespace memgraph::dbms
--- a/src/dbms/rpc.cpp
+++ b/src/dbms/rpc.cpp
@@ -1,122 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "dbms/rpc.hpp"
-
-#include "slk/streams.hpp"
-#include "storage/v2/replication/rpc.hpp"
-#include "utils/enum.hpp"
-#include "utils/typeinfo.hpp"
-
-namespace memgraph {
-
-namespace storage::replication {
-
-void CreateDatabaseReq::Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void CreateDatabaseReq::Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void CreateDatabaseRes::Save(const CreateDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void CreateDatabaseRes::Load(CreateDatabaseRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void DropDatabaseReq::Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropDatabaseReq::Load(DropDatabaseReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-void DropDatabaseRes::Save(const DropDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropDatabaseRes::Load(DropDatabaseRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-
-const utils::TypeInfo CreateDatabaseReq::kType{utils::TypeId::REP_CREATE_DATABASE_REQ, "CreateDatabaseReq", nullptr};
-
-const utils::TypeInfo CreateDatabaseRes::kType{utils::TypeId::REP_CREATE_DATABASE_RES, "CreateDatabaseRes", nullptr};
-
-const utils::TypeInfo DropDatabaseReq::kType{utils::TypeId::REP_DROP_DATABASE_REQ, "DropDatabaseReq", nullptr};
-
-const utils::TypeInfo DropDatabaseRes::kType{utils::TypeId::REP_DROP_DATABASE_RES, "DropDatabaseRes", nullptr};
-
-}  // namespace storage::replication
-
-// Autogenerated SLK serialization code
-namespace slk {
-
-// Serialize code for CreateDatabaseReq
-
-void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.config, builder);
-}
-
-void Load(memgraph::storage::replication::CreateDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->config, reader);
-}
-
-// Serialize code for CreateDatabaseRes
-
-void Save(const memgraph::storage::replication::CreateDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(utils::EnumToNum<uint8_t>(self.result), builder);
-}
-
-void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk::Reader *reader) {
-  uint8_t res = 0;
-  memgraph::slk::Load(&res, reader);
-  if (!utils::NumToEnum(res, self->result)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-}
-
-// Serialize code for DropDatabaseReq
-
-void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.uuid, builder);
-}
-
-void Load(memgraph::storage::replication::DropDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->uuid, reader);
-}
-
-// Serialize code for DropDatabaseRes
-
-void Save(const memgraph::storage::replication::DropDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(utils::EnumToNum<uint8_t>(self.result), builder);
-}
-
-void Load(memgraph::storage::replication::DropDatabaseRes *self, memgraph::slk::Reader *reader) {
-  uint8_t res = 0;
-  memgraph::slk::Load(&res, reader);
-  if (!utils::NumToEnum(res, self->result)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-}
-
-}  // namespace slk
-}  // namespace memgraph
--- a/src/dbms/rpc.hpp
+++ b/src/dbms/rpc.hpp
@@ -1,122 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <utility>
-
-#include "rpc/messages.hpp"
-#include "slk/streams.hpp"
-#include "storage/v2/config.hpp"
-#include "utils/uuid.hpp"
-
-namespace memgraph::storage::replication {
-
-struct CreateDatabaseReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader);
-  static void Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder);
-  CreateDatabaseReq() = default;
-  CreateDatabaseReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_group_timestamp,
-                    uint64_t new_group_timestamp, storage::SalientConfig config)
-      : main_uuid(main_uuid),
-        epoch_id(std::move(epoch_id)),
-        expected_group_timestamp{expected_group_timestamp},
-        new_group_timestamp(new_group_timestamp),
-        config(std::move(config)) {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  storage::SalientConfig config;
-};
-
-struct CreateDatabaseRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  enum class Result : uint8_t { SUCCESS, NO_NEED, FAILURE, /* Leave at end */ N };
-
-  static void Load(CreateDatabaseRes *self, memgraph::slk::Reader *reader);
-  static void Save(const CreateDatabaseRes &self, memgraph::slk::Builder *builder);
-  CreateDatabaseRes() = default;
-  explicit CreateDatabaseRes(Result res) : result(res) {}
-
-  Result result;
-};
-
-using CreateDatabaseRpc = rpc::RequestResponse<CreateDatabaseReq, CreateDatabaseRes>;
-
-struct DropDatabaseReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropDatabaseReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder);
-  DropDatabaseReq() = default;
-  DropDatabaseReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_group_timestamp,
-                  uint64_t new_group_timestamp, const utils::UUID &uuid)
-      : main_uuid(main_uuid),
-        epoch_id(std::move(epoch_id)),
-        expected_group_timestamp{expected_group_timestamp},
-        new_group_timestamp(new_group_timestamp),
-        uuid(uuid) {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  utils::UUID uuid;
-};
-
-struct DropDatabaseRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  enum class Result : uint8_t { SUCCESS, NO_NEED, FAILURE, /* Leave at end */ N };
-
-  static void Load(DropDatabaseRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DropDatabaseRes &self, memgraph::slk::Builder *builder);
-  DropDatabaseRes() = default;
-  explicit DropDatabaseRes(Result res) : result(res) {}
-
-  Result result;
-};
-
-using DropDatabaseRpc = rpc::RequestResponse<DropDatabaseReq, DropDatabaseRes>;
-
-}  // namespace memgraph::storage::replication
-
-// SLK serialization declarations
-namespace memgraph::slk {
-
-void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::CreateDatabaseReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::CreateDatabaseRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::DropDatabaseReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::DropDatabaseRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::DropDatabaseRes *self, memgraph::slk::Reader *reader);
-
-}  // namespace memgraph::slk
--- a/src/dbms/transaction.hpp
+++ b/src/dbms/transaction.hpp
@@ -11,10 +11,7 @@

 #pragma once

-#include <list>
 #include <memory>
-#include <optional>
-#include "auth/models.hpp"
 #include "storage/v2/config.hpp"

 namespace memgraph::dbms {
@@ -23,70 +20,17 @@ struct SystemTransaction {
    enum class Action {
      CREATE_DATABASE,
      DROP_DATABASE,
-      UPDATE_AUTH_DATA,
-      DROP_AUTH_DATA,
-      /**
-       *
-       * CREATE USER user_name [IDENTIFIED BY 'password'];
-       * SET PASSWORD FOR user_name TO 'new_password';
-       * ^ SaveUser
-       *
-       * DROP USER user_name;
-       * ^ Directly on KVStore
-       *
-       * CREATE ROLE role_name;
-       * ^ SaveRole
-       *
-       * DROP ROLE
-       * ^ RemoveRole
-       *
-       * SET ROLE FOR user_name TO role_name;
-       * CLEAR ROLE FOR user_name;
-       * ^ Do stuff then do SaveUser
-       *
-       * GRANT privilege_list TO user_or_role;
-       * DENY AUTH, INDEX TO moderator:
-       * REVOKE AUTH, INDEX TO moderator:
-       * GRANT permission_level ON (LABELS | EDGE_TYPES) label_list TO user_or_role;
-       * REVOKE (LABELS | EDGE_TYPES) label_or_edge_type_list FROM user_or_role
-       * DENY (LABELS | EDGE_TYPES) label_or_edge_type_list TO user_or_role
-       * ^ all of these are EditPermissions <-> SaveUser/Role
-       *
-       * Multi-tenant TODO Doc;
-       * ^ Should all call SaveUser
-       *
-       */
    };

    static constexpr struct CreateDatabase {
    } create_database;
    static constexpr struct DropDatabase {
    } drop_database;
-    static constexpr struct UpdateAuthData {
-    } update_auth_data;
-    static constexpr struct DropAuthData {
-    } drop_auth_data;

-    enum class AuthData { USER, ROLE };
-
-    // Multi-tenancy
    Delta(CreateDatabase /*tag*/, storage::SalientConfig config)
        : action(Action::CREATE_DATABASE), config(std::move(config)) {}
    Delta(DropDatabase /*tag*/, const utils::UUID &uuid) : action(Action::DROP_DATABASE), uuid(uuid) {}

-    // Auth
-    Delta(UpdateAuthData /*tag*/, std::optional<auth::User> user)
-        : action(Action::UPDATE_AUTH_DATA), auth_data{std::move(user), std::nullopt} {}
-    Delta(UpdateAuthData /*tag*/, std::optional<auth::Role> role)
-        : action(Action::UPDATE_AUTH_DATA), auth_data{std::nullopt, std::move(role)} {}
-    Delta(DropAuthData /*tag*/, AuthData type, std::string_view name)
-        : action(Action::DROP_AUTH_DATA),
-          auth_data_key{
-              .type = type,
-              .name = std::string{name},
-          } {}
-
-    // Generic
    Delta(const Delta &) = delete;
    Delta(Delta &&) = delete;
    Delta &operator=(const Delta &) = delete;
@@ -98,14 +42,8 @@ struct SystemTransaction {
          std::destroy_at(&config);
          break;
        case Action::DROP_DATABASE:
-          std::destroy_at(&uuid);
-          break;
-        case Action::UPDATE_AUTH_DATA:
-          std::destroy_at(&auth_data);
-          break;
-        case Action::DROP_AUTH_DATA:
-          std::destroy_at(&auth_data_key);
          break;
+          // Some deltas might have special destructor handling
      }
    }

@@ -113,20 +51,13 @@ struct SystemTransaction {
    union {
      storage::SalientConfig config;
      utils::UUID uuid;
-      struct {
-        std::optional<auth::User> user;
-        std::optional<auth::Role> role;
-      } auth_data;
-      struct {
-        AuthData type;
-        std::string name;
-      } auth_data_key;
    };
  };

  explicit SystemTransaction(uint64_t timestamp) : system_timestamp(timestamp) {}

-  std::list<Delta> deltas{};
+  // Currently system transitions support a single delta
+  std::optional<Delta> delta{};
  uint64_t system_timestamp;
 };

--- a/src/dbms/utils.hpp
+++ b/src/dbms/utils.hpp
@@ -0,0 +1,133 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "dbms/dbms_handler.hpp"
+#include "dbms/replication_handler.hpp"
+#include "replication/include/replication/state.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::dbms {
+
+inline bool DoReplicaToMainPromotion(dbms::DbmsHandler &dbms_handler) {
+  auto &repl_state = dbms_handler.ReplicationState();
+  // STEP 1) bring down all REPLICA servers
+  dbms_handler.ForEach([](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    // Remember old epoch + storage timestamp association
+    storage->PrepareForNewEpoch();
+  });
+
+  // STEP 2) Change to MAIN
+  // TODO: restore replication servers if false?
+  if (!repl_state.SetReplicationRoleMain()) {
+    // TODO: Handle recovery on failure???
+    return false;
+  }
+
+  // STEP 3) We are now MAIN, update storage local epoch
+  const auto &epoch =
+      std::get<replication::RoleMainData>(std::as_const(dbms_handler.ReplicationState()).ReplicationData()).epoch_;
+  dbms_handler.ForEach([&](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    storage->repl_storage_state_.epoch_ = epoch;
+  });
+
+  return true;
+};
+
+inline bool SetReplicationRoleReplica(dbms::DbmsHandler &dbms_handler,
+                                      const memgraph::replication::ReplicationServerConfig &config) {
+  if (dbms_handler.ReplicationState().IsReplica()) {
+    return false;
+  }
+
+  // TODO StorageState needs to be synched. Could have a dangling reference if someone adds a database as we are
+  //      deleting the replica.
+  // Remove database specific clients
+  dbms_handler.ForEach([&](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    storage->repl_storage_state_.replication_clients_.WithLock([](auto &clients) { clients.clear(); });
+  });
+  // Remove instance level clients
+  std::get<replication::RoleMainData>(dbms_handler.ReplicationState().ReplicationData()).registered_replicas_.clear();
+
+  // Creates the server
+  dbms_handler.ReplicationState().SetReplicationRoleReplica(config);
+
+  // Start
+  const auto success = std::visit(utils::Overloaded{[](replication::RoleMainData const &) {
+                                                      // ASSERT
+                                                      return false;
+                                                    },
+                                                    [&dbms_handler](replication::RoleReplicaData const &data) {
+                                                      return StartRpcServer(dbms_handler, data);
+                                                    }},
+                                  dbms_handler.ReplicationState().ReplicationData());
+  // TODO Handle error (restore to main?)
+  return success;
+}
+
+inline bool RegisterAllDatabasesClients(dbms::DbmsHandler &dbms_handler,
+                                        replication::ReplicationClient &instance_client) {
+  if (!allow_mt_repl && dbms_handler.All().size() > 1) {
+    spdlog::warn("Multi-tenant replication is currently not supported!");
+  }
+
+  bool all_clients_good = true;
+
+  // Add database specific clients (NOTE Currently all databases are connected to each replica)
+  dbms_handler.ForEach([&](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    if (!allow_mt_repl && storage->name() != kDefaultDB) {
+      return;
+    }
+    // TODO: ATM only IN_MEMORY_TRANSACTIONAL, fix other modes
+    if (storage->storage_mode_ != storage::StorageMode::IN_MEMORY_TRANSACTIONAL) return;
+
+    all_clients_good &= storage->repl_storage_state_.replication_clients_.WithLock(
+        [storage, &instance_client, db_acc = std::move(db_acc)](auto &storage_clients) mutable {  // NOLINT
+          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
+          // All good, start replica client
+          client->Start(storage, std::move(db_acc));
+          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
+          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
+          // Failed to start due an error like branching of MAIN and REPLICA
+          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+            return false;  // TODO: sometimes we need to still add to storage_clients
+          }
+          storage_clients.push_back(std::move(client));
+          return true;
+        });
+  });
+
+  return all_clients_good;
+}
+
+inline std::optional<RegisterReplicaError> HandleRegisterReplicaStatus(
+    utils::BasicResult<replication::RegisterReplicaError, replication::ReplicationClient *> &instance_client) {
+  if (instance_client.HasError()) switch (instance_client.GetError()) {
+      case replication::RegisterReplicaError::NOT_MAIN:
+        MG_ASSERT(false, "Only main instance can register a replica!");
+        return {};
+      case replication::RegisterReplicaError::NAME_EXISTS:
+        return dbms::RegisterReplicaError::NAME_EXISTS;
+      case replication::RegisterReplicaError::ENDPOINT_EXISTS:
+        return dbms::RegisterReplicaError::ENDPOINT_EXISTS;
+      case replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+        return dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+      case replication::RegisterReplicaError::SUCCESS:
+        break;
+    }
+  return {};
+}
+
+}  // namespace memgraph::dbms
--- a/src/flags/CMakeLists.txt
+++ b/src/flags/CMakeLists.txt
@@ -1,17 +1,12 @@
-add_library(mg-flags STATIC
-        audit.cpp
-        bolt.cpp
-        general.cpp
-        isolation_level.cpp
-        log_level.cpp
-        memory_limit.cpp
-        run_time_configurable.cpp
-        storage_mode.cpp
-        query.cpp
-        replication.cpp
-        experimental.cpp
-        experimental.hpp)
-target_include_directories(mg-flags PUBLIC include)
-target_link_libraries(mg-flags
-        PUBLIC spdlog::spdlog mg-settings mg-utils
-        PRIVATE lib::rangev3)
+add_library(mg-flags STATIC audit.cpp
+                            bolt.cpp
+                            general.cpp
+                            isolation_level.cpp
+                            log_level.cpp
+                            memory_limit.cpp
+                            run_time_configurable.cpp
+                            storage_mode.cpp
+                            query.cpp
+                            replication.cpp)
+target_include_directories(mg-flags PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(mg-flags PUBLIC spdlog::spdlog mg-settings mg-utils)
--- a/src/flags/all.hpp
+++ b/src/flags/all.hpp
@@ -12,7 +12,6 @@

 #include "flags/audit.hpp"
 #include "flags/bolt.hpp"
-#include "flags/experimental.hpp"
 #include "flags/general.hpp"
 #include "flags/isolation_level.hpp"
 #include "flags/log_level.hpp"
--- a/src/flags/experimental.cpp
+++ b/src/flags/experimental.cpp
@@ -1,67 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "flags/experimental.hpp"
-#include "range/v3/all.hpp"
-#include "utils/string.hpp"
-
-#include <map>
-#include <string_view>
-
-// Bolt server flags.
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(experimental_enabled, "",
-              "Experimental features to be used, comma seperated. Options [system-replication]");
-
-using namespace std::string_view_literals;
-
-namespace memgraph::flags {
-
-auto const mapping = std::map{std::pair{"system-replication"sv, Experiments::SYSTEM_REPLICATION}};
-
-auto ExperimentsInstance() -> Experiments & {
-  static auto instance = Experiments{};
-  return instance;
-}
-
-bool AreExperimentsEnabled(Experiments experiments) {
-  using t = std::underlying_type_t<Experiments>;
-
-  auto actual = static_cast<t>(ExperimentsInstance());
-  auto check = static_cast<t>(experiments);
-
-  return (actual & check) == check;
-}
-
-void InitializeExperimental() {
-  namespace rv = ranges::views;
-
-  auto const connonicalize_string = [](auto &&rng) {
-    auto const is_space = [](auto c) { return c == ' '; };
-    auto const to_lower = [](unsigned char c) { return std::tolower(c); };
-
-    return rng | rv::drop_while(is_space) | rv::take_while(std::not_fn(is_space)) | rv::transform(to_lower) |
-           ranges::to<std::string>;
-  };
-
-  auto const mapping_end = mapping.cend();
-  using underlying_type = std::underlying_type_t<Experiments>;
-  auto to_set = underlying_type{};
-  for (auto &&experiment : FLAGS_experimental_enabled | rv::split(',') | rv::transform(connonicalize_string)) {
-    if (auto it = mapping.find(experiment); it != mapping_end) {
-      to_set |= static_cast<underlying_type>(it->second);
-    }
-  }
-
-  ExperimentsInstance() = static_cast<Experiments>(to_set);
-}
-
-}  // namespace memgraph::flags
--- a/src/flags/general.cpp
+++ b/src/flags/general.cpp
@@ -195,9 +195,3 @@ DEFINE_HIDDEN_string(organization_name, "", "Organization name.");
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_string(auth_user_or_role_name_regex, memgraph::glue::kDefaultUserRoleRegex.data(),
              "Set to the regular expression that each user or role name must fulfill.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(auth_password_permit_null, true, "Set to false to disable null passwords.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(auth_password_strength_regex, memgraph::glue::kDefaultPasswordRegex.data(),
-              "The regular expression that should be used to match the entire "
-              "entered password to ensure its strength.");
--- a/src/flags/general.hpp
+++ b/src/flags/general.hpp
@@ -118,7 +118,3 @@ DECLARE_string(license_key);
 DECLARE_string(organization_name);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_string(auth_user_or_role_name_regex);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(auth_password_permit_null);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_string(auth_password_strength_regex);
--- a/src/flags/replication.cpp
+++ b/src/flags/replication.cpp
@@ -13,15 +13,9 @@

 #ifdef MG_ENTERPRISE
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(coordinator, false, "Controls whether the instance is a replication coordinator.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_uint32(coordinator_server_port, 0, "Port on which coordinator servers will be started.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(raft_server_port, 0, "Port on which raft servers will be started.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(raft_server_id, 0, "Unique ID of the raft server.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(instance_down_timeout_sec, 5, "Time duration after which an instance is considered down.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(instance_health_check_frequency_sec, 1, "The time duration between two health checks/pings.");
 #endif

 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
--- a/src/flags/replication.hpp
+++ b/src/flags/replication.hpp
@@ -15,15 +15,9 @@

 #ifdef MG_ENTERPRISE
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(coordinator);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_uint32(coordinator_server_port);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(raft_server_port);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(raft_server_id);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_down_timeout_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_health_check_frequency_sec);
 #endif

 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
--- a/src/glue/ServerT.hpp
+++ b/src/glue/ServerT.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -33,7 +33,7 @@ class WritePrioritizedRWLock;

 struct Context {
  memgraph::query::InterpreterContext *ic;
-  memgraph::auth::SynchedAuth *auth;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
 #if MG_ENTERPRISE
  memgraph::audit::Log *audit_log;
 #endif
--- a/src/glue/SessionHL.cpp
+++ b/src/glue/SessionHL.cpp
@@ -319,7 +319,8 @@ void SessionHL::Configure(const std::map<std::string, memgraph::communication::b
 SessionHL::SessionHL(memgraph::query::InterpreterContext *interpreter_context,
                     memgraph::communication::v2::ServerEndpoint endpoint,
                     memgraph::communication::v2::InputStream *input_stream,
-                     memgraph::communication::v2::OutputStream *output_stream, memgraph::auth::SynchedAuth *auth
+                     memgraph::communication::v2::OutputStream *output_stream,
+                     memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
 #ifdef MG_ENTERPRISE
                     ,
                     memgraph::audit::Log *audit_log
--- a/src/glue/SessionHL.hpp
+++ b/src/glue/SessionHL.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -25,7 +25,8 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
  SessionHL(memgraph::query::InterpreterContext *interpreter_context,
            memgraph::communication::v2::ServerEndpoint endpoint,
            memgraph::communication::v2::InputStream *input_stream,
-            memgraph::communication::v2::OutputStream *output_stream, memgraph::auth::SynchedAuth *auth
+            memgraph::communication::v2::OutputStream *output_stream,
+            memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
 #ifdef MG_ENTERPRISE
            ,
            memgraph::audit::Log *audit_log
@@ -87,7 +88,7 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
  memgraph::audit::Log *audit_log_;
  bool in_explicit_db_{false};  //!< If true, the user has defined the database to use via metadata
 #endif
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
  memgraph::communication::v2::ServerEndpoint endpoint_;
  std::optional<std::string> implicit_db_;
 };
--- a/src/glue/auth_checker.cpp
+++ b/src/glue/auth_checker.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -66,7 +66,9 @@ bool IsUserAuthorizedEdgeType(const memgraph::auth::User &user, const memgraph::
 #endif
 namespace memgraph::glue {

-AuthChecker::AuthChecker(memgraph::auth::SynchedAuth *auth) : auth_(auth) {}
+AuthChecker::AuthChecker(
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
+    : auth_(auth) {}

 bool AuthChecker::IsUserAuthorized(const std::optional<std::string> &username,
                                   const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
--- a/src/glue/auth_checker.hpp
+++ b/src/glue/auth_checker.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -22,7 +22,8 @@ namespace memgraph::glue {

 class AuthChecker : public query::AuthChecker {
 public:
-  explicit AuthChecker(memgraph::auth::SynchedAuth *auth);
+  explicit AuthChecker(
+      memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth);

  bool IsUserAuthorized(const std::optional<std::string> &username,
                        const std::vector<query::AuthQuery::Privilege> &privileges,
@@ -40,7 +41,7 @@ class AuthChecker : public query::AuthChecker {
                                             const std::string &db_name = "");

 private:
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
  mutable memgraph::utils::Synchronized<auth::User, memgraph::utils::SpinLock> user_;  // cached user
 };
 #ifdef MG_ENTERPRISE
--- a/src/glue/auth_global.hpp
+++ b/src/glue/auth_global.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -13,5 +13,4 @@

 namespace memgraph::glue {
 inline constexpr std::string_view kDefaultUserRoleRegex = "[a-zA-Z0-9_.+-@]+";
-static constexpr std::string_view kDefaultPasswordRegex = ".+";
 }  // namespace memgraph::glue
--- a/src/glue/auth_handler.cpp
+++ b/src/glue/auth_handler.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -210,25 +210,16 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedUserPrivile
  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
    return {};
  }
+  const auto &label_permissions = user->GetFineGrainedAccessLabelPermissions();
+  const auto &edge_type_permissions = user->GetFineGrainedAccessEdgeTypePermissions();

-  auto all_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetUserFineGrainedAccessLabelPermissions(), "LABEL", "USER");
-  auto all_role_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetRoleFineGrainedAccessLabelPermissions(), "LABEL", "ROLE");
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(all_role_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(all_role_fine_grained_permissions.end()));
+  auto all_fine_grained_permissions =
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "USER");
+  auto edge_type_fine_grained_permissions =
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "USER");

-  auto edge_type_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetUserFineGrainedAccessEdgeTypePermissions(), "EDGE_TYPE", "USER");
-  auto role_edge_type_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetRoleFineGrainedAccessEdgeTypePermissions(), "EDGE_TYPE", "ROLE");
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(edge_type_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(edge_type_fine_grained_permissions.end()));
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(role_edge_type_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(role_edge_type_fine_grained_permissions.end()));
+  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(), edge_type_fine_grained_permissions.begin(),
+                                      edge_type_fine_grained_permissions.end());

  return ConstructFineGrainedPrivilegesResult(all_fine_grained_permissions);
 }
@@ -242,9 +233,9 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedRolePrivile
  const auto &edge_type_permissions = role->GetFineGrainedAccessEdgeTypePermissions();

  auto all_fine_grained_permissions =
-      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "ROLE");
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "USER");
  auto edge_type_fine_grained_permissions =
-      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "ROLE");
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "USER");

  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(), edge_type_fine_grained_permissions.begin(),
                                      edge_type_fine_grained_permissions.end());
@@ -257,15 +248,31 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedRolePrivile

 namespace memgraph::glue {

-AuthQueryHandler::AuthQueryHandler(memgraph::auth::SynchedAuth *auth) : auth_(auth) {}
+AuthQueryHandler::AuthQueryHandler(
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+    std::string name_regex_string)
+    : auth_(auth), name_regex_string_(std::move(name_regex_string)), name_regex_(name_regex_string_) {}

-bool AuthQueryHandler::CreateUser(const std::string &username, const std::optional<std::string> &password,
-                                  system::Transaction *system_tx) {
+bool AuthQueryHandler::CreateUser(const std::string &username, const std::optional<std::string> &password) {
+  if (name_regex_string_ != kDefaultUserRoleRegex) {
+    if (const auto license_check_result =
+            memgraph::license::global_license_checker.IsEnterpriseValid(memgraph::utils::global_settings);
+        license_check_result.HasError()) {
+      throw memgraph::auth::AuthException(
+          "Custom user/role regex is a Memgraph Enterprise feature. Please set the config "
+          "(\"--auth-user-or-role-name-regex\") to its default value (\"{}\") or remove the flag.\n{}",
+          kDefaultUserRoleRegex,
+          memgraph::license::LicenseCheckErrorToString(license_check_result.GetError(), "user/role regex"));
+    }
+  }
+  if (!std::regex_match(username, name_regex_)) {
+    throw query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    const auto [first_user, user_added] = std::invoke([&, this] {
      auto locked_auth = auth_->Lock();
      const auto first_user = !locked_auth->HasUsers();
-      const auto user_added = locked_auth->AddUser(username, password, system_tx).has_value();
+      const auto user_added = locked_auth->AddUser(username, password).has_value();
      return std::make_pair(first_user, user_added);
    });

@@ -284,11 +291,10 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
            }
          }
 #endif
-          ,
-          system_tx);
+      );
 #ifdef MG_ENTERPRISE
-      GrantDatabaseToUser(auth::kAllDatabases, username, system_tx);
-      SetMainDatabase(dbms::kDefaultDB, username, system_tx);
+      GrantDatabaseToUser(auth::kAllDatabases, username);
+      SetMainDatabase(dbms::kDefaultDB, username);
 #endif
    }

@@ -298,61 +304,73 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
  }
 }

-bool AuthQueryHandler::DropUser(const std::string &username, system::Transaction *system_tx) {
+bool AuthQueryHandler::DropUser(const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
    if (!user) return false;
-    return locked_auth->RemoveUser(username, system_tx);
+    return locked_auth->RemoveUser(username);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

-void AuthQueryHandler::SetPassword(const std::string &username, const std::optional<std::string> &password,
-                                   system::Transaction *system_tx) {
+void AuthQueryHandler::SetPassword(const std::string &username, const std::optional<std::string> &password) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
    if (!user) {
      throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist.", username);
    }
-    locked_auth->UpdatePassword(*user, password);
-    locked_auth->SaveUser(*user, system_tx);
+    user->UpdatePassword(password);
+    locked_auth->SaveUser(*user);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

-bool AuthQueryHandler::CreateRole(const std::string &rolename, system::Transaction *system_tx) {
+bool AuthQueryHandler::CreateRole(const std::string &rolename) {
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
-    return locked_auth->AddRole(rolename, system_tx).has_value();
+    return locked_auth->AddRole(rolename).has_value();
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

 #ifdef MG_ENTERPRISE
-bool AuthQueryHandler::RevokeDatabaseFromUser(const std::string &db_name, const std::string &username,
-                                              system::Transaction *system_tx) {
+bool AuthQueryHandler::RevokeDatabaseFromUser(const std::string &db, const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
    if (!user) return false;
-    return locked_auth->RevokeDatabaseFromUser(db_name, username, system_tx);
+    return locked_auth->RevokeDatabaseFromUser(db, username);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

-bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db_name, const std::string &username,
-                                           system::Transaction *system_tx) {
+bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db, const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
    if (!user) return false;
-    return locked_auth->GrantDatabaseToUser(db_name, username, system_tx);
+    return locked_auth->GrantDatabaseToUser(db, username);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
@@ -360,6 +378,9 @@ bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db_name, const std

 std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetDatabasePrivileges(
    const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+  }
  try {
    auto locked_auth = auth_->ReadLock();
    auto user = locked_auth->GetUser(username);
@@ -372,28 +393,33 @@ std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetDatab
  }
 }

-bool AuthQueryHandler::SetMainDatabase(std::string_view db_name, const std::string &username,
-                                       system::Transaction *system_tx) {
+bool AuthQueryHandler::SetMainDatabase(std::string_view db, const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
    if (!user) return false;
-    return locked_auth->SetMainDatabase(db_name, username, system_tx);
+    return locked_auth->SetMainDatabase(db, username);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

-void AuthQueryHandler::DeleteDatabase(std::string_view db_name, system::Transaction *system_tx) {
+void AuthQueryHandler::DeleteDatabase(std::string_view db) {
  try {
-    auth_->Lock()->DeleteDatabase(std::string(db_name), system_tx);
+    auth_->Lock()->DeleteDatabase(std::string(db));
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }
 #endif

-bool AuthQueryHandler::DropRole(const std::string &rolename, system::Transaction *system_tx) {
+bool AuthQueryHandler::DropRole(const std::string &rolename) {
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto role = locked_auth->GetRole(rolename);
@@ -402,7 +428,7 @@ bool AuthQueryHandler::DropRole(const std::string &rolename, system::Transaction
      return false;
    };

-    return locked_auth->RemoveRole(rolename, system_tx);
+    return locked_auth->RemoveRole(rolename);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
@@ -439,6 +465,9 @@ std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetRolenames() {
 }

 std::optional<std::string> AuthQueryHandler::GetRolenameForUser(const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->ReadLock();
    auto user = locked_auth->GetUser(username);
@@ -456,6 +485,9 @@ std::optional<std::string> AuthQueryHandler::GetRolenameForUser(const std::strin
 }

 std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetUsernamesForRole(const std::string &rolename) {
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
  try {
    auto locked_auth = auth_->ReadLock();
    auto role = locked_auth->GetRole(rolename);
@@ -474,8 +506,13 @@ std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetUsernamesForRole(c
  }
 }

-void AuthQueryHandler::SetRole(const std::string &username, const std::string &rolename,
-                               system::Transaction *system_tx) {
+void AuthQueryHandler::SetRole(const std::string &username, const std::string &rolename) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
@@ -491,13 +528,16 @@ void AuthQueryHandler::SetRole(const std::string &username, const std::string &r
                                                   current_role->rolename());
    }
    user->SetRole(*role);
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

-void AuthQueryHandler::ClearRole(const std::string &username, system::Transaction *system_tx) {
+void AuthQueryHandler::ClearRole(const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
  try {
    auto locked_auth = auth_->Lock();
    auto user = locked_auth->GetUser(username);
@@ -505,13 +545,16 @@ void AuthQueryHandler::ClearRole(const std::string &username, system::Transactio
      throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
    }
    user->ClearRole();
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
  }
 }

 std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetPrivileges(const std::string &user_or_role) {
+  if (!std::regex_match(user_or_role, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+  }
  try {
    auto locked_auth = auth_->ReadLock();
    std::vector<std::vector<memgraph::query::TypedValue>> grants;
@@ -559,8 +602,7 @@ void AuthQueryHandler::GrantPrivilege(
    const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
        &edge_type_privileges
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
  EditPermissions(
      user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -583,13 +625,11 @@ void AuthQueryHandler::GrantPrivilege(
        }
      }
 #endif
-      ,
-      system_tx);
+  );
 }  // namespace memgraph::glue

 void AuthQueryHandler::DenyPrivilege(const std::string &user_or_role,
-                                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
-                                     system::Transaction *system_tx) {
+                                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) {
  EditPermissions(
      user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -605,8 +645,7 @@ void AuthQueryHandler::DenyPrivilege(const std::string &user_or_role,
      ,
      [](auto &fine_grained_permissions, const auto &privilege_collection) {}
 #endif
-      ,
-      system_tx);
+  );
 }

 void AuthQueryHandler::RevokePrivilege(
@@ -618,8 +657,7 @@ void AuthQueryHandler::RevokePrivilege(
    const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
        &edge_type_privileges
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
  EditPermissions(
      user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -641,8 +679,7 @@ void AuthQueryHandler::RevokePrivilege(
        }
      }
 #endif
-      ,
-      system_tx);
+  );
 }  // namespace memgraph::glue

 template <class TEditPermissionsFun
@@ -666,8 +703,10 @@ void AuthQueryHandler::EditPermissions(
    ,
    const TEditFineGrainedPermissionsFun &edit_fine_grained_permissions_fun
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
+  if (!std::regex_match(user_or_role, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+  }
  try {
    std::vector<memgraph::auth::Permission> permissions;
    permissions.reserve(privileges.size());
@@ -696,7 +735,7 @@ void AuthQueryHandler::EditPermissions(
        }
      }
 #endif
-      locked_auth->SaveUser(*user, system_tx);
+      locked_auth->SaveUser(*user);
    } else {
      for (const auto &permission : permissions) {
        edit_permissions_fun(role->permissions(), permission);
@@ -712,7 +751,7 @@ void AuthQueryHandler::EditPermissions(
        }
      }
 #endif
-      locked_auth->SaveRole(*role, system_tx);
+      locked_auth->SaveRole(*role);
    }
  } catch (const memgraph::auth::AuthException &e) {
    throw memgraph::query::QueryRuntimeException(e.what());
--- a/src/glue/auth_handler.hpp
+++ b/src/glue/auth_handler.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -23,36 +23,35 @@
 namespace memgraph::glue {

 class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
+  std::string name_regex_string_;
+  std::regex name_regex_;

 public:
-  explicit AuthQueryHandler(memgraph::auth::SynchedAuth *auth);
+  AuthQueryHandler(memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+                   std::string name_regex_string);

-  bool CreateUser(const std::string &username, const std::optional<std::string> &password,
-                  system::Transaction *system_tx) override;
+  bool CreateUser(const std::string &username, const std::optional<std::string> &password) override;

-  bool DropUser(const std::string &username, system::Transaction *system_tx) override;
+  bool DropUser(const std::string &username) override;

-  void SetPassword(const std::string &username, const std::optional<std::string> &password,
-                   system::Transaction *system_tx) override;
+  void SetPassword(const std::string &username, const std::optional<std::string> &password) override;

 #ifdef MG_ENTERPRISE
-  bool RevokeDatabaseFromUser(const std::string &db_name, const std::string &username,
-                              system::Transaction *system_tx) override;
+  bool RevokeDatabaseFromUser(const std::string &db, const std::string &username) override;

-  bool GrantDatabaseToUser(const std::string &db_name, const std::string &username,
-                           system::Transaction *system_tx) override;
+  bool GrantDatabaseToUser(const std::string &db, const std::string &username) override;

  std::vector<std::vector<memgraph::query::TypedValue>> GetDatabasePrivileges(const std::string &username) override;

-  bool SetMainDatabase(std::string_view db_name, const std::string &username, system::Transaction *system_tx) override;
+  bool SetMainDatabase(std::string_view db, const std::string &username) override;

-  void DeleteDatabase(std::string_view db_name, system::Transaction *system_tx) override;
+  void DeleteDatabase(std::string_view db) override;
 #endif

-  bool CreateRole(const std::string &rolename, system::Transaction *system_tx) override;
+  bool CreateRole(const std::string &rolename) override;

-  bool DropRole(const std::string &rolename, system::Transaction *system_tx) override;
+  bool DropRole(const std::string &rolename) override;

  std::vector<memgraph::query::TypedValue> GetUsernames() override;

@@ -62,9 +61,9 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {

  std::vector<memgraph::query::TypedValue> GetUsernamesForRole(const std::string &rolename) override;

-  void SetRole(const std::string &username, const std::string &rolename, system::Transaction *system_tx) override;
+  void SetRole(const std::string &username, const std::string &rolename) override;

-  void ClearRole(const std::string &username, system::Transaction *system_tx) override;
+  void ClearRole(const std::string &username) override;

  std::vector<std::vector<memgraph::query::TypedValue>> GetPrivileges(const std::string &user_or_role) override;

@@ -78,12 +77,10 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
      const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
          &edge_type_privileges
 #endif
-      ,
-      system::Transaction *system_tx) override;
+      ) override;

  void DenyPrivilege(const std::string &user_or_role,
-                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
-                     system::Transaction *system_tx) override;
+                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) override;

  void RevokePrivilege(
      const std::string &user_or_role, const std::vector<memgraph::query::AuthQuery::Privilege> &privileges
@@ -94,8 +91,7 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
      const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
          &edge_type_privileges
 #endif
-      ,
-      system::Transaction *system_tx) override;
+      ) override;

 private:
  template <class TEditPermissionsFun
@@ -119,7 +115,6 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
      ,
      const TEditFineGrainedPermissionsFun &edit_fine_grained_permissions_fun
 #endif
-      ,
-      system::Transaction *system_tx);
+  );
 };
 }  // namespace memgraph::glue
--- a/src/io/network/endpoint.cpp
+++ b/src/io/network/endpoint.cpp
@@ -39,7 +39,7 @@ Endpoint::IpFamily Endpoint::GetIpFamily(const std::string &address) {
 }

 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrIpAddress(
-    const std::string &address, const std::optional<uint16_t> default_port) {
+    const std::string &address, const std::optional<uint16_t> default_port = {}) {
  /// expected address format:
  ///   - "ip_address:port_number"
  ///   - "ip_address"
--- a/src/io/network/endpoint.hpp
+++ b/src/io/network/endpoint.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -61,8 +61,8 @@ struct Endpoint {
   * it into an ip address and a port number; even if a default port is given,
   * it won't be used, as we expect that it is given in the address string.
   */
-  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(
-      const std::string &address, std::optional<uint16_t> default_port = {});
+  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(const std::string &address,
+                                                                                std::optional<uint16_t> default_port);

  /**
   * Tries to parse given string as either socket address or hostname.
--- a/src/kvstore/kvstore.cpp
+++ b/src/kvstore/kvstore.cpp
@@ -37,7 +37,6 @@ KVStore::KVStore(std::filesystem::path storage) : pimpl_(std::make_unique<impl>(
 }

 KVStore::~KVStore() {
-  if (pimpl_ == nullptr) return;
  spdlog::debug("Destroying KVStore at {}", pimpl_->storage.string());
  const auto sync = pimpl_->db->SyncWAL();
  if (!sync.ok()) spdlog::error("KVStore sync failed!");
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Andi Skrgat	ccabbe7a63	Main restoration working	2024-01-29 14:15:26 +01:00
Andi Skrgat	aac169c5b3	Improve restoration process, WIP	2024-01-29 10:36:30 +01:00
Andi Skrgat	d0cb85e642	Support main restart	2024-01-26 12:12:34 +01:00
Andi Skrgat	34a7fed59a	Tests for main restoration	2024-01-26 11:45:41 +01:00
Andi Skrgat	8124226ba9	Replica instance restored	2024-01-26 11:23:38 +01:00
antoniofilipovic	eea21dd73e	start restorations	2024-01-26 09:34:43 +01:00
Andi Skrgat	a6483fc6a7	No role when instance down	2024-01-26 08:59:28 +01:00
Andi	45def388c7	Merge branch 'master' into automatic-failover	2024-01-25 21:37:01 +01:00
Andi Skrgat	da3db9f3bc	Fix coordinator test	2024-01-25 16:02:17 +01:00
Andi Skrgat	34b2e360a9	fixup! Improve concurrency model	2024-01-25 15:33:33 +01:00
Andi Skrgat	9bc0d9425e	Improve concurrency model	2024-01-25 15:20:25 +01:00
antoniofilipovic	62d1b68c2f	Merge branch 'automatic-failover' of github.com:memgraph/memgraph into automatic-failover	2024-01-25 14:00:43 +01:00
antoniofilipovic	ec46cca7a3	fix issues	2024-01-25 14:00:29 +01:00
antoniofilipovic	326a04c6a3	fix failover to main	2024-01-25 12:08:01 +01:00
Andi Skrgat	b21f9e71ed	fixup! fixup! Fix build	2024-01-25 11:12:34 +01:00
Andi Skrgat	c2e0b310f5	fixup! Fix build	2024-01-25 09:54:00 +01:00
Andi Skrgat	b492c7d34f	Fix build	2024-01-25 09:38:11 +01:00
Andi Skrgat	303608982a	Remove cluster_initialized and client_initiated failover tests	2024-01-25 09:38:11 +01:00
Andi Skrgat	c0f979fdcb	Forbid spurious fail from new main during failover	2024-01-25 09:38:11 +01:00
antoniofilipovic	5242427686	merge with Andi's work, register instance works	2024-01-25 09:38:11 +01:00
antoniofilipovic	d3168ded5a	merge with Andi's work - comment out problematic parts	2024-01-25 09:38:11 +01:00
antoniofilipovic	0a28fee34b	add register instance and set instance to main queries and logic	2024-01-25 09:38:11 +01:00
Gareth Lloyd	dc9a2c45c4	Changes from Gareth to make build + comments	2024-01-25 09:38:11 +01:00
Andi Skrgat	1133bb8ecb	Idempotent failover from coordinator	2024-01-25 09:38:11 +01:00
Andi Skrgat	e9c5cc3b82	Remove ShowMainReplica status	2024-01-25 09:38:11 +01:00
Andi Skrgat	3f4ac0dd58	Thread-safe AF working	2024-01-25 09:38:10 +01:00
Andi Skrgat	a0ecea7d1c	Add generic CoordinatorInstance	2024-01-25 09:38:10 +01:00
Andi Skrgat	567e1fa1cb	CoordinatorState -> CoordinatorData	2024-01-25 09:38:10 +01:00
Andi Skrgat	ef37c44149	Thread-unsafe automatic failover	2024-01-25 09:38:10 +01:00
Andi Skrgat	ab34b060c0	Thread-safe access to coordinator data	2024-01-25 09:38:10 +01:00
Andi Skrgat	67c1874e81	AF callbacks	2024-01-25 09:38:10 +01:00
Andi Skrgat	9d457eafa8	AF thread issue	2024-01-25 09:38:10 +01:00
Andi Skrgat	986ea37ead	Refactoring of coord state	2024-01-25 09:38:10 +01:00
Andi Skrgat	afe7d47a5c	Improve coordinator handler	2024-01-25 09:38:10 +01:00
Andi Skrgat	8884a0ea78	Rename replica_check_freq to instance_check_freq	2024-01-25 09:38:10 +01:00