Added a logger and the ability to simulate faulty data. Demo also plots a graph of repuation over time

Author: bprobert97

.gitignore

@@ -8,4 +8,5 @@ pyvenv.cfg
 /.vscode
 /src/__pycache__
 /.mypy_cache
-/__pycache__
+/__pycache__
+app.log

README.md

@@ -38,6 +38,7 @@ The project is currently at TRL 0. The PoISE consensus mechanism is in the early
 │   └── __init__.py                # Empty file, for module creation
 │   └── consensus_mech.py          # Code for the PoISE consensus mechanism
 │   └── dag.py                     # Code for the Directed Acyclic Graph ledger structure
+│   └── logger.py                  # Code for the app logger
 │   └── satellite_node.py          # Code representing a satellite in the network
 │   └── transaction.py             # Code representing a transaction submitted by a satellite
 │   └── utils.py                   # Utility functions and global variables

accord_demo.py

@@ -31,10 +31,12 @@
 from skyfield.api import EarthSatellite
 from src.consensus_mech import ConsensusMechanism
 from src.dag import DAG
+from src.logger import get_logger
 from src.reputation import MAX_REPUTATION, ReputationManager
 from src.satellite_node import SatelliteNode
 from src.transaction import Transaction, TransactionMetadata
 
+logger = get_logger(__name__)
 
 def create_noisy_transaction(base_sat: EarthSatellite) -> Transaction:
     """
@@ -70,7 +72,7 @@ def create_noisy_transaction(base_sat: EarthSatellite) -> Transaction:
 
 async def run_consensus_demo(initial_n_tx: int = 3,
                              n_test_tx: int = 1) -> tuple[Optional[DAG], Optional[list[float]]]:
-    """ 
+    """
     This function runs a demonstration of the ACCORD Distributed Ledger.
     The following steps are demonstrated:
     - Loading in TLE data from a JSON file
@@ -103,7 +105,7 @@ async def run_consensus_demo(initial_n_tx: int = 3,
     sat_rep_list: list = []
 
     if test_satellite.tle_data[0] is None:
-        print("No satellite data found.")
+        logger.info("No satellite data found.")
         return None, None
 
     base_sat = test_satellite.tle_data[0]
@@ -121,6 +123,25 @@ async def run_consensus_demo(initial_n_tx: int = 3,
     asyncio.create_task(test_dag.listen())
 
     # TODO - get more data to simulate better, rather than adding the same data
+    logger.info("Submitting Valid Transactions")
+    for _ in range(n_test_tx):
+        # Run consensus on a single satellite observation - the test transaction
+        await test_satellite.submit_transaction(
+             satellite=base_sat,
+             recipient_address=123
+             )
+        sat_rep_list.append(test_satellite.reputation)
+
+    logger.info("Submitting Malicious Transaction")
+    test_satellite.is_malicious = True
+    await test_satellite.submit_transaction(
+             satellite=test_satellite.tle_data[0],
+             recipient_address=123
+             )
+    sat_rep_list.append(test_satellite.reputation)
+
+    logger.info("Submitting Valid Transactions")
+    test_satellite.is_malicious = False
     for _ in range(n_test_tx):
         # Run consensus on a single satellite observation - the test transaction
         await test_satellite.submit_transaction(
@@ -130,8 +151,10 @@ async def run_consensus_demo(initial_n_tx: int = 3,
         sat_rep_list.append(test_satellite.reputation)
 
     # Output results
-    print(test_dag.ledger)
-    print(sat_rep_list)
+    # logger.info("Test DAG:")
+    # logger.info(test_dag.ledger)
+    # logger.info("Satellite Reputations")
+    # logger.info(sat_rep_list)
     return test_dag, sat_rep_list
 
 

src/consensus_mech.py

@@ -122,7 +122,7 @@ def get_correctness_score(self, sat: EarthSatellite, dag: DAG) -> float:
 
         # Very basic check — mean motion deviation, inclination deviation
         past = matches[-1]
-        motion_dev = abs(sat.model.no_kozai - float(past["MEAN_MOTION"]))
+        motion_dev = abs(((sat.model.no_kozai / (2 * np.pi)) * 1440)- float(past["MEAN_MOTION"]))
         incl_dev = abs((sat.model.inclo * 180 / np.pi) - float(past["INCLINATION"]))
 
         correctness_score = 1.0
@@ -143,6 +143,7 @@ def estimate_accuracy(self, sat: EarthSatellite) -> float:
         speed = np.linalg.norm(velocity)
 
         deviation = abs(speed - ideal_speed)
+
         if deviation < 0.3:
             return 1.0
         if deviation < 0.6:
@@ -157,19 +158,21 @@ def calculate_consensus_score(self, correctness: float,
         Weighted score. Tuneable weights.
         TODO - tune
         """
