distributed-state-network 0.0.1__tar.gz

distributed_state_network-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    environment: release
+    permissions:
+      id-token: write
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+        cache: 'pip'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip 
+        pip install hatch
+    - name: Build package
+      run: hatch build
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}

distributed_state_network-0.0.1/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+env/
+certs/
+.vscode/
+credentials/
+test.key
+.coverage
+count.py
+appended.py
+py_line_count_history.jsonl

distributed_state_network-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colton Clemmer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

distributed_state_network-0.0.1/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: distributed-state-network
+Version: 0.0.1
+Summary: A tool to distribute the state of a network device to other devices on the network
+Project-URL: Homepage, https://github.com/erinclemmer/distributed_state_network
+Project-URL: Issues, https://github.com/erinclemmer/distributed_state_network/issues
+Author-email: Erin Clemmer <erin.c.clemmer@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: distributed,networking
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Communications
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: cryptography
+Requires-Dist: ecdsa
+Requires-Dist: ipaddress
+Requires-Dist: logging
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# Distributed State Network
+
+A Python framework for building distributed applications where nodes automatically share state without explicit data requests.
+
+## Why DSN?
+
+Traditional distributed systems require constant polling or complex pub/sub mechanisms to share state between nodes. DSN solves this by providing:
+
+- **Automatic state synchronization** - Changes propagate instantly across the network
+- **No single point of failure** - Every node maintains its own state
+- **Simple key-value interface** - Read any node's data as easily as local variables
+- **Complete Security** - Triple-layer encryption protects your network
+
+Perfect for building distributed monitoring systems, IoT networks, or any application where multiple machines need to share state efficiently.
+
+## Installation
+
+```bash
+pip install distributed-state-network
+```
+
+## Quick Start
+
+### 1. Create Your First Node
+
+The simplest DSN network is a single node:
+
+```python
+from distributed_state_network import DSNodeServer, DSNodeConfig
+
+# Generate a network key (do this once for your entire network)
+DSNodeServer.generate_key("network.key")
+
+# Start a node
+node = DSNodeServer.start(DSNodeConfig(
+    node_id="my_first_node",
+    port=8000,
+    aes_key_file="network.key",
+    bootstrap_nodes=[]  # Empty for the first node
+))
+
+# Write some data
+node.node.update_data("status", "online")
+node.node.update_data("temperature", "72.5")
+```
+
+## How It Works
+
+DSN creates a peer-to-peer network where each node maintains its own state database:
+
+**Key concepts:**
+- Each node owns its state and is the only one who can modify it
+- State changes are automatically broadcast to all connected nodes
+- Any node can read any other node's state instantly
+- All communication is encrypted with AES + ECDSA + HTTPS
+
+## API Reference
+
+### Node Methods
+
+**update_data(key, value)** - Update a key in this node's state
+```python
+node.update_data("sensor_reading", "42.0")
+```
+
+**read_data(node_id, key)** - Read a value from any node's state
+
+```python
+temperature = node.read_data("sensor_node", "temperature")
+```
+
+**peers()** - List all connected nodes
+```python
+connected_nodes = node.peers()
+```
+
+## Real-World Examples
+
+### Distributed Temperature Monitoring
+
+Create a network of temperature sensors that share readings:
+
+```python
+# On each Raspberry Pi with a sensor:
+sensor_node = DSNodeServer.start(DSNodeConfig(
+    node_id=f"sensor_{location}",
+    port=8000,
+    aes_key_file="network.key",
+    bootstrap_nodes=[{"address": "coordinator.local", "port": 8000}]
+))
+
+# Continuously update temperature
+while True:
+    temp = read_temperature_sensor()
+    sensor_node.node.update_data("temperature", str(temp))
+    sensor_node.node.update_data("timestamp", str(time.time()))
+    time.sleep(60)
+```
+
+On the monitoring station:
+```python
+for node_id in monitor.node.peers():
+    if node_id.startswith("sensor_"):
+        temp = monitor.node.read_data(node_id, "temperature")
+        print(f"{node_id}: {temp}°F")
+```
+
+## Troubleshooting
+
+### Node Can't Connect
+- Verify the AES key file is identical on all nodes
+- Check firewall rules allow traffic on the configured port
+- Ensure bootstrap node address is reachable
+
+### State Not Updating
+- Confirm nodes show as connected with `node.peers()`
+- Check network latency between nodes
+- Verify no duplicate node IDs (each must be unique)
+
+## Performance Characteristics
+- State updates typically propagate in <100ms on local networks
+- Each node stores the complete state of all other nodes
+- Suitable for networks up to ~100 nodes
+- State values should be kept reasonably small (< 1MB per key)

