A Smart Contract-Based Algorithm for Offline UAV Task Collaboration: A New Solution for Managing Communication Interruptions

1. Introduction

With the rapid advancement of UAV technology, UAV swarm systems are being increasingly deployed in diverse mission scenarios, such as disaster rescue, logistics, and military operations, due to their efficiency and flexibility [1]. In particular, it has shown significant advantages in flexible response in complex environments. However, environmental factors and electronic interference often interfere with the communication between the drone cluster and the ground control center, causing communication interruption. At this time, the drone needs to complete the task without central control [2]. This places extremely high demands on the autonomous and collaborative capabilities of the drone. Therefore, it is crucial for drone swarms to have efficient offline autonomous decision-making and collaborative capabilities in complex environments. Most current research relies on ground control support and focuses on UAV collaboration under continuous communication, lacking systematic exploration of task allocation and coordination mechanisms in offline environments. This limitation compromises task efficiency and communication security, particularly when UAV swarms perform complex missions in disconnected settings [3].

In recent years, research has increasingly explored the use of blockchain and smart contracts to address the need for autonomous task execution in offline UAV (Unmanned Aerial Vehicle) systems [4]. Blockchain, as a decentralized and tamper-resistant ledger technology, offers a secure environment for data exchange within UAV swarms, ensuring mission data is transmitted and stored safely and effectively mitigating data security risks in offline scenarios. In such settings, traditional centralized control mechanisms often struggle with information flow and task continuity due to a lack of real-time communication and remote support. By contrast, the censorship-resistant, distributed nature of blockchain provides a more resilient operational foundation for UAV swarms. The timestamping capability of blockchain enables each task step to be precisely recorded, protecting against potential data tampering. Furthermore, blockchain’s immutability and transparency allow all mission-related information and decisions to be verified independently by each node, enhancing transparency and trustworthiness throughout mission execution.

Smart contracts further enable automation of predefined coordination rules, supporting key processes for UAV swarms operating offline [5]. Unlike traditional manual intervention or centralized control, smart contracts ensure that the rules and conditions set during mission planning are strictly followed, facilitating automated task response. This is particularly valuable in scenarios requiring UAV swarms to make autonomous decisions and respond immediately to emergencies. For instance, tasks like route adjustments and dynamic resource allocation can be handled swiftly through the self-executing nature of smart contracts, ensuring efficient task completion.

However, despite these advantages, current research has not yet fully exploited the potential of blockchain smart contracts to enhance collaborative decision-making within UAV swarms in offline conditions. Particularly in complex and dynamic task environments, maintaining coherent decision-making and secure communication offline remains a pressing challenge. Current solutions primarily apply blockchain and smart contracts to basic data exchange and simple task scheduling, without leveraging their potential in complex decision-making, such as facilitating efficient multi-UAV collaboration and flexible adaptation without real-time communication. Therefore, developing a method that fully utilizes blockchain to enhance task continuity and communication security in offline settings is essential. This approach would improve UAV systems’ autonomy and collaboration during missions and support their intelligent, autonomous development for more demanding scenarios, equipping UAV systems with adaptive capabilities for dynamic environments and ensuring stable, efficient operation under varied mission conditions.

Therefore, the main contributions of this paper are as follows:

• Development of a Blockchain-Based Autonomous Collaboration Algorithm for Offline UAV Swarms: To improve task execution efficiency of UAV swarms in offline environments, this paper presents an autonomous collaboration mechanism, including algorithms for task allocation, resource scheduling, and collaborative decision-making. These algorithms are embedded within smart contracts to enable autonomous task coordination and efficient execution under offline conditions.
• Design of an Automatic Smart Contract Triggering Mechanism for Unforeseen Offline States: Addressing task interruptions and communication failures in offline UAV swarm environments, this paper introduces an automatic triggering mechanism within smart contracts. This mechanism initiates the autonomous collaboration processes based on predefined conditions and rules, ensuring uninterrupted task execution even in offline states.
• Performance and Robustness Validation of the Algorithm in Offline Environments: Through simulation experiments, this paper validates the algorithm’s effectiveness in enhancing task continuity and communication security in offline conditions, demonstrating its applicability across various offline mission scenarios.

The remainder of this paper is organized as follows: Section 2 reviews related research on offline coordination in UAV swarms. Section 3 presents the blockchain-based UAV network architecture, and Section 4 details the design of the proposed autonomous task coordination algorithm based on blockchain smart contracts. Section 5 describes the simulation and performance evaluation of the algorithm. Finally, Section 7 concludes the paper and provides suggestions for future research directions.

2. Related Work

2.1. Challenges in Offline Communication for UAV Swarms

Due to their flexibility, mobility, and cost-effectiveness, UAV swarms have seen widespread application in areas such as military operations, disaster response, and logistics [6]. However, their deployment presents significant communication challenges, particularly in establishing high-speed communication links and developing efficient collaborative decision-making algorithms [7]. Achieving decentralized communication among UAVs requires the integration of sensor arrays and advanced routing algorithms to enable autonomous operation without relying on a central base station, thus ensuring quality of service (QoS) [8]. Continuous communication is essential for task coordination, especially in critical scenarios like disaster relief and military operations [9]. Studies have shown that communication failures often lead to mission failure, whereas effective information sharing enhances collaboration and conflict resolution in multi-agent systems, ultimately improving decision-making and operational efficiency [10,11,12].

Despite advancements in UAV communication and collaboration technology, several challenges persist. UAVs need to establish high-speed links, ensure secure data transmission, and maintain reliable control strategies [13]. Additionally, UAVs are prone to interference and have limited payload capacity, which further complicates integration with existing communication infrastructure [14]. UAV communication networks (FANETs) face numerous issues in security, resource management, and physical constraints, exacerbated by the dynamic nature of UAV operations [15,16]. Secure communication is especially critical; robust encryption and authentication mechanisms are essential to defend against potential attacks [17,18,19]. In multi-UAV systems, collaborative communication is vital for mission success, yet achieving intelligent UAVs with autonomous coordination capabilities remains technically challenging [20,21].

The challenges become even more pronounced when UAVs lose communication with the ground control center or other UAVs. Electromagnetic interference (EMI) often leads to communication instability in air-to-ground applications. Additionally, given the small size, limited battery life, and high-speed maneuverability of UAVs, maintaining reliable communication in complex environments is even more difficult [22]. Multi-UAV collaborative communication, forming an “aerial network,” is seen as a crucial approach to improving communication reliability [23]. As shown in Table 1, designing network topologies suited for UAV swarms is essential to ensure the safe and efficient operation of UAVs when communication interruptions occur.

2.2. Limitations of Centralized Control Systems in Dynamic Environments

In dynamic environments, centralized control systems face significant limitations, primarily due to their reliance on pre-programmed decision logic that lacks the flexibility to adapt to unpredictable and complex scenarios. This inherent inflexibility makes centralized systems slow to respond to rapid environmental changes and uncertainties, often resulting in inefficient task execution or even mission failure [24,25]. This challenge is especially critical in Unmanned Aerial Systems (UAS), where real-time responsiveness and high adaptability are essential.