-        return 0.4 * correctness + 0.4 * accuracy + 0.2 * reputation
+        return 0.7 * correctness + 0.3 * accuracy + 0.2 * reputation
 
 
     def proof_of_inter_satellite_evaluation(self, dag: DAG,
                                             sat_node: SatelliteNode,
                                             transaction: Transaction) -> bool:
         """
-        Returns a bool of it consensus has been reached  
-        NOTE: Assume one witnessed satellite per transaction   
+        Returns a bool of it consensus has been reached
+        NOTE: Assume one witnessed satellite per transaction
         """
         # 1)  Turn transaction data into an EarthSatellite object
         # for validation using wsg4 and skyfield
-        sat = build_earth_satellite_list_from_str(load.timescale(), transaction.tx_data)[0]
+        sat = build_earth_satellite_list_from_str(load.timescale(),
+                                                  transaction.tx_data,
+                                                  sat_node.is_malicious)[0]
 
         # 2) TODO Check if data is valid, if not - ignore.
         # If the list is empty, there is no data that can be valid
@@ -212,6 +215,8 @@ def proof_of_inter_satellite_evaluation(self, dag: DAG,
                                                          accuracy_score,
                                                          sat_node.reputation)
 
+        print(consensus_score >= self.consensus_threshold)
+
         sat_node.reputation = sat_node.rep_manager.decay(sat_node.reputation)
 
         # 7) if consensus reached - strong node (maybe affects node reputation?),

src/dag.py

@@ -27,11 +27,14 @@
 import random
 from collections import OrderedDict
 from typing import TYPE_CHECKING
+from .logger import get_logger
 from .transaction import Transaction, TransactionMetadata
 
 if TYPE_CHECKING:
     from .consensus_mech import ConsensusMechanism
 
+logger = get_logger(__name__)
+
 class DAG():
     """
     A class representing the Directed Acyclic Graph (DAG) Distributed Ledger Technology.
@@ -57,7 +60,7 @@ async def listen(self) -> None:
         """
         while True:
             transaction, satellite, future = await self.queue.get()
-            print(f"DAG received transaction {transaction.hash}")
+            logger.info("DAG received transaction %s", transaction.hash)
             consensus_result = self.consensus_mech.proof_of_inter_satellite_evaluation(
                 dag=self,
                 sat_node=satellite,

src/logger.py

@@ -0,0 +1,46 @@
+"""
+The Autonomous Cooperative Consensus Orbit Determination (ACCORD) framework.
+Author: Beth Probert
+Email: beth.probert@strath.ac.uk
+
+Copyright (C) 2025 Applied Space Technology Laboratory
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import logging
+from logging import Logger
+
+def get_logger(name: str = __name__) -> Logger:
+    """
+    Returns a logger for the application
+    """
+    logger = logging.getLogger(name)
+    if not logger.hasHandlers():  # Avoid adding multiple handlers
+        logger.setLevel(logging.DEBUG)
+
+        # Console handler
+        ch = logging.StreamHandler()
+        ch.setLevel(logging.INFO)  # Adjust level for console output
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+        # File handler (optional)
+        fh = logging.FileHandler('app.log')
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+
+    return logger

src/satellite_node.py

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-instance-attributes
 """
 The Autonomous Cooperative Consensus Orbit Determination (ACCORD) framework.
 Author: Beth Probert
@@ -25,18 +26,22 @@
 from typing import Optional
 from skyfield.api import EarthSatellite
 from .dag import DAG
+from .logger import get_logger
 from .reputation import ReputationManager, MAX_REPUTATION
 from .transaction import Transaction, TransactionMetadata
 from .utils import build_tx_data_str, load_json_data
 
+logger = get_logger(__name__)
+
 
 class SatelliteNode():
     """
-    A class representing a node in the network, in this case a LEO satellite. 
+    A class representing a node in the network, in this case a LEO satellite.
     This does NOT represent a node in the ledger - these are transactions
     """
-    def __init__(self, node_id: str, queue: asyncio.Queue) -> None:
+    def __init__(self, node_id: str, queue: asyncio.Queue, is_malicious: bool = False) -> None:
         self.id: str = node_id
+        self.is_malicious: bool = is_malicious
         self.queue = queue
         self.exp_pos: int = 0
         # Reputation starts at 0, affected by validity and accuracy
@@ -47,9 +52,11 @@ def __init__(self, node_id: str, queue: asyncio.Queue) -> None:
         self.rep_manager = ReputationManager()
         self.local_dag: Optional[DAG] = None
 
-        # This is for testing purposes. In reality, data will
+        # TODO This is for testing purposes. In reality, data will
         # be loaded from a sensor
-        self.tle_data: list[Optional[EarthSatellite]] = load_json_data("od_data.json")
+        self.tle_data: list[Optional[EarthSatellite]] = load_json_data(
+            "od_data.json",
+            faulty_data = self.is_malicious)
 
     async def submit_transaction(self,
                                  satellite: EarthSatellite,
@@ -77,7 +84,7 @@ async def submit_transaction(self,
                                   metadata=metadata)
 
         future = asyncio.get_running_loop().create_future()
-        print(f"Satellite {self.id}: submitting transaction {transaction.hash}")
+        logger.info("Satellite %s: submitting transaction %s", self.id, transaction.hash)
         await self.queue.put((transaction, self, future))
         # Waits until DAG sets the result
         return await future

src/utils.py

@@ -25,6 +25,46 @@
 from typing import Optional
 from skyfield.api import EarthSatellite, load, Timescale
 import numpy as np
+from sgp4.api import Satrec, WGS72 # type: ignore[import-untyped]
+
+def corrupt_satellite(sat: EarthSatellite, mean_motion_factor: float = 0.8) -> EarthSatellite:
+    """
+    mean motion factor of >1.05 or <0.73 makes the data invalid
+    1.0 is the same.
+    1.01 - 1.04 affects correctness
+    0.74-0.93 affects accuracy and correctness
+    0.94-0.99 affects correctness
+    """
+    # Copy fields from the original model
+    m = sat.model
+
+    # Build a new Satrec with modified mean motion
+    corrupted_model = Satrec()
+    corrupted_model.sgp4init(
+        WGS72,
+        'i',
+        int(m.satnum),
+        float(m.jdsatepoch - 2433281.5),  # epoch in days since 1949-12-31
+        float(m.bstar),
+        float(m.ndot),
+        float(m.nddot),
+        float(m.ecco),
+        float(m.argpo),
+        float(m.inclo),
+        float(m.mo),
+        float(m.no_kozai) * mean_motion_factor,  # corrupted mean motion
+        float(m.nodeo)
+    )
+
+    # Create an EarthSatellite instance without calling __init__
+    corrupted_sat = EarthSatellite.__new__(EarthSatellite)
+    corrupted_model.intldesg = sat.model.intldesg
+    corrupted_sat.model = corrupted_model
+    corrupted_sat.name = sat.name
+    corrupted_sat.epoch = sat.epoch
+    corrupted_sat.target = sat.target
+
+    return corrupted_sat
 
 
 def build_tx_data_str(satellite_data: EarthSatellite) -> str:
@@ -85,15 +125,18 @@ def build_tx_data_str(satellite_data: EarthSatellite) -> str:
                 "MEAN_MOTION_DDOT": motion_ddot
             })
 