distributed_state_network-0.0.1/README.md

@@ -0,0 +1,124 @@
+# Distributed State Network
+
+A Python framework for building distributed applications where nodes automatically share state without explicit data requests.
+
+## Why DSN?
+
+Traditional distributed systems require constant polling or complex pub/sub mechanisms to share state between nodes. DSN solves this by providing:
+
+- **Automatic state synchronization** - Changes propagate instantly across the network
+- **No single point of failure** - Every node maintains its own state
+- **Simple key-value interface** - Read any node's data as easily as local variables
+- **Complete Security** - Triple-layer encryption protects your network
+
+Perfect for building distributed monitoring systems, IoT networks, or any application where multiple machines need to share state efficiently.
+
+## Installation
+
+```bash
+pip install distributed-state-network
+```
+
+## Quick Start
+
+### 1. Create Your First Node
+
+The simplest DSN network is a single node:
+
+```python
+from distributed_state_network import DSNodeServer, DSNodeConfig
+
+# Generate a network key (do this once for your entire network)
+DSNodeServer.generate_key("network.key")
+
+# Start a node
+node = DSNodeServer.start(DSNodeConfig(
+    node_id="my_first_node",
+    port=8000,
+    aes_key_file="network.key",
+    bootstrap_nodes=[]  # Empty for the first node
+))
+
+# Write some data
+node.node.update_data("status", "online")
+node.node.update_data("temperature", "72.5")
+```
+
+## How It Works
+
+DSN creates a peer-to-peer network where each node maintains its own state database:
+
+**Key concepts:**
+- Each node owns its state and is the only one who can modify it
+- State changes are automatically broadcast to all connected nodes
+- Any node can read any other node's state instantly
+- All communication is encrypted with AES + ECDSA + HTTPS
+
+## API Reference
+
+### Node Methods
+
+**update_data(key, value)** - Update a key in this node's state
+```python
+node.update_data("sensor_reading", "42.0")
+```
+
+**read_data(node_id, key)** - Read a value from any node's state
+
+```python
+temperature = node.read_data("sensor_node", "temperature")
+```
+
+**peers()** - List all connected nodes
+```python
+connected_nodes = node.peers()
+```
+
+## Real-World Examples
+
+### Distributed Temperature Monitoring
+
+Create a network of temperature sensors that share readings:
+
+```python
+# On each Raspberry Pi with a sensor:
+sensor_node = DSNodeServer.start(DSNodeConfig(
+    node_id=f"sensor_{location}",
+    port=8000,
+    aes_key_file="network.key",
+    bootstrap_nodes=[{"address": "coordinator.local", "port": 8000}]
+))
+
+# Continuously update temperature
+while True:
+    temp = read_temperature_sensor()
+    sensor_node.node.update_data("temperature", str(temp))
+    sensor_node.node.update_data("timestamp", str(time.time()))
+    time.sleep(60)
+```
+
+On the monitoring station:
+```python
+for node_id in monitor.node.peers():
+    if node_id.startswith("sensor_"):
+        temp = monitor.node.read_data(node_id, "temperature")
+        print(f"{node_id}: {temp}°F")
+```
+
+## Troubleshooting
+
+### Node Can't Connect
+- Verify the AES key file is identical on all nodes
+- Check firewall rules allow traffic on the configured port
+- Ensure bootstrap node address is reachable
+
+### State Not Updating
+- Confirm nodes show as connected with `node.peers()`
+- Check network latency between nodes
+- Verify no duplicate node IDs (each must be unique)
+
+## Performance Characteristics
+- State updates typically propagate in <100ms on local networks
+- Each node stores the complete state of all other nodes
+- Suitable for networks up to ~100 nodes
+- State values should be kept reasonably small (< 1MB per key)

distributed_state_network-0.0.1/coverage.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+coverage run test.py && coverage report -m --omit=test.py

distributed_state_network-0.0.1/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling", "cryptography", "logging", "ipaddress", "requests", "ecdsa"]
+build-backend = "hatchling.build"
+
+[project]
+name = "distributed-state-network"
+version = "0.0.1"
+authors = [{name="Erin Clemmer", email="erin.c.clemmer@gmail.com"}]
+description = "A tool to distribute the state of a network device to other devices on the network"
+keywords = ["distributed", "networking"]
+license = "MIT"
+readme = "README.md"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python",
+    "Development Status :: 5 - Production/Stable",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Telecommunications Industry",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Communications",
+    "Typing :: Typed"
+]
+requires-python = ">=3.10"
+dependencies = [
+    "cryptography",
+    "logging",
+    "ipaddress",
+    "requests",
+    "ecdsa"
+]
+
+[project.urls]
+Homepage = "https://github.com/erinclemmer/distributed_state_network"
+Issues = "https://github.com/erinclemmer/distributed_state_network/issues"
+ 
+[tool.hatch.build.targets.wheel]
+packages = ["src/distributed_state_network"]

