Distributed ledger technologies (DLT) have emerged as transformative solutions for managing data integrity, transparency, and security across decentralized systems. Among these, IOTA stands out as a promising platform tailored specifically for the Internet of Things (IoT), leveraging a Directed Acyclic Graph (DAG) structure known as the Tangle instead of traditional blockchain architectures. This innovative approach eliminates transaction fees, enhances scalability, and reduces latency—critical advantages in IoT environments where microtransactions and real-time data exchange are paramount.
However, despite its benefits, IOTA faces challenges in resource distribution among network participants. The system classifies nodes into full nodes, which store the entire ledger and validate transactions, and light nodes, which rely on full nodes due to limited computational power. In current implementations, light nodes manually connect to full nodes using IP addresses or basic load balancers, often resulting in uneven workloads—some full nodes become overloaded while others remain underutilized. This imbalance threatens network performance and reliability.
To address this issue, we propose an enhanced resource allocation scheme based on the Weighted Least Connection (WLC) algorithm—a dynamic load-balancing method that considers both node capacity (weight) and current connection load. By integrating WLC into the IOTA architecture, our solution ensures fair distribution of validation tasks across full nodes, improving overall system efficiency and resilience.
Understanding IOTA and the Tangle Architecture
Unlike blockchains that organize transactions into sequential blocks, IOTA uses a DAG-based ledger called the Tangle. Each new transaction must approve two previous ones, creating a web-like structure that enables parallel processing and eliminates miners. This design supports feeless transactions and high throughput, making it ideal for IoT applications such as smart cities, supply chain tracking, and machine-to-machine payments.
In the Tangle, every participant contributes to consensus by validating prior transactions before issuing their own. This mechanism promotes decentralization but introduces dependency: low-resource devices (light nodes) cannot perform proof-of-work (PoW) or store the full ledger. Instead, they offload these tasks to full nodes, creating a need for efficient computing resource allocation.
Despite improvements like adaptive PoW—which adjusts computational difficulty based on device capability—there is no inherent mechanism to balance the load among full nodes. As a result, certain nodes may be overwhelmed during peak activity periods, leading to delays and potential bottlenecks.
The Need for Dynamic Load Balancing in IOTA Networks
Current node connection strategies in IOTA are static or random. Light nodes typically select full nodes via hardcoded configurations or simple round-robin methods, without considering real-time workload or hardware capabilities. This leads to three key problems:
- Overloaded Nodes: High-traffic full nodes degrade in performance, increasing latency.
- Underutilized Resources: Capable nodes remain idle while others struggle.
- Single Point of Failure: If a heavily used full node goes offline, connected light nodes lose access to the network.
These issues undermine the robustness and scalability of the IOTA ecosystem. A dynamic, intelligent load-balancing solution is essential to ensure equitable resource usage and maintain high availability.
The Weighted Least Connection (WLC) algorithm offers a compelling solution. Unlike static methods, WLC dynamically assigns incoming requests to the node with the lowest active connections relative to its processing capacity. This dual consideration of load and capability makes WLC particularly suitable for heterogeneous IoT environments where devices vary widely in computing power.
How WLC Works in Decentralized Systems
In centralized systems like web servers, WLC is commonly used behind a proxy or load balancer. However, in peer-to-peer DLTs like IOTA, no central authority exists. Therefore, we adapt WLC to function in a decentralized manner, where each node acts as both a client and a potential server.
Each full node broadcasts its:
- CPU idle ratio
- Free memory ratio
- Number of active connections
Using these metrics, a weight value between 0 and 100 is calculated:
Weight = α × (CPU Idle Ratio) + (1 - α) × (Free Memory Ratio)Where α is a tunable coefficient (set to 0.5 in our tests). This weight reflects the node’s ability to handle additional tasks.
When a light or zero node needs to attach a transaction, it runs the WLC algorithm over its neighbor list (up to nine nodes) and selects the most suitable full node based on:
Selected Node j = argmin(Connections_j / Weight_j)This ensures that powerful nodes handle more requests without being overwhelmed, while weaker nodes receive fewer tasks proportionate to their capacity.
👉 Learn how next-generation DLT platforms are redefining scalability and efficiency
Proposed Node Classification and Resource Sharing Model
To enhance flexibility and responsiveness, we extend IOTA’s original two-node model (full and light) by introducing zero nodes, further categorized as permanent and temporary:
| Node Type | Description |
|---|---|
| Full Node | Stores full Tangle, validates transactions, performs PoW, and can serve other nodes. |
| Light Node | Can create and sign transactions but relies on full nodes for PoW and attachment. |
| Permanent Zero Node | Very low-resource IoT device (e.g., sensor) that never stores data or performs validation; always depends on others. |
| Temporary Zero Node | A full or light node that temporarily stops sharing resources due to high load, maintenance, or user decision. |
This classification allows dynamic role switching. For example, a full node experiencing high traffic can transition into a temporary zero node and delegate its transaction processing to less-loaded peers using WLC.
Experimental Validation and Performance Results
We evaluated our WLC-based resource allocation scheme through two approaches: implementation in a private Tangle network and simulation using a Java-based environment.
Private Tangle Implementation
A testbed was created with multiple virtual machines acting as full nodes with varying CPU and RAM specifications. One VM served as a light node running a custom Node.js application that replaced IOTA’s default random selection logic with the WLC algorithm.
Using libraries such as @iota/core and node-os-utils, the light node collected real-time resource data from full nodes and applied WLC for connection decisions. Results showed:
- Even distribution of transaction attachments
- Reduced response time on high-capacity nodes
- Prevention of overload on weaker nodes
Simulation of Heterogeneous Networks
A Java-based simulator modeled 16 nodes with diverse hardware profiles. Incoming transactions were assigned using WLC logic, with each connection consuming fixed CPU (10 MHz) and RAM (50 MB).
Two scenarios were tested:
1. Nodes with Similar Resources
All nodes had equal CPU (1 GHz) and RAM (4 GB). As transaction load increased from 50 to 1000 requests:
- Connections were evenly distributed
- Remaining weights decreased uniformly
- No single node exceeded 65 connections at peak load
2. Nodes with Different Resources
Nodes varied in CPU (1 KHz – 6 GHz) and RAM (500 MB – 16 GB). Under increasing load:
- High-capacity nodes handled more connections
- Lower-capacity nodes maintained stable performance
- The ratio of connections per unit weight remained balanced
These results confirm that WLC effectively achieves load balancing while respecting hardware heterogeneity.
Scaling Across Multiple Network Clusters
In large-scale deployments, IOTA networks may consist of geographically distributed clusters with overlapping neighbor lists. Our decentralized WLC model scales naturally across such topologies.
Each node maintains a local neighbor list updated via gossip protocols. When making a selection:
- The WLC calculation uses only nodes within the same list
- Overlapping nodes (e.g., connected to multiple clusters) participate in multiple balancing groups
- Global balance emerges from localized decisions
Simulations with three interconnected clusters demonstrated efficient inter-cluster load distribution, proving the model’s suitability for enterprise-grade IoT infrastructures.
Conclusion
The integration of the Weighted Least Connection algorithm into DAG-based IOTA networks presents a significant advancement in decentralized resource management. By enabling intelligent, dynamic task allocation based on real-time node conditions and capabilities, this approach resolves critical bottlenecks in current implementations.
Our experiments demonstrate improved load balancing, enhanced system resilience, and optimal utilization of heterogeneous computing resources—key requirements for scalable IoT ecosystems. Future work will focus on optimizing the weight coefficient α and exploring machine learning enhancements for predictive load management.
As DLT continues to evolve beyond blockchain, solutions like ours pave the way for truly efficient, self-regulating decentralized networks.
Frequently Asked Questions (FAQ)
Q: What is the main advantage of using WLC over round-robin in IOTA?
A: Round-robin treats all nodes equally regardless of capacity or current load, risking overload on weak nodes. WLC considers both resource availability and active connections, ensuring smarter, fairer task distribution.
Q: Can light nodes run the WLC algorithm themselves?
A: Yes—light nodes can execute WLC locally using publicly shared metrics from full nodes in their neighbor list, enabling autonomous decision-making without central coordination.
Q: How does this solution impact network latency?
A: By preventing node congestion and distributing tasks efficiently, WLC reduces processing delays and improves overall transaction confirmation speed.
Q: Is this model compatible with IOTA’s upcoming Coordicide update?
A: Yes—the decentralized nature of WLC aligns perfectly with Coordicide’s goal of removing central coordinators and enhancing peer-to-peer autonomy.
Q: Does implementing WLC require changes to the core IOTA protocol?
A: Minimal changes are needed—primarily extending node communication to share real-time resource metrics. The core consensus and transaction logic remain unchanged.
Q: How does a node transition from full to temporary zero status?
A: When a full node detects high traffic, maintenance needs, or user input, it stops accepting external requests and uses WLC to delegate its own transactions to other capable nodes.
👉 Explore tools that empower developers to build scalable decentralized applications