-def build_earth_satellite_list_from_str(ts: Timescale, data: str) -> list[Optional[EarthSatellite]]:
+def build_earth_satellite_list_from_str(ts: Timescale, data: str,
+                                        make_faulty: bool) -> list[Optional[EarthSatellite]]:
     """
     Construct an EarthSatellite object from a string of data to be
     used for data validation.
 
     Arguments:
     - ts: The timescale, used to build the satellite's epoch time
-    - data: a string of data (ideally in a dict format) to be used to populate
+    - data: A string of data (ideally in a dict format) to be used to populate
     the attributes of the EarthSatellite object.
+    - make_faulty: A boolean flag about whether the data generated should be faulty, to
+    represent a malicious node
 
     Returns:
     - A list of EarthSatellite objects
@@ -112,13 +155,21 @@ def build_earth_satellite_list_from_str(ts: Timescale, data: str) -> list[Option
     if not isinstance(data, list) or not all(isinstance(d, dict) for d in data):
         raise TypeError("Expected a list of dicts after parsing satellite data")
 
-    return [EarthSatellite.from_omm(ts, fields) for fields in data]
+    sat_list = [EarthSatellite.from_omm(ts, fields) for fields in data]
 
-def load_json_data(file_name: str) -> list[Optional[EarthSatellite]]:
+    if make_faulty:
+        for i, sat in enumerate(sat_list):
+            sat_list[i] = corrupt_satellite(sat)
+
+    return sat_list
+
+def load_json_data(file_name: str, faulty_data: bool) -> list[Optional[EarthSatellite]]:
     """
     Turns json data in a file into a Python dict.
     JSON data must be in the Celestrak format
     https://rhodesmill.org/skyfield/earth-satellites.html
+
+    If faulty_data is True, this function will generate faulty data for testing
     """
     try:
         with load.open(file_name) as f:
@@ -128,5 +179,5 @@ def load_json_data(file_name: str) -> list[Optional[EarthSatellite]]:
         return []
 
     ts = load.timescale()
-    satellite_list = build_earth_satellite_list_from_str(ts, data)
+    satellite_list = build_earth_satellite_list_from_str(ts, data, faulty_data)
     return satellite_list