distributed_state_network-0.0.1/security.md

@@ -0,0 +1,14 @@
+## Security Architecture
+We use a three-layer security model where each layer addresses a specific vulnerability. Understanding this design helps explain why certain setup steps are necessary and how your data stays protected.
+The Three-Layer Defense
+Think of our security like protecting a secret club where members share sensitive information. You need multiple types of protection because different attacks require different defenses.
+### Layer 1: AES
+AES Encryption acts as the network's membership card. Every message between nodes is encrypted with a shared AES key, making the network invisible to outsiders. If someone intercepts your network traffic without this key, they see only meaningless encrypted bytes. This is why you must carefully share the key file with trusted nodes - it's the fundamental gatekeeper of your network.
+### Layer 2: ECDSA
+ECDSA Signatures solve a critical problem that AES alone cannot address. Once someone has the network key, how do you prevent them from impersonating other nodes? Each node has its own unforgeable cryptographic identity. When node "sensor_1" shares its temperature reading, it signs that data with its private key. Other nodes verify this signature to ensure the data truly came from sensor_1, not from an attacker pretending to be sensor_1. This is why node IDs must be unique - each ID is permanently bound to a specific cryptographic identity.
+### Layer 3: HTTPS
+HTTPS/TLS prevents sophisticated network-level attacks. Even with encryption and signatures, an attacker positioned between two nodes could intercept messages, block updates, or redirect traffic to malicious servers. HTTPS certificates ensure you're communicating with the exact node you intend to reach. During the initial handshake, nodes exchange certificates that get verified on every subsequent connection, creating authenticated channels that can't be hijacked.
+
+## Why This Matters
+Each layer compensates for what the others cannot protect. AES keeps outsiders out but can't distinguish between insiders. ECDSA proves identity but doesn't hide data. HTTPS secures the transport but doesn't control network access. Together, they create a system where only authorized nodes can join, every piece of state data is cryptographically guaranteed to come from its claimed source, and all communications flow through verified channels. This isn't over-engineering - it's the minimum required for nodes to trust each other in a truly distributed system without any central authority.
+When you see the various key files and certificates being generated during setup, you're watching these three defensive layers being constructed. Each one is essential for maintaining the integrity and privacy of your distributed application.

distributed_state_network-0.0.1/src/distributed_state_network/__init__.py

@@ -0,0 +1,4 @@
+from distributed_state_network.handler import DSNodeServer
+from distributed_state_network.dsnode import DSNode
+from distributed_state_network.objects.config import DSNodeConfig
+from distributed_state_network.objects.endpoint import Endpoint

distributed_state_network-0.0.1/src/distributed_state_network/create_key.py

@@ -0,0 +1,10 @@
+import sys
+from util.aes import generate_aes_key
+
+if len(sys.argv) < 2:
+    raise Exception("Usage: python create_key.py [output_key_file_location]")
+
+location = sys.argv[1]
+
+with open(location, 'wb') as f:
+    f.write(generate_aes_key())

distributed_state_network-0.0.1/src/distributed_state_network/dsnode.py

