diff --git a/.gitignore b/.gitignore
index cf3940e5..3f2ce7f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -169,3 +169,4 @@ tags
 .DS_Store
 
 # End of https://www.gitignore.io/api/vim,git,sbt,java,maven,scala,intellij
+B-Raft/src/.github/workflows/ci-test.yml
diff --git a/B-Raft/.gitignore b/B-Raft/.gitignore
new file mode 100644
index 00000000..a7c5d0ea
--- /dev/null
+++ b/B-Raft/.gitignore
@@ -0,0 +1,4 @@
+experiments/resources/
+src/null/
+target/
+experiments/.idea/
diff --git a/B-Raft/README.md b/B-Raft/README.md
new file mode 100644
index 00000000..02bad5d5
--- /dev/null
+++ b/B-Raft/README.md
@@ -0,0 +1,15 @@
+# [A Byzantine Fault-Tolerant Raft Algorithm Combined with Schnorr Signature (B-Raft), [1]](https://ieeexplore.ieee.org/document/9377376)
+## Implemented in Scala for IN4391 Distributed Systems (2021/22 Q3)
+Group 10: Julian Biesheuvel, Riley Jense & Pepijn te Marvelde
+
+## General Information
+This repo contains the code for the project of the Distributed Systems course. It is an implementation of the B-Raft with Schnorr Signature [[1]](###-bibliography), based on a prototype Raft implementation by Max Bundscherer [[2]](###-biblography). Akka Actors are used for communication between nodes. 
+
+## File Structure
+Source code for the Raft/B-Raft implementation is found in [`src` (link)](src). Experiments, including result dataset and plotting code, are found in [`experiments` (link)](experiments). More info on each folder is found in their respective `README.md`'s.
+
+
+
+### Bibliography
+1.  S. Tian, Y. Liu, Y. Zhang and Y. Zhao, "A Byzantine Fault-Tolerant Raft Algorithm Combined with Schnorr Signature," 2021 15th International Conference on Ubiquitous Information Management and Communication (IMCOM), 2021, pp. 1-5, doi: 10.1109/IMCOM51814.2021.9377376.
+2. M. Bundscherer, "(Prototype) Raft Consensus Algorithm in Scala," Github repository, 2020, https://github.com/maxbundscherer/prototype-scala-raft
\ No newline at end of file
diff --git a/B-Raft/experiments/DS Graphs.ipynb b/B-Raft/experiments/DS Graphs.ipynb
new file mode 100644
index 00000000..a6537a11
--- /dev/null
+++ b/B-Raft/experiments/DS Graphs.ipynb	
@@ -0,0 +1,567 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "aa69db8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "from tqdm import tqdm\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
+   "source": [
+    "def purge_conf(conf_dict):\n",
+    "    keep_keys = ['raftTypeStr', 'nodes']\n",
+    "    return {k:v for k,v in conf_dict.items() if k in keep_keys}"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "outputs": [],
+   "source": [
+    "def parse_line_election(message, timestamp, curr_dict, node_name, num_nodes):\n",
+    "    append = False\n",
+    "        # Start of election: \"Change behavior from 'LEADER' to 'SLEEP'\"\n",
+    "    if \"Change behavior from 'LEADER' to 'SLEEP'\" in message:\n",
+    "        curr_dict['election_start'] = timestamp\n",
+    "        curr_dict['messages'] = [message]\n",
+    "    elif \"Change behavior from 'CANDIDATE' to 'LEADER'\" in message and curr_dict.get('election_start'):\n",
+    "        curr_dict['election_end'] = timestamp\n",
+    "        curr_dict['messages'] = curr_dict['messages'] + [message]\n",
+    "        append = True\n",
+    "    elif \"Received message\" in message:\n",
+    "        if curr_dict.get('election_start'):\n",
+    "            curr_dict['messages'] = curr_dict.get('messages', []) + [message]\n",
+    "\n",
+    "    return curr_dict, append\n",
+    "\n",
+    "def parse_line_appenddata(message, timestamp, curr_dict, node_name, num_nodes):\n",
+    "    append = False\n",
+    "    if \"SEND APR\" in message:\n",
+    "        if not curr_dict.get('appenddata_start'):\n",
+    "            curr_dict['appenddata_start'] = timestamp\n",
+    "    if \"FOLLOWER WRITING DATA\" in message:\n",
+    "        curr_dict['appenddata_end'] = timestamp\n",
+    "        # (data = Map(x -> 5, y -> 4, z -> 3, q -> 2))\n",
+    "        data_map_str = message.split(', (')[1][11:-2]\n",
+    "        entries = data_map_str.split(', ')\n",
+    "\n",
+    "        curr_node_entry_set = curr_dict['written_data'].get(node_name, set())\n",
+    "        curr_node_entry_set.update(entries)\n",
+    "        curr_dict['written_data'][node_name] = curr_node_entry_set\n",
+    "\n",
+    "        # if all followers have written all data set append to True\n",
+    "        num_appended = 0\n",
+    "        for data in curr_dict['written_data'].values():\n",
+    "            if len(data) == 4:\n",
+    "                num_appended += 1\n",
+    "        if num_appended + 1 == (num_nodes // 2) + 1:\n",
+    "            # print(f\"Finish, nodes written = {num_appended}: {message = }\")\n",
+    "            curr_dict['appenddata_majority'] = timestamp\n",
+    "    if \"[VERIFY APPEND DATA], Consistent\" in message:\n",
+    "        curr_dict.pop('written_data')\n",
+    "        append = True\n",
+    "\n",
+    "    return curr_dict, append\n",
+    "\n",
+    "def load_logfile(file, exp_type='election') -> list:\n",
+    "    with open(file, 'r') as f:\n",
+    "        logs = f.readlines()\n",
+    "\n",
+    "    log_start_idx = -1\n",
+    "    # find start of actual logs and parse config:\n",
+    "    conf = {}\n",
+    "    for i, log in enumerate(logs):\n",
+    "        if 'Starting Main with Config' in log:\n",
+    "            log_start_idx = i\n",
+    "            conf = {x.split('=')[0]: x.split('=')[1] for x in log[:-2].split(\"Config:\")[-1].split(',')}\n",
+    "            break\n",
+    "\n",
+    "    logs = logs[log_start_idx:]\n",
+    "    conf = purge_conf(conf)\n",
+    "    conf['file'] = file\n",
+    "    conf['nodes'] = int(conf['nodes'])\n",
+    "\n",
+    "    if exp_type == 'appenddata':\n",
+    "        conf['written_data'] = {}\n",
+    "        parse_line_func = parse_line_appenddata\n",
+    "    else:\n",
+    "        parse_line_func = parse_line_election\n",
+    "\n",
+    "    results = []\n",
+    "    curr_dict = conf.copy()\n",
+    "    for log in logs:\n",
+    "        # split message, indices: 0=timestamp, 1=loglevel, 2=akka actor string, 3=message\n",
+    "        timestamp, _, node_name, message = log.split('\\t')\n",
+    "        timestamp = timestamp[1:-1]\n",
+    "        node_name = node_name.split('/')[-1][:-1]\n",
+    "        curr_dict, append = parse_line_func(message, timestamp, curr_dict, node_name, conf['nodes'])\n",
+    "        if append:\n",
+    "            # curr_dict.pop('written_data', None)\n",
+    "            results.append(curr_dict)\n",
+    "            curr_dict = conf.copy()\n",
+    "\n",
+    "    return results"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "[{'raftTypeStr': 'BRaft',\n  'nodes': 21,\n  'file': 'resources/output/append_data_1/run1_raftType=BRaft_crashIntervalHeartbeats=10000_nodes=21.log',\n  'written_data': {'BraftNodeActor-3': {'q -> 2',\n    'x -> 5',\n    'y -> 4',\n    'z -> 3'},\n   'BraftNodeActor-10': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-19': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-20': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-15': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-18': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-6': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-9': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-16': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-4': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-5': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-12': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-7': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-1': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-0': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-8': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-13': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-2': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-17': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-14': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'},\n   'BraftNodeActor-11': {'q -> 2', 'x -> 5', 'y -> 4', 'z -> 3'}},\n  'appenddata_start': '2022-04-13 20:46:48,780',\n  'appenddata_end': '2022-04-13 20:47:13,107',\n  'appenddata_majority': '2022-04-13 20:47:13,107'}]"
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "load_logfile('resources/output/append_data_1/run1_raftType=BRaft_crashIntervalHeartbeats=10000_nodes=21.log', 'appenddata')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\ptema\\AppData\\Local\\Temp\\ipykernel_15576\\3542859334.py:10: FutureWarning: casting timedelta64[ns] values to int64 with .astype(...) is deprecated and will raise in a future version. Use .view(...) instead.\n",
+      "  append_df['duration_ms'] = (append_df.end - append_df.start).astype(np.int64) / int(1e6)\n",
+      "C:\\Users\\ptema\\AppData\\Local\\Temp\\ipykernel_15576\\3542859334.py:11: FutureWarning: casting timedelta64[ns] values to int64 with .astype(...) is deprecated and will raise in a future version. Use .view(...) instead.\n",
+      "  append_df['duration_majority_ms'] = (append_df.majority - append_df.start).astype(np.int64) / int(1e6)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "    raftTypeStr  nodes                                               file  \\\n0         BRaft     12  resources/output\\append_data_1\\run10_raftType=...   \n1         BRaft     16  resources/output\\append_data_1\\run10_raftType=...   \n2         BRaft     18  resources/output\\append_data_1\\run10_raftType=...   \n3         BRaft     21  resources/output\\append_data_1\\run10_raftType=...   \n4         BRaft      3  resources/output\\append_data_1\\run10_raftType=...   \n..          ...    ...                                                ...   \n491        Raft     21  resources/output\\append_data_2\\run4_raftType=R...   \n492        Raft      3  resources/output\\append_data_2\\run4_raftType=R...   \n493        Raft      5  resources/output\\append_data_2\\run4_raftType=R...   \n494        Raft      7  resources/output\\append_data_2\\run4_raftType=R...   \n495        Raft      9  resources/output\\append_data_2\\run4_raftType=R...   \n\n            appenddata_start           appenddata_end  \\\n0    2022-04-13 22:17:24,913  2022-04-13 22:17:30,267   \n1    2022-04-13 22:22:43,684  2022-04-13 22:22:51,915   \n2    2022-04-13 22:23:03,264  2022-04-13 22:23:13,604   \n3    2022-04-13 22:23:26,520  2022-04-13 22:23:39,048   \n4    2022-04-13 22:16:18,810  2022-04-13 22:16:20,527   \n..                       ...                      ...   \n491  2022-04-14 08:33:48,784  2022-04-14 08:33:50,935   \n492  2022-04-14 08:31:57,141  2022-04-14 08:31:59,787   \n493  2022-04-14 08:32:11,079  2022-04-14 08:32:11,941   \n494  2022-04-14 08:32:25,042  2022-04-14 08:32:25,556   \n495  2022-04-14 08:32:38,988  2022-04-14 08:32:40,613   \n\n         appenddata_majority                   start                     end  \\\n0    2022-04-13 22:17:30,210 2022-04-13 22:17:24.913 2022-04-13 22:17:30.267   \n1    2022-04-13 22:22:50,916 2022-04-13 22:22:43.684 2022-04-13 22:22:51.915   \n2    2022-04-13 22:23:12,794 2022-04-13 22:23:03.264 2022-04-13 22:23:13.604   \n3    2022-04-13 22:23:38,150 2022-04-13 22:23:26.520 2022-04-13 22:23:39.048   \n4    2022-04-13 22:16:20,481 2022-04-13 22:16:18.810 2022-04-13 22:16:20.527   \n..                       ...                     ...                     ...   \n491  2022-04-14 08:33:48,898 2022-04-14 08:33:48.784 2022-04-14 08:33:50.935   \n492  2022-04-14 08:31:59,787 2022-04-14 08:31:57.141 2022-04-14 08:31:59.787   \n493  2022-04-14 08:32:11,940 2022-04-14 08:32:11.079 2022-04-14 08:32:11.941   \n494  2022-04-14 08:32:25,555 2022-04-14 08:32:25.042 2022-04-14 08:32:25.556   \n495  2022-04-14 08:32:39,607 2022-04-14 08:32:38.988 2022-04-14 08:32:40.613   \n\n                   majority  duration_ms  duration_majority_ms  \\\n0   2022-04-13 22:17:30.210       5354.0                5297.0   \n1   2022-04-13 22:22:50.916       8231.0                7232.0   \n2   2022-04-13 22:23:12.794      10340.0                9530.0   \n3   2022-04-13 22:23:38.150      12528.0               11630.0   \n4   2022-04-13 22:16:20.481       1717.0                1671.0   \n..                      ...          ...                   ...   \n491 2022-04-14 08:33:48.898       2151.0                 114.0   \n492 2022-04-14 08:31:59.787       2646.0                2646.0   \n493 2022-04-14 08:32:11.940        862.0                 861.0   \n494 2022-04-14 08:32:25.555        514.0                 513.0   \n495 2022-04-14 08:32:39.607       1625.0                 619.0   \n\n     duration_majority_s  duration_s  \n0                  5.297       5.354  \n1                  7.232       8.231  \n2                  9.530      10.340  \n3                 11.630      12.528  \n4                  1.671       1.717  \n..                   ...         ...  \n491                0.114       2.151  \n492                2.646       2.646  \n493                0.861       0.862  \n494                0.513       0.514  \n495                0.619       1.625  \n\n[496 rows x 13 columns]",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>raftTypeStr</th>\n      <th>nodes</th>\n      <th>file</th>\n      <th>appenddata_start</th>\n      <th>appenddata_end</th>\n      <th>appenddata_majority</th>\n      <th>start</th>\n      <th>end</th>\n      <th>majority</th>\n      <th>duration_ms</th>\n      <th>duration_majority_ms</th>\n      <th>duration_majority_s</th>\n      <th>duration_s</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BRaft</td>\n      <td>12</td>\n      <td>resources/output\\append_data_1\\run10_raftType=...</td>\n      <td>2022-04-13 22:17:24,913</td>\n      <td>2022-04-13 22:17:30,267</td>\n      <td>2022-04-13 22:17:30,210</td>\n      <td>2022-04-13 22:17:24.913</td>\n      <td>2022-04-13 22:17:30.267</td>\n      <td>2022-04-13 22:17:30.210</td>\n      <td>5354.0</td>\n      <td>5297.0</td>\n      <td>5.297</td>\n      <td>5.354</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>BRaft</td>\n      <td>16</td>\n      <td>resources/output\\append_data_1\\run10_raftType=...</td>\n      <td>2022-04-13 22:22:43,684</td>\n      <td>2022-04-13 22:22:51,915</td>\n      <td>2022-04-13 22:22:50,916</td>\n      <td>2022-04-13 22:22:43.684</td>\n      <td>2022-04-13 22:22:51.915</td>\n      <td>2022-04-13 22:22:50.916</td>\n      <td>8231.0</td>\n      <td>7232.0</td>\n      <td>7.232</td>\n      <td>8.231</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>BRaft</td>\n      <td>18</td>\n      <td>resources/output\\append_data_1\\run10_raftType=...</td>\n      <td>2022-04-13 22:23:03,264</td>\n      <td>2022-04-13 22:23:13,604</td>\n      <td>2022-04-13 22:23:12,794</td>\n      <td>2022-04-13 22:23:03.264</td>\n      <td>2022-04-13 22:23:13.604</td>\n      <td>2022-04-13 22:23:12.794</td>\n      <td>10340.0</td>\n      <td>9530.0</td>\n      <td>9.530</td>\n      <td>10.340</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>BRaft</td>\n      <td>21</td>\n      <td>resources/output\\append_data_1\\run10_raftType=...</td>\n      <td>2022-04-13 22:23:26,520</td>\n      <td>2022-04-13 22:23:39,048</td>\n      <td>2022-04-13 22:23:38,150</td>\n      <td>2022-04-13 22:23:26.520</td>\n      <td>2022-04-13 22:23:39.048</td>\n      <td>2022-04-13 22:23:38.150</td>\n      <td>12528.0</td>\n      <td>11630.0</td>\n      <td>11.630</td>\n      <td>12.528</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>BRaft</td>\n      <td>3</td>\n      <td>resources/output\\append_data_1\\run10_raftType=...</td>\n      <td>2022-04-13 22:16:18,810</td>\n      <td>2022-04-13 22:16:20,527</td>\n      <td>2022-04-13 22:16:20,481</td>\n      <td>2022-04-13 22:16:18.810</td>\n      <td>2022-04-13 22:16:20.527</td>\n      <td>2022-04-13 22:16:20.481</td>\n      <td>1717.0</td>\n      <td>1671.0</td>\n      <td>1.671</td>\n      <td>1.717</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>491</th>\n      <td>Raft</td>\n      <td>21</td>\n      <td>resources/output\\append_data_2\\run4_raftType=R...</td>\n      <td>2022-04-14 08:33:48,784</td>\n      <td>2022-04-14 08:33:50,935</td>\n      <td>2022-04-14 08:33:48,898</td>\n      <td>2022-04-14 08:33:48.784</td>\n      <td>2022-04-14 08:33:50.935</td>\n      <td>2022-04-14 08:33:48.898</td>\n      <td>2151.0</td>\n      <td>114.0</td>\n      <td>0.114</td>\n      <td>2.151</td>\n    </tr>\n    <tr>\n      <th>492</th>\n      <td>Raft</td>\n      <td>3</td>\n      <td>resources/output\\append_data_2\\run4_raftType=R...</td>\n      <td>2022-04-14 08:31:57,141</td>\n      <td>2022-04-14 08:31:59,787</td>\n      <td>2022-04-14 08:31:59,787</td>\n      <td>2022-04-14 08:31:57.141</td>\n      <td>2022-04-14 08:31:59.787</td>\n      <td>2022-04-14 08:31:59.787</td>\n      <td>2646.0</td>\n      <td>2646.0</td>\n      <td>2.646</td>\n      <td>2.646</td>\n    </tr>\n    <tr>\n      <th>493</th>\n      <td>Raft</td>\n      <td>5</td>\n      <td>resources/output\\append_data_2\\run4_raftType=R...</td>\n      <td>2022-04-14 08:32:11,079</td>\n      <td>2022-04-14 08:32:11,941</td>\n      <td>2022-04-14 08:32:11,940</td>\n      <td>2022-04-14 08:32:11.079</td>\n      <td>2022-04-14 08:32:11.941</td>\n      <td>2022-04-14 08:32:11.940</td>\n      <td>862.0</td>\n      <td>861.0</td>\n      <td>0.861</td>\n      <td>0.862</td>\n    </tr>\n    <tr>\n      <th>494</th>\n      <td>Raft</td>\n      <td>7</td>\n      <td>resources/output\\append_data_2\\run4_raftType=R...</td>\n      <td>2022-04-14 08:32:25,042</td>\n      <td>2022-04-14 08:32:25,556</td>\n      <td>2022-04-14 08:32:25,555</td>\n      <td>2022-04-14 08:32:25.042</td>\n      <td>2022-04-14 08:32:25.556</td>\n      <td>2022-04-14 08:32:25.555</td>\n      <td>514.0</td>\n      <td>513.0</td>\n      <td>0.513</td>\n      <td>0.514</td>\n    </tr>\n    <tr>\n      <th>495</th>\n      <td>Raft</td>\n      <td>9</td>\n      <td>resources/output\\append_data_2\\run4_raftType=R...</td>\n      <td>2022-04-14 08:32:38,988</td>\n      <td>2022-04-14 08:32:40,613</td>\n      <td>2022-04-14 08:32:39,607</td>\n      <td>2022-04-14 08:32:38.988</td>\n      <td>2022-04-14 08:32:40.613</td>\n      <td>2022-04-14 08:32:39.607</td>\n      <td>1625.0</td>\n      <td>619.0</td>\n      <td>0.619</td>\n      <td>1.625</td>\n    </tr>\n  </tbody>\n</table>\n<p>496 rows × 13 columns</p>\n</div>"
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# appenddata_results = []\n",
+    "# for file in glob.glob('resources/output/append_data*/*.log'):\n",
+    "#     appenddata_results.extend(load_logfile(file, 'appenddata'))\n",
+    "#\n",
+    "# append_df = pd.json_normalize(appenddata_results)\n",
+    "# append_df['start'] = pd.to_datetime(append_df.appenddata_start)\n",
+    "# append_df['end'] = pd.to_datetime(append_df.appenddata_end)\n",
+    "# append_df['majority'] = pd.to_datetime(append_df.appenddata_majority)\n",
+    "#\n",
+    "# append_df['duration_ms'] = (append_df.end - append_df.start).astype(np.int64) / int(1e6)\n",
+    "# append_df['duration_majority_ms'] = (append_df.majority - append_df.start).astype(np.int64) / int(1e6)\n",
+    "# append_df['duration_majority_s'] = append_df.duration_majority_ms / 1000\n",
+    "# append_df['duration_s'] = append_df.duration_ms / 1000\n",
+    "# append_df.to_json('appenddata_results.json.gz',  compression='gzip')\n",
+    "# append_df\n",
+    "\n",
+    "append_df = pd.read_json('appenddata_results.json.gz', compression='gzip')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 720x1080 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(2, 1, sharex='col', figsize=(10, 15))\n",
+    "axs = axs.flatten()\n",
+    "plot_box(append_df, ax=axs[0], y='duration_s', logy=False)\n",
+    "plot_line(append_df, ax=axs[1], y='duration_s', logy=False)\n",
+    "\n",
+    "for ax in axs:\n",
+    "    ax.set_xlabel(\"Number of nodes\")\n",
+    "    ax.set_ylabel(\"Duration (seconds) from append data to consistent state\")\n",
+    "    ax.legend(title='Algorithm')\n",
+    "\n",
+    "# fig.savefig('appenddata_duration.png', dpi=250)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 1080x720 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2, figsize=(15, 10))\n",
+    "\n",
+    "# append_df['majority'] =\n",
+    "append_df['rank'] = append_df['nodes'].rank(method='dense') - 1\n",
+    "sns.lineplot(data=append_df[append_df.raftTypeStr == 'BRaft'], x='nodes', y='duration_s',ax=axs[0], label='Time until consistent')\n",
+    "sns.lineplot(data=append_df[append_df.raftTypeStr == 'BRaft'], x='nodes', y='duration_majority_s',ax=axs[0], label='Time until majority has replicated')\n",
+    "axs[0].set_title('BRaft')\n",
+    "sns.lineplot(data=append_df[append_df.raftTypeStr == 'Raft'], x='nodes', y='duration_s',ax=axs[1], label='Time until consistent')\n",
+    "sns.lineplot(data=append_df[append_df.raftTypeStr == 'Raft'], x='nodes', y='duration_majority_s',ax=axs[1], label='Time until majority has replicated')\n",
+    "axs[1].set_title('Raft')\n",
+    "\n",
+    "for ax in axs:\n",
+    "    ax.set_xlabel(\"Number of nodes\")\n",
+    "    ax.set_ylabel(\"Duration (seconds) from append data\")\n",
+    "    # ax.legend(title='Algorithm')\n",
+    "    ax.grid()\n",
+    "# fig.savefig('appenddata_time_to_majority.png', dpi=250)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(2520, 11)"
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_json('election_results.json.gz', compression='infer')\n",
+    "df['duration_s'] = df.duration_ms / 1000\n",
+    "df.shape"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 215,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 720x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1,1, figsize=(10,6))\n",
+    "sns.scatterplot(data=df, x='num_messages', y='duration_s', hue='nodes', style='raftTypeStr', s=10)\n",
+    "ax.set_xscale('log')\n",
+    "ax.set_yscale('log')\n",
+    "ax.grid()\n",
+    "# ax.get_legend().remove()\n",
+    "ax.set_xlabel(\"Number of messages\")\n",
+    "ax.set_ylabel(\"Duration (seconds)\")\n",
+    "fig.savefig('scatter.png', dpi=250)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "outputs": [],
+   "source": [
+    "def plot_box(data, ax=None, save=False, fig=None, y='duration_s', logy=True):\n",
+    "    if not ax:\n",
+    "        fig, ax = plt.subplots(1,1,figsize=(20,10))\n",
+    "    sns.boxplot(data=data, x='nodes', y=y, hue='raftTypeStr', ax=ax)\n",
+    "    if logy:\n",
+    "        ax.set_yscale('log')\n",
+    "    ax.grid()\n",
+    "    # ax.set_ylim([0, 30000])\n",
+    "\n",
+    "    if fig and save:\n",
+    "        fig.savefig('results_combined_box', dpi=250)\n",
+    "    return fig, ax"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "outputs": [],
+   "source": [
+    "# fig, axs = plt.subplots(1,2, sharey=True, figsize=(10,5))\n",
+    "def plot_line(data, ax, y='duration_s', logy=True):\n",
+    "    data['rank'] = data['nodes'].rank(method='dense') - 1\n",
+    "    sns.lineplot(data=data, x='rank', y=y, hue='raftTypeStr',ax=ax)\n",
+    "    if logy:\n",
+    "        ax.set_yscale('log')\n",
+    "    ax.grid()\n",
+    "    return fig, ax"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 720x1080 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(2, 1, sharex='col', figsize=(10, 15))\n",
+    "\n",
+    "plot_box(df, ax=axs[0])\n",
+    "plot_line(df, ax=axs[1])\n",
+    "\n",
+    "for ax in axs:\n",
+    "    ax.set_xlabel(\"Number of nodes\")\n",
+    "    ax.set_ylabel(\"Duration (seconds)\")\n",
+    "    ax.legend(title='Algorithm')\n",
+    "\n",
+    "fig.savefig('election_duration.png', dpi=250)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "140.0"
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.shape[0] / 9 / 2"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 228,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 720x1080 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(2, 1, sharex='col', figsize=(10, 15))\n",
+    "\n",
+    "plot_box(df, ax=axs[0], y='num_messages')\n",
+    "plot_line(df, ax=axs[1], y='num_messages')\n",
+    "\n",
+    "for ax in axs:\n",
+    "    ax.set_xlabel(\"Number of nodes\")\n",
+    "    ax.set_ylabel(\"Number of sent messages\")\n",
+    "    ax.legend(title='Algorithm')\n",
+    "\n",
+    "fig.savefig('election_messages.png', dpi=250)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# fig, axs = plt.subplots(1,2, sharey=True, figsize=(10,5))\n",
+    "def plot_line_v1(data, ax=None, save=False, fig=None):\n",
+    "    if not ax:\n",
+    "        fig, axs = plt.subplots(1,2, sharey=True, figsize=(10,5))\n",
+    "    else:\n",
+    "        axs = ax\n",
+    "\n",
+    "    for i, (algo, group) in enumerate(data.groupby('raftTypeStr')):\n",
+    "        ax = axs if type(axs) != np.ndarray else axs[i]\n",
+    "        agged = group.groupby('nodes').duration_ms.agg([np.mean, np.std])\n",
+    "        agged.plot(kind='line', y='mean', ax=ax, label=algo)\n",
+    "        ax.fill_between(agged.index, agged['mean'] - agged['std'], agged['mean'] + agged['std'], alpha = 0.1)\n",
+    "\n",
+    "        # ax.set_yscale('log')\n",
+    "        ax.set_xlabel('Number of Nodes')\n",
+    "        ax.set_ylabel('Average time taken in ms')\n",
+    "        ax.grid()\n",
+    "    if fig and save:\n",
+    "        fig.savefig('election_time', dpi=250)\n",
+    "    return fig, ax"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(1,1)\n",
+    "for i, (algo, group) in enumerate(df.groupby('raftTypeStr')):\n",
+    "    group.groupby('nodes').duration_ms.agg([np.mean, np.std]).plot(kind='line', y='mean', yerr='std', ax=ax, label=algo)\n",
+    "\n",
+    "ax.set_yscale('log')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "for i in range(3):\n",
+    "    print(i+1)\n",
+    "    c = df[df.file.apply(lambda k: f'election_timer_{i+1}' in k)].groupby(['raftTypeStr', 'nodes', 'run']).count()\n",
+    "    display(c[c==9].dropna())"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/B-Raft/experiments/README.md b/B-Raft/experiments/README.md
new file mode 100644
index 00000000..1ba971ac
--- /dev/null
+++ b/B-Raft/experiments/README.md
@@ -0,0 +1,46 @@
+# BRaft Experiments
+To quantitatively assess the quality of our BRaft implementation run our cluster under different circumstances with different configurations. 
+
+This is done in run_experiments.py.
+At the bottom of this file one can specify what experiments to run and how many times to replicate these.
+
+The script then creates the different configurations and call BRaft Main with them, this starts our cluster. Logs are captured as they contain an accurate view of our system at any time. These logs are then parsed to collect metrics and draw conclusions.
+
+## Configuring experiments
+Through the `experiment_config` dict all parameters in BRaft's [`application.conf` (link)](../src_/main/resources/application.conf) raftPrototype key can be controlled. These are:
+
+```editorconfig
+raftPrototype {
+	raftType="BRaft"
+
+	electionTimerIntervalMin=3
+
+	electionTimerIntervalMax=4
+
+	heartbeatTimerInterval=1
+
+	nodes=21
+
+	crashIntervalHeartbeats=1000000
+
+	sleepDowntime=8
+
+	maxTerm=9999
+}
+```
+
+### example
+By setting 
+```python
+    num_replications = 4
+    experiment_config = {
+        "raftType": ["Raft", "BRaft"],
+        "nodes": np.linspace(start=3, stop=21, num=9, dtype=int),
+    }
+```
+in `run_experiments.py` 4 runs of experiments are done with every combination of nodes and raftType specified. This particular config will thus result in 2 * 9 * 4 = 54 output logs.
+
+
+## Log parsing and plotting
+Can be found in the [Plotting notebook](DS%20Graphs.ipynb)
+
diff --git a/B-Raft/experiments/__init__.py b/B-Raft/experiments/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/B-Raft/experiments/appenddata_results.json.gz b/B-Raft/experiments/appenddata_results.json.gz
new file mode 100644
index 00000000..a4732e0e
Binary files /dev/null and b/B-Raft/experiments/appenddata_results.json.gz differ
diff --git a/B-Raft/experiments/election_results.json.gz b/B-Raft/experiments/election_results.json.gz
new file mode 100644
index 00000000..f31af9b3
Binary files /dev/null and b/B-Raft/experiments/election_results.json.gz differ
diff --git a/B-Raft/experiments/julian_run.txt b/B-Raft/experiments/julian_run.txt
new file mode 100644
index 00000000..22c60aea
--- /dev/null
+++ b/B-Raft/experiments/julian_run.txt
@@ -0,0 +1 @@
+C:\Users\Jbies\.jdks\azul-13.0.10\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2021.3.2\lib\idea_rt.jar=51173:C:\Program Files\JetBrains\IntelliJ IDEA 2021.3.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\target\scala-2.13\classes;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\github\oshi\oshi-core\5.7.5\oshi-core-5.7.5.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\akka\akka-actor-typed_2.13\2.6.0\akka-actor-typed_2.13-2.6.0.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\akka\akka-actor_2.13\2.6.0\akka-actor_2.13-2.6.0.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\akka\akka-slf4j_2.13\2.6.0\akka-slf4j_2.13-2.6.0.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\config\1.4.1\config-1.4.1.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\io\kamon\kamon-apm-reporter_2.13\2.5.1\kamon-apm-reporter_2.13-2.5.1.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\io\kamon\kamon-bundle_2.13\2.5.1\kamon-bundle_2.13-2.5.1.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\io\kamon\kamon-core_2.13\2.5.1\kamon-core_2.13-2.5.1.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\net\java\dev\jna\jna-platform\5.8.0\jna-platform-5.8.0.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\net\java\dev\jna\jna\5.8.0\jna-5.8.0.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scala-lang\modules\scala-java8-compat_2.13\0.9.0\scala-java8-compat_2.13-0.9.0.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scala-lang\scala-library\2.13.1\scala-library-2.13.1.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scala-lang\scala-reflect\2.13.1\scala-reflect-2.13.1.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scalactic\scalactic_2.13\3.0.8\scalactic_2.13-3.0.8.jar;C:\Users\Jbies\OneDrive\Masters\CSE\Q3\Distibuted Sytems\prototype-scala-raft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar" de.maxbundscherer.scala.raft.Main
\ No newline at end of file
diff --git a/B-Raft/experiments/run_experiments.py b/B-Raft/experiments/run_experiments.py
new file mode 100644
index 00000000..a18e9ab8
--- /dev/null
+++ b/B-Raft/experiments/run_experiments.py
@@ -0,0 +1,138 @@
+import atexit
+import itertools
+import logging
+import os
+import subprocess
+import time
+
+import numpy as np
+from tqdm import tqdm
+
+with open("run_main_pepijn.txt", "r") as f:
+    run_main_command = f.read()
+
+CURR_POPEN_PROCESS = None
+
+
+def run_experiments(
+        experiment_config,
+        exp_dir=None,
+        max_elections=10,
+        num_replications=10,
+        follow_raft_log=True,
+):
+    global CURR_POPEN_PROCESS
+    if not exp_dir:
+        exp_dir = time.strftime("%Y%m%d-%H%M%S")
+
+    exp_dir = os.path.join(os.path.abspath(os.getcwd()), exp_dir)
+    logging.info(f"Creating experiment directory: {exp_dir}")
+    os.makedirs(exp_dir, exist_ok=True)
+
+    experiments = []
+    for key, values in experiment_config.items():
+        experiments.append([(key, val) for val in values])
+
+    all_exps = sorted(list(itertools.product(*experiments)), key=lambda x: -x[1][1])
+
+    exp_string = "\n".join([str(x) for x in all_exps])
+    logging.info("All experiments: \n" + exp_string)
+    with open(os.path.join(exp_dir, "experiments.txt"), "w+") as f:
+        f.write(exp_string)
+
+    for run in range(num_replications):
+        logging.info(f"Replication run {run + 1}/{num_replications}")
+        for exp_num, value_list in tqdm(enumerate(all_exps)):
+            logging.info(f"Running exp {exp_num}/{len(all_exps)} with values: {value_list}")
+            experiment_vars = {}
+            for (variable, value) in value_list:
+                experiment_vars[variable] = str(value)
+
+            logfile = os.path.join(
+                exp_dir, f"run{run + 1}_" +
+                         "_".join([f"{key}={value}" for key, value in experiment_vars.items()])
+                         + ".log"
+            )
+            # specify logfile
+            logging.info(f"Setting logfile to {logfile}")
+            experiment_vars["LOGFILE"] = logfile
+
+            # run experiment
+            num_elections = 0
+            starttime = time.time()
+            popen = subprocess.Popen(
+                run_main_command,
+                stdout=subprocess.PIPE,
+                env=experiment_vars,
+                bufsize=10,
+                stdin=subprocess.PIPE,
+            )
+
+            CURR_POPEN_PROCESS = popen
+
+            for stdout_line in iter(
+                    popen.stdout.readline,
+                    "",
+            ):
+                stdout_line = str(stdout_line)
+
+                if "[VERIFY APPEND DATA]" in stdout_line:
+                    break
+
+                if "[UNABLE TO VERIFY DUE TO TIMEOUT]" in stdout_line:
+                    break
+
+                if (time.time() - starttime) > 300:
+                    logging.warning(f"Experiment {exp_num} took more than 5 minutes, skipping")
+                    break
+
+            popen.terminate()
+            logging.info(
+                f"Experiment {exp_num} finished in {time.time() - starttime :.2f} seconds"
+            )
+
+
+def cleanup():
+    timeout_sec = 5
+    p = CURR_POPEN_PROCESS
+    if not p:
+        return
+    p_sec = 0
+    for second in range(timeout_sec):
+        if p.poll() == None:
+            time.sleep(1)
+            p_sec += 1
+    if p_sec >= timeout_sec:
+        p.kill()  # supported from python 2.6
+
+    logging.info("Killed all processes")
+
+
+atexit.register(cleanup)
+
+if __name__ == "__main__":
+    # Specify the list of values to use here, see src/main/resources/application.conf for possible variables
+    # Every combination of the values set here will be run 'num_replications' times
+    num_replications = 4
+    experiment_config = {
+        "raftType": ["Raft", "BRaft"],
+        "crashIntervalHeartbeats": [10000],
+        "nodes": np.linspace(start=3, stop=21, num=9, dtype=int),
+    }
+
+    logging.getLogger().setLevel("INFO")
+
+    # output experiment directory, replace with name of experiment(group)
+    experiment_dir = "resources/output/append_data_2"
+
+    # set to true to see Raft logging in console of this process
+    follow_raft_log = False
+
+    # actually run the experiments
+    run_experiments(
+        experiment_config,
+        exp_dir=experiment_dir,
+        max_elections=10,
+        num_replications=num_replications,
+        follow_raft_log=follow_raft_log,
+    )
diff --git a/B-Raft/experiments/run_main_pepijn.txt b/B-Raft/experiments/run_main_pepijn.txt
new file mode 100644
index 00000000..886a7868
--- /dev/null
+++ b/B-Raft/experiments/run_main_pepijn.txt
@@ -0,0 +1 @@
+"C:\Program Files\Java\jdk-13.0.1\bin\java.exe" -Dfile.encoding=UTF-8 -classpath C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\target\scala-2.13\classes;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scalactic\scalactic_2.13\3.0.8\scalactic_2.13-3.0.8.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scala-lang\scala-reflect\2.13.1\scala-reflect-2.13.1.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scala-lang\scala-library\2.13.1\scala-library-2.13.1.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\org\scala-lang\modules\scala-java8-compat_2.13\0.9.0\scala-java8-compat_2.13-0.9.0.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\net\java\dev\jna\jna\5.8.0\jna-5.8.0.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\net\java\dev\jna\jna-platform\5.8.0\jna-platform-5.8.0.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\io\kamon\kamon-core_2.13\2.5.1\kamon-core_2.13-2.5.1.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\io\kamon\kamon-bundle_2.13\2.5.1\kamon-bundle_2.13-2.5.1.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\io\kamon\kamon-apm-reporter_2.13\2.5.1\kamon-apm-reporter_2.13-2.5.1.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\config\1.4.1\config-1.4.1.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\akka\akka-slf4j_2.13\2.6.0\akka-slf4j_2.13-2.6.0.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\akka\akka-actor_2.13\2.6.0\akka-actor_2.13-2.6.0.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\typesafe\akka\akka-actor-typed_2.13\2.6.0\akka-actor-typed_2.13-2.6.0.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\com\github\oshi\oshi-core\5.7.5\oshi-core-5.7.5.jar;C:\Users\ptema\Documents\uni\y4\IN4391\lab\AkkaRaft\null\Coursier\cache\v1\https\repo1.maven.org\maven2\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar de.maxbundscherer.scala.raft.Main
\ No newline at end of file
diff --git a/B-Raft/src/.gitignore b/B-Raft/src/.gitignore
new file mode 100644
index 00000000..c80514b0
--- /dev/null
+++ b/B-Raft/src/.gitignore
@@ -0,0 +1,9 @@
+../target/
+.idea/
+*.class
+*.log
+.DS_Store
+.java-version
+.idea
+src/null/
+experiments/resources/
diff --git a/B-Raft/src/LICENSE b/B-Raft/src/LICENSE
new file mode 100644
index 00000000..261eeb9e
--- /dev/null
+++ b/B-Raft/src/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/B-Raft/src/README.md b/B-Raft/src/README.md
new file mode 100644
index 00000000..82895f6a
--- /dev/null
+++ b/B-Raft/src/README.md
@@ -0,0 +1,402 @@
+# (Prototype) Raft Consensus Algorithm in Scala
+
+**Protoype [Raft Consensus](https://raft.github.io/raft.pdf) Algorithm in Scala**
+
+![](src/docImg/logos.png)
+
+Tested on ``macOs 10.15.2`` with ``openjdk64-11.0.2`` and ``sbt 1.3.3``
+
+[![shields.io](http://img.shields.io/badge/license-Apache2-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.txt)
+![](https://github.com/maxbundscherer/prototype-scala-raft/workflows/CI%20Test/badge.svg)
+
+Test line-coverage: 88,11% ([12-30-2019](src/docImg/test-report-12-30-2019.zip))
+
+Author: [Maximilian Bundscherer](https://bundscherer-online.de)
+
+## Let's get started
+
+- [sbt](https://www.scala-sbt.org/) and [openjdk64-11.0.2](https://jdk.java.net/archive/) are required to build and run project
+
+- Run with: ``sbt run`` (see ***What happens in normal run?*** below)
+- Test with: ``sbt test`` (or see ci-tests in GitHub-Actions-CI-Pipeline) (see ***What happens in test run?*** below)
+- Generate test-coverage-html-report with: ``sbt jacoco``
+
+### Used dependencies
+
+- [akka actors](https://doc.akka.io/docs/akka/current/actors.html): Actor model implementation (Scala/Java).
+- [scalactic](http://www.scalactic.org/): Test kit for Scala.
+- [sbt-jacoco](https://github.com/sbt/sbt-jacoco): SBT plugin for generating coverage-reports.
+
+### What is implemented?
+
+- RaftNode as Finite-state machine (**FSM**) with **key-value storage**
+
+    - ``(Uninitialized)``: Not initialized
+    - ``Follower`` (Default behavior): Waiting for heartbeats from leader-node with hashCode from data. If local stored data's hashCode is not equal to leader-node data's hashCode, the node will synchronize with leader-node. If there is no heartbeat from leader-node in configured randomized interval received, the node will change to candidate-behavior. 
+    - ``Candidate``: The candidate requests votes from all followers and votes for himself. If he wins the election in configured interval, he will become the leader. If not, he will become follower again. For winning the election the node requires the majority of votes.
+    - ``Leader``: The leader is sending continuous heartbeats to all followers with hashCode from his stored data. The leader is the only node that is allowed to write data.
+    - ``(Sleep)``: Is used for simulating leader-crashes (triggered by crashIntervalHeartbeats in normal run or by SimulateLeaderCrash in test run). In this behavior, the node does not respond to non-debug-messages. After configured downtime, the node changes to follower-behavior.
+    
+![](src/docImg/raftFsm.png)
+
+#### Configuration
+
+There are two configurations:
+
+- ``./src/main/resources/application.conf`` used for normal run
+- ``./src/test/resources/application.conf`` used for test run
+    
+```
+akka {
+
+    # Log Level (DEBUG, INFO, WARNING, ERROR)
+    loglevel = "DEBUG"
+
+}
+
+raftPrototype {
+
+    # Election Timer Min (Seconds)
+    electionTimerIntervalMin = 2
+
+    # Election Timer Max (Seconds)
+    electionTimerIntervalMax = 3
+
+    # Heartbeat Timer Interval (Seconds)
+    heartbeatTimerInterval = 1
+
+    # Raft Nodes (Amount)
+    nodes = 5
+
+    # Crash Interval (auto simulate crash after some heartbeats in LEADER behavior)
+    crashIntervalHeartbeats = 10
+
+    # Sleep downtime (Seconds) (after simulated crash in SLEEP behavior)
+    sleepDowntime = 8
+
+}
+```
+
+### What happens in normal run?
+
+All nodes start in follower behavior (some of them will change their behavior to candidate) and elect the first leader.
+
+After some (configured) heartbeats from leader, the leader is simulating its crash and is "sleeping" for configured downtime. The next leader will be elected.
+
+This happens again and again and again... until you stop the program or the earth is going to overheat. 😉
+
+Data exchange (write data trough leader to followers) will be tested in test run (see below).
+
+### What happens in test run?
+
+1. Leader election (after init nodes)
+2. Write data trough leader to followers (first write data to leader and replicate data to followers)
+3. Get back data from all nodes (all nodes should have same data)
+4. Simulate leader crash (triggered in test)
+5. New leader election (old leader is gone)
+6. Write data trough leader to followers (first write data to leader and replicate data to followers)
+7. Get back data from all nodes (all nodes should have same data)
+
+
+The ***integration-test*** is well documented - it is self explaining:
+
+- ``./src/test/scala/de/maxbundscherer/scala/raft/RaftServiceTest.scala``
+
+## Exciting (scala) stuff
+
+Concurrent programming in Scala is usually done with akka actors. Akka actors is an actor model implementation for Scala and Java. Akka is developed/maintained by [Lightbend](https://www.lightbend.com/) (earlier called Typesafe).
+
+The program and business logic is divided into separated actors. Each of these actors has its own state (own protected memory) and can only communicate with other actors by immutable messages.
+
+![](src/docImg/ActorModel.png)
+
+([Image source](https://blog.scottlogic.com/2014/08/15/using-akka-and-scala-to-render-a-mandelbrot-set.html))
+
+The ``RaftNodeActor`` has the following state implemented:
+
+```scala
+/**
+    * Internal (mutable) actor state
+    * @param neighbours Vector with another actors
+    * @param electionTimer Cancellable for timer (used in FOLLOWER and CANDIDATE behavior)
+    * @param heartbeatTimer Cancellable for timer (used in LEADER behavior)
+    * @param alreadyVoted Boolean (has already voted in FOLLOWER behavior)
+    * @param voteCounter Int (counter in CANDIDATE behavior)
+    * @param majority Int (calculated majority - set up in init)
+    * @param heartbeatCounter Int (auto simulate crash after some heartbeats in LEADER behavior)
+   *  @param data Map (String->String) (used in FOLLOWER and LEADER behavior)
+   *  @param lastHashCode Int (last hashcode from data) (used in FOLLOWER and LEADER behavior)
+    */
+  case class NodeState(
+      var neighbours            : Vector[ActorRef]    = Vector.empty,
+      var electionTimer         : Option[Cancellable] = None,
+      var heartbeatTimer        : Option[Cancellable] = None,
+      var alreadyVoted          : Boolean             = false,
+      var voteCounter           : Int                 = 0,
+      var majority              : Int                 = -1,
+      var heartbeatCounter      : Int                 = 0,
+      var data                  : Map[String, String] = Map.empty,
+      var lastHashCode          : Int                 = -1,
+  )
+```
+
+### Akka Actors Example
+
+```scala
+package de.maxbundscherer.scala.raft.examples
+
+import akka.actor.{Actor, ActorLogging}
+
+class SimpleActor extends Actor with ActorLogging {
+  
+  override def receive: Receive = {
+
+    case data: String =>
+      
+      sender ! data + "-pong"
+
+    case any: Any =>
+      
+      log.error(s"Got unhandled message '$any'")
+      
+  }
+  
+}
+```
+
+In this example, you can see a very simple akka actor: The actor is waiting for string-messages and replies with a new string (``!`` is used for [fire-and-forget-pattern](https://doc.akka.io/docs/akka/current/typed/interaction-patterns.html#fire-and-forget) / use ``?`` to use [ask-pattern](https://doc.akka.io/docs/akka/current/typed/interaction-patterns.html#request-response-with-ask-from-outside-an-actor) instead).
+
+Non-string-messages are displayed by an error-logger.
+
+### Raft nodes as akka actors
+
+In this project, raft nodes are implemented as an akka actor (``RaftNodeActor``) with finite-state machine (FSM) behavior (see description and image above).
+
+#### Finite-state machine (FSM) in akka
+
+You can define multiple behaviors in an akka actor - see example:
+
+```scala
+package de.maxbundscherer.scala.raft.examples
+
+import akka.actor.{Actor, ActorLogging}
+
+object SimpleFSMActor {
+  
+  //Initialize message/command
+  case class Initialize(state: Int)
+  
+}
+
+class SimpleFSMActor extends Actor with ActorLogging {
+
+  import SimpleFSMActor._
+  
+  //Actor mutable state
+  private var state = -1
+
+  //Initialized behavior 
+  def initialized: Receive = {
+
+    case any: Any => log.info(s"Got message '$any'")
+    
+  }
+
+  //Default behavior
+  override def receive: Receive = {
+
+    case Initialize(newState) =>
+
+      state = newState
+      context.become(initialized)
+
+    case any: Any => log.error(s"Not initialized '$any'")
+
+  }
+
+}
+```
+
+#### Service-Layer
+
+Classic akka actors are not type safety. To "simulate" type safety, the service-layer (``RaftService``) was implemented. The service-layer is also used to spawn & initialize actors and to supervise the actor system - see examples:
+
+- Spawn akka actor:
+```scala
+actorSystem.actorOf(props = RaftNodeActor.props, name = "myRaftNode")
+```
+
+- Ask (type safety non-blocking request):
+```scala
+def ping(): Future[Pong] = {
+  ( actorRef ? Ping() ).asInstanceOf[Future[Pong]]
+}
+```
+
+#### Aggregates
+
+The object (read-only-singleton) ``RaftAggregate`` includes all necessary classes and objects (actor messages) for ``RaftService``, ``RaftNodeActor`` and ``RaftScheduler``.
+
+#### Trait ``Configuration``
+
+Scala traits are very similar to Java's interfaces. Traits can also include implementation. Normal classes can be extended (inheritance) by multiple traits, but only extend from one abstract class. Traits support multiple inheritance.
+
+In this project the trait ``Configuration`` with internal object (read-only-singleton) ``Config`` is used to pass user-config to program.
+
+The user-config is defined in the file ``application.conf`` and is loaded by a config-factory (see project dependencies).
+
+#### Trait ``RaftScheduler``
+
+The trait ``RaftScheduler`` is used to control raft-nodes timers in ``RaftNodeActor`` with the following function-calls:
+
+- ``def stopElectionTimer()``: Used to stop electionTimer. This timer informs about "heartbeat-timeout" (``SchedulerTrigger.ElectionTimeout``) in FOLLOWER behavior and about "election-timeout" (``SchedulerTrigger.ElectionTimeout``) in CANDIDATE behavior.
+- ``def restartElectionTimer()``: Used to stop and start electionTimer.
+- ``def stopHeartbeatTimer()``: Used to stop heartbeatTimer. This timer informs about "send-heartbeat to all followers" (``SchedulerTrigger.Heartbeat``) in LEADER behavior.
+- ``def restartHeartbeatTimer()``: Used to stop and start heartbeatTimer.
+- ``def scheduleAwake()``: Used to trigger awakening automatically after downtime in SLEEP behavior (``SchedulerTrigger.Awake``). Awakening means: The node changes to follower-behavior.
+
+Timers are controlled by ``changeBehavior`` and ``followerBehavior`` in ``RaftNodeActor`` to stop and start timers dependent on the nodes' behavior:
+
+```scala
+/**
+   * Before change of behavior
+   */
+val newBehavior: Receive = toBehavior match {
+
+  [...]
+  
+  case BehaviorEnum.FOLLOWER =>
+    restartElectionTimer()
+    stopHeartbeatTimer()
+    followerBehavior
+
+  case BehaviorEnum.CANDIDATE =>
+    restartElectionTimer()
+    stopHeartbeatTimer()
+    candidateBehavior
+
+  [...]
+
+}
+```
+
+```scala
+/**
+   * After change of behavior
+   */
+toBehavior match {
+      
+  [...]
+
+  case BehaviorEnum.SLEEP => scheduleAwake()
+      
+  [...]
+
+}
+```
+
+```scala
+/**
+   * In followerBehavior
+   */
+case Heartbeat(lastHashCode) =>
+      
+      [...]
+
+      restartElectionTimer()
+```
+
+#### Service Configurator Pattern
+
+The program architecture is based on the [Service Configurator Pattern](https://www.usenix.org/legacy/publications/library/proceedings/coots97/full_papers/jain/jain.pdf).
+
+The actor system & the services are started and configured in ...
+
+- ... object ``Main`` for normal run.
+- ... trait ``BaseServiceTest`` for test run.
+
+## Scala compared to Go
+
+- Data-types in Scala and Go are strong, static, inferred and structural typed.
+- Scala intends to multicore architectures and brings functional programming & object oriented programming together. To improve code quality, you should not mix both concepts.
+- Go intends to multicore architectures, too, and is an alternative to the programming language C.
+- Learning Scala is time-consuming and sometimes quite involved because of the necessity to be familiar with the concept of functional programming and the huge amounts of complex concepts in the basic-language implemented.
+- Learning Go is not so time-consuming, because Go is built on easy & familiar concepts (for example the concept of object oriented programming).
+- Scala is usually running in the Java-virtual-machine (JVM) and can interact with Java-libraries. Compiling Scala [native](https://github.com/scala-native/scala-native) is possible, but unusual.
+- Go is running native (is not compiled to byte-code) and can interact with C-libraries.
+
+### Go concurrency
+
+The language provides multiple possibilities:
+
+- Concurrent execution ([goroutines](https://golangbot.com/goroutines/))
+- Synchronization and messaging ([channels](https://www.geeksforgeeks.org/channel-in-golang/) - very similar to akka actors - Buffered Channels - FIFO)
+- Multi-way concurrent control ([select](https://gobyexample.com/select))
+- Low level blocking primitives ([locks/sync](https://golang.org/pkg/sync/))
+
+### Scala concurrency
+
+In Scala ``ExecutionContext`` (default is ``ExecutionContext.global``) is responsible for executing computations. The default ``ExecutionContext`` is a global static thread pool and is based on [Java's Fork/Join](https://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html). For example, you can set:
+
+- ``scala.concurrent.context.minThreads``
+- ``scala.concurrent.context.maxThreads``
+
+You can also use multiple ``ExecutionContext``s in your application (or server-cluster).
+
+Concurrent programming in Scala is usually done with akka actors. See "Exciting (scala) stuff" above.
+
+You can also use:
+
+- Scala Futures
+
+```scala
+val future = Future {
+  getData()
+}
+
+future.onComplete {
+  case Success(data) => println(s"Got $data")
+  case Failure(exception) => println(s"Got failure $exception")
+}
+```
+
+- Threads and Thread Pools from Java (unusually)
+
+```scala
+// This is unusually. Better use akka actors.
+
+class ExampleProcessor extends Thread {
+  override def run() {
+    while(true) {
+      val examples = Examples.getExamples()
+      examples.foreach{ example =>
+        process(example)
+      }
+    }
+  }
+}
+
+//Start new thread
+val thread = new ExampleProcessor()
+thread.start()
+
+//Wait for finishing
+thread.join()
+```
+
+### My personal opinion:
+
+- Scala is more empowering and you need less code.
+- Go runs faster and very effective but sometimes feels repetitive and very mechanic.
+- Scala is used for high-level cloud-applications (for example [Apache Spark](https://spark.apache.org/)).
+- Go is used for low-level applications to make high-level-applications possible (for example [Docker](https://www.docker.com/)).
+- **Comparing both languages is quite inconclusive because of their different fields of application.**
+
+## Prospects
+
+- This implementation is a prototype and should not be used in production.
+- You can use [akka cluster](https://doc.akka.io/docs/akka/current/cluster-usage.html) to run this implementation on network and different machines. You have to modify the ``RaftService`` to spawn actors in cluster.
+- Do not use Java serializer in production. It is slow and not secure. Use [Protobuf](https://github.com/protocolbuffers/protobuf) instead.
+
+
+![](src/docImg/logos.png)
\ No newline at end of file
diff --git a/B-Raft/src/build.sbt b/B-Raft/src/build.sbt
new file mode 100644
index 00000000..2cff5a1f
--- /dev/null
+++ b/B-Raft/src/build.sbt
@@ -0,0 +1,25 @@
+name := "prototype-scala-raft"
+version := "0.1"
+scalaVersion := "2.13.1"
+
+//Akka Actors
+val akkaVersion = "2.6.0"
+libraryDependencies += "com.typesafe.akka" %% "akka-actor-typed" % akkaVersion
+libraryDependencies += "com.typesafe.akka" %% "akka-testkit" % akkaVersion % Test
+
+//ScalaTest
+val scalaTestVersion = "3.0.8"
+libraryDependencies += "org.scalactic" %% "scalactic" % scalaTestVersion
+libraryDependencies += "org.scalatest" %% "scalatest" % scalaTestVersion % "test"
+logBuffered in Test := false //Disable buffered logs in test
+parallelExecution in Test := false //Run suites sequentially
+
+// Kamon (Akka telemetry)
+libraryDependencies += "io.kamon" %% "kamon-bundle" % "2.5.1"
+libraryDependencies += "io.kamon" %% "kamon-apm-reporter" % "2.5.1"
+
+//Config Factory
+libraryDependencies += "com.typesafe" % "config" % "1.4.0"
+
+//Logger
+libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3"
\ No newline at end of file
diff --git a/B-Raft/src/docImg/ActorModel.png b/B-Raft/src/docImg/ActorModel.png
new file mode 100644
index 00000000..a089ca5e
Binary files /dev/null and b/B-Raft/src/docImg/ActorModel.png differ
diff --git a/B-Raft/src/docImg/logos.png b/B-Raft/src/docImg/logos.png
new file mode 100644
index 00000000..cd447a5a
Binary files /dev/null and b/B-Raft/src/docImg/logos.png differ
diff --git a/B-Raft/src/docImg/raftFsm.png b/B-Raft/src/docImg/raftFsm.png
new file mode 100644
index 00000000..2640d0e2
Binary files /dev/null and b/B-Raft/src/docImg/raftFsm.png differ
diff --git a/B-Raft/src/project/build.properties b/B-Raft/src/project/build.properties
new file mode 100644
index 00000000..010613d5
--- /dev/null
+++ b/B-Raft/src/project/build.properties
@@ -0,0 +1 @@
+sbt.version = 1.3.3
\ No newline at end of file
diff --git a/B-Raft/src/project/plugins.sbt b/B-Raft/src/project/plugins.sbt
new file mode 100644
index 00000000..731a40b0
--- /dev/null
+++ b/B-Raft/src/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("com.github.sbt" % "sbt-jacoco" % "3.1.0")
\ No newline at end of file
diff --git a/B-Raft/src/src/main/resources/application.conf b/B-Raft/src/src/main/resources/application.conf
new file mode 100644
index 00000000..7dd70db9
--- /dev/null
+++ b/B-Raft/src/src/main/resources/application.conf
@@ -0,0 +1,50 @@
+akka {
+
+    # Log Level (DEBUG, INFO, WARNING, ERROR)
+    loglevel = "INFO"
+}
+
+kamon {
+  environment.service = "Braft"
+  apm.api-key = ""
+  apm.api-key = ${?KAMON_API_KEY}
+  instrumentals.akka.filters {
+     actors.track {
+       includes = [ "Braft/raftSystem/**"]
+     }
+
+     dispatchers {
+       includes = [ "Braft/**" ]
+     }
+
+     routers {
+       includes = [ "Braft/**" ]
+     }
+  }
+}
+
+raftPrototype {
+	raftType="BRaft"
+	raftType=${?raftType}
+
+	electionTimerIntervalMin=3
+	electionTimerIntervalMin=${?electionTimerIntervalMin}
+
+	electionTimerIntervalMax=4
+	electionTimerIntervalMax=${?electionTimerIntervalMax}
+
+	heartbeatTimerInterval=1
+	heartbeatTimerInterval=${?heartbeatTimerInterval}
+
+	nodes=21
+	nodes=${?nodes}
+
+	crashIntervalHeartbeats=1000000
+	crashIntervalHeartbeats=${?crashIntervalHeartbeats}
+
+	sleepDowntime=8
+	sleepDowntime=${?sleepDowntime}
+
+	maxTerm=9999
+	maxterm=${?maxTerm}
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/resources/logback.xml b/B-Raft/src/src/main/resources/logback.xml
new file mode 100644
index 00000000..2fdf6e9b
--- /dev/null
+++ b/B-Raft/src/src/main/resources/logback.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>[%date{ISO8601}]\t[%level]\t[%X{akkaSource}]\t- %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+        <file>${LOGFILE}}</file>
+        <encoder>
+            <pattern>[%date{ISO8601}]\t[%level]\t[%X{akkaSource}]\t- %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="DEBUG">
+        <appender-ref ref="STDOUT"/>
+        <appender-ref ref="FILE"/>
+    </root>
+
+</configuration>
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/Main.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/Main.scala
new file mode 100644
index 00000000..e566f999
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/Main.scala
@@ -0,0 +1,86 @@
+package de.maxbundscherer.scala.raft
+
+import akka.actor.ActorSystem
+import akka.event.LoggingAdapter
+import akka.util.Timeout
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.ActualData
+import de.maxbundscherer.scala.raft.services.RaftService
+import kamon.Kamon
+import de.maxbundscherer.scala.raft.utils.Configuration
+
+import scala.concurrent.ExecutionContextExecutor
+import scala.concurrent.duration._
+
+
+object Main extends App with Configuration {
+  def checkFinished(data: Vector[ActualData]): Boolean = {
+    log.info("Checking if data is consistent")
+    val uniqueHashCodes: Vector[Int] = data.map(_.data.hashCode()).distinct
+    uniqueHashCodes.size == 1 && data.head.data.size == 4
+  }
+
+  import de.maxbundscherer.scala.raft.services._
+//  Kamon.init()
+  private implicit val actorSystem: ActorSystem = ActorSystem("raftSystem")
+  private implicit val executionContext: ExecutionContextExecutor = actorSystem.dispatcher
+  private implicit val timeout: Timeout = 15.seconds
+  private val log: LoggingAdapter = actorSystem.log
+  log.warning(s"Starting Main with Config:$Config")
+
+  // No nice inheritance here unfortunately (in the interest of time...)
+  if (Config.raftTypeStr == "Raft") {
+    val raftService = new RaftService(numberNodes = Config.nodes)
+
+    Thread.sleep(8000)
+
+    raftService.appendData("x", "5")
+    raftService.appendData("y", "4")
+    raftService.appendData("z", "3")
+    raftService.appendData("q", "2")
+
+    Thread.sleep(5000)
+    try {
+      var data: Vector[ActualData] = raftService.evaluateActualData
+      while(!checkFinished(data)) {
+        Thread.sleep(10000)
+        data = raftService.evaluateActualData
+      }
+      log.info(s"[VERIFY APPEND DATA], Consistent")
+    }
+    catch {
+      case _ => log.info(s"[UNABLE TO VERIFY DUE TO TIMEOUT]")
+    }
+
+    log.warning("Press [Enter] to terminate actorSystem")
+//    scala.io.StdIn.readLine()
+    raftService.terminate()
+  } else {
+    val raftService = new BRaftService(numberNodes = Config.nodes)
+
+    Thread.sleep(8000)
+
+    raftService.appendBRaftData("x", "5")
+    raftService.appendBRaftData("y", "4")
+    raftService.appendBRaftData("z", "3")
+    raftService.appendBRaftData("q", "2")
+
+    Thread.sleep(5000)
+    try {
+      var data: Vector[ActualData] = raftService.evaluateActualData
+      while(!checkFinished(data)) {
+        Thread.sleep(10000)
+        data = raftService.evaluateActualData
+      }
+      log.info(s"[VERIFY APPEND DATA], Consistent")
+    }
+    catch {
+      case _ => log.info(s"[UNABLE TO VERIFY DUE TO TIMEOUT]")
+    }
+
+    log.warning("Press [Enter] to terminate actorSystem")
+//    scala.io.StdIn.readLine()
+    raftService.terminate()
+  }
+  Kamon.stop()
+  System.exit(0)
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/actors/BRaftNodeActor.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/actors/BRaftNodeActor.scala
new file mode 100644
index 00000000..fabf2cb7
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/actors/BRaftNodeActor.scala
@@ -0,0 +1,824 @@
+package de.maxbundscherer.scala.raft.actors
+
+import akka.actor.{Actor, ActorLogging, ActorRef}
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.BehaviorEnum.BehaviorEnum
+import de.maxbundscherer.scala.raft.aggregates.Aggregate._
+import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate.GrantVote.GrantVoteSigned
+import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate.LogEntry
+import de.maxbundscherer.scala.raft.schnorr.Schnorr.{string_sign, string_verify}
+import de.maxbundscherer.scala.raft.utils.{Configuration, Hasher, RaftScheduler}
+
+import scala.collection.mutable.ArrayBuffer
+import scala.concurrent.ExecutionContext
+
+// TODO verify/sign more (or all?) messages?
+object BRaftNodeActor {
+
+  import akka.actor.Props
+
+  val prefix: String = "BraftNodeActor"
+
+  def props()(implicit executionContext: ExecutionContext): Props = Props(new BRaftNodeActor())
+
+  /**
+    * Internal (mutable) actor state
+    *
+    */
+
+  /**
+    *
+    * @param lastHashCode          Int (last hashcode from data) (used in FOLLOWER and LEADER behavior)
+    * @param entryLog              ArrayBuffer[LogEntry] to keep track of all entries, in the order they arrive, and whether they
+    *                              are committed yet
+    * @param appendEntryResponseMap    Map (Int ->Set[String]) that links LogEntry indices to a set of nodes that have already
+    *                              written that log entry. Used to control when an entry is committed by the node.
+    * @param publicKey             PublicKey used by other nodes to verify messages
+    * @param privateKey            Private Key used by this node to sign messages
+    * @param hasher                Hasher (sha256)
+    * @param publicKeyStorage      Map(String -> BigInt) stores the public keys of all other nodes, used for verifying messages
+    *                              were not tampered with.
+    * @param term                  current Leader term
+    * @param byzantineActor        ??? TODO
+    * @param behaviour             Current behaviour this node is exhibiting (one of :
+    *                              UNINITIALIZED, FOLLOWER, CANDIDATE, LEADER, SLEEP)
+    * @param forceIamNotConsistent boolean to force an IamNotConsistent RPC to be sent.
+    *                              Used when a majority of nodes committed a LogEntry, but this node
+    *                              has not received it yet.
+    * @param voteRequestResponses  Map to track the Votes of each node in a Leader election (only for Leader state)
+    *                              Maps the node ID to GrantVoteSigned object
+    */
+  case class BRaftNodeState(
+                             var lastHashCode: BigInt = -1,
+                             var entryLog: ArrayBuffer[LogEntry] = ArrayBuffer(),
+                             var appendEntryResponseMap: Map[Int, Set[String]] = Map.empty,
+                             var publicKey: BigInt = -1,
+                             var privateKey: BigInt = -1,
+                             var hasher: Hasher = Hasher(),
+                             var publicKeyStorage: Map[String, BigInt] = Map.empty,
+                             var term: Int = 0,
+                             var byzantineActor: Option[ActorRef] = None,
+                             var behaviour: BehaviorEnum = BehaviorEnum.UNINITIALIZED,
+                             var forceIamNotConsistent: Boolean = false,
+                             var voteRequestResponses: Map[String, GrantVoteSigned] = Map.empty,
+                             var lastHeartBeatTimestamp: Long = 0
+                           ) extends NodeState
+
+}
+
+/**
+  * ------------------
+  * --- BRaft Node ----
+  * ------------------
+  *
+  * # 5 Behaviors (Finite-state machine / FSM)
+  *
+  * !!! SEE PROJECT README !!!
+  *
+  * - (UNINITIALIZED)
+  * - FOLLOWER (Default - after init)
+  * - CANDIDATE (after election timeout)
+  * - LEADER
+  * - (SLEEP) (after simulated crash in LEADER)
+  */
+class BRaftNodeActor()(implicit val executionContext: ExecutionContext)
+  extends Actor
+    with ActorLogging
+    with RaftScheduler
+    with Configuration {
+
+  import BRaftNodeActor._
+  import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate._
+
+  val notHandled = new Object
+
+  val notHandledFun: Any => Object = (_: Any) => notHandled
+
+  override def aroundReceive(receive: Receive, msg: Any): Unit = {
+    log.info(s"Received message:${msg.getClass.toGenericString},${this.state.behaviour},${this.state.term}")
+    super.aroundReceive(receive, msg)
+  }
+
+  /**
+    * Mutable actor state
+    */
+  override val state: BRaftNodeState = BRaftNodeState()
+
+  log.info("Actor online (uninitialized)")
+
+  /**
+    * Uninitialized behavior
+    */
+  override def receive: Receive = {
+
+    case InitActor(neighbours, keyPair, clientPublicKey, keys) =>
+      log.info("Initializing actor")
+
+      state.neighbours = neighbours
+      state.majority = ((neighbours.size + 1) / 2) + 1
+      state.privateKey = keyPair._1
+      state.publicKey = keyPair._2
+      state.publicKeyStorage = keys
+      state.publicKeyStorage += (CLIENT_NAME -> clientPublicKey)
+
+      log.debug(s"State: ${state.publicKeyStorage.toString()}")
+      log.debug(s"pubkey: ${state.publicKey}, keypair: ${keyPair}")
+
+      changeBehavior(
+        fromBehavior = BehaviorEnum.UNINITIALIZED,
+        toBehavior = BehaviorEnum.FOLLOWER,
+        loggerMessage = s"Got ${state.neighbours.size} neighbours (majority=${state.majority})"
+      )
+
+    case any: Any => log.error(s"Node is not initialized but got message $any")
+
+  }
+
+  def verify_votes(term: Int, voteRequestResponses: Map[String, GrantVoteSigned]): Boolean = {
+    // For each voteRequestReponse verify signature, and count number of granted votes
+    val validVotes = voteRequestResponses.filter(entry => {
+      val node: String = entry._1
+      val grantVoteSigned: GrantVoteSigned = entry._2
+      string_verify(state.publicKeyStorage(node), grantVoteSigned.vote.toString, grantVoteSigned.signature)
+    })
+
+    validVotes.count(entry => entry._2.granted) >= state.majority && term > state.term
+  }
+
+  /**
+    * Raft FOLLOWER
+    */
+  def followerBehavior: Receive = {
+
+    case GrantVoteSigned => //Ignore message
+
+    case InitiateLeaderElection =>
+
+      changeBehavior(fromBehavior = BehaviorEnum.FOLLOWER,
+        toBehavior = BehaviorEnum.CANDIDATE,
+        loggerMessage = "No heartbeat from leader (InitiateLeaderElection case")
+
+    case SchedulerTrigger.ElectionTimeout =>
+
+      changeBehavior(fromBehavior = BehaviorEnum.FOLLOWER,
+        toBehavior = BehaviorEnum.CANDIDATE,
+        loggerMessage = "No heartbeat from leader, ElectionTimeOut")
+
+    case BroadcastTerm(term, voteRequestResponses) =>
+      if (verify_votes(term, voteRequestResponses)) {
+        log.info(s"Updated term from: ${state.term}, to new term: ${term}, got enough valid votes")
+        state.term = term
+
+        restartElectionTimer()
+      } else {
+        log.info(s"Node ${sender().path.name} says it is the new leader, but not enough votes are valid or granted, or term was lower")
+        changeBehavior(fromBehavior = BehaviorEnum.FOLLOWER,
+          toBehavior = BehaviorEnum.CANDIDATE,
+          loggerMessage = "Leader did not get enough valid votes")
+      }
+
+
+    case BroadcastKey(actorID, publicKey) =>
+
+      state.publicKeyStorage.get(actorID) match {
+        case Some(_) => // Already in the map
+        case None =>
+          state.publicKeyStorage += (actorID -> publicKey) // Not in the map yet, therefore add it
+          log.debug(s"I received a BroadcastKey from: ${sender.path.name} and append it to my storage")
+      }
+
+
+    case SimulateLeaderCrash => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case WhoIsLeader => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case _: AppendData => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case GetActualData =>
+
+      log.info(s"Returning actual data: ${state.data}")
+      sender ! ActualData(data = state.data)
+
+    case GetState =>
+
+      log.info("I have sent my state")
+      sender ! MyStateIs(state)
+
+    case Heartbeat(lastHashCode, publicKeysStorage, term) =>
+
+      // TODO : we have to take care of the scenario when a leader crash is initiated and the leader changes behavior from leader
+      //  to sleep. In this period a new leader is elected and the publicKeyStorage and term will be updated accordingly. Only, as
+      //  as the node is asleep it does not receive these updates. Therefore we need to make sure that this node will become eventually
+      //  consistent i.e. has for the current term the right termID and publicKeyStorage to prevent inconsistent states.
+      //
+      //  Do we want to send the publicKeyStorage everytime in a heartbeat? Does seem a bit cumbersome.
+      //  Alternatively, we can change the behavior for a sleeping node as soon as it wakes up? But it is actually unaware who the
+      //  new leader is therefore we can't ask or send IAmInconsistent to the leader. We have to wait for a heartbeat.
+
+      log.debug(s"Got heartbeat from (${sender().path.name}), own entrylog: ${state.entryLog}")
+      log.debug(s"Got heartbeat from (${sender().path.name}), own data: ${state.data}")
+
+      // One case in which this is called is when we had a sleeper node that just woken up and is unaware of the new
+      // term and key storage that were sent by the new leader.
+      val hashCodeEqual = lastHashCode.equals(state.lastHashCode)
+      val termEqual = this.state.term == term
+      val pubKeyStorageEqual = this.state.publicKeyStorage.equals(publicKeysStorage)
+//      val waitingForAERs = this.state.entryLog.count(logEntry => !logEntry.committed) > 0
+
+      if (!hashCodeEqual || !pubKeyStorageEqual || this.state.forceIamNotConsistent || !termEqual
+//        || waitingForAERs
+      ) {
+        this.state.forceIamNotConsistent = false
+        var reason = ""
+        if (!hashCodeEqual) reason += s"HashCode was not equal (was ${state.lastHashCode} expected $lastHashCode),"
+        if (!termEqual) reason += s"Term was not equal(was ${term} expected ${this.state.term}), "
+        if (!pubKeyStorageEqual) reason += s"PubKeyStorage was not equal(was ${this.state.publicKeyStorage.keys} expected ${publicKeysStorage.keys}), "
+        if (this.state.forceIamNotConsistent) reason += s"Forcing Inconsistent to update values"
+//        if (waitingForAERs) reason += s"Waiting for Append Entries Responses"
+        log.info(s"I am not consistent - request data from leader (reason: $reason)")
+        sender ! IamNotConsistent
+      }
+
+      restartElectionTimer()
+
+    /**
+      * AppendEntries happens here, but only to the log because we don't know if enough nodes have written it.
+      */
+    case OverrideData(entryLog: ArrayBuffer[LogEntry], publicKeysStorage, term) =>
+      log.info(s"Received OverrideData: entryLog: $entryLog, term: $term")
+      this.state.publicKeyStorage = publicKeysStorage
+      this.state.term = term
+
+      val startIndex: Int = if (state.entryLog.nonEmpty) state.entryLog.length else 0
+      // Only replay log if we got new entries
+      if (entryLog.nonEmpty && startIndex < entryLog.length) {
+        log.debug(s"Overriding data from index $startIndex, received log len: ${entryLog.length}, " +
+          s"entries: ${entryLog.toString()} \nslice: ${entryLog.slice(startIndex, entryLog.length)}")
+        // Replay all entries from latest index we have logged upwards
+        entryLog.slice(startIndex, entryLog.length).foreach(entry => handleReceivedEntry(entry))
+        log.debug(s"finished replaying, own log: ${state.entryLog.toString()}")
+        log.info(s"Follower is writing data (newHashCode = ${state.entryLog.last.hash})")
+      }
+
+    case RequestVote(term) =>
+
+      val heartBeatPeriodPassed = state.lastHeartBeatTimestamp < (System.currentTimeMillis() - electionTimeout)
+      log.info(s"Incoming VR from: ${sender.path.name}, state.alreadyVoted should be false," +
+        s"is ${state.alreadyVoted}, heartBeatPeriodPassed=$heartBeatPeriodPassed +, state.electionTimer.isDefined " +
+        s"should be true, is ${state.electionTimer.isDefined}, received term is $term, own term is ${state.term}")
+
+      if (!state.alreadyVoted && term > state.term && heartBeatPeriodPassed) {
+        log.info(s"I voted for actor: ${sender.path.name}")
+        // We send the along with the signature, also the public key to the leader so that
+        // he can store all the public keys of all the actors that are currently participating
+        // in this term.
+        log.info(s"Granting vote to ${sender().path.name}")
+        val vote = Vote(granted = true, from = this.self.path.name, to = sender().path.name, term = term)
+        sender ! GrantVoteSigned(string_sign(this.state.privateKey, vote.toString), granted = true, vote)
+        state.alreadyVoted = true
+      } else {
+        log.info(s"I did not vote granted for actor: ${sender.path.name}")
+        val vote = Vote(granted = false, from = this.self.path.name, to = sender().path.name, term = state.term + 1)
+        sender ! GrantVoteSigned(string_sign(this.state.privateKey, vote.toString), granted = false, vote)
+      }
+
+    case appendEntriesResponse: AppendEntriesResponse =>
+      handleAppendEntriesResponse(appendEntriesResponse, sender().path.name)
+
+
+    case any: Any =>
+
+      log.warning(s"Got unhandled message in followerBehavior '${any.getClass.getSimpleName}' from (${sender().path.name})")
+
+  }
+
+  /**
+    * Raft CANDIDATE
+    */
+  def candidateBehavior: Receive = {
+
+    case GetActualData =>
+
+      log.info(s"Returning actual data: ${state.data}")
+      sender ! ActualData(data = state.data)
+
+    case appendEntriesResponse: AppendEntriesResponse =>
+      handleAppendEntriesResponse(appendEntriesResponse, sender().path.name)
+
+    case BroadcastKey(_, _) => // Ignore this case here, a new node can not join during an election
+
+    case GetState =>
+
+      log.info("I have sent my state")
+      sender ! MyStateIs(state)
+
+    case SchedulerTrigger.ElectionTimeout =>
+
+      state.term = state.term - 1
+
+      changeBehavior(
+        fromBehavior = BehaviorEnum.CANDIDATE,
+        toBehavior = BehaviorEnum.FOLLOWER,
+        loggerMessage = s"Not enough votes (${state.voteCounter}/${state.majority})")
+
+    case BroadcastTerm(_, _) => //Ignore
+
+    case Heartbeat(_, _, term) =>
+
+    //      if (state.term < term) {
+    //        state.term = state.term - 1
+    //
+    //        changeBehavior(
+    //          fromBehavior = BehaviorEnum.CANDIDATE,
+    //          toBehavior = BehaviorEnum.FOLLOWER,
+    //          loggerMessage = s"Not enough votes (${state.voteCounter}/${state.majority})")
+    //      }
+
+    case RequestVote =>
+      val vote = Vote(granted = false, from = this.self.path.name, to = sender().path.name, term = this.state.term + 1)
+      sender ! GrantVoteSigned(string_sign(this.state.privateKey, vote.toString), granted = false, vote)
+
+    case SimulateLeaderCrash => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case WhoIsLeader => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case _: AppendData => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case grantVote: GrantVoteSigned =>
+      if (grantVote.granted && string_verify(state.publicKeyStorage(sender().path.name), grantVote.vote.toString, grantVote.signature)) {
+        state.voteCounter = state.voteCounter + 1
+
+        log.debug(s"Got vote ${state.voteCounter}/${state.majority} from (${sender().path.name})")
+        state.voteRequestResponses += sender().path.name -> grantVote
+        if (state.voteCounter >= state.majority) {
+
+          log.info(s"The new term is ${state.term}")
+
+          changeBehavior(
+            fromBehavior = BehaviorEnum.CANDIDATE,
+            toBehavior = BehaviorEnum.LEADER,
+            loggerMessage = s"Become leader - enough votes (${state.voteCounter}/${state.majority})"
+          )
+
+          // TODO : as the leader is elected we want to broadcast all the publicKeys it has received during the
+          //  leader election of the nodes that have participated.
+
+
+          log.info("Became leader, broadcasting term to all neighbours")
+          state.neighbours.foreach({ neighbour =>
+            neighbour ! BroadcastTerm(state.term, state.voteRequestResponses)
+          })
+
+        }
+      }
+
+    case any: Any =>
+      log.warning(s"Got unhandled message in candidateBehavior '${any.getClass.getSimpleName}' from (${sender().path.name})")
+  }
+
+  /**
+    * Raft LEADER
+    */
+  def leaderBehavior: Receive = {
+    case msg: Any =>
+      leaderMatch(msg)
+  }
+
+  /**
+    * Default leader behavior
+    *
+    * @param msg received message
+    */
+  def leaderMatch(msg: Any): Unit = msg match {
+    case BroadcastKey(actorID, publicKey) =>
+      log.info("BroadCastKeys")
+      state.publicKeyStorage.get(actorID) match {
+        case Some(_) => // Already in the map
+        case None => state.publicKeyStorage += (actorID -> publicKey) // Not in the map yet, therefore add it
+      }
+
+    case BroadcastTerm(term, voteRequestResponses) =>
+      if (verify_votes(term, voteRequestResponses)) {
+        changeBehavior(fromBehavior = BehaviorEnum.LEADER,
+          toBehavior = BehaviorEnum.FOLLOWER,
+          loggerMessage = "there is a new leader with higher term and majority of the votes, stepping down")
+      }
+
+    case SchedulerTrigger.Heartbeat =>
+
+      log.info(s"My state is: ${state.behaviour}, and I am going to send a heartbeat! (counter = ${state.heartbeatCounter})")
+
+      state.neighbours.foreach(neighbour => neighbour ! Heartbeat(lastHashCode = state.lastHashCode, state.publicKeyStorage, state.term))
+
+      state.heartbeatCounter = state.heartbeatCounter + 1
+
+      if (state.heartbeatCounter >= Config.crashIntervalHeartbeats) {
+        changeBehavior(
+          fromBehavior = BehaviorEnum.LEADER,
+          toBehavior = BehaviorEnum.SLEEP,
+          loggerMessage = s"Simulated test crash (crashIntervalHeartbeats) - sleep ${Config.sleepDowntime} seconds now"
+        )
+      }
+
+    case BroadcastTerm => //Ignore
+
+    case GrantVoteSigned => //Ignore message
+
+    case GrantVote => //Ignore message
+
+    case RequestVote => //Ignore message
+
+    case appendEntriesResponse: AppendEntriesResponse =>
+      handleAppendEntriesResponse(appendEntriesResponse, sender().path.name)
+
+    case SimulateLeaderCrash =>
+
+      sender ! LeaderIsSimulatingCrash(actorName = self.path.name)
+
+      changeBehavior(
+        fromBehavior = BehaviorEnum.LEADER,
+        toBehavior = BehaviorEnum.SLEEP,
+        loggerMessage = s"Simulated test crash (externalTrigger) - sleep ${Config.sleepDowntime} seconds now"
+      )
+
+    case WhoIsLeader =>
+
+      sender ! IamTheLeader(actorName = self.path.name)
+
+    case AppendData(key, value, signature) =>
+      log.info(s"Appending new data in Leader Node: ($key -> $value)")
+
+      // Create the hash and find the relevant public key
+      val newHash = createIncrementalHash(key, value, state.lastHashCode)
+      val publicKey = state.publicKeyStorage(CLIENT_NAME)
+
+      // Check if the signature is correct with verify
+      if (!string_verify(publicKey, s"$key,$value", signature)) {
+        log.warning("Signature from client was invalid. Ignoring this message")
+        sender ! WriteResponse(actorName = self.path.name, success = false, reason = "Signature from client was Invalid")
+      } else {
+        sender ! WriteResponse(actorName = self.path.name, success = true, "Write successful in leader")
+        handleReceivedEntry(LogEntry(key, value, newHash, signature))
+        log.info(s"[SEND APR], ${System.currentTimeMillis()}, (key/value = $key->$value), (newHashCode = ${state.lastHashCode}), Leader is writing data")
+
+        // AppendEntriesResponse:
+        // TODO what to do here, entry is not committed/replicated yet
+        //      sender ! WriteSuccess(actorName = self.path.name)
+      }
+
+    case GetActualData =>
+
+      log.info(s"Returning actual data: ${state.data}")
+      sender ! ActualData(data = state.data)
+
+    case GetState =>
+
+      log.info("I have sent my state")
+      sender ! MyStateIs(state)
+
+    case BroadcastKey(actorID, publicKey) =>
+
+      // First add the public key of the new node in the map, if it isn't already. Of course
+      // it is not always the case that an inconsistent node is a new node (such as a sleeper)
+
+      // Check if the key is already in the store, if not we add it and broadcast the new key to all the followers as a heartbeat
+
+      state.publicKeyStorage.get(actorID) match {
+        case Some(_) => // Hooray we already have this actor in our storage
+        case None => // This actor is unknown to us as of now, we are broadcasting the new key
+
+          state.publicKeyStorage += (actorID -> publicKey) // Not in the map yet, therefore add it
+          log.debug(s"I received a BroadcastKey from: ${sender.path.name} and append it to my storage")
+
+          val followers = state.neighbours.filter(neighbour => neighbour != sender)
+
+          followers.foreach(follower => {
+            follower ! BroadcastKey(actorID, publicKey)
+          })
+      }
+
+    case IamNotConsistent =>
+      // AppendEntries
+      log.info(s"Leader received IamNotConsistent from ${sender().path.name}")
+      sender ! OverrideData(data = state.entryLog, publicKeysStorage = this.state.publicKeyStorage, term = this.state.term)
+
+    case Heartbeat(_, _, _) =>
+      if (sender().path.name != this.self.path.name) {
+        log.debug(s"Received heartbeat from ${sender().path.name}")
+      }
+
+    case BecomeByzantine =>
+      changeBehavior(
+        fromBehavior = BehaviorEnum.LEADER,
+        toBehavior = BehaviorEnum.BYZANTINELEADER,
+        loggerMessage = s"Received BecomeByzantine RPC, transitioning to Byzantine Leader"
+      )
+
+    case any: Any =>
+      log.warning(s"Got unhandled message in leaderBehavior '${any.getClass.getSimpleName}' from (${sender().path.name})")
+  }
+
+  /**
+    * Byzantine leader behavior
+    *
+    * @param msg received message
+    */
+  def byzantineLeaderMatch(msg: Any): Unit = msg match {
+
+    case AppendData(key, value, signature) =>
+      log.info(s"Appending new data in Byzantine Leader Node: ($key -> $value)")
+
+      // Create the hash and find the relevant public key
+      val newHash = createIncrementalHash(key, value, state.lastHashCode)
+      val publicKey = state.publicKeyStorage(CLIENT_NAME)
+
+      handleReceivedEntry(LogEntry(key, value, newHash, signature))
+      log.info(s"Byzantine Leader is writing data ($key->$value) (newHashCode = ${newHash})\n " +
+        s"Waiting for enough nodes to write before committing")
+
+      // AppendEntriesResponse:
+      // TODO what to do here, entry is not committed/replicated yet
+      //      sender ! WriteSuccess(actorName = self.path.name)
+      sender ! WriteResponse(actorName = self.path.name, success = true, "Write successful in leader")
+
+    case any =>
+      leaderMatch(any)
+  }
+
+  /**
+    * Byzantine Raft LEADER
+    */
+  def byzantineLeaderBehavior: Receive = {
+    case msg: Any =>
+      log.debug("ByzantineBehavior")
+      byzantineLeaderMatch(msg)
+  }
+
+  /**
+    * Sleep behavior
+    */
+  def sleepBehavior: Receive = {
+
+    case GetActualData =>
+
+      log.info(s"Returning actual data: ${state.data}")
+      sender ! ActualData(data = state.data)
+
+    case SchedulerTrigger.Awake =>
+
+      changeBehavior(fromBehavior = BehaviorEnum.SLEEP,
+        toBehavior = BehaviorEnum.FOLLOWER,
+        loggerMessage = s"Awake after ${Config.sleepDowntime} seconds downtime")
+
+    case SimulateLeaderCrash => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case WhoIsLeader => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case _: AppendData => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case appendEntriesResponse: AppendEntriesResponse =>
+      handleAppendEntriesResponse(appendEntriesResponse, sender.path.name)
+
+  }
+
+  /**
+    * Store a newly received entry until we are confident more
+    * than half the nodes have written it.
+    */
+  private def handleReceivedEntry(logEntry: LogEntry): Unit = {
+    log.info(s"Entry received: $logEntry")
+    if (addEntryToLog(logEntry)) {
+      val idx = state.entryLog.length - 1
+      val s = this.state.appendEntryResponseMap.getOrElse(idx, Set.empty)
+      this.state.appendEntryResponseMap += (idx -> s)
+
+      // Broadcast AppendEntriesResponse to all neighbours
+      val appendEntriesResponse = AppendEntriesResponse(idx, state.entryLog.last.hash)
+      appendEntriesResponse.sign(state.privateKey)
+
+      log.debug(s"Signing entry at ${appendEntriesResponse.index} with hash ${appendEntriesResponse.hash}, " +
+        s"pubkey: ${state.publicKey}, private key: ${state.privateKey}: " +
+        s"signature: ${appendEntriesResponse.signature}")
+
+      this.state.neighbours.foreach(node => node ! appendEntriesResponse)
+    } else {
+      // TODO inconsistent hash, but how to handle?
+    }
+  }
+
+  /**
+    * Handle an AppendEntriesResponse received from another node. This message states
+    * that the sender has written the entry to their log.
+    *
+    * @param appendEntriesResponse Message sent by the node to notify the cluster that it has written an entry
+    * @param senderName            Name of the node that sent this AppendEntriesResponse
+    */
+  private def handleAppendEntriesResponse(appendEntriesResponse: AppendEntriesResponse, senderName: String): Unit = {
+    // verify signature
+    val index = appendEntriesResponse.index
+    val hash = appendEntriesResponse.hash
+    val signature = appendEntriesResponse.signature
+    // We only care about this message if
+    //  1. we have not received the message to write this entry
+    //  2. or we have not committed this entry ourselves.
+    if (state.entryLog.length <= index || (!state.entryLog(index).committed)) {
+      if (string_verify(state.publicKeyStorage(senderName), appendEntriesResponse.toString, signature)) {
+
+        log.debug(s"Signature verified, updating uncommittedEntries at index $index to include $senderName")
+        var newCommittedNeighboursSet: Set[String] = state.appendEntryResponseMap.getOrElse(index, Set.empty)
+        newCommittedNeighboursSet += senderName
+        state.appendEntryResponseMap += (index -> newCommittedNeighboursSet)
+
+        // Check if we need to write an uncommitted entry to data
+        if (newCommittedNeighboursSet.size >= state.majority && this.state.entryLog.size > index && hash == this.state.entryLog(index).hash) {
+          // Check if we have 'old' entries that also need to be committed (as they inductively got enough
+          // append entries responses)
+          val indicesToCommit = Range(0, index+1).filter(i => state.entryLog.size > i && !state.entryLog(i).committed)
+          log.info(s"enough nodes committed entry/entries at index $indicesToCommit, I am also committing this entry")
+
+          indicesToCommit.foreach(f = commitEntry)
+        }
+      } else {
+        log.warning(s"Signature from $senderName was invalid, ignoring msg")
+        log.debug(s"AppendEntriesResponse at $index from $senderName, verifiedMessage = false, " +
+          s"pubkey of sender:\t ${state.publicKeyStorage(senderName)}, with msg: \t${appendEntriesResponse.toString}, " +
+          s"signature:\t $signature")
+      }
+    } else {
+      log.debug(s"Entry at $index already committed")
+    }
+  }
+
+  /**
+    * Write a LogEntry from entryLog to state.data.
+    * Called when a majority of nodes has written an entry
+    *
+    * @param entryLogIndex Index of the entry to write.
+    */
+  private def commitEntry(entryLogIndex: Int): Unit = {
+    if (state.entryLog.length <= entryLogIndex) {
+      // inconsistent, we don't have access to the leader here so we wait for
+      // a heartbeat and then respond with IamNotConsistent.
+      log.warning("Trying to commit log which is not in my entryLog, forcing IamNotConsistent")
+      this.state.forceIamNotConsistent = true
+    } else {
+      val entry = state.entryLog(entryLogIndex)
+      state.data += (entry.key -> entry.value)
+      log.info(s"[FOLLOWER WRITING DATA], ${System.currentTimeMillis()}, (data = ${state.data}), (newHashCode = ${state.lastHashCode}), The follower is writing the new data")
+      entry.committed = true
+    }
+  }
+
+  private def clientEntryToString(key: String, value: String) = {
+    s"$key,$value"
+  }
+
+  /**
+    * Write a LogEntry to the entryLog, also check the hash to verify the order.
+    *
+    * @param logEntry to write
+    * @return whether the write was successful
+    */
+  private def addEntryToLog(logEntry: LogEntry): Boolean = {
+    val (key, value, expectedHash, clientSignature) = (logEntry.key, logEntry.value, logEntry.hash, logEntry.clientSignature)
+
+    // Verify this message actually came from the client
+    if (string_verify(state.publicKeyStorage(CLIENT_NAME), clientEntryToString(key, value), clientSignature)) {
+
+      log.debug(s"addEntryToLog(key=$key,value=$value), prevhash=${state.lastHashCode}")
+      val hashCode = createIncrementalHash(key, value, state.lastHashCode)
+      if (hashCode == expectedHash) {
+        this.state.lastHashCode = hashCode
+        state.entryLog.addOne(LogEntry(key, value, hashCode, clientSignature))
+        log.debug(s"addEntryToLog finished successfuly, new hash=${state.lastHashCode}")
+        true
+      } else {
+        log.debug(s"Inconsistent hash in addEntryToLog, own computed hash=\n:$hashCode, but received hash was:" +
+          s"\n:$expectedHash, \n:${hashCode - expectedHash}")
+        false
+      }
+    } else {
+      log.warning(s"Received LogEntry with invalid client signature (was $clientSignature), discarding")
+      false
+    }
+  }
+
+  /**
+    * Create the incremental hash used to verify data lineage.
+    * It's composed of the key and value of the current entry, and the hash of the
+    * previous entry. This ensures that if two nodes have equal hashes
+    * at index i, then all entries before index i were equal.
+    *
+    * @param key      key
+    * @param value    value
+    * @param lastHash previous  incremental hash
+    * @return hash
+    */
+  private def createIncrementalHash(key: String, value: String, lastHash: BigInt): BigInt = {
+    val hashstr = s"key=$key value=$value lasthash=$lastHash"
+    log.debug(s"Hashing: $hashstr")
+    val hash = this.state.hasher.hash(hashstr)
+    log.debug(s"create Incremental Hash: $hash")
+    hash
+  }
+
+  /**
+    * Change actor behavior
+    *
+    * @param fromBehavior  Behavior
+    * @param toBehavior    Behavior
+    * @param loggerMessage String (logging)
+    */
+  private def changeBehavior(fromBehavior: BehaviorEnum,
+                             toBehavior: BehaviorEnum,
+                             loggerMessage: String): Unit = {
+
+    log.info(s"Change behavior from '$fromBehavior' to '$toBehavior' ($loggerMessage)")
+
+    /**
+      * Before change of behavior
+      */
+    val newBehavior: Receive = toBehavior match {
+
+      case BehaviorEnum.FOLLOWER =>
+        restartElectionTimer()
+        stopHeartbeatTimer()
+        followerBehavior
+
+      case BehaviorEnum.CANDIDATE =>
+        restartElectionTimer()
+        stopHeartbeatTimer()
+        candidateBehavior
+
+      case BehaviorEnum.LEADER =>
+        stopElectionTimer()
+        restartHeartbeatTimer()
+        leaderBehavior
+
+      case BehaviorEnum.BYZANTINELEADER =>
+        stopElectionTimer()
+        restartHeartbeatTimer()
+        byzantineLeaderBehavior
+
+      case BehaviorEnum.SLEEP =>
+        stopElectionTimer()
+        stopHeartbeatTimer()
+        sleepBehavior
+
+      case _ =>
+        stopElectionTimer()
+        stopHeartbeatTimer()
+        receive
+
+    }
+
+    /**
+      * Change of behavior
+      */
+    context.become(newBehavior)
+
+    /**
+      * After change of behavior
+      */
+    toBehavior match {
+
+      case BehaviorEnum.FOLLOWER =>
+
+        state.alreadyVoted = false
+        state.behaviour = BehaviorEnum.FOLLOWER
+
+      case BehaviorEnum.CANDIDATE =>
+
+        state.voteCounter = 0
+
+        // Send a VR to all neighbours and itself with increased termID
+        // If the candidate becomes a leader the term should increased by one, as the leader election has ended
+        // Also the followers should be informed about this new term
+        state.term = state.term + 1
+        state.neighbours.foreach(neighbour => neighbour ! RequestVote(state.term))
+        val vote = Vote(granted = true, this.self.path.name, this.self.path.name, state.term)
+        self ! GrantVoteSigned(string_sign(this.state.privateKey, vote.toString), granted = true, vote)
+
+        state.behaviour = BehaviorEnum.CANDIDATE
+
+      case BehaviorEnum.LEADER =>
+
+        state.heartbeatCounter = 0
+        state.behaviour = BehaviorEnum.LEADER
+
+      case BehaviorEnum.BYZANTINELEADER =>
+        log.info("Becoming Byzantine Leader")
+        state.heartbeatCounter = 0
+        state.behaviour = BehaviorEnum.BYZANTINELEADER
+
+      case BehaviorEnum.SLEEP =>
+
+        scheduleAwake()
+        state.behaviour = BehaviorEnum.SLEEP
+
+      case _ =>
+
+        state.behaviour = BehaviorEnum.UNINITIALIZED
+    }
+
+  }
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/actors/RaftNodeActor.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/actors/RaftNodeActor.scala
new file mode 100644
index 00000000..732ab61e
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/actors/RaftNodeActor.scala
@@ -0,0 +1,345 @@
+package de.maxbundscherer.scala.raft.actors
+
+import akka.actor.{Actor, ActorLogging}
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.BehaviorEnum.BehaviorEnum
+import de.maxbundscherer.scala.raft.aggregates.Aggregate._
+import de.maxbundscherer.scala.raft.aggregates.RaftAggregate._
+import de.maxbundscherer.scala.raft.utils.{Configuration, RaftScheduler}
+
+import scala.concurrent.ExecutionContext
+
+object RaftNodeActor {
+
+  import akka.actor.Props
+
+  val prefix: String  = "raftNodeActor"
+  def props()(implicit executionContext: ExecutionContext): Props = Props(new RaftNodeActor())
+
+  /**
+    * Internal (mutable) actor state
+    *  @param lastHashCode Int (last hashcode from data) (used in FOLLOWER and LEADER behavior)
+    */
+  case class RaftNodeState(
+      var lastHashCode          : Int                 = -1,
+  ) extends NodeState
+}
+
+/**
+  * ------------------
+  * --- Raft Node ----
+  * ------------------
+  *
+  * # 5 Behaviors (Finite-state machine / FSM)
+  *
+  * !!! SEE PROJECT README !!!
+  *
+  * - (UNINITIALIZED)
+  * - FOLLOWER (Default - after init)
+  * - CANDIDATE (after election timeout)
+  * - LEADER
+  * - (SLEEP) (after simulated crash in LEADER)
+  */
+class RaftNodeActor()(implicit val executionContext: ExecutionContext)
+    extends Actor
+    with ActorLogging
+    with RaftScheduler
+    with Configuration {
+
+  import RaftNodeActor._
+
+
+  /**
+    * Mutable actor state
+    */
+  override val state: RaftNodeState = RaftNodeState()
+
+  val notHandled = new Object
+
+  val notHandledFun: Any => Object = (_: Any) => notHandled
+
+  override def aroundReceive(receive: Receive, msg: Any): Unit = {
+    log.info(s"${System.currentTimeMillis()},Received message:${msg.getClass.toGenericString},,")
+    super.aroundReceive(receive, msg)
+  }
+
+  log.info("Actor online (uninitialized)")
+
+  /**
+    * Change actor behavior
+    * @param fromBehavior Behavior
+    * @param toBehavior Behavior
+    * @param loggerMessage String (logging)
+    */
+  private def changeBehavior(fromBehavior: BehaviorEnum,
+                             toBehavior: BehaviorEnum,
+                             loggerMessage: String): Unit = {
+
+    log.info(s"${System.currentTimeMillis()},Change behavior from '$fromBehavior' to '$toBehavior' ($loggerMessage)")
+
+    /**
+      * Before change of behavior
+      */
+    val newBehavior: Receive = toBehavior match {
+
+      case BehaviorEnum.FOLLOWER =>
+        restartElectionTimer()
+        stopHeartbeatTimer()
+        followerBehavior
+
+      case BehaviorEnum.CANDIDATE =>
+        restartElectionTimer()
+        stopHeartbeatTimer()
+        candidateBehavior
+
+      case BehaviorEnum.LEADER =>
+        stopElectionTimer()
+        restartHeartbeatTimer()
+        leaderBehavior
+
+      case BehaviorEnum.SLEEP =>
+        stopElectionTimer()
+        stopHeartbeatTimer()
+        sleepBehavior
+
+      case _ =>
+        stopElectionTimer()
+        stopHeartbeatTimer()
+        receive
+
+    }
+
+    /**
+      * Change of behavior
+      */
+    context.become(newBehavior)
+
+    /**
+      * After change of behavior
+      */
+    toBehavior match {
+
+      case BehaviorEnum.FOLLOWER =>
+
+        state.alreadyVoted = false
+
+      case BehaviorEnum.CANDIDATE =>
+
+        state.voteCounter = 0
+        state.neighbours.foreach(neighbour => neighbour ! RequestVote)
+        self ! GrantVote
+
+      case BehaviorEnum.LEADER =>
+
+        state.heartbeatCounter = 0
+
+      case BehaviorEnum.SLEEP =>
+
+        scheduleAwake()
+
+      case _ =>
+
+    }
+
+  }
+
+  /**
+    * Uninitialized behavior
+    */
+  override def receive: Receive = {
+
+    case InitActor(neighbours) =>
+
+      state.neighbours = neighbours
+      state.majority = ( (neighbours.size + 1) / 2 ) + 1
+
+      changeBehavior(
+        fromBehavior = BehaviorEnum.UNINITIALIZED,
+        toBehavior = BehaviorEnum.FOLLOWER,
+        loggerMessage = s"Got ${state.neighbours.size} neighbours (majority=${state.majority})"
+      )
+
+    case _: Any => log.error("Node is not initialized")
+
+  }
+
+  /**
+    * Raft FOLLOWER
+    */
+  def followerBehavior: Receive = {
+
+    case SchedulerTrigger.ElectionTimeout =>
+
+      changeBehavior(fromBehavior = BehaviorEnum.FOLLOWER,
+                     toBehavior = BehaviorEnum.CANDIDATE,
+                     loggerMessage = "No heartbeat from leader")
+
+    case SimulateLeaderCrash => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case WhoIsLeader         => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case _: AppendData       => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case GetActualData =>
+
+      log.info(s"Returning actual data ${state.data}")
+      sender ! ActualData(data = state.data)
+
+    case Heartbeat(lastHashCode) =>
+
+      log.debug(s"Got heartbeat from (${sender().path.name})")
+
+      if(! lastHashCode.equals(state.lastHashCode)) {
+
+        log.info("I am not consistent - request data from leader")
+        sender ! IamNotConsistent
+      }
+
+      restartElectionTimer()
+
+    case OverrideData(newData) =>
+
+      state.data = newData
+      state.lastHashCode = state.data.hashCode()
+
+      log.info(s"[FOLLOWER WRITING DATA], ${System.currentTimeMillis()}, (data = ${state.data}), (newHashCode = ${state.lastHashCode}), The follower is writing the new data")
+
+
+      //log.info(s"Follower is writing data (newHashCode = ${state.lastHashCode})")
+
+    case RequestVote =>
+
+      if(!state.alreadyVoted) {
+        sender ! GrantVote
+        state.alreadyVoted = true
+      }
+
+    case any: Any =>
+
+      log.warning(s"Got unhandled message in followerBehavior '${any.getClass.getSimpleName}' from (${sender().path.name})")
+
+  }
+
+  /**
+    * Raft CANDIDATE
+    */
+  def candidateBehavior: Receive = {
+
+    case SchedulerTrigger.ElectionTimeout =>
+
+      changeBehavior(
+        fromBehavior = BehaviorEnum.CANDIDATE,
+        toBehavior = BehaviorEnum.FOLLOWER,
+        loggerMessage = s"Not enough votes (${state.voteCounter}/${state.majority})")
+
+    case _: Heartbeat =>    //Ignore message
+
+    case RequestVote =>     //Ignore message
+
+    case SimulateLeaderCrash => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case WhoIsLeader         => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case _: AppendData       => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case GrantVote =>
+
+      state.voteCounter = state.voteCounter + 1
+
+      log.debug(s"Got vote ${state.voteCounter}/${state.majority} from (${sender().path.name})")
+
+      if (state.voteCounter >= state.majority) {
+
+        changeBehavior(
+          fromBehavior = BehaviorEnum.CANDIDATE,
+          toBehavior = BehaviorEnum.LEADER,
+          loggerMessage = s"Become leader - enough votes (${state.voteCounter}/${state.majority})"
+        )
+
+      }
+
+    case any: Any =>
+
+      log.warning(s"Got unhandled message in candidateBehavior '${any.getClass.getSimpleName}' from (${sender().path.name})")
+
+  }
+
+  /**
+    * Raft LEADER
+    */
+  def leaderBehavior: Receive = {
+
+    case SchedulerTrigger.Heartbeat =>
+
+      state.neighbours.foreach(neighbour => neighbour ! Heartbeat(lastHashCode = state.lastHashCode))
+
+      state.heartbeatCounter = state.heartbeatCounter + 1
+
+      if (state.heartbeatCounter >= Config.crashIntervalHeartbeats) {
+        changeBehavior(
+          fromBehavior = BehaviorEnum.LEADER,
+          toBehavior = BehaviorEnum.SLEEP,
+          loggerMessage =  s"Simulated test crash (crashIntervalHeartbeats) - sleep ${Config.sleepDowntime} seconds now"
+        )
+      }
+
+    case GrantVote =>   //Ignore message
+
+    case RequestVote => //Ignore message
+
+    case SimulateLeaderCrash =>
+
+      sender ! LeaderIsSimulatingCrash(actorName = self.path.name)
+
+      changeBehavior(
+        fromBehavior = BehaviorEnum.LEADER,
+        toBehavior = BehaviorEnum.SLEEP,
+        loggerMessage =  s"Simulated test crash (externalTrigger) - sleep ${Config.sleepDowntime} seconds now"
+      )
+
+    case WhoIsLeader =>
+
+      sender ! IamTheLeader(actorName = self.path.name)
+
+    case AppendData(key, value) =>
+
+      state.data = state.data + (key -> value)
+      state.lastHashCode = state.data.hashCode()
+
+      log.info(s"[SEND APR], ${System.currentTimeMillis()}, (key/value = $key->$value), (newHashCode = ${state.lastHashCode}), Leader is writing data")
+
+      sender ! WriteSuccess(actorName = self.path.name)
+
+    case GetActualData =>
+      log.info(s"Returning actual data ${state.data}")
+      sender ! ActualData(data = state.data)
+
+    case IamNotConsistent =>
+
+      sender ! OverrideData(data = state.data)
+
+    case any: Any =>
+
+      log.warning(s"Got unhandled message in leaderBehavior '${any.getClass.getSimpleName}' from (${sender().path.name})")
+
+  }
+
+  /**
+    * Sleep behavior
+    */
+  def sleepBehavior: Receive = {
+
+    case SchedulerTrigger.Awake =>
+
+      changeBehavior(fromBehavior = BehaviorEnum.SLEEP,
+                     toBehavior = BehaviorEnum.FOLLOWER,
+                     loggerMessage = s"Awake after ${Config.sleepDowntime} seconds downtime")
+
+    case SimulateLeaderCrash => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case WhoIsLeader         => sender ! IamNotTheLeader(actorName = self.path.name)
+
+    case _: AppendData       => sender ! IamNotTheLeader(actorName = self.path.name)
+
+  }
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/Aggregate.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/Aggregate.scala
new file mode 100644
index 00000000..361da38b
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/Aggregate.scala
@@ -0,0 +1,61 @@
+package de.maxbundscherer.scala.raft.aggregates
+
+import akka.actor.Cancellable
+
+
+object Aggregate {
+  import akka.actor.ActorRef
+
+  trait Request
+  trait Response
+
+  /**
+    * Internal (mutable) actor state
+    * @param neighbours Vector with another actors
+    * @param electionTimer Cancellable for timer (used in FOLLOWER and CANDIDATE behavior)
+    * @param heartbeatTimer Cancellable for timer (used in LEADER behavior)
+    * @param alreadyVoted Boolean (has already voted in FOLLOWER behavior)
+    * @param voteCounter Int (counter in CANDIDATE behavior)
+    * @param majority Int (calculated majority - set up in init)
+    * @param heartbeatCounter Int (auto simulate crash after some heartbeats in LEADER behavior)
+    *  @param data Map (String->String) (used in FOLLOWER and LEADER behavior)
+    */
+  class NodeState(
+                        var neighbours            : Vector[ActorRef]    = Vector.empty,
+                        var electionTimer         : Option[Cancellable] = None,
+                        var heartbeatTimer        : Option[Cancellable] = None,
+                        var alreadyVoted          : Boolean             = false,
+                        var voteCounter           : Int                 = 0,
+                        var majority              : Int                 = -1,
+                        var heartbeatCounter      : Int                 = 0,
+                        var data                  : Map[String, String] = Map.empty,
+                      )
+
+  case class  GetActualData(data: Map[String, String])          extends Request
+  case class  ActualData(data: Map[String, String])             extends Response
+
+  object      WhoIsLeader                                       extends Request
+  case class  IamTheLeader(actorName: String)                   extends Response
+  case class  IamNotTheLeader(actorName: String)                extends Response
+
+  object      GetState                                          extends Request
+
+  object      SimulateLeaderCrash                               extends Request
+  case class  LeaderIsSimulatingCrash(actorName: String)        extends Response
+
+  object      InitiateLeaderElection
+    extends Response
+
+  //FSM States (RaftNodeActor)
+  object BehaviorEnum extends Enumeration {
+    type BehaviorEnum = Value
+    val UNINITIALIZED, FOLLOWER, CANDIDATE, LEADER, SLEEP, BYZANTINELEADER = Value
+  }
+
+  //Used by RaftScheduler
+  object SchedulerTrigger {
+    object ElectionTimeout
+    object Heartbeat
+    object Awake
+  }
+}
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/BRaftAggregate.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/BRaftAggregate.scala
new file mode 100644
index 00000000..12610a39
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/BRaftAggregate.scala
@@ -0,0 +1,68 @@
+package de.maxbundscherer.scala.raft.aggregates
+
+import de.maxbundscherer.scala.raft.actors.BRaftNodeActor.BRaftNodeState
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.{Request, Response}
+import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate.GrantVote.GrantVoteSigned
+import de.maxbundscherer.scala.raft.schnorr.Schnorr.string_sign
+
+import scala.collection.mutable.ArrayBuffer
+
+object BRaftAggregate {
+  import akka.actor.ActorRef
+
+
+  case class InitActor(neighbours: Vector[ActorRef], keyPair: (BigInt, BigInt), clientPublicKey: BigInt, keys: Map[String, BigInt]) extends Request
+
+  case class RequestVote(term: Int) extends Request
+
+  object GrantVote {
+    sealed trait Response
+    final case class GrantVoteSigned(signature: BigInt, granted: Boolean, vote: Vote) extends Response
+  }
+
+//  object GrantVote    extends Response
+  case class RejectMessage(reason: String)
+  case class  Heartbeat(lastHashCode: BigInt, publicKeysStorage: Map[String, BigInt], term: Int)                    extends Request
+  case class  IamNotConsistent()          extends Response
+
+  case class  OverrideData(data: ArrayBuffer[LogEntry], publicKeysStorage: Map[String, BigInt], term: Int)  extends Request
+  case class  AppendEntriesResponse(index: Int, hash: BigInt) {
+    var signature: BigInt = -1
+    override def toString: String = {
+      s"hash=$hash,index=$index"
+    }
+
+    def sign(privateKey: BigInt): Unit = {
+      signature = string_sign(privateKey, this.toString)
+    }
+  }
+
+  case class  BecomeByzantine() extends Request
+
+
+  case class  AppendData(key: String,
+                         value: String,
+                         signature: BigInt)                     extends Request
+  case class  WriteResponse(actorName: String, success: Boolean, reason: String) extends Response
+
+  case class  BroadcastKey(actorID: String, publicKeys: BigInt) extends Request
+  case class  BroadcastTerm(term: Int, voteRequestResponses: Map[String, GrantVoteSigned])                          extends Request
+  case class  BroadcastVotesToClient()
+
+  case class LogEntry(key: String, value: String, hash: BigInt, clientSignature: BigInt) {
+     var committed: Boolean = false
+    override def toString: String = {
+      s"$key->$value, hash:$hash"
+    }
+  }
+
+  case class Vote(granted: Boolean, from: String, to:String, term:Int) {
+    override def toString: String = {
+      s"$from $granted vote $to in $term"
+    }
+  }
+
+  case class  MyStateIs(state: BRaftNodeState)                       extends Response
+
+  val CLIENT_NAME: String = "client"
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/RaftAggregate.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/RaftAggregate.scala
new file mode 100644
index 00000000..302c03e4
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/aggregates/RaftAggregate.scala
@@ -0,0 +1,22 @@
+package de.maxbundscherer.scala.raft.aggregates
+
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.Request
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.Response
+
+object RaftAggregate {
+  import akka.actor.ActorRef
+
+
+  case class InitActor(neighbours: Vector[ActorRef]) extends Request
+
+  object RequestVote  extends Request
+  object GrantVote    extends Response
+
+  case class  Heartbeat(lastHashCode: Int)            extends Request
+  object      IamNotConsistent                        extends Response
+  case class  OverrideData(data: Map[String, String]) extends Request
+
+  case class  AppendData(key: String, value: String)  extends Request
+  case class  WriteSuccess(actorName: String)         extends Response
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/examples/SimpleActor.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/examples/SimpleActor.scala
new file mode 100644
index 00000000..c37c5c3e
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/examples/SimpleActor.scala
@@ -0,0 +1,19 @@
+package de.maxbundscherer.scala.raft.examples
+
+import akka.actor.{Actor, ActorLogging}
+
+class SimpleActor extends Actor with ActorLogging {
+
+  override def receive: Receive = {
+
+    case data: String =>
+
+      sender ! data + "-pong"
+
+    case any: Any =>
+
+      log.error(s"Got unhandled message '$any'")
+
+  }
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/examples/SimpleFSMActor.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/examples/SimpleFSMActor.scala
new file mode 100644
index 00000000..5e552076
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/examples/SimpleFSMActor.scala
@@ -0,0 +1,38 @@
+package de.maxbundscherer.scala.raft.examples
+
+import akka.actor.{Actor, ActorLogging}
+
+object SimpleFSMActor {
+
+  //Initialize message/command
+  case class Initialize(state: Int)
+
+}
+
+class SimpleFSMActor extends Actor with ActorLogging {
+
+  import SimpleFSMActor._
+
+  //Actor mutable state
+  private var state = -1
+
+  //Initialized behavior
+  def initialized: Receive = {
+
+    case any: Any => log.info(s"Got message '$any'")
+
+  }
+
+  //Default behavior
+  override def receive: Receive = {
+
+    case Initialize(newState) =>
+
+      state = newState
+      context.become(initialized)
+
+    case any: Any => log.error(s"Not initialized '$any'")
+
+  }
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/Schnorr.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/Schnorr.scala
new file mode 100644
index 00000000..83555889
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/Schnorr.scala
@@ -0,0 +1,103 @@
+package de.maxbundscherer.scala.raft.schnorr
+
+import de.maxbundscherer.scala.raft.schnorr.SchnorrMath._
+import de.maxbundscherer.scala.raft.schnorr.SchnorrUtil._
+import de.maxbundscherer.scala.raft.utils.Hasher
+import org.slf4j.{Logger, LoggerFactory}
+
+import scala.util.Random
+
+object Schnorr {
+  def main(args: Array[String]): Unit = {
+    test_vectors()
+  }
+
+  private val hasher: Hasher = Hasher()
+  val logger: Logger = LoggerFactory.getLogger(this.toString)
+
+  /**
+   * Generates a public key and private key
+   * @return the generated keys as pair (sk, pk)
+   */
+  def generateKeypair(): (BigInt, BigInt) = {
+    val sk = BigInt.probablePrime(bitLength = 32*8, Random)
+    (sk, generatePublicKey(sk))
+  }
+
+  /**
+   * Generates a public key using a private key
+   * @param sk as the 32-byte private key
+   * @return the newly computed 32-byte public key
+   */
+  def generatePublicKey(sk: BigInt): BigInt = {
+    if (sk == 0 || sk >= N) return null
+    val p = point_mul(Some(G), sk)
+    assert(p.isDefined)
+    p.get.x
+  }
+
+  /**
+   * Sign some big integer using a private key and auxiliary data
+   * @param sk as the 32-byte private key
+   * @param msg as the 32-byte big integer message
+   * @param aux as the 32-byte random auxiliary data
+   * @return the newly computed 64-byte signature as big integer
+   */
+  def sign(sk: BigInt, msg: BigInt, aux: BigInt = r_big()): BigInt = {
+    if (sk <= 0 || sk >= N) return null
+    val p: Point = point_mul(Some(G), sk).get
+    val d = if (even_y(Some(p))) sk else N - sk
+    val t = d ^ hashtag("BIP0340/aux", big2bytes(aux))
+    val k_0 = hashtag("BIP0340/nonce", concat(t, p.x, msg)).mod(N)
+    if (k_0 <= 0) return null
+    val r = point_mul(Some(G), k_0).get
+    val k = if (even_y(Some(r))) k_0 else N - k_0
+    val e = hashtag("BIP0340/challenge", concat(r.x, p.x, msg)).mod(N)
+    val signature = BigInt(1, concat(r.x, compute_sign(k, e, d).mod(N)))
+    if (!verify(p.x, msg, signature)) return null
+    signature
+  }
+
+  /**
+   * Verify some big integer using a public key and a signature
+   * @param pk as the 32-byte public key
+   * @param msg as the 32-byte big integer message
+   * @param sig as the 64-byte signature to use
+   * @return true if the verification passed
+   */
+  def verify(pk: BigInt, msg: BigInt, sig: BigInt): Boolean = {
+    val p = lift(pk)
+    val s_l = bytes2int(big2bytes(sig, 64).slice(0, 32))
+    val s_r = bytes2int(big2bytes(sig, 64).slice(32, 64))
+    if (p.isEmpty || s_l - P > 0 || s_r - N > 0) return false
+    val e = hashtag("BIP0340/challenge", concat(s_l, p.get.x, msg)).mod(N)
+    val r = point_add(point_mul(Some(G), s_r.mod(N)), point_mul(p, N - e.mod(N)))
+    if (is_infinite(r) || !even_y(r) || r.get.x - s_l != 0) return false
+    true
+  }
+
+  /**
+   * Sign some string using a private key and auxiliary data
+   * @param sk as the 32-byte private key
+   * @param str as the message string with up to 32 chars
+   * @param aux as the 32-byte random auxiliary data
+   * @return the newly computed 64-byte signature as big integer
+   */
+  implicit def string_sign(sk: BigInt, str: String, aux: BigInt = r_big()): BigInt = {
+    sign(sk, hasher.hash(str), aux)
+  }
+
+  /**
+   * Verify some string using a public key and a signature
+   * @param pk as the 32-byte public key
+   * @param str as the 32-byte big integer message
+   * @param sig as the 64-byte signature to use
+   * @return true if the verification passed
+   */
+  implicit def string_verify(pk: BigInt, str: String, sig: BigInt): Boolean = {
+    val hash = hasher.hash(str)
+    val res = verify(pk, hash, sig)
+//    logger.debug(s"String verify '$str' res: $res, hash:$hash, pubkey: $pk")
+    res
+  }
+}
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/SchnorrMath.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/SchnorrMath.scala
new file mode 100644
index 00000000..6735a994
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/SchnorrMath.scala
@@ -0,0 +1,108 @@
+package de.maxbundscherer.scala.raft.schnorr
+
+import java.nio.charset.Charset
+import java.security.MessageDigest
+import de.maxbundscherer.scala.raft.schnorr.SchnorrUtil._
+
+object SchnorrMath {
+    var P: BigInt = hex2big("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F")
+    var N: BigInt = hex2big("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")
+    var X: BigInt = hex2big("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798")
+    var Y: BigInt = hex2big("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8")
+    var G: Point = Point(X, Y)
+
+    /**
+     * Generate a 32-byte hash with SHA256(SHA256(tag) || SHA256(tag) || msg)
+     * @param tag to be used to hash with
+     * @param msg to be encoded
+     * @return the sha256 digest
+     */
+    def hashtag(tag: String, msg: Array[Byte]): BigInt = {
+      val sha256 = MessageDigest.getInstance("SHA-256")
+      val bytes = sha256.digest(tag.getBytes(Charset.forName("UTF-8")))
+      BigInt(1, sha256.digest(bytes ++ bytes ++ msg))
+    }
+
+    /**
+     * Computes the signature as a big integer
+     * @param k The nonce hash
+     * @param e The hashed message
+     * @param d The private key
+     * @return the resulting signature
+     */
+    def compute_sign(k: BigInt, e: BigInt, d: BigInt): BigInt = {
+      val x1 = (BigInt(1, big2bytes(e)) * BigInt(1, big2bytes(d))).mod(N)
+      (x1 + BigInt(1, big2bytes(k))).mod(N)
+    }
+
+    /**
+     * Determine whether the point lays at infinity
+     * @param p as the point to evaluate
+     * @return true if at infinity
+     */
+    def is_infinite(p: Option[Point]): Boolean = p match {
+      case None ⇒ true
+      case _    ⇒ false
+    }
+
+    /**
+     * Determine whether the y-coordinate is even
+     * @param p as the point to evaluate
+     * @return true if y is even
+     */
+    def even_y(p: Option[Point]): Boolean = {
+      assert(!is_infinite(p))
+      (p.get.y % 2) == 0
+    }
+
+    /**
+     * Performs elliptic curve group operation on two points
+     * @param p1 as the first point
+     * @param p2 as the second point
+     * @return the newly computed point
+     */
+    def point_add(p1: Option[Point], p2: Option[Point]): Option[Point] = {
+      if (p1.isEmpty) return p2
+      if (p2.isEmpty) return p1
+      val (x1, x2) = (p1.get.x, p2.get.x)
+      val (y1, y2) = (p1.get.y, p2.get.y)
+      var lam: BigInt = 0
+      if (x1 == x2) {
+        if (y1 != y2) return None
+        else lam = ((x1 * x1 * 3) * (y1 * 2).modPow(P - 2, P)).mod(P)
+      } else {
+        lam = ((y2 - y1) * (x2 - x1).modPow(P - 2, P)).mod(P)
+      }
+      val x3 = (lam * lam - x1 - x2).mod(P)
+      Some(Point(x3, ((lam * (x1 - x3)).mod(P) - y1).mod(P)))
+    }
+
+    /**
+     * Performs elliptic curve point multiplication using some scalar
+     * @param p the point to multiply
+     * @param n the scalar as big integer
+     * @return the resulting point after repeated addition
+     */
+    def point_mul(p: Option[Point], n: BigInt): Option[Point] = {
+      var q: Option[Point] = p
+      var r: Option[Point] = None
+      for (i ← 0 to 256) {
+        if (((n >> i) & 1) == 1) r = point_add(r, q)
+        q = point_add(q, q)
+      }
+      r
+    }
+
+    /**
+     * Finds an even y-coordinate for some x if it exists
+     * @param x the x-coordinate to consider
+     * @return the point with even y if found
+     */
+    def lift(x: BigInt): Option[Point] = {
+      if (x >= P) return None
+      val sq = (x.modPow(3, P) + 7).mod(P)
+      val y = sq.modPow(((P + 1) / 4).mod(P), P) // Maybe division needs flooring
+      if (sq != y.modPow(2, P)) return None
+      if (y.testBit(0)) Some(Point(x, P - y)) else Some(Point(x, y))
+    }
+  }
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/SchnorrUtil.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/SchnorrUtil.scala
new file mode 100644
index 00000000..bdbb00cd
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/schnorr/SchnorrUtil.scala
@@ -0,0 +1,123 @@
+package de.maxbundscherer.scala.raft.schnorr
+
+import de.maxbundscherer.scala.raft.schnorr.Schnorr._
+import scala.io.Source
+import scala.util.Random
+
+case class Point(x: BigInt, y: BigInt)
+
+  object SchnorrUtil {
+    /**
+     * Runs the Schnorr sign and verification functions for some test vectors.
+     */
+    def test_vectors(): Boolean = {
+      println("Secret Key, Public Key, Auxiliary, Message, Signature, Verification")
+      val bufferedSource = Source.fromFile(getClass.getClassLoader.getResource("vectors.csv").getPath.replace("%20", " "))
+      for (line ← bufferedSource.getLines.drop(1)) {
+        val cols = line.split(",").map(_.trim)
+        // index secret_key	public_key	aux_rand	message	signature	verification result	comment
+        println(s"> SEC ${cols(1)}\n> PUB ${cols(2)}\n> AUX ${cols(3)}\n> MSG ${cols(4)}\n> SIG ${cols(5)}")
+        var verified = false
+        val string = ""
+        if (cols(1) == "") {
+          verified = verify(hex2big(cols(2)), hex2big(cols(4)), hex2big(cols(5)))
+        } else {
+          verified = verify(hex2big(cols(2)), hex2big(cols(4)), hex2big(cols(5)))
+        }
+        println(s"Expected ${cols(6).toLowerCase()} and got $verified $string \n")
+      }
+      bufferedSource.close
+      var (count, n) = (0, 10)
+      for (_ ← count to n) {
+        val msg = r_big()
+        val str = Random.nextString(32)
+        val (sk, pk) = generateKeypair()
+        if (!verify(pk, msg, sign(sk, msg))) count += 1
+        if (!string_verify(pk, str, string_sign(sk, str))) count += 1
+      }
+      println("Successful for " + (2 * n - count) + "/" + (2 * n) + " randomised vector sets")
+      true
+    }
+
+    /**
+     * Generate a random with system time
+     * @return the random object
+     */
+    def get_seed(): Random = {
+      new scala.util.Random(new java.util.Date().hashCode)
+    }
+
+    /**
+     * Generate a random big integer using system time
+     * @return the random big integer
+     */
+    def r_big(): BigInt = {
+      BigInt.probablePrime(bitLength = 32, get_seed())
+    }
+
+    /**
+     * Convert a hex string to a big integer
+     * @param hex as the hex string
+     * @return the big integer
+     */
+    def hex2big(hex: String): BigInt = {
+      BigInt(("00" + hex).sliding(2, 2).toArray.map(Integer.parseInt(_, 16).toByte))
+    }
+
+    /**
+     * Convert a big integer to a hex string
+     * @param x as the big integer
+     * @param size as the byte length
+     * @return
+     */
+    def big2hex(x: BigInt, size: Int = 32): String = {
+      "0x" + big2bytes(x, size).map("%02x" format _).mkString
+    }
+
+    /**
+     * Convert a big integer to an unsigned byte array
+     * @param x as the big integer
+     * @param size as the byte length
+     * @return
+     */
+    def big2bytes(x: BigInt, size: Int = 32): Array[Byte] = {
+      val bytes = x.toByteArray
+      if (bytes.length == size) x.toByteArray
+      else if (bytes.length > size) bytes.slice(bytes.length - size, bytes.length)
+      else {
+        val buffer = new Array[Byte](size)
+        Array.copy(bytes, 0, buffer, buffer.length - bytes.length, bytes.length)
+        buffer
+      }
+    }
+
+    /**
+     * Convert some big integer to an unsigned big integer
+     * @param x as the signed big integer
+     * @return the unsigned big integer
+     */
+    def bytes2int(x: Array[Byte]): BigInt = {
+      BigInt(1, x)
+    }
+
+    /**
+     * Concatenate the unsigned byte arrays of two big integers
+     * @param x1 the first big integer
+     * @param x2 the second big integer
+     * @return
+     */
+    def concat(x1: BigInt, x2: BigInt): Array[Byte] = {
+      big2bytes(x1) ++ big2bytes(x2)
+    }
+
+    /**
+     * Concatenate the unsigned byte arrays of three big integers
+     * @param x1 the first big integer
+     * @param x2 the second big integer
+     * @param x3 the third big integer
+     * @return
+     */
+    def concat(x1: BigInt, x2: BigInt, x3: BigInt): Array[Byte] = {
+      big2bytes(x1) ++ big2bytes(x2) ++ big2bytes(x3)
+    }
+  }
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/services/BRaftService.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/services/BRaftService.scala
new file mode 100644
index 00000000..77d55727
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/services/BRaftService.scala
@@ -0,0 +1,178 @@
+package de.maxbundscherer.scala.raft.services
+
+import akka.pattern.ask
+import akka.actor.{ActorRef, ActorSystem}
+import akka.util.Timeout
+import de.maxbundscherer.scala.raft.actors.BRaftNodeActor.BRaftNodeState
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.{ActualData, GetActualData, GetState, IamNotTheLeader, IamTheLeader, InitiateLeaderElection, LeaderIsSimulatingCrash, SimulateLeaderCrash, WhoIsLeader}
+import de.maxbundscherer.scala.raft.schnorr.Schnorr.{generateKeypair, string_sign}
+
+import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.Await
+
+// Messages from client should be signed (Implement in RaftService)
+class BRaftService(numberNodes: Int)(implicit actorSystem: ActorSystem,
+                                     timeout: Timeout,
+                                     executionContext: ExecutionContext) {
+
+  import de.maxbundscherer.scala.raft.actors.BRaftNodeActor
+  import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate._
+  // Protected to give access in tests
+  private val (privateKey, publicKey): (BigInt, BigInt) = generateKeypair()
+
+  /**
+    * Declare and start up nodes
+    */
+  final val nodes: Map[Int, ActorRef] =
+    (0 until numberNodes)
+      .map(i => {
+        i -> actorSystem.actorOf(props = BRaftNodeActor.props,
+                                 name = s"${BRaftNodeActor.prefix}-$i")
+      })
+      .toMap
+
+  /**
+    * Init nodes with neighbors and keypair
+    */
+  var keys: Map[(Int, String), (BigInt, BigInt)] = nodes.map(node => ((node._1, node._2.path.name), generateKeypair()))
+
+  var pKeys : Map[String, BigInt] = keys.map(x => (x._1._2, x._2._2))
+
+  nodes.toList.sortBy(entry => entry._1).zip(keys.toList.sortBy(entry => entry._1._1)).foreach(pair => {
+    val node = pair._1
+    val keypair = pair._2
+    print(s"creating node $node with keypair $keypair")
+    node._2 ! InitActor(nodes.filter(_._1 != node._1).values.toVector, keypair._2, this.publicKey, pKeys)
+  })
+
+  /**
+   * Ask each node: Are you the leader? (Waiting for result - blocking)
+   * @return Vector with Either [Left = IamTheLeader, Right = IamNotTheLeader]
+   */
+  def evaluateActualLeaders: Vector[Either[IamTheLeader, IamNotTheLeader]] = {
+
+    nodes.map(node => {
+
+      val awaitedResult = Await.result(node._2 ? WhoIsLeader, timeout.duration)
+
+      awaitedResult match {
+        case msg: IamTheLeader    => Left(msg)
+        case msg: IamNotTheLeader => Right(msg)
+      }
+
+    }).toVector
+
+  }
+
+  /**
+    * Return current leader (or first leader if there are multiple...?)
+    * @return
+    */
+  def getLeader: (Int, ActorRef) = {
+    nodes.filter(node => {
+      Await.result(node._2 ? WhoIsLeader, timeout.duration).isInstanceOf[IamTheLeader]
+    }).head
+  }
+
+  /**
+    * Get all the actors in the system.
+    * @return Vector with all actors in the system
+    */
+  def getNodeStates: Map[Int, BRaftNodeState] = {
+
+    var nodeStates: Map[Int, BRaftNodeState] = Map.empty
+
+    nodes.foreach(node => {
+
+      val awaitedResult  = Await.result(node._2 ? GetState, timeout.duration)
+
+      awaitedResult match {
+        case MyStateIs(state)    => nodeStates += (node._1 -> state)
+        case _ => //Ignore everything else
+      }
+    })
+
+    nodeStates
+  }
+
+  /**
+   * Send SimulateLeaderCrash to each node (Leader is confirming - Waiting for result - blocking)
+   * @return Vector with Either [Left = LeaderIsSimulatingCrash, Right = IamNotTheLeader]
+   */
+  def simulateLeaderCrash(): Vector[Either[LeaderIsSimulatingCrash, IamNotTheLeader]] = {
+
+    nodes.map(node => {
+
+      val awaitedResult = Await.result(node._2 ? SimulateLeaderCrash, timeout.duration)
+      awaitedResult match {
+        case msg: LeaderIsSimulatingCrash => Left(msg)
+        case msg: IamNotTheLeader         => Right(msg)
+      }
+
+    }).toVector
+
+  }
+
+  /**
+    * Send SimulateLeaderCrash to each node (Leader is confirming - Waiting for result - blocking)
+    * @return Vector with Either [Left = LeaderIsSimulatingCrash, Right = IamNotTheLeader]
+    */
+  def simulateByzantineActorBecomingLeader(actor: ActorRef): Unit = {
+    actor ! InitiateLeaderElection
+  }
+
+
+  def appendData(key: String, value: String): Vector[Either[WriteResponse, IamNotTheLeader]] = {
+    this.appendData(key, value, this.privateKey)
+  }
+
+  /**
+   * Append data (only leader is allowed to write data - synchronized by heartbeat from leader with followers - blocking)
+   * @param key String
+   * @param value String
+   * @return Vector with Either [Left = WriteSuccess, Right = IamNotTheLeader]
+   */
+  def appendData(key: String, value: String, ownPrivateKey: BigInt): Vector[Either[WriteResponse, IamNotTheLeader]] = {
+    val signature = string_sign(ownPrivateKey, s"$key,$value")
+
+    nodes.map(node => {
+      val awaitedResult = Await.result(node._2 ? AppendData(key = key, value = value, signature=signature), timeout.duration)
+      awaitedResult match {
+        case msg: WriteResponse            => {
+          if (!msg.success) {
+            println(s"Appenddata unsuccesful in leader, reason: ${msg.reason}")
+          }
+          Left(msg)
+        }
+        case msg: IamNotTheLeader         => Right(msg)
+        // case IamNotConsistent             => null // TODO: do not return null
+      }
+    }).toVector
+  }
+
+  def appendBRaftData(key: String, value: String): Unit = {
+    val currentLeader = getLeader
+
+    currentLeader._2 ! appendData(key, value)
+  }
+
+
+  /**
+   * Ask each node: Provide your actual data (blocking)
+   * @return Vector with ActualData
+   */
+  def evaluateActualData: Vector[ActualData] = {
+    nodes.map(node => {
+
+      Await.result(node._2 ? GetActualData, timeout.duration).asInstanceOf[ActualData]
+
+    }).toVector
+
+  }
+
+  /**
+   * Terminates actor system
+   */
+  def terminate(): Future[Boolean] = actorSystem.terminate().map(_ => true)
+
+}
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/services/RaftService.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/services/RaftService.scala
new file mode 100644
index 00000000..a7255b59
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/services/RaftService.scala
@@ -0,0 +1,112 @@
+package de.maxbundscherer.scala.raft.services
+
+import akka.actor.{ActorRef, ActorSystem}
+import akka.pattern.ask
+import akka.util.Timeout
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.{ActualData, GetActualData, IamNotTheLeader, IamTheLeader, LeaderIsSimulatingCrash, SimulateLeaderCrash, WhoIsLeader}
+
+import scala.concurrent.{Await, ExecutionContext, Future}
+
+class RaftService(numberNodes: Int)(implicit actorSystem: ActorSystem,
+                                    timeout: Timeout,
+                                    executionContext: ExecutionContext) {
+
+  import de.maxbundscherer.scala.raft.actors.RaftNodeActor
+  import de.maxbundscherer.scala.raft.aggregates.RaftAggregate._
+
+  /**
+    * Declare and start up nodes
+    */
+  final val nodes: Map[Int, ActorRef] =
+    (0 until numberNodes)
+      .map(i => {
+        i -> actorSystem.actorOf(props = RaftNodeActor.props,
+                                 name = s"${RaftNodeActor.prefix}-$i")
+      })
+      .toMap
+
+  /**
+    * Init nodes (each node with neighbors)
+    */
+  nodes.foreach(node =>
+    node._2 ! InitActor(nodes.filter(_._1 != node._1).values.toVector))
+
+  /**
+   * Ask each node: Are you the leader? (Waiting for result - blocking)
+   * @return Vector with Either [Left = IamTheLeader, Right = IamNotTheLeader]
+   */
+  def evaluateActualLeaders: Vector[Either[IamTheLeader, IamNotTheLeader]] = {
+
+    nodes.map(node => {
+
+      val awaitedResult = Await.result(node._2 ? WhoIsLeader, timeout.duration)
+
+      awaitedResult match {
+        case msg: IamTheLeader    => Left(msg)
+        case msg: IamNotTheLeader => Right(msg)
+      }
+
+    }).toVector
+
+  }
+
+  /**
+   * Send SimulateLeaderCrash to each node (Leader is confirming - Waiting for result - blocking)
+   * @return Vector with Either [Left = LeaderIsSimulatingCrash, Right = IamNotTheLeader]
+   */
+  def simulateLeaderCrash(): Vector[Either[LeaderIsSimulatingCrash, IamNotTheLeader]] = {
+
+    nodes.map(node => {
+
+      val awaitedResult = Await.result(node._2 ? SimulateLeaderCrash, timeout.duration)
+
+      awaitedResult match {
+        case msg: LeaderIsSimulatingCrash => Left(msg)
+        case msg: IamNotTheLeader         => Right(msg)
+      }
+
+    }).toVector
+
+  }
+
+  /**
+   * Append data (only leader is allowed to write data - synchronized by heartbeat from leader with followers - blocking)
+   * @param key String
+   * @param value String
+   * @return Vector with Either [Left = WriteSuccess, Right = IamNotTheLeader]
+   */
+  def appendData(key: String, value: String): Vector[Either[WriteSuccess, IamNotTheLeader]] = {
+
+    nodes.map(node => {
+
+      val awaitedResult = Await.result(node._2 ? AppendData(key = key, value = value), timeout.duration)
+
+      awaitedResult match {
+        case msg: WriteSuccess            => Left(msg)
+        case msg: IamNotTheLeader         => Right(msg)
+      }
+
+    }).toVector
+
+  }
+
+  /**
+   * Ask each node: Provide your actual data (blocking)
+   * @return Vector with ActualData
+   */
+  def evaluateActualData: Vector[ActualData] = {
+
+    nodes.map(node => {
+
+      Await.result(node._2 ? GetActualData, timeout.duration).asInstanceOf[ActualData]
+
+    }).toVector
+
+  }
+
+  /**
+   * Terminates actor system
+   */
+  def terminate(): Future[Boolean] = actorSystem.terminate().map(_ => true)
+
+}
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/Configuration.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/Configuration.scala
new file mode 100644
index 00000000..85ba89f0
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/Configuration.scala
@@ -0,0 +1,44 @@
+package de.maxbundscherer.scala.raft.utils
+
+import de.maxbundscherer.scala.raft.services.{BRaftService, RaftService}
+
+import akka.japi.Util
+import com.typesafe.config.ConfigList
+
+trait Configuration {
+
+  object Config {
+
+    import com.typesafe.config.ConfigFactory
+
+    private val raftPrototypeConfig = ConfigFactory.load().getConfig("raftPrototype")
+
+    //Election Timer Min (Seconds)
+    val electionTimerIntervalMin: Int = raftPrototypeConfig.getInt("electionTimerIntervalMin")
+
+    //Election Timer Max (Seconds)
+    val electionTimerIntervalMax: Int = raftPrototypeConfig.getInt("electionTimerIntervalMax")
+
+    //Heartbeat Timer Interval (Seconds)
+    val heartbeatTimerInterval: Int = raftPrototypeConfig.getInt("heartbeatTimerInterval")
+
+    //Raft Nodes (Amount)
+    val nodes : Int = raftPrototypeConfig.getInt("nodes")
+
+    //Crash Interval (auto simulate crash after some heartbeats in LEADER behavior)
+    val crashIntervalHeartbeats: Int = raftPrototypeConfig.getInt("crashIntervalHeartbeats")
+
+    // Sleep downtime (Seconds) (after simulated crash in SLEEP behavior)
+    val sleepDowntime: Int = raftPrototypeConfig.getInt("sleepDowntime")
+
+    val raftTypeStr: String = raftPrototypeConfig.getString("raftType")
+
+    val maxTerm: Int = raftPrototypeConfig.getInt("maxTerm")
+
+    override def toString: String = {
+      s"sleepDowntime=$sleepDowntime,raftTypeStr=$raftTypeStr,maxTerm=$maxTerm" +
+      s"electionTimerIntervalMin=$electionTimerIntervalMin,electionTimerIntervalMax=$electionTimerIntervalMax," +
+      s"heartbeatTimerInterval=$heartbeatTimerInterval,nodes=$nodes,crashIntervalHeartbeats=$crashIntervalHeartbeats"
+    }
+  }
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/Hasher.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/Hasher.scala
new file mode 100644
index 00000000..2c3a5f44
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/Hasher.scala
@@ -0,0 +1,26 @@
+package de.maxbundscherer.scala.raft.utils
+
+import de.maxbundscherer.scala.raft.schnorr.SchnorrUtil.hex2big
+import org.slf4j.{Logger, LoggerFactory}
+
+import java.nio.charset.Charset
+import java.security.MessageDigest
+
+class Hasher {
+  val UTF_8: Charset = Charset.forName("UTF-8")
+  val logger: Logger = LoggerFactory.getLogger(this.toString)
+
+  def hash(toHash: String): BigInt = {
+    val messageDigest: MessageDigest = MessageDigest.getInstance("SHA-256")
+    val hex: String = messageDigest.digest(toHash.getBytes(UTF_8)).map("%02x".format(_)).mkString
+    val res = hex2big(hex)
+//    logger.debug(s"hasher Hashing '$toHash', result: $res")
+    res
+  }
+}
+
+object Hasher {
+  def apply(): Hasher = {
+    new Hasher()
+  }
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/RaftScheduler.scala b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/RaftScheduler.scala
new file mode 100644
index 00000000..77914720
--- /dev/null
+++ b/B-Raft/src/src/main/scala/de/maxbundscherer/scala/raft/utils/RaftScheduler.scala
@@ -0,0 +1,93 @@
+package de.maxbundscherer.scala.raft.utils
+
+import akka.actor.Actor
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.NodeState
+
+/**
+  * RaftScheduler
+  */
+trait RaftScheduler extends Actor with Configuration {
+
+  import de.maxbundscherer.scala.raft.actors.BRaftNodeActor.BRaftNodeState
+  import de.maxbundscherer.scala.raft.aggregates.Aggregate.SchedulerTrigger
+  import scala.concurrent.ExecutionContext
+  import scala.concurrent.duration._
+
+  /*
+   * Set up by actor
+   */
+  val state: NodeState
+  implicit val executionContext: ExecutionContext
+
+  //Set electionTimeout randomized in [electionTimerIntervalMin, electionTimerIntervalMax]
+  def electionTimeout : Int = Config.electionTimerIntervalMin * 1000 + scala.util.Random.nextInt(Config.electionTimerIntervalMax * 1000)
+
+  //Set heartbeat to fixed interval
+  private val heartbeatTimeout: Int = Config.heartbeatTimerInterval * 1000
+
+  /**
+    * Stop electionTimer
+    */
+  def stopElectionTimer(): Unit = {
+
+    if (state.electionTimer.isDefined) {
+      state.electionTimer.get.cancel()
+      state.electionTimer = None
+    }
+
+  }
+
+  /**
+    * Start electionTimer (if already running = stop timer)
+    */
+  def restartElectionTimer(): Unit = {
+
+    stopElectionTimer()
+
+    state.electionTimer = Some(
+      context.system.scheduler.scheduleWithFixedDelay(
+        initialDelay = electionTimeout.millis,
+        delay = electionTimeout.millis,
+        receiver = self,
+        message = SchedulerTrigger.ElectionTimeout
+      ))
+
+  }
+
+  /**
+    * Stop heartbeatTimer
+    */
+  def stopHeartbeatTimer(): Unit = {
+
+    if (state.heartbeatTimer.isDefined) {
+      state.heartbeatTimer.get.cancel()
+      state.heartbeatTimer = None
+    }
+
+  }
+
+  /**
+    * Start heartbeatTimer (if already running = stop timer)
+    */
+  def restartHeartbeatTimer(): Unit = {
+
+    stopHeartbeatTimer()
+
+    state.heartbeatTimer = Some(
+      context.system.scheduler.scheduleWithFixedDelay(
+        initialDelay = heartbeatTimeout.millis,
+        delay = heartbeatTimeout.millis,
+        receiver = self,
+        message = SchedulerTrigger.Heartbeat
+      ))
+  }
+
+  /**
+    * Start heartbeatTimer (if already running = stop timer)
+    */
+  def scheduleAwake(): Unit =
+    context.system.scheduler.scheduleOnce(delay = Config.sleepDowntime.seconds,
+                                          receiver = self,
+                                          message = SchedulerTrigger.Awake)
+
+}
diff --git a/B-Raft/src/src/test/resources/application.conf b/B-Raft/src/src/test/resources/application.conf
new file mode 100644
index 00000000..9bbc307a
--- /dev/null
+++ b/B-Raft/src/src/test/resources/application.conf
@@ -0,0 +1,29 @@
+akka {
+
+    # Log Level (DEBUG, INFO, WARNING, ERROR)
+    loglevel = "INFO"
+
+}
+
+raftPrototype {
+
+    # Election Timer Min (Seconds)
+    electionTimerIntervalMin = 2
+
+    # Election Timer Max (Seconds)
+    electionTimerIntervalMax = 3
+
+    # Heartbeat Timer Interval (Seconds)
+    heartbeatTimerInterval = 2
+
+    # Raft Nodes (Amount)
+    nodes = 5
+
+    # Crash Interval (auto simulate crash after some heartbeats in LEADER behavior)
+    # Set to high number in test (ignore crash interval in testMode)
+    crashIntervalHeartbeats = 9999999
+
+    # Sleep downtime (Seconds) (after simulated crash in SLEEP behavior)
+    sleepDowntime = 8
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/BRaftServiceTest.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/BRaftServiceTest.scala
new file mode 100644
index 00000000..b0dbcc91
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/BRaftServiceTest.scala
@@ -0,0 +1,146 @@
+package de.maxbundscherer.scala.raft.BRaft
+
+import de.maxbundscherer.scala.raft.BRaft.utils.BaseServiceTest
+import de.maxbundscherer.scala.raft.aggregates.Aggregate._
+import de.maxbundscherer.scala.raft.utils.Configuration
+
+class BRaftServiceTest extends BaseServiceTest with Configuration {
+
+  import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate._
+
+  "RaftService" should {
+
+    var temporaryFirstLeaderName: String    = ""
+    var temporaryData: Map[String, String]  = Map.empty
+    var lastHash: BigInt = -1
+
+    "elect only one leader" in {
+
+      freezeTest(seconds = Config.nodes * Config.electionTimerIntervalMax, loggerMessage = "Waiting for first leader election")
+
+      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      temporaryFirstLeaderName = localLeaderName
+
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "append data in leader node" in {
+      println("append data in leader node")
+      val newDataKey    = "key1"
+      val newDataValue  = "val1"
+
+      temporaryData = temporaryData + (newDataKey->newDataValue)
+
+      val data: Vector[Either[WriteResponse, IamNotTheLeader]] = raftService.appendData(key = newDataKey, value = newDataValue)
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       shouldBe temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "has all nodes synchronized with new data" in {
+
+      freezeTest(seconds = Config.nodes * Config.heartbeatTimerInterval * 2, loggerMessage = "Waiting for sync data")
+
+      val data: Vector[ActualData] = raftService.evaluateActualData
+      log.info(s"Data: $data")
+      val uniqueHashCodes: Vector[Int] = data.map(_.data.hashCode()).distinct
+
+      uniqueHashCodes.size shouldBe 1
+      uniqueHashCodes.head shouldBe temporaryData.hashCode()
+    }
+
+    "reject invalid client appendData message" in {
+      val newDataKey = "key"
+      val newDataValue = "key"
+
+      val data: Vector[Either[WriteResponse, IamNotTheLeader]] = raftService.appendData(key = newDataKey, value = newDataValue, BigInt(101001))
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+      data.filter(_.isLeft).head match {
+        case Left(left) => left.success shouldBe false
+        case _ => fail()
+      }
+    }
+
+    "simulate leader crash" in {
+
+      val data: Vector[Either[LeaderIsSimulatingCrash, IamNotTheLeader]] = raftService.simulateLeaderCrash()
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       shouldBe temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only one leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+
+    "elect new leader after leader crash" in {
+
+      freezeTest(seconds = Config.nodes * Config.electionTimerIntervalMax, loggerMessage = "Waiting for second leader election")
+
+      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       should not be temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "append new data in leader node" in {
+      println("append new data in leader node")
+      val newDataKey    = "key2"
+      val newDataValue  = "val2"
+
+      temporaryData = temporaryData + (newDataKey->newDataValue)
+      val data: Vector[Either[WriteResponse, IamNotTheLeader]] = raftService.appendData(key = newDataKey, value = newDataValue)
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       should not be temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "has all nodes synchronized with new data again" in {
+
+      freezeTest(seconds = Config.nodes * Config.heartbeatTimerInterval, loggerMessage = "Waiting for sync data")
+
+      val data: Vector[ActualData] = raftService.evaluateActualData
+
+      val uniqueHashCodes: Vector[Int] = data.map(_.data.hashCode()).distinct
+
+      uniqueHashCodes.size shouldBe 1
+      uniqueHashCodes.head shouldBe temporaryData.hashCode()
+    }
+
+    "terminate actor system" in {
+
+      raftService.terminate().map(response => response shouldBe true)
+    }
+
+  }
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/BroadcastTest.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/BroadcastTest.scala
new file mode 100644
index 00000000..3d36fcc7
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/BroadcastTest.scala
@@ -0,0 +1,49 @@
+package de.maxbundscherer.scala.raft.BRaft
+
+import de.maxbundscherer.scala.raft.BRaft.utils.BaseServiceTest
+import de.maxbundscherer.scala.raft.actors.BRaftNodeActor.BRaftNodeState
+import de.maxbundscherer.scala.raft.utils.Configuration
+
+class BroadcastTest extends BaseServiceTest with Configuration {
+
+  "Broadcast" should {
+
+    "terms after after one election should be the same" in {
+
+      Thread.sleep(3000)
+
+      val nodeStates : Map[Int, BRaftNodeState] = raftService.getNodeStates
+
+      val terms : Iterable[Int] = nodeStates.map(x => x._2.term)
+
+      terms.forall(_ == terms.head) shouldBe(true)
+    }
+
+//    "elect new leader after leader crash" in {
+//
+//      Thread.sleep(3000)
+//
+//
+//      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+//
+//      val localLeaderName = data.filter(_.isLeft).head match {
+//        case Left(left) => left.actorName
+//        case _ => ""
+//      }
+//
+//      data.count(_.isLeft)  shouldBe 1 //Only on leader
+//      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+//
+//      val nodeStates : Map[Int, NodeState] = raftService.getNodeStates
+//
+//      val terms : Iterable[Int] = nodeStates.map(x => x._2.term)
+//
+//      terms.toList.distinct.length shouldBe(1)
+//    }
+
+    "terminate actor system" in {
+
+      raftService.terminate().map(response => response shouldBe true)
+    }
+  }
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/ByzantineLeaderTest.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/ByzantineLeaderTest.scala
new file mode 100644
index 00000000..cf09d8e7
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/ByzantineLeaderTest.scala
@@ -0,0 +1,35 @@
+package de.maxbundscherer.scala.raft.BRaft
+
+import de.maxbundscherer.scala.raft.BRaft.utils.BaseServiceTest
+import de.maxbundscherer.scala.raft.aggregates.Aggregate.{BehaviorEnum, IamNotTheLeader}
+import de.maxbundscherer.scala.raft.aggregates.BRaftAggregate.{BecomeByzantine, WriteResponse}
+import de.maxbundscherer.scala.raft.utils.Configuration
+
+class ByzantineLeaderTest extends BaseServiceTest with Configuration {
+  // Test Byzantine Behavior
+  freezeTest(10, "Waiting for startup")
+  "start byzantine behavior" in {
+    val (leaderID, leaderNodeRef) = raftService.getLeader
+    leaderNodeRef ! BecomeByzantine
+    Thread.sleep(3000)
+    val leaderState = raftService.getNodeStates.filter(tuple => {
+      tuple._1 == leaderID
+    }).head._2
+
+    val leaders = raftService.getNodeStates.filter(tuple => {
+      tuple._2.behaviour == BehaviorEnum.BYZANTINELEADER || tuple._2.behaviour == BehaviorEnum.LEADER
+    }).keys
+
+    log.info(s"leaders: $leaders")
+    Thread.sleep(8000)
+    leaders.size shouldBe 1
+    leaderState.behaviour shouldBe BehaviorEnum.BYZANTINELEADER
+  }
+
+  "byzantine leader adds entry to log by itself (not received from client)" in {
+    // AppendData, but don't sign message
+    val data: Vector[Either[WriteResponse, IamNotTheLeader]] = raftService.appendData("testkey", "testvalue", 999999999)
+    Thread.sleep(3000)
+    data.size shouldBe(5)
+  }
+}
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/FaultyLeaderElection.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/FaultyLeaderElection.scala
new file mode 100644
index 00000000..f7647b00
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/FaultyLeaderElection.scala
@@ -0,0 +1,93 @@
+package de.maxbundscherer.scala.raft.BRaft
+
+import akka.actor.ActorRef
+import de.maxbundscherer.scala.raft.BRaft.utils.BaseServiceTest
+import de.maxbundscherer.scala.raft.actors.BRaftNodeActor.BRaftNodeState
+import de.maxbundscherer.scala.raft.aggregates.Aggregate._
+import de.maxbundscherer.scala.raft.utils.Configuration
+
+class FaultyLeaderElection extends BaseServiceTest with Configuration {
+
+  "Election" should {
+
+    var temporaryFirstLeaderName: String    = ""
+
+    "elect only one leader" in {
+
+      freezeTest(seconds = Config.nodes * Config.electionTimerIntervalMax, loggerMessage = "Waiting for first leader election")
+
+      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      temporaryFirstLeaderName = localLeaderName
+
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "has node become candidate" in {
+
+      val nodeStates : Map[Int, BRaftNodeState] = raftService.getNodeStates
+
+      // Every node except the leader
+      val nodeFollowerStates = nodeStates.filter(x => x._2.behaviour != BehaviorEnum.LEADER)
+
+      val (nodeActorID, _) : (Int, BRaftNodeState) = nodeFollowerStates.head
+
+      val actor : Option[ActorRef] = raftService.nodes.get(nodeActorID)
+
+      actor match {
+        case Some(actor) => actor ! InitiateLeaderElection
+      }
+
+
+      val nodeStates_after : Map[Int, BRaftNodeState] = raftService.getNodeStates
+
+      val state = nodeStates_after.get(nodeActorID)
+
+      state match {
+        case Some(state) => state.behaviour.shouldBe(BehaviorEnum.CANDIDATE)
+      }
+    }
+
+    "simulate leader crash" in {
+
+      val data: Vector[Either[LeaderIsSimulatingCrash, IamNotTheLeader]] = raftService.simulateLeaderCrash()
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       shouldBe temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+
+    "elect new leader after leader crash" in {
+
+      freezeTest(seconds = Config.nodes * Config.electionTimerIntervalMax, loggerMessage = "Waiting for second leader election")
+
+      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       should not be temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "terminate actor system" in {
+
+      raftService.terminate().map(response => response shouldBe true)
+    }
+  }
+}
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/utils/BaseServiceTest.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/utils/BaseServiceTest.scala
new file mode 100644
index 00000000..0aa61b0e
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/BRaft/utils/BaseServiceTest.scala
@@ -0,0 +1,40 @@
+package de.maxbundscherer.scala.raft.BRaft.utils
+
+import de.maxbundscherer.scala.raft.services.{BRaftService, RaftService}
+import akka.event.LoggingAdapter
+import de.maxbundscherer.scala.raft.utils.Configuration
+import org.scalatest.{AsyncWordSpec, Matchers}
+
+object BaseServiceTest extends Configuration {
+
+  import akka.actor.ActorSystem
+  import akka.util.Timeout
+  import scala.concurrent.ExecutionContextExecutor
+  import scala.concurrent.duration._
+
+  private implicit val actorSystem: ActorSystem = ActorSystem("testSystem")
+  private implicit val executionContext: ExecutionContextExecutor = actorSystem.dispatcher
+  private implicit val timeout: Timeout = 15.seconds
+  private lazy val log: LoggingAdapter = actorSystem.log
+
+  private lazy val raftService = new BRaftService(numberNodes = Config.nodes)
+
+}
+
+trait BaseServiceTest extends AsyncWordSpec with Matchers {
+
+  val log: LoggingAdapter = BaseServiceTest.log
+  val raftService: BRaftService = BaseServiceTest.raftService
+
+  /**
+    * Freeze test (actorSystem is still working)
+    *
+    * @param seconds       Int
+    * @param loggerMessage String
+    */
+  def freezeTest(seconds: Int, loggerMessage: String): Unit = {
+    log.warning(s"Test is in sleepMode for $seconds seconds ($loggerMessage)")
+    Thread.sleep(seconds * 1000)
+    log.warning(s"Test continues")
+  }
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/Raft/RaftServiceTest.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/Raft/RaftServiceTest.scala
new file mode 100644
index 00000000..f1319694
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/Raft/RaftServiceTest.scala
@@ -0,0 +1,146 @@
+package de.maxbundscherer.scala.raft.Raft
+
+import de.maxbundscherer.scala.raft.Raft.utils.BaseServiceTest
+import de.maxbundscherer.scala.raft.aggregates.Aggregate._
+import de.maxbundscherer.scala.raft.utils.Configuration
+
+class RaftServiceTest extends BaseServiceTest with Configuration {
+
+  import de.maxbundscherer.scala.raft.aggregates.RaftAggregate._
+
+  /**
+   * Freeze test (actorSystem is still working)
+   * @param seconds Int
+   * @param loggerMessage String
+   */
+  private def freezeTest(seconds: Int, loggerMessage: String): Unit = {
+
+    log.warning(s"Test is in sleepMode for $seconds seconds ($loggerMessage)")
+    Thread.sleep(seconds * 1000)
+    log.warning(s"Test continues")
+
+  }
+
+  "RaftService" should {
+
+    var temporaryFirstLeaderName: String    = ""
+    var temporaryData: Map[String, String]  = Map.empty
+
+    "elect only one leader" in {
+
+      freezeTest(seconds = Config.nodes * Config.electionTimerIntervalMax, loggerMessage = "Waiting for first leader election")
+
+      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      temporaryFirstLeaderName = localLeaderName
+
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "append data in leader node" in {
+
+      val newDataKey    = "key1"
+      val newDataValue  = "val1"
+
+      temporaryData = temporaryData + (newDataKey->newDataValue)
+
+      val data: Vector[Either[WriteSuccess, IamNotTheLeader]] = raftService.appendData(key = newDataKey, value = newDataValue)
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       shouldBe temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "has all nodes synchronized with new data" in {
+
+      freezeTest(seconds = Config.nodes * Config.heartbeatTimerInterval, loggerMessage = "Waiting for sync data")
+
+      val data: Vector[ActualData] = raftService.evaluateActualData
+
+      val uniqueHashCodes: Vector[Int] = data.map(_.data.hashCode()).distinct
+
+      uniqueHashCodes.size shouldBe 1
+      uniqueHashCodes.head shouldBe temporaryData.hashCode()
+    }
+
+    "simulate leader crash" in {
+
+      val data: Vector[Either[LeaderIsSimulatingCrash, IamNotTheLeader]] = raftService.simulateLeaderCrash()
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       shouldBe temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+
+    "elect new leader after leader crash" in {
+
+      freezeTest(seconds = Config.nodes * Config.electionTimerIntervalMax, loggerMessage = "Waiting for second leader election")
+
+      val data: Vector[Either[IamTheLeader, IamNotTheLeader]] = raftService.evaluateActualLeaders
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       should not be temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "append new data in leader node" in {
+
+      val newDataKey    = "key2"
+      val newDataValue  = "val2"
+
+      temporaryData = temporaryData + (newDataKey->newDataValue)
+
+      val data: Vector[Either[WriteSuccess, IamNotTheLeader]] = raftService.appendData(key = newDataKey, value = newDataValue)
+
+      val localLeaderName = data.filter(_.isLeft).head match {
+        case Left(left) => left.actorName
+        case _ => ""
+      }
+
+      localLeaderName       should not be temporaryFirstLeaderName
+      data.count(_.isLeft)  shouldBe 1 //Only on leader
+      data.count(_.isRight) shouldBe ( Config.nodes - 1 ) //Other nodes shouldBe follower
+    }
+
+    "has all nodes synchronized with new data again" in {
+
+      freezeTest(seconds = Config.nodes * Config.heartbeatTimerInterval, loggerMessage = "Waiting for sync data")
+
+      val data: Vector[ActualData] = raftService.evaluateActualData
+
+      val uniqueHashCodes: Vector[Int] = data.map(_.data.hashCode()).distinct
+
+      uniqueHashCodes.size shouldBe 1
+      uniqueHashCodes.head shouldBe temporaryData.hashCode()
+    }
+
+    "terminate actor system" in {
+
+      raftService.terminate().map(response => response shouldBe true)
+    }
+
+  }
+
+}
\ No newline at end of file
diff --git a/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/Raft/utils/BaseServiceTest.scala b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/Raft/utils/BaseServiceTest.scala
new file mode 100644
index 00000000..c4e95ed4
--- /dev/null
+++ b/B-Raft/src/src/test/scala/de/maxbundscherer/scala/raft/Raft/utils/BaseServiceTest.scala
@@ -0,0 +1,29 @@
+package de.maxbundscherer.scala.raft.Raft.utils
+
+import de.maxbundscherer.scala.raft.services.RaftService
+import akka.event.LoggingAdapter
+import de.maxbundscherer.scala.raft.utils.Configuration
+import org.scalatest.{AsyncWordSpec, Matchers}
+
+object BaseServiceTest extends Configuration {
+
+  import akka.actor.ActorSystem
+  import akka.util.Timeout
+  import scala.concurrent.ExecutionContextExecutor
+  import scala.concurrent.duration._
+
+  private implicit val actorSystem: ActorSystem = ActorSystem("testSystem")
+  private implicit val executionContext: ExecutionContextExecutor = actorSystem.dispatcher
+  private implicit val timeout: Timeout = 15.seconds
+  private lazy val log: LoggingAdapter = actorSystem.log
+
+  private lazy val raftService = new RaftService(numberNodes = Config.nodes)
+
+}
+
+trait BaseServiceTest extends AsyncWordSpec with Matchers {
+
+  val log: LoggingAdapter = BaseServiceTest.log
+  val raftService: RaftService = BaseServiceTest.raftService
+
+}
\ No newline at end of file