Given these challenges, decentralized and autonomous control methods present a more promising alternative. By distributing decision-making authority across multiple agents, each agent can independently adjust its behavior based on local information without relying on a central command, enhancing the system’s flexibility and scalability [26,27,28]. In the field of Unmanned Aerial Vehicles (UAVs), decentralized control methods have been successfully applied in navigation and formation control [29,30]. For instance, techniques such as virtual spring-damper models and rotational force fields facilitate autonomous navigation and obstacle avoidance in complex environments, allowing UAV swarms to operate effectively even during communication outages [31].

Furthermore, decentralized control also offers advantages in security management. Issues like electromagnetic interference and data encryption are more effectively managed in a distributed framework, underscoring the limitations of centralized control systems.

2.3. Autonomy and Collaboration in Offline UAV

The autonomy and collaboration capabilities of offline UAVs are crucial for executing complex multi-UAV tasks with greater efficiency and effectiveness. Integrating game-theoretic methods and multi-agent systems plays a central role in achieving these capabilities. For example, game-theoretic learning frameworks enable dynamic, decentralized task planning, allowing UAVs to autonomously coordinate and allocate tasks efficiently, as demonstrated in multi-UAV inspection tasks [32,33]. Similarly, Multi-Agent Reinforcement Learning (MARL) addresses collaborative task execution challenges in UAV networks, focusing on energy efficiency and trajectory optimization to ensure task completion even in dynamic environments [34]. Distributed or decoupled collaborative autonomy frameworks (D2CAF) further support multi-agent task allocation solutions, enabling communication and task execution among physically disconnected agents [35].

Moreover, integrating ground and aerial robots in disaster response highlights the complementary capabilities of robotic systems, where UAVs provide rapid environmental mapping while ground robots conduct detailed tasks based on gathered data [36]. Autonomous collaborative decision-making systems, which incorporate threat assessment, task planning, and negotiation modules, enhance the capacity of UAV swarms to operate independently and make real-time decisions [37]. Together, these advancements underscore the importance of autonomy and collaboration in offline UAV operations, allowing UAVs to undertake complex tasks with minimal human intervention and maximize task efficiency through intelligent coordination and resource management.

2.4. Application of Blockchain Technology in UAV

Blockchain technology is increasingly integrated into UAV systems to address challenges related to security, data integrity, and operational efficiency. One major application is enhancing the security and verifiability of UAV surveillance systems. By leveraging blockchain’s decentralized and tamper-resistant properties, UAVs can ensure data reliability and trustworthiness, with smart contracts managing data access and privacy [38]. In the context of Industry 5.0, blockchain frameworks are transforming UAV communication by providing secure and efficient channels essential for human-machine collaboration in industrial applications [39].

Blockchain also supports federated learning initiatives by transferring training tasks to local servers and using new consensus algorithms like Proof-of-Energy to manage UAV participation, thereby safeguarding data and protecting user privacy [40]. Additionally, IoT and blockchain integration improves UAV operational efficiency by increasing data transmission rates and reducing energy consumption [41]. Privacy-preserving blockchain authentication frameworks are under development to secure UAV operations by providing unique digital identities and processing authentication requests through smart contracts, enhancing resilience against unauthorized access and attacks [42].

In multi-UAV networks, blockchain-assisted zero-trust authentication schemes like BAZAM ensure continuous UAV identity verification, preventing data breaches and system failures [43]. Decentralized PKI frameworks, based on blockchain, eliminate single points of failure in UAV communication systems, improving the security and reliability of spatial crowdsourcing services [44]. For UAV swarms, dynamic consensus algorithms like DTPBFT enhance scalability and fault tolerance, enabling efficient management of large-scale UAV networks [45]. Lightweight blockchain solutions are also being developed for UAV ad hoc networks to support secure collaborative computation and efficient task allocation [46]. In smart agriculture, blockchain integration within UAV networks strengthens data integrity and confidentiality, ensuring secure communication and reducing the risk of unauthorized data access [47]. Overall, blockchain technology has proven to be essential for enhancing the security, efficiency, and reliability of UAV systems across various applications.

3. Blockchain-Based UAV Networks

This paper addresses the challenges of autonomous task execution and secure communication for UAV swarms operating in offline environments, focusing on two scenarios: one in which the entire UAV swarm loses connection with the ground station, and another where an individual UAV disconnects from the swarm. To tackle these issues, a blockchain-based network architecture for UAVs is proposed. This architecture integrates FANET (Flying Ad Hoc Network) with a reputation-based consensus algorithm, enabling efficient data transmission and a reliable consensus mechanism. As a result, the UAV swarm gains improved autonomous collaboration and secure communication capabilities even in the absence of ground control. The proposed architecture integrates hardware and software layers to create a highly autonomous and secure UAV system by leveraging blockchain technology and smart contracts.

On the hardware level, each UAV is equipped with an advanced onboard computing unit that manages flight control, data processing, and blockchain operations. Each UAV also includes a wireless communication module supporting the FANET protocol, allowing ad-hoc network connections between drones. Additionally, UAVs are outfitted with various sensors and actuators—including GPS, IMU, and cameras—to enable environmental awareness and task execution. An energy management system further supports sustained operation for high-power consumption tasks.

The system architecture, illustrated in Figure 1, comprises two main layers at the network level: the communication network layer and the blockchain network layer. In the communication network layer, the UAV swarm utilizes FANET’s mesh-based multi-hop communication for direct inter-node communication and information sharing. This flexible topology allows the network to sustain connectivity amidst frequent node additions or departures, which supports reliable information exchange for tasks in complex, dynamic environments.

On the blockchain network layer, the system integrates a distributed ledger, smart contract modules, and a reputation-based consensus mechanism. Each UAV node maintains a partial copy of the blockchain and utilizes smart contracts for automating task allocation, coordination strategies, and resource management. The reputation-based consensus algorithm is tightly integrated with the FANET network, safeguarding data security and consistency throughout task distribution and execution. This decentralized design empowers the UAV swarm to maintain autonomous coordination and task scheduling via smart contracts, even in the absence of a ground control center.

To enhance collaborative capabilities in resource-limited and dynamic environments, the blockchain network architecture emphasizes efficient resource use and streamlined collaboration. Given the UAV nodes’ limited computational power and battery constraints, the blockchain system employs lightweight nodes that store only essential task-related data and block headers. The reputation-based consensus protocol improves efficiency by scoring nodes based on their resource status, reducing unnecessary communication load [48]. Data pruning techniques further reduce storage requirements by deleting non-essential historical data, retaining only critical information. These optimizations substantially decrease storage and computational overhead, enhancing overall task execution efficiency.

3.1. Smart Contract Mechanism Design

The smart contract execution mechanism is crucial for achieving autonomous collaboration within UAV swarms. UAV nodes initiate task execution according to preset consensus rules. To support autonomous collaboration across tasks, the smart contracts offer various templates designed for different mission types, including patrol, search and rescue, supply transport, and attack operations. For example, in search and rescue missions, the contract outlines the UAV’s area search patterns, target identification techniques, and coordinated rescue steps upon locating a target. Collaboration strategies also include contingency protocols for UAV disconnection or failure, ensuring mission continuity. Each smart contract template is designed as a minimal functional unit, which can be assembled into sets of contracts as needed. This modular approach supports inter-contract activation and invocation, enhancing both task flexibility and execution efficiency.

