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.

Last updated