@@ -0,0 +1,263 @@
+import os
+import time
+import json
+import logging
+
+import requests
+import threading
+from requests import RequestException
+from typing import Dict, Tuple, List, Optional
+
+from distributed_state_network.objects.endpoint import Endpoint
+from distributed_state_network.objects.hello_packet import HelloPacket
+from distributed_state_network.objects.peers_packet import PeersPacket
+from distributed_state_network.objects.state_packet import StatePacket
+from distributed_state_network.objects.config import DSNodeConfig
+
+from distributed_state_network.util import get_dict_hash
+from distributed_state_network.util.key_manager import CertManager, CredentialManager
+from distributed_state_network.util.aes import aes_encrypt, aes_decrypt, generate_aes_key
+
+TICK_INTERVAL = 3
+
+class DSNode:
+    config: DSNodeConfig
+    address_book: Dict[str, Endpoint]
+    node_states: Dict[str, StatePacket]
+    shutting_down: bool = False
+
+    def __init__(
+            self, 
+            config: DSNodeConfig,
+            version: str,
+        ):
+        self.config = config
+        self.version = version
+        
+        self.cert_manager = CertManager(config.node_id)
+        self.cred_manager = CredentialManager(config.node_id)
+
+        self.cert_manager.generate_keys()
+        self.cred_manager.generate_keys()
+        
+        self.node_states = {
+            self.config.node_id: StatePacket.create(self.config.node_id, time.time(), self.cred_manager.my_private(), { })
+        }
+
+        self.address_book = {
+            self.config.node_id: Endpoint("127.0.0.1", config.port)
+        }
+        
+        self.logger = logging.getLogger("DSN: " + config.node_id)
+        if not os.path.exists(config.aes_key_file):
+            raise Exception(f"Could not find aes key file in {config.aes_key_file}")
+        threading.Thread(target=self.network_tick).start()
+
+    def get_aes_key(self):
+        with open(self.config.aes_key_file, 'rb') as f:
+            return f.read()
+
+    def network_tick(self):
+        time.sleep(TICK_INTERVAL)
+        if self.shutting_down:
+            self.logger.info(f"Shutting down node")
+            return
+        self.test_connections()
+        threading.Thread(target=self.network_tick).start()
+
+    def test_connections(self):
+        def remove(node_id: str):
+            if node_id in self.node_states:
+                del self.node_states[node_id]
+                self.logger.info(f"PING failed for {node_id}, disconnecting...")
+        for node_id in self.node_states.copy().keys():
+            if not node_id in self.node_states or node_id == self.config.node_id:
+                continue
+            try:
+                if self.shutting_down:
+                    return
+                self.send_ping(node_id)
+            except RequestException:
+                if node_id in self.node_states: # double check if something has changed since the ping request started
+                    remove(node_id)
+
+    def send_request_to_node(self, node_id: str, path: str, payload: bytes, verify) -> Tuple[requests.Response, bytes]:
+        con = self.connection_from_node(node_id)
+        return self.send_request(con, path, payload, verify)
+
+    def send_request(self, con: Endpoint, path: str, payload: bytes, verify, retries: int = 0) -> Tuple[requests.Response, bytes]:
+        try:
+            # Always send a ping first to throw an error if https validation does not work
+            requests.post(f'https://{con.to_string()}/ping', data=self.encrypt_data(payload), verify=verify, timeout=2)
+            res = requests.post(f'https://{con.to_string()}/{path}', data=self.encrypt_data(payload), verify=verify, timeout=2)
+        except Exception as e:
+            self.logger.error(e)
+            time.sleep(1)
+            if retries < 2:
+                return self.send_request(con, path, payload, verify, retries + 1)
+            else:
+                raise RequestException(f'{path.upper()} => {con.to_string()} (no response)')
+        return self.parse_response(con, path, res)
+
+    def parse_response(self, con: Endpoint, path: str, res: requests.Response) -> Tuple[requests.Response, bytes]:
+        if res.status_code != 200:
+            raise RequestException(f'{path.upper()} => {con.to_string()} (status code {res.status_code})')
+        
+        decrypted_data = b''
+        if len(res.content) > 0:
+            try:
+                decrypted_data = self.decrypt_data(res.content)
+            except Exception as e:
+                raise RequestException(f'{path.upper()} => {con.to_string()} (cannot decrypt response)')
+
+        return res, decrypted_data
+
+    def encrypt_data(self, data: bytes) -> bytes:
+        return aes_encrypt(self.get_aes_key(), data)
+
+    def decrypt_data(self, data: bytes) -> bytes:
+        return aes_decrypt(self.get_aes_key(), data)
+
+    def request_peers(self, node_id: str):
+        pkt = PeersPacket(self.config.node_id, None, { })
+        pkt.sign(self.cred_manager.my_private())
+        res, content = self.send_request_to_node(node_id, 'peers', pkt.to_bytes(), self.cert_manager.public_path(node_id))
+        pkt = PeersPacket.from_bytes(content)
+        if not pkt.verify_signature(self.cred_manager.read_public(node_id)):
+            raise Exception("Could not verify peers packet")
+
+        for key in pkt.connections.keys():
+            if key == self.config.node_id:
+                continue
+            
+            self.address_book[key] = pkt.connections[key]
+            
+            if key not in self.node_states:
+                self.send_hello(self.address_book[key])
+            
+            _, node_state = self.send_update(key)
+            self.handle_update(node_state)
+
+    def handle_peers(self, data: bytes):
+        pkt = PeersPacket.from_bytes(data)
+        if pkt.node_id not in self.address_book:
+            raise Exception(401) # Not Authorized
+        
+        if not pkt.verify_signature(self.cred_manager.read_public(pkt.node_id)):
+            raise Exception(406) # Not Acceptable
+
+        peers = { }
+        for key in self.address_book.keys():
+            peers[key] = self.address_book[key]
+        
+        pkt = PeersPacket(self.config.node_id, None, peers)
+        pkt.sign(self.cred_manager.my_private())
+        return pkt.to_bytes()
+
+    def send_hello(self, con: Endpoint):
+        self.logger.info(f"HELLO => {con.to_string()}")
+
+        payload = self.my_hello_packet().to_bytes()
+        _, content = self.send_request(con, 'hello', payload, False)
+        self.handle_hello(content)
+
+        pkt = HelloPacket.from_bytes(content)
+        return pkt.node_id
+
+    def handle_hello(self, data: bytes) -> bytes:
+        pkt = HelloPacket.from_bytes(data)
+        self.logger.info(f"Received HELLO from {pkt.node_id}")
+        if pkt.version != self.version:
+            msg = f"HELLO => {pkt.node_id} (Version mismatch \"{pkt.version}\" != \"{self.version}\")"
+            self.logger.error(msg)
+            raise Exception(505) # Version not supported
+
+        self.cert_manager.ensure_public(pkt.node_id, pkt.https_certificate)
+        self.cred_manager.ensure_public(pkt.node_id, pkt.ecdsa_public_key)
+        
+        if pkt.node_id not in self.address_book:
+            self.address_book[pkt.node_id] = pkt.connection
+
+        if pkt.node_id not in self.node_states:
+            self.node_states[pkt.node_id] = StatePacket(pkt.node_id, 0, b'', { })
+
+        return self.my_hello_packet().to_bytes()
+
+    def my_hello_packet(self) -> HelloPacket:
+        pkt = HelloPacket(
+            self.version, 
+            self.config.node_id, 
+            self.my_con(), 
+            self.cred_manager.my_public(), 
+            None,
+            self.cert_manager.my_public()
+        )
+        pkt.sign(self.cred_manager.my_private())
+        return pkt
+
+    def send_ping(self, node_id: str):     
+        try:
+            self.send_request_to_node(node_id, 'ping', b' ', verify=self.cert_manager.public_path(node_id))
+        except Exception as e:
+            raise RequestException(f'PING => {node_id}: {e}')
+
+    def send_update(self, node_id: str):
+        self.logger.info(f"UPDATE => {node_id}")
+        return self.send_request_to_node(node_id, 'update', self.my_state().to_bytes(), self.cert_manager.public_path(node_id))
+
+    def handle_update(self, data: bytes):
+        pkt = StatePacket.from_bytes(data)
+        self.logger.info(f"Received UPDATE from {pkt.node_id}")
+        
+        # ignore if we accidentally sent an update to ourselves
+        if pkt.node_id == self.config.node_id:
+            raise Exception(406) # Not acceptable
+        
+        # don't use packets older than last update
+        if pkt.node_id in self.node_states and self.node_states[pkt.node_id].last_update > pkt.last_update:
+            raise Exception(406) # Not acceptable
+        
+        if not pkt.verify_signature(self.cred_manager.read_public(pkt.node_id)):
+            raise Exception(401) # Not authorized
+        
+        if pkt.node_id not in self.node_states:
+            self.node_states[pkt.node_id] = pkt
+            return
+
+        if get_dict_hash(self.node_states[pkt.node_id].state_data) != get_dict_hash(pkt.state_data):
+            self.node_states[pkt.node_id] = pkt
+
+        return self.my_state().to_bytes()
+
+    def my_state(self):
+        return self.node_states[self.config.node_id]
+
+    def bootstrap(self, con: Endpoint):
+        bootstrap_id = self.send_hello(con)
+        self.address_book[bootstrap_id] = con
+        _, content = self.send_update(bootstrap_id)
+        self.handle_update(content)
+        self.request_peers(bootstrap_id)
+
+    def connection_from_node(self, node_id: str) -> Endpoint:
+        if node_id not in self.address_book:
+            raise Exception(f"could not find connection for {node_id}")
+        return self.address_book[node_id]
+
+    def update_data(self, key: str, val: str):
+        self.node_states[self.config.node_id].update_state(key, val, self.cred_manager.my_private())
+        for key in list(self.node_states.keys())[:]:
+            if key == self.config.node_id:
+                continue
+            self.send_update(key)
+
+    def my_con(self) -> Endpoint:
+        return self.connection_from_node(self.config.node_id)
+
+    def read_data(self, node_id: str, key: str) -> Optional[str]:
+        if key not in self.node_states[node_id].state_data.keys():
+            return None
+        return self.node_states[node_id].state_data[key]
+
+    def peers(self) -> List[str]:
+        return list(self.node_states.keys())