As shown in Figure 2, this paper adopts a smart contract deployment strategy that combines full replication and partial replication. In the full replication mode, all UAV nodes store essential smart contracts (e.g., Node 1) to ensure that any node can independently execute core tasks. In partial replication mode, certain contracts are stored only on selected nodes (e.g., Nodes 2, 3, and 4) based on each UAV’s resources and assigned roles, conserving storage space. Each smart contract template clearly specifies task objectives, resource requirements, execution procedures, and coordination strategies (see algorithm in Section 4.3).

In offline conditions, smart contract execution depends on the UAVs’ autonomous decision-making capabilities and the FANET network. FANET allows direct communication between UAVs, so even if some nodes are disconnected, other nodes can maintain network-wide connectivity through multi-hop communication. This environment supports the continued effectiveness of the reputation-based consensus algorithm, ensuring that smart contract execution results are consistently agreed upon across the network.

Moreover, smart contract execution is designed with integrated security and reliability features. During contract execution, UAVs use encryption and authentication mechanisms to ensure only authorized nodes can participate in specific tasks. The system’s redundancy and fault tolerance capabilities further enhance the stability of the UAV swarm, enabling it to withstand single or multiple node failures.

4. Design of Autonomous Collaborative Algorithms Based on Smart Contracts

Offline autonomous task execution by drone swarms in real-world applications involves addressing a range of complex requirements and challenges. Operating in highly dynamic and unpredictable environments, drone swarms must exhibit high levels of autonomy and collaboration, particularly when communication with ground control centers is unavailable. In these offline conditions, drones need to manage a variety of tasks effectively, including efficient task allocation, reliable data sharing, stable communication, and robust collaboration mechanisms. To meet these demands, this paper presents an autonomous collaboration algorithm that efficiently addresses task allocation, resource scheduling, and collaborative decision-making complexities. The algorithm is designed to reduce energy consumption, ensure efficient task execution, enhance swarm collaboration in complex environments, and minimize the computational load on smart contracts.

As illustrated in Figure 3, the autonomous collaboration algorithm includes three sub-algorithms, which operate in the following coordinated sequence:

• Step 1: When tasks are registered and added to the task pool, the task allocation algorithm immediately assesses all available drone nodes based on resource status (e.g., battery level, current task load) and selects the highest-scoring node to execute the task.
• Step 2: If the designated node fails during task execution, the resource scheduling algorithm reallocates the task to a suitable alternative node (Step 5).
• Step 3: For tasks requiring multiple nodes, the collaborative decision-making algorithm selects an optimal group of nodes to execute the task jointly (Step 7).
• Step 4: If any node in this group fails, the resource scheduling algorithm replaces it with a new node (Step 6) to maintain uninterrupted task execution (Step 7).

To implement this algorithm effectively, key performance metrics are defined for both drone nodes and task requirements. As show Table 2 and Table 3:

• UAV Node Set: Let there be N UAV nodes, denoted as the set $\mathcal{N}=\{n_1,n_2,\dots ,n_N\}$.
• Task Set: Let there be M tasks, denoted as the set $\mathcal{T}=\{t_1,t_2,\dots ,t_M\}$.

4.1. Task Allocation Algorithm

The task allocation algorithm initiates the autonomous collaboration process and is critical to efficient task execution within the UAV swarm. By scoring each node’s resource status, the algorithm identifies the most suitable node to execute a given task, optimizing resource utilization and aligning node selection with task requirements.

The task allocation algorithm operates as outlined in Figure 4:

• Information Collection: Each UAV node collects its resource status information, while the smart contract identifies task requirements.
• Resource Scoring: Each node’s metrics are normalized, and a scoring function calculates its resource status score.
• Optimal Node Selection: Based on resource scores, an initial set of qualified UAV nodes is selected, from which the optimal node is chosen. To prevent overload, a dynamic load adjustment mechanism recalculates scores based on each node’s current load, balancing task allocation. The final optimal node is determined through an optimization model.
• Task Assignment Execution: The optimal node is then assigned the task.
• Task Allocation Consensus: Upon successful task allocation, a consensus is recorded on the blockchain to confirm the assignment’s validity and the node’s acceptance of the task.

4.1.1. Resource Status Scoring

This paper utilizes a reputation-based consensus algorithm to identify UAV nodes with high scores (indicating strong resource availability) for task execution. The consensus threshold can be adjusted to facilitate rapid selection of high-scoring nodes. A UAV node’s score is calculated using five key metrics: remaining energy, task load, computational power, communication bandwidth, and communication delay. Thus, nodes with higher scores indicate greater available resources.

As shown in Table 2, the scoring process consists of two stages. First, normalization adjusts for differences in units and value ranges across metrics. Then, a resource status scoring function, $S_i$, evaluates each node’s suitability by computing a weighted sum of the normalized metrics:

$$S_i=w_1{E}_i^{\mathrm{norm}}+w_2{L}_i^{\mathrm{norm}}+w_3{C}_i^{\mathrm{norm}}+w_4{B}_i^{\mathrm{norm}}+w_5\Delta T_i^{\mathrm{norm}}$$

(1)

where the weight coefficients $w_k=\{w_1,w_2,w_3,w_4,w_5\}$ satisfy:

$$\sum _k{w}_k=1,w_k\ge 0$$

(2)

The weight coefficients can be dynamically adjusted based on task requirements:

• For urgent tasks, increase $w_2$ to prioritize nodes with lower load.
• For compute-intensive tasks, increase $w_3$ to prioritize nodes with higher computational power.
• For tasks requiring high reliability, increase $w_5$.

4.1.2. Optimal Node Selection

The smart contract selects the UAV node with the highest resource score to execute the task, provided it meets the task’s requirements. This method maximizes the efficient use of UAV resources. Once the task is assigned, a consensus is reached within the UAV swarm, ensuring consistent understanding among nodes and minimizing potential miscommunication during execution.

For a given task $t_j$, the goal is to select a UAV that meets the task requirements. Specifically, we aim to find a node $n_{i^{*}}$ within the feasible set ${\mathcal{N}}_j^{\mathrm{feasible}}$ that maximizes the scoring function $S_{ij}$. Thus, $n_{i^{*}}$ is the node with the highest score $S_{ij}$ in the feasible set, defined as:

$$n_{i^{*}}=arg\underset{n_i\in {\mathcal{N}}_j^{\mathrm{feasible}}}{max}{S}_{ij}$$

(3)

The feasible node set ${\mathcal{N}}_j^{\mathrm{feasible}}$, which meets the task requirements, is defined as:

$${\mathcal{N}}_j^{\mathrm{feasible}}=\left\{n_i\left|\begin{array}{c}{E}_i\ge E_j^{\mathrm{req}}\hfill \\ C_i\ge C_j^{\mathrm{req}}\hfill \\ B_i\ge B_j^{\mathrm{req}}\hfill \\ T_{ij}^{\mathrm{est}}\le T_j^{\mathrm{ddl}}\hfill \end{array}\right.\right\}$$

(4)

Where, $E_j^{\mathrm{req}}$, $C_j^{\mathrm{req}}$, and $B_j^{\mathrm{req}}$ represent the minimum requirements for remaining energy, computational power, and communication bandwidth, respectively, to complete task $t_j$. $T_{ij}^{\mathrm{est}}$ is the estimated time for node $n_i$ to complete the task, and $T_j^{\mathrm{ddl}}$ is the task deadline. The estimated completion time $T_{ij}^{\mathrm{est}}$ is calculated as:

