> For the complete documentation index, see [llms.txt](https://docs.lumoratoken.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.lumoratoken.ai/lumora/architecture-and-technical-framework.md).

# Architecture and Technical Framework

The Lumora network operates on a decentralized architecture designed for efficiency, security, and scalability. Below is the detailed breakdown of the core components, algorithms, and equations.

***

**Core Components**

* **Bandwidth Providers**: Share unused internet bandwidth via the Lumora browser extension or DApp. Contributions are encrypted and optimized to ensure no disruption to regular internet usage.
* **Decentralized Task Manager**: Dynamically assigns tasks to nodes based on proximity, availability, and capacity, ensuring efficient task distribution.
* **Task Executors (Nodes)**: Perform data scraping, processing, and encryption tasks using adaptive frameworks.
* **Blockchain Infrastructure**: Implements smart contracts for task validation, reward distribution, and fraud prevention, ensuring a transparent and immutable system.
* **Data Consumers**: Access aggregated and encrypted data through a decentralized marketplace and pay using Lumora tokens.

***

**Task Allocation Algorithm**

To ensure efficient task execution, a **weighted proximity-based task allocation algorithm** is used.

**Algorithm:**

1. **Input Variables:**
   * `B_i`: Bandwidth capacity of node `i`.
   * `P_i`: Proximity of node `i` to the data source.
   * `L_i`: Latency of node `i`.
   * `W_i`: Weighted score for node `i`.
2. **Weighted Score Calculation:**

   ```
   W_i = α * (B_i / B_max) + β * (1 / P_i) + γ * (1 / L_i)
   ```

   * `α`, `β`, `γ`: Tunable parameters for balancing bandwidth, proximity, and latency.
   * `B_max`: Maximum bandwidth available in the network.
3. **Task Assignment:**
   * The node with the highest `W_i` is selected for task execution.

***

**Proof-of-Bandwidth Validation**

The **Proof-of-Bandwidth (PoB)** protocol ensures fair validation of contributions and reward distribution.

**Equations:**

1. **Bandwidth Contribution:**

   ```
   C_i = Used Bandwidth by Node i / Total Bandwidth Used in the Network
   ```
2. **Reward Calculation:**

   ```
   R_i = C_i * R_total
   ```

   * `R_total`: Total reward tokens allocated for the current cycle.
3. **Validation:**
   * Contributions are logged on the blockchain and verified using smart contracts.

***

**Dynamic Load Balancing**

To optimize resource utilization, a **real-time load balancing algorithm** is implemented.

**Algorithm:**

1. **Input Variables:**
   * `N_i`: Current load on node `i`.
   * `C_max`: Maximum capacity of node `i`.
2. **Load Balancing Condition:**

   ```
   If N_i >= 0.8 * C_max, redirect tasks to the next available node.
   ```
3. **Task Redistribution:**
   * Tasks are dynamically reassigned to nodes with available capacity to prevent overloading.

***

**Data Encryption and Aggregation**

* **Encryption Protocol**: AES-256 encryption ensures data security.

  ```
  E_k(M) = AES-256(k, M)
  ```

  * `E_k(M)`: Encrypted message `M` using key `k`.
* **Aggregation Framework**:
  1. Normalize raw data into a structured format (e.g., JSON, CSV).
  2. Validate data integrity with:

     ```
     H(M) = SHA-256(M)
     ```

     * `H(M)`: Hash value of message `M`.

***

**Reward Distribution Mechanism**

The reward system is automated using blockchain smart contracts.

**Workflow:**

1. **Task Logging:**
   * Tasks are logged immutably on the blockchain.
2. **Reward Disbursement:**
   * Rewards are calculated using the Proof-of-Bandwidth equation and distributed automatically to participants.

***

**Layer-2 Scaling and Sharding**

1. **Layer-2 Integration**:
   * Utilizes Layer-2 solutions (e.g., Polygon) to reduce transaction fees and improve throughput.
2. **Sharding**:

   * Splits the network into smaller partitions (shards) for scalability.

   ```
   S_i = N / k
   ```

   * `S_i`: Number of nodes in shard `i`.
   * `N`: Total number of nodes.
   * `k`: Number of shards.

***

This architecture ensures that Lumora operates as a robust, scalable, and secure decentralized network, supporting optimal task allocation, secure data handling, and fair reward distribution.