$$T_{ij}^{\mathrm{est}}={\displaystyle \frac{D_{ij}}{V_i}}+{\displaystyle \frac{W_j}{C_i}}+\Delta T_i+f\left(E_i\right)$$

(5)

Where, ${\displaystyle \frac{D_{ij}}{V_i}}$ denotes the estimated flight time for node $n_i$ to reach the task location, ${\displaystyle \frac{W_j}{C_i}}$ represents the estimated execution time for task $t_j$, $W_j$ is the workload of $t_j$, and $f\left(E_i\right)$ captures the effect of energy consumption on execution time.

4.1.3. Multi-Objective Constraints for Task Allocation

In multi-task, multi-node scenarios, task allocation becomes an optimization problem aimed at maximizing overall task execution utility. The utility function U is defined as the weighted sum of resource status scores and task priorities for all task-node combinations:

$$U=\sum _{j=1}^M\sum _{n_i\in {\mathcal{N}}_j^{\mathrm{feasible}}}{x}_{ij}\left(S_i·P_j·U_j\right)$$

(6)

where $x_{ij}$ is a decision variable, with $x_{ij}=1$ if node $n_i$ is assigned task $t_j$, and $x_{ij}=0$ otherwise. Here, $P_j$ represents the priority of task $t_j$, and $U_j$ represents its urgency.

To ensure feasible and efficient task allocation, the following constraints must be satisfied:

• A. Unique Task Assignment: Each task $t_j$ is assigned to only one node $n_i$.
• B. Node Resource Limits: Node resource limits, including computational power, communication bandwidth, and remaining energy, must not be exceeded.
• C. Task Deadline with Penalty: If the estimated completion time $T_{ij}^{\mathrm{est}}$ exceeds the task deadline $T_j^{\mathrm{ddl}}$, a penalty is applied to the node’s score $S_i$, reducing its likelihood of selection. This mechanism ensures timely completion of high-priority tasks.
• D. Decision Variable Restriction: $x_{ij}$ is constrained to $x_{ij}\in \{0,1\}$.

$$\begin{gathered} \mathrm{Constraints}:\left\{\begin{array}{cc}A:\hfill & \sum _{n_i\in {\mathcal{N}}_j^{\mathrm{feasible}}}{x}_{ij}=1,\forall t_j\in \mathcal{T}\hfill \\ \\ B:\hfill & \begin{array}{cc}\sum _{t_j\in \mathcal{T}}{x}_{ij}·C_j^{\mathrm{req}}\le C_i,\hfill & \forall n_i\in \mathcal{N}\hfill \\ \sum _{t_j\in \mathcal{T}}{x}_{ij}·B_j^{\mathrm{req}}\le B_i,\hfill & \forall n_i\in \mathcal{N}\hfill \\ \sum _{t_j\in \mathcal{T}}{x}_{ij}·E_j^{\mathrm{req}}\le E_i,\hfill & \forall n_i\in \mathcal{N}\hfill \end{array}\hfill \\ \\ C:\hfill & x_{ij}·T_{ij}^{\mathrm{est}}\le T_j^{\mathrm{ddl}},\forall n_i\in \mathcal{N},\forall t_j\in \mathcal{T}\hfill \\ D:\hfill & x_{ij}\in \{0,1\}\hfill \end{array}\right. \end{gathered}$$

(7)

where $C_j^{\mathrm{req}}$ is the computational requirement of task $t_j$, and $C_i$ is the available computational power of node $n_i$; $B_j^{\mathrm{req}}$ is the communication bandwidth requirement of task $t_j$, and $B_i$ is the available bandwidth of node $n_i$; $E_j^{\mathrm{req}}$ is the energy requirement of task $t_j$, and $E_i$ is the remaining energy of node $n_i$. The estimated completion time $T_{ij}^{\mathrm{est}}$ for node $n_i$ to execute task $t_j$ must meet the deadline $T_j^{\mathrm{ddl}}$.

In summary, the optimization objective for task allocation is ${max}_{x_{ij}}U$. This process constitutes an Integer Linear Programming (ILP) problem, as the decision variable $x_{ij}$ is binary and both the objective function and constraints are linear. By incorporating task priority $P_j$, urgency $U_j$, and node resource status $S_i$, the algorithm prioritizes high-priority, urgent tasks, ensuring they are allocated to the most suitable nodes.

4.2. Resource Scheduling Algorithm

The resource scheduling algorithm manages task execution dynamically. While tasks are initially assigned to specific nodes, a node’s resource status can change due to factors like rapid battery depletion, task load increases beyond capacity, or external changes (e.g., signal fluctuations). In such cases, the resource scheduling mechanism assesses real-time node status and reallocates resources as needed to maintain task continuity and stability.

As illustrated in Figure 5, the resource scheduling algorithm follows these steps:

• Node Resource Change: When a node’s resource status changes, the system evaluates its ability to continue the task, triggering adjustments or reallocation if necessary.
• System State Monitoring: Nodes continuously monitor their resource statuses $E_i,L_i,C_i,B_i,\Delta T_i$ while the system periodically aggregates global parameters such as available node ratio ${\rho }_N$, task density ${\lambda }_T$, and averages of computational power $\overline{C}$, bandwidth $\overline{B}$, and delay $\overline{\Delta T}$.
• Dynamic Threshold Update: Using current system parameters, dynamic thresholds $E_{\mathrm{th}}$ and $L_{\mathrm{th}}$ are calculated.
• Node Status Assessment: Nodes compare their resource status with dynamic thresholds. If a node’s status falls below the threshold, task reassignment is triggered; otherwise, the node continues executing the task.
• Task Reallocation: For nodes that do not meet requirements (${\delta }_i\ge 1$), the system identifies pending tasks ${\mathcal{T}}_i^{\mathrm{pending}}$ and estimates remaining workload for reassignment.
• New Node Selection: Pending tasks return to the task pool, where a new node $n_k$ is selected based on resource status score $S_k$ and optimization objectives.
• Task Migration and Execution: The original node $n_i$ transfers task data to the new node $n_k$, which begins execution. The system updates task allocation consensus.
• System Status Update: Resource statuses and task allocations are updated, preparing for the next monitoring and adjustment cycle.

4.2.1. Global Dynamic Threshold Setting

To enable flexible resource management, dynamic thresholding based on the DVRC consensus algorithm adjusts thresholds according to the system’s overall state. When task density is high or available nodes are limited, thresholds are lowered to expand the pool of nodes eligible for tasks. Conversely, when task density is low or node availability is high, thresholds are raised to ensure optimal allocation. This dynamic threshold mechanism improves resource scheduling efficiency and reduces computational overhead.

Key parameters used for dynamic threshold setting include available node ratio ${\rho }_N$ and task density ${\lambda }_T$:

$${\rho }_N={\displaystyle \frac{N_{\mathrm{avail}}}{N_{\mathrm{total}}}}\mathrm{and}{\lambda }_T={\displaystyle \frac{M_{\mathrm{pending}}}{N_{\mathrm{avail}}}}$$

(8)

where $N_{\mathrm{avail}}$ represents available UAV nodes (those not overloaded and with sufficient resources), $N_{\mathrm{total}}$ is the total number of nodes, and $M_{\mathrm{pending}}$ is the number of pending tasks, reflecting resource demand relative to availability.

For adaptive management, thresholds for key resources, such as battery level $E_i$ and task load $L_i$, adjust dynamically based on system parameters. Average communication delay $\overline{\Delta T}$, computational power $\overline{C}$, and bandwidth $\overline{B}$ are also considered for more accurate UAV node selection.

$$\left\{\begin{array}{ccc}\overline{C}& =& {\displaystyle \frac{1}{N_{\mathrm{avail}}}}\sum _{n_i\in {\mathcal{N}}_{\mathrm{avail}}}{C}_i\\ \overline{B}& =& {\displaystyle \frac{1}{N_{\mathrm{avail}}}}\sum _{n_i\in {\mathcal{N}}_{\mathrm{avail}}}{B}_i\\ \overline{\Delta T}& =& {\displaystyle \frac{1}{N_{\mathrm{avail}}}}\sum _{n_i\in {\mathcal{N}}_{\mathrm{avail}}}{\Delta T}_i\end{array}\right.$$

(9)

Where, $C_i$, $B_i$, and $\Delta T_i$ represent the computational power, bandwidth, and delay metrics of node $n_i$, respectively.

The battery threshold $E_{\mathrm{th}}$ is defined as a function of ${\rho }_N$ and ${\lambda }_T$:

$$\begin{array}{cc}\hfill E_{\mathrm{th}}=E_{\min }& +w_1(1-{\rho }_N)+w_2{\lambda }_T\hfill \\ \hfill & +w_3(1-\overline{C})+w_4(1-\overline{B})\hfill \\ \hfill & +w_5(1-\overline{\Delta T})·(E_{\max }-E_{\min })\hfill \end{array}$$

(10)

where $E_{\min }$ and $E_{\max }$ are the minimum and maximum battery levels, respectively, and $w_1,w_2,w_3,w_4,w_5\ge 0$ are weight coefficients reflecting the influence of available node ratio and task density.

Similarly, the task load threshold $L_{\mathrm{th}}$ is defined as:

$$\begin{array}{cc}\hfill L_{\mathrm{th}}=L_{\max }& -w_1(1-{\rho }_N)+w_2{\lambda }_T\hfill \\ \hfill & +w_3(1-\overline{C})+w_4(1-\overline{B})\hfill \\ \hfill & +w_5(1-\overline{\Delta T})·(L_{\max }-L_{\min })\hfill \end{array}$$

(11)

where $L_{\min }$ and $L_{\max }$ are the minimum and maximum task loads, respectively, with $w_1,w_2,w_3,w_4,w_5\ge 0$ as weight coefficients for the task load threshold.

Threshold Adjustment Explanation:

• When ${\rho }_N$ decreases (indicating fewer available nodes) or ${\lambda }_T$ increases, $E_{\mathrm{th}}$ is lowered, allowing nodes with lower battery levels to participate and expanding the resource pool.
• An increase in $L_{\mathrm{th}}$ permits nodes with higher loads to continue accepting tasks, meeting high-demand scenarios.

This adaptive thresholding approach enhances resource allocation and optimizes UAV task management in dynamic environments.

4.2.2. Dynamic Task Adjustment Algorithm

During task execution, nodes continuously monitor their resource status. When a node’s resources fall below specified thresholds, a smart contract automatically triggers task reallocation, redirecting incomplete tasks to other eligible nodes. This process ensures continuity and system robustness, preventing task failures due to resource depletion at individual nodes.

To determine if UAV nodes meet threshold requirements, a composite status function (including battery status and task load) is defined for each node $n_i$:

Battery Status Indicator ${\delta }_{E_i}$:

$${\delta }_{E_i}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{E}_i\le E_{\mathrm{th}}\hfill \\ 0,\hfill & \mathrm{if}{E}_i>E_{\mathrm{th}}\hfill \end{array}\right.$$

(12)

Task Load Status Indicator ${\delta }_{L_i}$:

$${\delta }_{L_i}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{L}_i\le L_{\mathrm{th}}\hfill \\ 0,\hfill & \mathrm{if}{L}_i>L_{\mathrm{th}}\hfill \end{array}\right.$$

(13)

Composite Status Indicator ${\delta }_i$:

$${\delta }_i={\delta }_{E_i}+{\delta }_{L_i}$$

(14)

If ${\delta }_i\ge 1$, the resource status of node $n_i$ falls below threshold, activating the dynamic task adjustment mechanism. The task adjustment strategy proceeds with the following steps:

• Identify Uncompleted Tasks: Define ${\mathcal{T}}_i$ as the set of tasks currently assigned to node $n_i$. Identify the subset of uncompleted tasks, ${\mathcal{T}}_i^{\mathrm{pending}}$.
• Estimate Remaining Workload: For each uncompleted task $t_j\in {\mathcal{T}}_i^{\mathrm{pending}}$, calculate the remaining workload $W_{ij}^{\mathrm{rem}}$: $W_{ij}^{\mathrm{rem}}=W_j^{\mathrm{total}}-W_{ij}^{\mathrm{completed}}$
• where $W_j^{\mathrm{total}}$ is the total workload of task $t_j$, and $W_{ij}^{\mathrm{completed}}$ is the workload completed by node $n_i$.
• Trigger Task Reallocation: Reassign each uncompleted task $t_j\in {\mathcal{T}}_i^{\mathrm{pending}}$ to the task pool, making it available for other qualified nodes.
• Select New Node: Based on the resource status score $S_{kj}$ , select the highest-scoring eligible node $n_k$ for task $t_j$.

In reallocating tasks, it is crucial to minimize delay and resource consumption. When transferring task status and intermediate data from node $n_i$ to $n_k$, the estimated task completion time $T_{kj}^{\mathrm{est}}$ for $n_k$ combines task execution and data transfer times:

$$\underset{n_k}{min}{T}_{kj}^{\mathrm{est}}=\underset{n_k}{min}\left({\displaystyle \frac{D_{ij}^{\mathrm{data}}}{B_{ik}}}+{\displaystyle \frac{W_{ij}^{\mathrm{rem}}}{C_k}}\right)$$

(15)

where $D_{ij}^{\mathrm{data}}$ is the data volume (task status and intermediate results) to transfer, $B_{ik}$ the communication bandwidth between $n_i$ and $n_k$, $W_{ij}^{\mathrm{rem}}$ the remaining workload of task $t_j$, and $C_k$ the computational power of $n_k$.

Similarly, to minimize resource consumption during task migration, the total energy consumption $E_{\mathrm{total}}$ includes energy for data transfer and task execution:

$$\underset{n_k}{min}{E}_{\mathrm{total}}=\underset{n_k}{min}\left(P_{ik}^{\mathrm{comm}}·{\displaystyle \frac{D_{ij}^{\mathrm{data}}}{B_{ik}}}+P_k^{\mathrm{comp}}·{\displaystyle \frac{W_{ij}^{\mathrm{rem}}}{C_k}}\right)$$

(16)

where $P_{ik}^{\mathrm{comm}}$ is the communication power, $P_k^{\mathrm{comp}}$ the computational power consumption rate of the new node, ${\displaystyle \frac{D_{ij}^{\mathrm{data}}}{B_{ik}}}$ the data transfer energy, and ${\displaystyle \frac{W_{ij}^{\mathrm{rem}}}{C_k}}$ the task execution energy.

In practical applications, multiple objectives are optimized simultaneously to select an appropriate new node $n_k$ for task reassignment. A comprehensive objective function, incorporating resource status score $S_k$ (see Section 4.3.1), is formed with each objective combined in a weighted form:

$$\underset{n_k}{min}U\left(n_k\right)=\underset{n_k}{min}\left({\lambda }_1{T}_{kj}^{\mathrm{est}}+{\lambda }_2{E}_{\mathrm{total}}-{\lambda }_3{S}_k\right)$$

(17)

where ${\lambda }_1,{\lambda }_2,{\lambda }_3\ge 0$ are weight coefficients indicating the importance of each objective. This composite objective seeks to minimize time and energy consumption while maximizing the resource status score, achieving optimal task reassignment under task allocation constraints (see equation 7 ).

4.3. Collaborative Decision-Making Algorithm

Collaborative decision-making is essential for effective multi-node coordination during task execution, especially in complex environments where multiple nodes must work together. While the task allocation phase assigns initial nodes and establishes mechanisms to handle potential failures, dynamic conditions often require multi-node collaboration. This study employs a multi-attribute decision-making (MADM) approach to identify optimal task plans and node combinations, as outlined below:

• Information Collection: Nodes report their attribute metrics and reputation scores, while the smart contract provides task requirements and candidate plans.
• Decision Matrix Construction: Attribute metrics for each node are collected, forming a decision matrix for each plan.
• Weighted Standardization of the Decision Matrix: The decision matrix is standardized, then weighted according to attribute importance.
• Identifying Ideal Solutions: Calculate the positive ideal solution (PIS) and negative ideal solution (NIS) for each attribute.
• Relative Closeness Calculation: Compute each node’s relative closeness to the ideal solutions, resulting in support scores for each plan.
• Node Selection with Constraints: Based on support scores and constraints (e.g., resource limits, connectivity), select suitable nodes for task execution.
• Optimal Plan Selection: Calculate each plan’s total score and select the plan with the highest score.
• Task Execution: Nodes execute tasks according to the assigned plan.
• Feedback and Reputation Update: Upon task completion, update each node’s reputation score.

4.3.1. Problem Definition

The goal of collaborative decision-making is to select the optimal plan $o_j^{*}$ and the participating node set ${\mathcal{N}}_j$ for each task $t_j$, maximizing task execution efficiency. The UAV node set $\mathcal{N}=\{n_1,n_2,\dots ,n_N\}$ contains N nodes, and the task set $\mathcal{T}=\{t_1,t_2,\dots ,t_M\}$ contains M tasks. Each task $t_j$ has a set of candidate plans ${\mathcal{O}}_j=\{o_{j1},o_{j2},\dots ,o_{jL}\}$.

4.3.2. Constructing the Initial Decision Matrix

For each candidate plan $o_{jl}$ of task $t_j$, node performance is evaluated based on its attributes, forming the decision matrix $X_{jl}$, where rows represent nodes $n_i$ and columns represent K attribute metrics. The matrix is structured as follows:

$$X_{jl}=\left[\begin{array}{cccc}{x}_{11}& x_{12}& \cdots & x_{1K}\\ x_{21}& x_{22}& \cdots & x_{2K}\\ ⋮& ⋮& \ddots & ⋮\\ x_{N1}& x_{N2}& \cdots & x_{NK}\end{array}\right]$$

(18)

where each element $x_{ik}$ represents the original value of the k-th attribute metric for node $n_i$.

4.3.3. Weighted Standardization of the Decision Matrix

To eliminate measurement scale differences, the decision matrix is standardized using a cost-based normalization method. The standardized decision matrix $R_{jl}$ is:

$$R_{jl}=\left[\begin{array}{cccc}{r}_{11}& r_{12}& \cdots & r_{1K}\\ r_{21}& r_{22}& \cdots & r_{2K}\\ ⋮& ⋮& \ddots & ⋮\\ r_{N1}& r_{N2}& \cdots & r_{NK}\end{array}\right]$$

(19)

where $r_{ik}$ is the standardized value of the k-th attribute for node $n_i$.

Next, the standardized decision matrix $R_{jl}$ is multiplied by the weight vector $w=\{w_1,w_2,\dots ,w_k\}$, where weights are calculated based on attribute dispersion, resulting in the weighted standardized decision matrix $V_{jl}$:

$$V_{jl}=\left[\begin{array}{cccc}{v}_{11}& v_{12}& \cdots & v_{1K}\\ v_{21}& v_{22}& \cdots & v_{2K}\\ ⋮& ⋮& \ddots & ⋮\\ v_{N1}& v_{N2}& \cdots & v_{NK}\end{array}\right]$$

(20)

Therefore, the relationship of the three matrices is:

• $X_{jl}$: Initial decision matrix containing the original attribute metrics of nodes.
• $R_{jl}$: Standardized decision matrix derived from $X_{jl}$.
• $V_{jl}$: Weighted standardized matrix, obtained by multiplying $r_{ik}$ with weight $w_k$.

4.3.4. Calculating Positive and Negative Ideal Solutions

The ideal solutions identify the best and worst values for each attribute.

Positive Ideal Solution $A^{+}$ (Best Case): Composed of the maximum values for each attribute:

$$A^{+}=\left\{v_1^{+},v_2^{+},\dots ,v_K^{+}\right\},v_k^{+}=\underset{i}{min}{v}_{ik}$$

(21)

Negative Ideal Solution $A^{-}$ (Worst Case): Composed of the minimum values for each attribute:

$$A^{-}=\left\{v_1^{-},v_2^{-},\dots ,v_K^{-}\right\},v_k^{-}=\underset{i}{max}{v}_{ik}$$

(22)

4.3.5. Calculating Node Relative Closeness

For each node $n_i$, calculate the Euclidean distances to the positive ideal solution $S_i^{+}$ and the negative ideal solution $S_i^{-}$. The support score $V_{il}$ for candidate plan $o_{jl}$ is defined as:

$$S_i^{+}=\sqrt{{\sum }_{k=1}^K{\left(v_{ik}-v_k^{+}\right)}^2},S_i^{-}=\sqrt{{\sum }_{k=1}^K{\left(v_{ik}-v_k^{-}\right)}^2}$$

(23)

$$V_{il}={\displaystyle \frac{S_i^{-}}{S_i^{+}+S_i^{-}}},0\le V_{il}\le 1$$

(24)

A larger $V_{il}$ indicates closer proximity to the positive ideal solution, signifying stronger support for the plan.

4.3.6. Node Selection and Constraints

Select nodes based on support scores and constraints to participate in task execution. Rank nodes by their relative closeness $C_i$, and select those with higher scores, ensuring the task’s required number of collaborative nodes is met: $K_j^{\min }\le \left|{\mathcal{N}}_j\right|\le K_j^{\max }$.

Verify that selected nodes meet resource constraints and communication connectivity requirements. Define a connectivity matrix $A_{ik}$, where $A_{ik}=1$ if nodes $n_i$ and $n_k$ can communicate; otherwise, $A_{ik}=0$. A cooperation variable $y_{ijk}$ represents multi-node cooperation relationships:

$$\begin{array}{cccc}\hfill y_{ijk}& \le x_{ij}\hfill & \hfill ,y_{ijk}& \le x_{kj}\hfill \\ \hfill y_{ijk}& \le A_{ik}\hfill & \hfill ,y_{ijk}& \ge x_{ij}+x_{kj}+A_{ik}-2\hfill \end{array}$$

(25)

where $y_{ijk}\in \{0,1\}$ signifies whether nodes $n_i$ and $n_k$ are cooperating in task $t_j$, with $x_{ij}=1$ indicating node selection and connectivity.

4.3.7. Optimal Plan Selection

Calculate each candidate plan’s score by combining support scores $V_{il}$ and weighted reputation scores $S_i$ for all nodes:

$$V_l=\sum _{i=1}^N{W}_i{V}_{il}$$

(26)

The objective of collaborative decision-making is to select the highest-scoring plan as the optimal choice $o_j^{*}$:

$$o_j^{*}=arg\underset{o_{jl}\in {\mathcal{O}}_j}{max}{V}_l$$

(27)

In the optimal plan, each selected node must meet resource and task requirements, ensuring no node is overloaded and that all selected nodes are communicatively connected.

By solving this optimization model, the system identifies the optimal set of nodes for task collaboration. If a selected node encounters a failure, the resource scheduling algorithm reallocates the task to maintain continuity, followed by feedback and reputation updates.

Finally, the collaborative decision-making algorithm can be expressed as the following optimization problem:

$$\begin{array}{cc}\hfill & \mathrm{Choose}\mathrm{the}\mathrm{best}\mathrm{solution}:o^{*}=arg\underset{o_l\in \mathcal{O}}{max}{V}_l\hfill \\ \hfill & \mathrm{Where}{V}_l=\sum _{i=1}^N{W}_i{V}_{il}\hfill \\ \hfill & \mathrm{Node}\mathrm{support}:V_{il}={\displaystyle \frac{S_i^{-}}{S_i^{+}+S_i^{-}}}\hfill \\ \hfill & \mathrm{Voting}\mathrm{weight}:W_i={\displaystyle \frac{R_i}{{\sum }_{j=1}^N{R}_j}}\hfill \\ \hfill & \mathrm{Node}\mathrm{selection}\mathrm{satisfies}:\hfill \\ \hfill & K_j^{\min }\le \left|{\mathcal{N}}_j\right|\le K_j^{\max },\forall j\hfill \\ \hfill & E_i\ge E_j^{\mathrm{req}}+E_{\mathrm{reserve}},\forall i\hfill \\ \hfill & C_i\ge C_j^{\mathrm{req}},\forall i\hfill \\ \hfill & B_i\ge B_j^{\mathrm{req}},\forall i\hfill \\ \hfill & y_{ijk}\le x_{ij},y_{ijk}\le x_{kj},y_{ijk}\le A_{ik},y_{ijk}\ge x_{ij}+x_{kj}+A_{ik}-2\hfill \\ \hfill & x_{ij},y_{ijk}\in \{0,1\},\forall i,k,j\hfill \end{array}$$

5. Simulation and Analysis

5.1. Algorithm Simulation

To evaluate the autonomous collaboration algorithm based on smart contracts, we deployed the algorithm within a blockchain-based smart contract environment. The simulation setup includes 10 UAV nodes and 5 tasks. Additional parameters are generated randomly within specified ranges, all of which comply with predefined constraints. This setup simulates real-time fluctuations in UAV node status and potential failures, as shown in Table 4.

As shown in Figure 6, the task allocation algorithm assigns tasks based on each node’s reputation score $S_i$, giving priority to tasks with higher urgency and importance. In the simulation, node $n9$, with the highest reputation score ($S_i=0.8$), is assigned to task $t4$, which has a priority $P_j$ and urgency $U_j$ of 3. This approach effectively directs high-priority tasks to nodes with the best reputation scores.

Similarly, as shown in Figure 7, the resource scheduling algorithm continuously monitors each node’s resource status after tasks are initially assigned. If a node becomes unable to continue due to a failure or lack of resources, the scheduling algorithm reassigns the task to a more suitable node. For instance, as node $n1$’s reputation score $S_k$ declines and its task load $L_i$ increases, it reaches the minimum resource threshold needed for task $t5$. This triggers the resource scheduling algorithm to reassign the task to node $n3$, which meets the resource constraints and successfully takes over the task during time steps [1-3].

The collaborative decision-making algorithm is illustrated in Figure 8. When tasks require collaboration from multiple UAVs, the algorithm dynamically forms a collaborative node set based on the current task requirements. To simulate the random occurrence of collaborative tasks, random numbers control their generation in the simulation; thus, only tasks $t2$ and $t5$ trigger collaboration. As time progresses, the number of collaborative nodes for task $t5$ increases. Notably, node $n4$ participates in tasks $t1$, $t2$, and $t5$. Due to variations in task priority and urgency, the resource scheduling algorithm continues to assign node $n4$ to different tasks as it completes each one, showing that node $n4$ has ample resources and remains within its operational threshold.

5.2. Algorithm Performance Analysis

To evaluate the reliability of the autonomous collaboration algorithm in task allocation, resource scheduling, and collaborative decision-making, simulations were conducted with 20, 50, and 100 UAV nodes performing 25 tasks. Performance metrics, including task completion rate, remaining UAV energy, and smart contract response time, were measured to assess task execution efficiency, collaboration, and overall system reliability.

As shown in Figure 9, the task completion rate increases significantly with a higher number of nodes. The steep curve illustrates the algorithm’s efficiency: fewer inflection points reflect smoother algorithm performance. For example, with 100 nodes, the task completion rate quickly reaches 100%, while with 50 nodes, it achieves 100% after a slightly longer duration. In the case of 20 nodes, the completion rate rose more slowly, reaching only 80% over the same time period. This indicates that the fewer the number of nodes, the task allocation and resource scheduling load exceeds the number of UAVs.

Figure 10 shows that nodes in smaller UAV swarms experience a more rapid decrease in remaining energy during task execution. With an increased number of nodes, the average remaining energy per node is higher, suggesting that a larger node count helps extend the operating time of each node. For heavy task loads, a higher node configuration is recommended to reduce energy consumption per node and extend the system’s overall task duration. These results demonstrate that the autonomous collaboration algorithm distributes task load more effectively with a larger node count, improving energy efficiency and task sustainability across the system.

Figure 11 also illustrates that upon triggering the smart contract, the collaborative algorithm initializes within 0-0.5 seconds. With 100 nodes, the initial delay reaches 24 ms, which is relatively high due to the large node count. After reaching a stable state, response times for all configurations fluctuate around 5 ms, indicating the monitoring phase for UAV status. Overall, while initial load fluctuations may impact the smart contract response time, it stabilizes quickly to maintain a low response time, ensuring the system’s real-time responsiveness and efficiency.

5.3. Virtual Simulation and Performance Analysis

To verify the effectiveness of the proposed blockchain-based UAV network architecture and autonomous collaboration algorithms, we built a comprehensive simulation platform. This platform utilizes Microsoft’s AirSim + UE simulation software along with the NS3 simulation tool for FANET networking, enabling the modeling of UAV swarm flight, communication, and task execution in complex environments. In this study, we created a 3D simulation environment in AirSim featuring a maritime defense platform to simulate UAV flight behavior under various obstacle conditions. Autonomous navigation, task execution, and collaboration functions were achieved using task-specific plugins and scripts.

For network communication, we enhanced the NS3 simulation tool to support data transmission and inter-node communication based on a reputation-based consensus algorithm. This integrated setup effectively utilizes FANET’s communication features to improve data synchronization and consensus efficiency, closely replicating UAV communication processes.

In terms of blockchain and smart contract implementation, we employed the lightweight blockchain framework FISCO BCOS, streamlining the blockchain data structure to retain only essential task information and consensus mechanisms. Smart contracts were designed as modular templates that can be customized for different task types. Finally, we conducted performance testing through virtual simulations, recording metrics such as the relationship between task completion rate and bandwidth/packet loss rate, as well as between consensus time and network latency. The performance of the centralized control system was compared with that of the distributed collaborative system, focusing on task completion rate and network stability.

Figure 12 illustrates the integration of NS3-based communication simulation with the blockchain network for the UAV swarm. Under normal conditions, the nodes are fully interconnected using a mesh topology, with the blockchain embedded in the communication network and operating on a reputation-based consensus algorithm. When Node 0 initiates a consensus request to other nodes, Node 5, for instance, records the consensus data upon receipt and subsequently sends a verification message to confirm that other nodes have recorded the same consensus data, thereby achieving network-wide blockchain consensus. In the event of disconnection from the ground station or similar failures, the UAV swarm restricts the FANET network, blocking external signals and executing only the predefined tasks and algorithms embedded in the smart contracts.

Figure 13 presents the AirSim+UE virtual simulation platform. To validate the effectiveness of the proposed autonomous collaboration algorithm, an offline scenario was defined, simulating the loss of ground control. In the event of an attack on the UAV swarm, smart contracts are automatically activated to assess the situation and, based on the autonomous collaboration algorithm, assign tasks to coordinate a phased counterattack. Throughout this process, performance tests were conducted on the virtual simulation platform to evaluate the algorithm’s real-world effectiveness.

Figure 14 illustrates the system’s task completion rate across different bandwidth conditions, showing an increase in completion rate with higher bandwidth. At lower bandwidths (e.g., 1 Mbps), the task completion rate is approximately 90%, while at 10 Mbps or higher, the rate nears 99%. Bandwidth is a critical factor influencing communication efficiency and data synchronization speed within the UAV swarm. Increased bandwidth allows for larger data transmission volumes, effectively minimizing communication bottlenecks. In this system, efficient communication is essential for blockchain data synchronization and smart contract execution. When bandwidth is ample, data exchanges between nodes become smoother, thereby improving the efficiency of task allocation and resource scheduling, which leads to a higher task completion rate.

Figure 15 shows the impact of network latency on consensus time. As latency increases from 10 ms to 200 ms, consensus time rises slightly but remains relatively stable. At a latency of 10 ms, the average consensus time is around 1 second, while at 200 ms, it is approximately 1.5 seconds. Network latency affects message transmission between nodes, which in turn influences the efficiency of the consensus algorithm. However, the coupling of the reputation-based consensus algorithm with FANET’s communication mechanism provides a level of latency tolerance within the system. This enables nodes to exchange critical information efficiently, even under high-latency conditions, thereby minimizing the negative impact of latency on the consensus process. Consequently, consensus time increases only slightly, and overall system performance remains stable.

Figure 16 illustrates the system’s task completion rate under different packet loss rates. The results indicate a slight decline in task completion rate from 99% to 95% as the packet loss rate increases from 0% to 20%. Even with a high packet loss rate of 20%, the task completion rate remains at a relatively high level. High packet loss can lead to unreliable data transmission, impacting task allocation, status updates, and consensus achievement. However, our system mitigates this issue through several mechanisms:

• Data Redundancy and Retransmission: The communication protocol includes data redundancy and an Automatic Repeat reQuest (ARQ) mechanism, ensuring that critical task data can still be successfully received despite packet loss.
• Fault-Tolerant Consensus Algorithm: The reputation-based consensus algorithm is designed with fault tolerance, enabling consensus even when data from some nodes is missing.
• Multipath Communication in FANET: FANET supports multi-hop and multipath communication, allowing data to reroute through alternative paths if a specific communication link fails.

As shown in Figure 17, the proposed solution is compared to traditional centralized control systems and other distributed collaboration methods, demonstrating clear advantages with a task completion rate of approximately 98%. Traditional centralized control systems depend on continuous communication links and directives from a ground control center, which leads to significant performance degradation when communication is disrupted or restricted. In contrast, the approach in this study leverages blockchain and smart contracts to enable autonomous collaboration and decision-making within the UAV swarm, eliminating the need for ground control.

Compared to other distributed collaboration methods, the main innovation of this study lies in the deep integration of blockchain technology with the FANET network. By implementing a reputation-based consensus algorithm and a coupled network communication mechanism, this design significantly improves consensus efficiency and network performance while reducing communication overhead. Experimental results indicate that the task completion rate and network stability of this system surpass those of other methods, especially in highly dynamic and complex environments.

6. Discussion

This paper introduces an offline collaborative decision-making framework for UAV swarms based on blockchain and smart contracts, showcasing its potential to significantly enhance task execution efficiency and data security in offline conditions. Compared to traditional centralized control systems, this approach excels in offline scenarios. Traditional methods rely on ground control centers, resulting in substantial performance degradation when communication is interrupted. In contrast, the integration of blockchain and smart contracts in this framework removes the dependence on ground control, allowing UAV swarms to maintain autonomous decision-making and task coordination in offline environments. This leads to higher task completion rates and improves the system’s robustness and security.

Current research primarily focuses on applying blockchain for data exchange and basic task scheduling, with limited investigation into complex multi-UAV collaborative decision-making in offline settings. This study fills that gap, offering a new perspective on task execution and communication security for offline UAV swarm operations. The results underscore the extensive applicability of blockchain and smart contracts in enhancing UAV swarm autonomy and intelligence, particularly in scenarios requiring high levels of autonomy and security, such as rescue, reconnaissance, and logistics. Furthermore, with its lightweight design and dynamic resource management strategies, this framework is highly scalable, making it suitable for large-scale UAV swarm applications.

7. Conclusions

In the context of complex task execution by UAV swarms, existing ground-control-based coordination mechanisms are insufficient for offline environments due to factors like environmental variability and communication interruptions. To address this, we propose an offline UAV collaborative decision-making framework based on blockchain smart contracts. This framework enables UAV swarms to autonomously allocate tasks, collaborate, and secure data communication even in offline states.

The main contributions and innovations of this work are summarized as follows:

• Blockchain-Based Distributed Communication Network: By integrating blockchain, we developed a distributed, tamper-proof communication network that ensures task data security in offline environments, enhancing UAV information sharing and coordination during task execution.
• Smart Contract-Driven Collaborative Algorithm*: A smart contract-based collaboration algorithm was designed, encompassing task allocation, resource scheduling, and collaborative decision-making. Smart contracts enable UAVs to autonomously execute predefined collaboration rules offline, facilitating efficient task distribution and resource utilization.
• Algorithm Performance Validation: Simulation experiments validated the proposed algorithm’s effectiveness and reliability. Results across various task scenarios show that the algorithm effectively increases task completion rates as the number of UAV nodes grows, extends node endurance, and maintains low smart contract response times.