Addressing the Cost Optimization Issue for IOTA Based on Lyapunov Optimization Theory ^†

Abstract

IOTA is an emerging decentralized computing paradigm for developing blockchain-based Internet of Things (IoT) applications. It has the advantages of zero transaction fees, incremental scalability, and high-performance transaction rates. Despite its well-understood benefits, IOTA nodes need to withstand considerable resource costs to generate the distributed ledger. The main reason for this is that IOTA abandons the original blockchain reward mechanism and does not charge transaction fees. Therefore, in this paper we address the cost optimization issue for IOTA based on Lyapunov optimization theory. We take the first step in investigating the cost optimization problem of IOTA and exploring a new optimization scheme using Lyapunov optimization theory. Our proposed scheme enables IOTA to minimize the total cost of IOTA nodes through a computational optimization algorithm. Then, an optimized transaction rate control algorithm can be designed based on the large deviation theory to reduce orphan tangles that waste computational costs. In addition, we define and deduce the effective width of the tangle to monitor the total throughput and reduce the time spent on cost optimization to avoid unnecessary waste of resources. Lastly, a comprehensive theoretical analysis and simulation experiments demonstrate that the proposed strategy is both efficient and practical.

1. Introduction

The Internet of Things (IoT) is gradually developing as an emerging global Internet-based information architecture that facilitates the exchange of goods and services [1,2,3,4]. In a traditional IoT model, service providers typically rely on centralized servers to execute tasks. However, this service model suffers from several challenges, including centralization and security issues. Therefore, the emergence of blockchain technology brings opportunities to address the challenges of IoT. IoT applications combined with blockchain technology [5,6,7,8,9,10,11] have tremendously promoted development in many fields, for example, smart cities, the fintech revolution, and decentralized machine networks; however, due to the rapid development of IoT, the traditional single-chain blockchain structure makes it difficult to meet the micropayment requirements, scalability, and high concurrency of IoT. Thus, recent studies have developed DAG-based (i.e., directed acyclic graph structure) distributed ledger technologies such as IOTA [12,13], Obyte [14], and Nano [15]. Among thees, IOTA is the most representative platform specially tailored for IoT. IOTA is a new public chain system specially designed for IoT. It provides a trust layer for any device connected to the global internet, and is mainly used for micropayments, data security transfer, and data anchoring between devices. IOTA can effectively solve the problems of centralization, low concurrency, and high transaction fees in IoT.

Unlike the miners in Bitcoin, Ethereum, or other blockchain applications, IOTA nodes must contribute their computational resources to maintain IOTA network stability for free. This is because the miners can obtain both mining rewards and transaction fees, while in IOTA these kinds of incentives are not available. With the IOTA network continuing to expand, this mechanism inevitably leads to increased costs and pressures for nodes. Therefore, widespread adoption and promotion of IOTA applications is hindered by this inherent cost constraint.

Unfortunately, there has been little research into cost optimization of IOTA. Because maximizing utility is proportional to minimizing cost, solutions must be approached indirectly through existing methods. Jay et al. [16] provided a way to maximize IOTA utility. Their idea is to analyze the critical factors underlying IOTA’s utility and to find the public item. The, they explored the relationship among these factors to achieve the purpose of maximizing the IOTA utility. However, their approach to extracting the public items is too arbitrarily. To address this issue, the design challenges of our proposed solution mainly come from three dimensions. First, an efficient scheme optimizing the computational costs of all IOTA nodes needs to be devised in order to reduce expenditure. Based on the desired scheme, the critical factors can be directly evaluated and the optimal transaction approval rate (i.e., threshold) of IOTA nodes determined in real time to reduce computational costs. Second, the desired scheme can eliminate orphan tangles, which are valid yet rejected ledgers from the IOTA network. Orphan tangles can waste a lot of computing resources and cause network congestion, imposing a performance penalty on IOTA. Third, to reduce the cost optimization frequency and avoid unnecessary wastage of resources, it is necessary to prejudge whether optimization is required each time. Thus, we are motivated to develop a scheme to reduce the cost consumption of IOTA nodes.

Our contributions. This paper presents the first study of IOTA’s cost optimization. We propose a scheme for effectively reducing the tangle generation cost of IOTA nodes while maintaining their strong robustness. Specifically, we first design a thorough optimization algorithm using Lyapunov optimization theory, resulting in an approach that can balance transaction traffic and IOTA node tolerance. In addition, we consider the situation of resource wastage caused by frequent unnecessary optimization. In particular, we appoint a committee elected from IOTA nodes to ensure the correctness of the effective width of the tangle in each time slot. In short, our contributions are listed as follows:

• We introduce Tangless, an efficient transaction cost optimization scheme for IOTA. By leveraging full-fledged optimization theories, Tangless ensures the robustness of the IOTA network with optimal costs for each node.
• We design a computational optimization algorithm based on Lyapunov optimization theory. Our design can effectively reduce the cost of IOTA nodes by introducing a Lyapunov-based optimization framework.
• We develop a transaction rate control algorithm using large deviation theory to reduce orphan transactions in the IOTA network. This algorithm helps to maintain a balance between transaction traffic and IOTA node tolerance, effectively addressing network congestion.
• To the best of our knowledge, we are the first to define and determine the effective width of the tangle, which can help to tackle the issue of cost optimization. Notably, the proposed approach can help to predict the throughput that the IOTA system can tolerate, thereby avoiding unnecessary optimization in the next time slot.
• In this paper, we offer a thorough theoretical analysis and conduct simulation experiments to validate the effectiveness of our proposed scheme.

The remainder of this paper is organized as follows: Section 2 describes the related work; Section 3 introduces the preliminaries; Section 4 presents the system overview; Section 5 presents the design of Tangless; the evaluation is shown in Section 6; finally, we conclude the paper in Section 7.

2. Related Work

In 2015, the IOTA Foundation launched the IOTA project to address the high transaction fees, concurrency, and scalability of blockchains in IoT. The distributed ledger of IOTA is named the tangle. Subsequently, Serguei Popov [17] explained the main working principle of the tangle ledger in a white paper. With the in-depth application of IOTA in IoT, many types of research have been carried out on IOTA [18,19]. In this work, we mainly focus on cost optimization and transaction rate control.

Cost optimization. Cost optimization of blockchains is a current research hotspot [20,21]. However, the existing research primarily focuses on blockchains with a single-chain structure while IOTA is based on a DAG structure. Because IOTA does not adopt a mining incentive mechanism and does not charge transaction fees, nodes cannot receive direct economic incentives for participating in the consensus, while still being exposed to many computational costs. One outstanding challenges is to reduce the overall cost of nodes. In [16], a method for maximizing IOTA utility based on some assumptions was provided by Jay et al. In their analysis, the authors extracted public items from the factors affecting the IOTA utility for optimization. Then, they directly added these items to build the maximum utility equation. However, this approach is too far-fetched to be practical, and the solution lacks credibility. In [22], Helmer et al. focused solely on the energy consumption of IOTA. Thus, it remains necessary to find an effective way to reduce the computational cost of IOTA nodes.

Rate control. Proof-of-Work (PoW) was the first consensus mechanism in the blockchain framework. PoW decides whether a miner has the right to form a block [23]. In the IOTA platform, PoW usually exists as a rate control mechanism, and its computational effort is much lighter than that performed by typical blockchains [24]. If the rate of issuing transactions has a good match with the approving ones, then the tangle continues to grow steadily; however, a sudden surge of new incoming transactions will lead to the transaction queue in each IOTA node being overly backlogged. This can easily lead to network congestion. In addition, time-sensitive transactions may be delayed, potentially causing huge losses. The literature [24] indicates that basic PoW cannot dynamically adjust network traffic on account of the constant difficulty value. Additionally, proposed solutions using adaptive PoW based on the mana value of a node fail to prevent unfairness. Mana is a reputation value, which represents the total funds transferred within a transaction. Wesolowski [25] introduced a sustainable verifiable delay function (VDF) that can resist parallel-accelerated computing; however, due to its complex nature, VDF is not a suitable replacement for PoW. Considering these observations, there is an urgent need for a more effective rate control method.

3. Preliminaries

IOTA and Tangle. Maintaining the growth of the IOTA tangle requires all IOTA nodes to reach consensus. Unapproved transactions (terminal transactions) in the tangle are called tips. Incoming transactions approving at least two tips can attach to the tangle. Figure 1 shows the structure of the tangle [1], with the the Genesis transaction on the left and the tips on the right.

Figure 1. DAG structure of the tangle.

In the early days of IOTA, the Coordinator was introduced to prevent malicious nodes from harming the developing IOTA network. Both IOTA $1.0$ Ledger and IOTA $1.5$ Chrysalis relied on the Coordinator to reach a consensus. However, if the Coordinator failed, the IOTA network would be paralyzed; thus, it was considered only a temporary solution. The plan was to remove the Coordinator in the future IOTA 2.0 update. IOTA $2.0$ proposed Coordicide [24] (i.e., killing the Coordinator) to replace the Coordinator. This paper analyzes the cost optimization and transaction rate control in Coordicide (IOTA 2.0).

Lyapunov optimization. In 1892, Lyapunov published the famous paper The general problem of the stability of motion and established a general theory of the study of motion stability [26]. Lyapunov stability theory starts from each equilibrium state of the dynamic system, and studies the local stability near it. Over the past hundred years, Lyapunov theory has been widely developed in mechanics, information science, and many other fields. The fundamental idea of Lyapunov optimization is to decompose a long-term optimization objective with long-term constraints into each time slot [27]. The target can then be directly optimized without breaking the agreement that the current time slot needs to follow. Many prior parameters do not require Lyapunov optimization, which has good adaptability to the real-time control of dynamic systems while ensuring relatively low computational complexity.

Supposing a system with n queues, we can use a vector to represent the whole queue. Let $I\left(t\right)\triangleq (I_1\left(t\right),\dots I_i\left(t\right),\dots I_n\left(t\right))$, where $I\left(t\right)$ is a queue backlog vector; then, the Lyapunov function is expressed as $L\left(I\left(t\right)\right)\triangleq {\displaystyle \frac{1}{2}}{\sum }_{i=1}^n{w}_i{I}_i{\left(t\right)}^{2}n\in N$. To simplify the calculation, $w_i=1$ is taken for any i. The function $L\left(I\right(t\left)\right)$ is always non-negative, and is equal to zero if and only if all components of $I\left(t\right)$ are zero; $△\left(I\right(t\left)\right)=L\left(I\right(t+1\left)\right)-L\left(I\right(t\left)\right)$, called the Lyapunov drift, represents the increment of all queue backlogs from time slot t to time slot $(t+1)$. In this paper, we optimize the resource costs of IOTA nodes based on the Lyapunov optimization framework.

Large deviation theory. Large deviation theory is a critical branch of probability theory and limit theory. It helps to estimate the probability of making mistakes in hypothesis testing of a stochastic system, the escape probability of a stochastic system, and the probability of deviations from the deterministic orbit [28]. This theory has found wide application in fields such as information and finance, and is gaining increasing attention. The principle of large deviations can be described as follows.

Let ($X_n$, $n\in N$) be a sequence of random variables that take values in $R^d$; say that $X_n$ satisfies a large deviation principle in $R^d$ with rate function H if H is a rate function and if, for any measurable set, $B\subset R^d$, $-{inf}_{x\in B^o}H\left(x\right)\le {liminf}_{n\to \infty }{\displaystyle \frac{1}{n}}logP(X_n\in B)\le {limsup}_{n\to \infty }{\displaystyle \frac{1}{n}}logP(X_n\in B)\le -{inf}_{x\in \tilde{B}}H\left(x\right)$, where $B^o$ denotes the interior of B and $\tilde{B}$ its closure. In this paper, the tolerable number of effective delayed transactions and the minimum transaction approval rate of a node are deduced using large deviation theory.

4. System Overview

Figure 2 illustrates the system structure of IOTA, containing four types of entities: IoT devices, clients, IOTA nodes, and the committee [1]. When messages arrive at IoT devices, they are delivered to clients immediately. The messages, called transactions, are then packaged by clients and sent to IOTA nodes. Generating transactions involves cooperation between clients and nodes. Specifically, when a node receives a tip-selected request from the client, it selects two terminal transactions to approve and complete the calculation of a cryptographic puzzle. The result is then returned to the client. Upon receiving the results, the client packages the transaction and sends it to the node for verification. If the transaction is legitimate, the node updates its local ledger and broadcasts it to other IOTA nodes through the P2P protocol to complete the consensus processes.

Figure 2. Overview of the system architecture.

In this work, we propose Tangless, a scheme for IOTA that optimizes node costs and controls transaction rates. To ensure smooth implementation of Tangless, we appoint a committee elected from IOTA nodes to conduct macro-level control.

Tangless is a crucial component in IOTA nodes that operates within the nodes. It consists of a Cost Optimization Module and a Verification and Rate Control Module. The main workflow, as highlighted in red in Figure 2, is as follows: upon initiation, the IOTA system gradually stabilizes as the number of joining nodes meets the system’s requirements. We can denote this time slot as t. At this point, each IOTA node initializes Tangless for the first time. Specifically, with the tangle updating in time slot t, the node transfers the relevant data from the tangle to the Cost Optimization Module for optimization. We employ the computational optimization algorithm to derive the threshold of transaction approval rate $a_i\left(t\right)$. Subsequently, $a_i\left(t\right)$ is transmitted to the Verification and Rate Control Module. In this module, we take the first step towards calculating the threshold for the minimum transaction approval rate $a_i^{*}\left(t\right)$ using large deviation theory. Then, based on the threshold of the transaction approval rate obtained from the cost optimization algorithm, we determine the optimal approval rate of each node. This rate is greater than $a_i^{*}\left(t\right)$ but close to $a_i\left(t\right)$. Additionally, the new difficulty of Tangless in each node can be calculated using the optimized transaction rate control algorithm. Based on these results, we implement the optimal approval rate for each node for time slot $t+1$. The proposed Tangless scheme can effectively minimize the resource costs of IOTA nodes and reduce the generation of orphan tangles.

Next, the committee members sum the optimal approval rate of each node to obtain the throughput of the tangle in time slot t. Specifically, the committee regards the current throughput as the initial value of the effective width of the tangle. Through numerical analysis, the committee calculates the quality of the approval parameter. This parameter is an indicator of the service quality provided by the current IOTA system. If the number and status of nodes fluctuate within the allowable range, this parameter will not change; however, if many nodes join or exit the IOTA network, then the parameter must be redetermined. Therefore, the committee members first need to pay attention to network changes. The committee then calculates the effective width of the tangle in subsequent time slots and compares the result with the throughput in the corresponding time slot. If the throughput is higher, then it is necessary to trigger Tangless again.

Remarks. In our design, the task of calculating the effective width of the tangle is carried out by a group of IOTA nodes, which act as a committee to carry out the final macro-level control when detecting the throughput. Each IOTA node has the potential to be chosen as a committee member. Similar to the election mechanism in [29,30], we assume that more than ${\displaystyle \frac{2}{3}}$ of the active IOTA nodes in the committee are honest. The trustworthiness of an IOTA node depends on the confidence value of its issuing transactions. The confidence level of a transaction is usually used to describe the validity of a message. The confidence level is mainly obtained by running the tip selection algorithm multiple times. The specific approach is to run the tip selection algorithm multiple times on conflicting transactions and select the transaction with the highest confidence value as the valid one. Additionally, we assume that the IOTA system will distinguish time-sensitive transactions, similar to blockchains [31]. Time-sensitive transactions are marked by clients when messages are sent. This enables us to determine which transactions should be prioritized for reception and approval when the throughput temporarily exceeds the effective width of the tangle.

5. Design of Tangless

This section presents our design of Tangless in detail. We first provide the computational optimization algorithm used in Tangless. Then, we propose the optimized transaction rate control algorithm based on the cost optimization of nodes. Moreover, we further introduce the effective width of the tangle, which is compared with the throughput to determine whether to optimize the next time slot.

5.1. Computational Optimization Algorithm

Reducing the expenditure of generating the tangle is the first step of Tangless. However, achieving this goal is challenging for two main reasons. First, the IOTA nodes issuing and approving transactions are unknown and dynamic, leading to unpredictable and unstable transaction queues. Second, long-term real-time optimization problems are generally complex and intertwined with various constraints, making traditional analysis methods ineffective [32]. To overcome the above challenges, we decouple the multi-objective optimization problem to achieve low computational complexity and make decisions without specific information. We leverage the Lyapunov optimization theory to embed transaction-related queues and constraints into the optimization framework, allowing us to solve the complex long-term cost optimization problem.

In what follows, suppose that the IOTA nodes issuing and approving transactions obey a Poisson distribution. Assume n nodes in IOTA, which are numbered with i, $i\in \{1,2,\dots ,n\}$. Finally, suppose that IOTA operates in the time interval $[0,T)$, which is divided into d time slots of equal length, and that each time slot is marked with t, $t\in \{1,2,\dots ,d\}$.

5.1.1. Modeling

For each node, we are interested in the difference between the number of new arriving transactions and the number of transaction approvals in each time slot t. Here, $r_i\left(t\right)$ indicates the number of new transactions arriving at node i, which are first buffered in node i’s backlog queue ${\epsilon }_i\left(t\right)$, where they await approval; $a_i\left(t\right)$ represents the number of transactions approved by node i. Both satisfy the independent identically distributed condition. Therefore, we can derive the following equation to formally demonstrate the evolution of each node i’s queue backlog:

$$\begin{array}{c}\hfill {\epsilon }_i(t+1)=max[{\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right),0]\forall i,t\end{array}$$

(1)

with ${\epsilon }_i\left(0\right)=0\forall i\in n$.

Next, we need to add temporal consideration to the queuing game to meet the latency demand. Let $h_i\left(t\right)$ represent the average time spent by node i from the arrival of a transaction to the approval of the transaction. In light of $Little’slaw$, the average approving delay constraint can be expressed as $h_i\left(t\right)={\displaystyle \frac{{lim}_{d\to \infty }\frac{1}{d}{\sum }_{t=0}^{d-1}E\left\{{\epsilon }_i\left(t\right)\right\}}{{lim}_{d\to \infty }\frac{1}{d}{\sum }_{t=0}^{d-1}E\left\{a_i\left(t\right)\right\}}}\le H$. We define H as the maximum delayed approval time of each transaction, which can be determined by the committee according to the network conditions. Meanwhile, regardless of the hardware cost and loss of each node, the average cost of approving two terminal transactions is a, the average cost of verifying a transaction is b, the average cost of updating the local ledger one time is c, the average cost of solving a puzzle is f, and the average cost of broadcasting the tangle one time is g. Thus, the consumption cost of node i in time slot t is

$$\begin{array}{c}\hfill D_i\left(t\right)=(a+c+f+g)·a_i\left(t\right)+b·y_i\left(t\right)\end{array},$$

(2)

where $y_i\left(t\right)=a\left(t\right)-a_i\left(t\right)$ and $a\left(t\right)={\sum }_{i=1}^n{a}_i\left(t\right)$.

Taking all of the above into consideration, we mathematically devise the node cost optimization goal as Problem 1:

$$\begin{array}{cc}\hfill Minimize:& \underset{d\to \infty }{lim\; sup}{\displaystyle \frac{1}{d}}\sum _{t=0}^{d-1}E\left\{\sum _{i=1}^n{D}_i\left(t\right)\right\}\hfill \end{array}$$

(3a)

$$\begin{array}{cc}\hfill Subjectto:& \underset{d\to \infty }{lim\; sup}{\displaystyle \frac{{\sum }_{t=0}^{d-1}E\left\{{\epsilon }_i\left(t\right)\right\}}{d}}<\infty \forall i,t\hfill \end{array}$$

(3b)

$$\begin{array}{c}{h}_i\left(t\right)⩽H\forall i,t\hfill \end{array}$$

(3c)

$$\begin{array}{c}{D}_i\left(t\right)⩾0\forall i,t.\hfill \end{array}$$

(3d)

Notably, the transaction approvals of each time slot are entangled; thus, we cannot achieve the optimal solution of Problem 1 through simple combinatorial optimization.

5.1.2. Lyapunov Optimization

We expect the whole IOTA system to be stable and the tangle to grow steadily. As such, Problem 1 can be addressed using Lyapunov optimization theory. According to [27], we know that if ${\epsilon }_i\left(t\right)$ is non-negative and if Equation (3b) holds, then $E\left\{{\epsilon }_i\left(t\right)\right\}$ is strongly stable. Similarly, $F_i\left(t\right)$ denotes the cumulative backlog of transactions for which node i cannot meet the delay requirements in time slot t. Thus, we can convert Equation (3c) into the stability constraint of the virtual queue $F_i\left(t\right)$, for which the expression is

$$\begin{array}{c}\hfill F_i(t+1)=max[F_i\left(t\right)-a_i\left(t\right)·h_i\left(t\right)+{\epsilon }_i\left(t\right),0]\forall i,t\end{array},$$

(4)

with $F_i\left(0\right)=0\forall i\in n$. Similar to ${\epsilon }_i\left(t\right)$, $F_i\left(t\right)$ satisfies the delay demand constraint in Equation (3c) and is stable [27]. Therefore, Problem 1 can be turned into Problem 2:

$$\begin{array}{cc}\hfill Minimize:& \underset{d\to \infty }{lim\; sup}{\displaystyle \frac{1}{d}}\sum _{t=0}^{d-1}E\left\{\sum _{i=1}^n{D}_i\left(t\right)\right\}\hfill \end{array}$$

(5a)

$$\begin{array}{cc}\hfill Subjectto:& \underset{d\to \infty }{lim\; sup}{\displaystyle \frac{{\sum }_{t=0}^{d-1}E\left\{{\epsilon }_i\left(t\right)\right\}}{d}}<\infty \forall i,t\hfill \end{array}$$

(5b)

$$\begin{array}{cc}\hfill & \underset{d\to \infty }{lim\; sup}{\displaystyle \frac{{\sum }_{t=0}^{d-1}E\left\{F_i\left(t\right)\right\}}{d}}<\infty \forall i,t\hfill \end{array}$$

(5c)

$$\begin{array}{c}{D}_i\left(t\right)⩾0\forall i,t.\hfill \end{array}$$

(5d)

We can analyze the evolution of queues using the Lyapunov optimization framework; see Table 1 for the specific parameter definitions.

Table 1. Definitions of Lyapunov optimization parameters.

Variable Name	Definition
$I\left(t\right)$	Queue backlog vector
$L\left(I\right(t\left)\right)$	Lyapunov function
$△\left(I\right(t\left)\right)$	Lyapunov drift
$DD\left(I\right(t\left)\right)$	Drift-plus-penalty
V	Non-negative weight

Let $I\left(t\right)\triangleq \left[\epsilon \right(t),F(t\left)\right]$. To simplify the calculation, $w_i=1$ is taken for any i. Thus, the Lyapunov function of our scheme is expressed as follows:

$$\begin{array}{c}\hfill L\left(I\left(t\right)\right)\triangleq {\displaystyle \frac{1}{2}}\sum _{i=1}^n{\epsilon }_i{\left(t\right)}^2+{\displaystyle \frac{1}{2}}\sum _{i=1}^n{F}_i{\left(t\right)}^{2}n\in N.\end{array}$$

(6)

If $L\left(I\right(t\left)\right)$ is reduced to a sufficiently small value, we can maintain the backlog of each queue at a low level to meet the queue stability; thus, we introduce the Lyapunov drift under a single-slot condition to achieve this goal. This measures the increase in the backlog of all queues from time slot t to time slot $t+1$:

$$\begin{array}{c}\hfill △\left(I\right(t\left)\right)\triangleq E\left\{L\right(I(t+1))-L(I\left(t\right))\mid I(t\left)\right\}.\end{array}$$

(7)

We can also understand this drift as the expected change of the Lyapunov function on a time slot. Because new transactions may become lost or invalid during network transmission, we can find a compromise between queue backlog and node cost by introducing and tuning the V value to minimize the drift and cost; here, V is an adjustable variable that describes the relative weight between queue stability and IOTA network cost minimization. In this work, we add a penalty function related to the value of V to both sides of Equation (7) to minimize the total cost of Equation (5a) and ensure the stability of the actual and virtual queues. According to this, the expression of the drift-plus-penalty of Lyapunov optimization is as follows:

$$\begin{array}{c}\hfill DD\left(I\right(t\left)\right)=△\left(I\right(t\left)\right)+V·E\left\{D\right(t\left)\right)\}\forall i,t,\end{array}$$

(8)

where $V>0$. Therefore, we turn Problem 2 into Problem 3:

$$\begin{array}{cc}\hfill Minimize:& E\{△(I\left(t\right))+V·D(t\left)\right\}\hfill \\ \hfill Subjectto:& \left(5b\right)-\left(5d\right).\hfill \end{array}$$

(9)

From a mathematical standpoint, $DD\left(I\right(t\left)\right)$ can be explicitly derived (please refer to Lemma 1).

Lemma 1.

The drift-plus-penalty $DD\left(I\right(t\left)\right)$ satisfies

$$\begin{array}{cc}\hfill DD\left(I\right(t\left)\right)\le & A+\sum _{i=1}^{n}E\{{\epsilon }_i\left(t\right)·r_i\left(t\right)-{\epsilon }_i\left(t\right)·a_i\left(t\right)+{\displaystyle \frac{1}{2}}{\epsilon }_i{\left(t\right)}^2\hfill \\ & \mid I\left(t\right)\}+\sum _{i=1}^{n}E\{F_i\left(t\right)[{\epsilon }_i\left(t\right)-a_i\left(t\right)·H]\mid I\left(t\right)\}\hfill \\ \hfill & +V·E\{\sum _{i=1}^n{D}_i\left(t\right)\mid I\left(t\right)\},\hfill \end{array}$$

(10)

where $A\ge {\displaystyle \frac{1}{2}}{\sum }_{i=1}^{n}E\{r_i{\left(t\right)}^2+a_i{\left(t\right)}^2+{[a_i\left(t\right)·H]}^2\mid I\left(t\right)\}$.

Proof. 

According to Equation (6), we can write

$$\begin{array}{cc}\hfill L\left(I\right(t+1\left)\right)-L\left(I\right(t\left)\right)& ={\displaystyle \frac{1}{2}}\sum _{i=1}^n{\epsilon }_i{(t+1)}^2-{\displaystyle \frac{1}{2}}\sum _{i=1}^n{\epsilon }_i{\left(t\right)}^2\hfill \\ \hfill & +{\displaystyle \frac{1}{2}}\sum _{i=1}^n{F}_i{(t+1)}^2-{\displaystyle \frac{1}{2}}\sum _{i=1}^n{F}_i{\left(t\right)}^2.\hfill \end{array}$$

(11)

Next, ${\displaystyle \frac{1}{2}}{\sum }_{i=1}^n{\epsilon }_i{(t+1)}^2-{\displaystyle \frac{1}{2}}{\sum }_{i=1}^n{\epsilon }_i{\left(t\right)}^2$ describes the detailed derivation process as an example. The derivation of other terms is similar. It is worth noting that

$$\begin{array}{cc}\hfill {\epsilon }_i{(t+1)}^2& ={\left(max[{\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right),0]\right)}^2\hfill \\ \hfill & \le {(max[{\epsilon }_i\left(t\right)-a_i\left(t\right),0]+r_i\left(t\right))}^2\hfill \\ \hfill & \le {\epsilon }_i{\left(t\right)}^2+a_i{\left(t\right)}^2+r_i{\left(t\right)}^2+2{\epsilon }_i\left(t\right)[r_i\left(t\right)\hfill \\ & -a_i\left(t\right)]-2a_i\left(t\right)·r_i\left(t\right)\hfill \\ \hfill & \le {\epsilon }_i{\left(t\right)}^2+a_i{\left(t\right)}^2+r_i{\left(t\right)}^2+2{\epsilon }_i\left(t\right)[r_i\left(t\right)\hfill \\ & -a_i\left(t\right)].\hfill \end{array}$$

(12)

The second line in Equation (12) is proved below.

If ${\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right)\ge 0$, then

$$\begin{array}{c}\hfill {\epsilon }_i(t+1)={\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right).\end{array}$$

(13)

Thus, we can know ${\epsilon }_i{(t+1)}^2={({\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right))}^2$.

If ${\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right)\le 0$, then

$$\begin{array}{c}\hfill {\epsilon }_i(t+1)=0>{\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right).\end{array}$$

(14)

As we can know ${\epsilon }_i{(t+1)}^2=0<{({\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right))}^2$, we obtain

$$\begin{array}{cc}\hfill & {\displaystyle \frac{1}{2}}\sum _{i=1}^n{\epsilon }_i{(t+1)}^2-{\displaystyle \frac{1}{2}}\sum _{i=1}^n{\epsilon }_i{\left(t\right)}^2\hfill \\ & \le {\displaystyle \frac{1}{2}}\sum _{i=1}^n[r_i{\left(t\right)}^2+a_i{\left(t\right)}^2\hfill \\ \hfill & +2{\epsilon }_i\left(t\right)[r_i\left(t\right)-a_i\left(t\right)]].\hfill \end{array}$$

(15)

Similarly, we have

$$\begin{array}{cc}\hfill & {\displaystyle \frac{1}{2}}\sum _{i=1}^n{F}_i{(t+1)}^2-{\displaystyle \frac{1}{2}}\sum _{i=1}^n{F}_i{\left(t\right)}^2\hfill \\ & \le {\displaystyle \frac{1}{2}}\sum _{i=1}^n[{\left({\epsilon }_i\left(t\right)\right)}^2+{[a_i\left(t\right)·H]}^2\hfill \\ & +2F_i\left(t\right)[{\epsilon }_i\left(t\right)-a_i\left(t\right)·H].\hfill \end{array}$$

(16)

After scaling and simplification, we obtain

$$\begin{array}{cc}\hfill DD\left(I\right(t\left)\right)\le & {\displaystyle \frac{1}{2}}\sum _{i=1}^{n}E\{r_i{\left(t\right)}^2+a_i{\left(t\right)}^2+2{\epsilon }_i\left(t\right)[r_i\left(t\right)-a_i\left(t\right)]\hfill \\ \hfill & \mid I\left(t\right)\}+{\displaystyle \frac{1}{2}}\sum _{i=1}^{n}E\{{[a_i\left(t\right)·H]}^2+{\left({\epsilon }_i\left(t\right)\right)}^2+\hfill \\ \hfill & 2F_i\left(t\right)[{\epsilon }_i\left(t\right)-a_i\left(t\right)·H]\mid I\left(t\right)\}+\hfill \\ \hfill & V·E\{\sum _{i=1}^n{D}_i\left(t\right)\mid I\left(t\right)\}.\hfill \end{array}$$

(17)

For any i and t, both $r_i\left(t\right)$ and $a_i\left(t\right)$ have upper bounds. We extract these parameters as $A_1$, that is, $A_1={\displaystyle \frac{1}{2}}{\sum }_{i=1}^{n}E\{a_i{\left(t\right)}^2+r_i{\left(t\right)}^2+{[a_i\left(t\right)·H]}^2\mid I\left(t\right)\}$. Consequently, when $A\ge A_1$, Lemma 1 holds.    □

Next, the approximate optimal solution of Problem 3 is solved through the drift-plus-penalty of Lyapunov optimization. Substituting Equation (2) into Equation (10), we have

$$\begin{array}{cc}\hfill DD\left(I\right(t\left)\right)\le & A+\sum _{i=1}^{n}E\{{\epsilon }_i\left(t\right)·r_i\left(t\right)-{\epsilon }_i\left(t\right)·a_i\left(t\right)+{\displaystyle \frac{1}{2}}{\epsilon }_i{\left(t\right)}^2\hfill \\ & \mid I\left(t\right)\}+\sum _{i=1}^{n}E\{F_i\left(t\right)[{\epsilon }_i\left(t\right)-a_i\left(t\right)·H]\mid I\left(t\right)\}\hfill \\ \hfill & +V\sum _{i=1}^n·E\{(a+c+f+g)·a_i\left(t\right)+b·[a\left(t\right)\hfill \\ \hfill & -a_i\left(t\right)\left]\right)\mid I\left(t\right)\}.\hfill \end{array}$$

(18)

According to the opportunistic minimization of expectation [33], we minimize the above expectation by minimizing the function inside the expectation. Therefore, we can realize Equation (18) by calculating the minimum of the following expression. Let

$$\begin{array}{cc}\hfill B=& {\displaystyle \frac{1}{2}}{a}_i{\left(t\right)}^2+{\displaystyle \frac{1}{2}}{r}_i{\left(t\right)}^2+{\displaystyle \frac{1}{2}}{[a_i\left(t\right)·H]}^2+{\epsilon }_i\left(t\right)[r_i\left(t\right)\hfill \\ \hfill & -a_i\left(t\right)]+{\displaystyle \frac{1}{2}}{\epsilon }_i{\left(t\right)}^2+F_i\left(t\right)[{\epsilon }_i\left(t\right)-a_i\left(t\right)·H]\hfill \\ \hfill & +V[(a+c+f+g-b)·a_i\left(t\right)+b·a\left(t\right)].\hfill \end{array}$$

(19)

We can achieve the approximate solution to Problem 3 by solving the minimum value of B. In time slot t, the values of ${\epsilon }_i\left(t\right)$ and $F_i\left(t\right)$ are fixed. In Equation (19), B is a quadratic convex function for $a_i\left(t\right)$ and has a minimum value in its definition domain. Thus, Problem 3 can be turned into Problem 4:

$$\begin{array}{cc}\hfill Minimize:& B\hfill \\ \hfill Subjectto:& \left(5b\right)-\left(5d\right).\hfill \end{array}$$

(20)

We can find the partial derivative of B to $a_i\left(t\right)$ in time slot t as follows:

$$\begin{array}{cc}\hfill {\displaystyle \frac{\partial B}{\partial a_i\left(t\right)}}=& a_i\left(t\right)+H^2·a_i\left(t\right)-{\epsilon }_i\left(t\right)-H·F_i\left(t\right)\hfill \\ & +V(a+c+f+g).\hfill \end{array}$$

(21)

Let ${\displaystyle \frac{\partial B}{\partial a_i\left(t\right)}}=0$. Then, we obtain

$$\begin{array}{c}\hfill a_i\left(t\right)={\displaystyle \frac{{\epsilon }_i\left(t\right)+H·F_i\left(t\right)-V(a+c+f+g)}{1+H^2}}.\end{array}$$

(22)

When the transaction approval rate of node i satisfies Equation (22), B has a minimum value. Algorithm 1 shows the details of the computational optimization algorithm [1]. In this way, the threshold for the transaction approval rate can be obtained to reduce the tangle generating expenditure.

Algorithm 1 Computational optimization algorithm.

Input: Time slot, t; number of new transactions received in time slot t, $r_i\left(t\right)$; number of transaction approvals in time slot t, $a_i\left(t\right)$; transaction backlog queue in time slot t, ${\epsilon }_i\left(t\right)$; cumulative backlog of new transactions for which node i cannot meet the delayed demand in time slot t, $F_i\left(t\right)$; resource cost of node i in time slot t, $D_i\left(t\right)$; maximum delayed approval time of a transaction, H. Output: $None$.  Initialize all parameters;  for $t=0$ to $d-1$//d is the number of time slots.        for $i=1$ to n//n is the number of nodes.              Obtain $a_i\left(t\right)$ and $r_i\left(t\right)$;              ${\epsilon }_i(t+1)=max[{\epsilon }_i\left(t\right)-a_i\left(t\right)+r_i\left(t\right),0]$;              $F_i(t+1)=max[F_i\left(t\right)-a_i\left(t\right)·H$                              $+{\epsilon }_i\left(t\right),0]$;              Get $D_i\left(t\right)$ by Equation (2);        Solve $DD\left(I\right(t\left)\right)$ by Equation (10);        //Determine the optimal control decision.        $a^{*}\left(t\right)=argminDD\left(I\left(t\right)\right)$;        for $i=1$ to n              Update ${\epsilon }_i\left(t\right)$ and $F_i\left(t\right)$;  Return;

5.2. Optimized Transaction Rate Control Algorithm

IOTA generates many orphan tangles due to network delay, resulting in wasted computational costs and potentially causing network congestion. Therefore, in this subsection we propose an optimized transaction rate control algorithm based on large deviation theory [28] to eliminate orphan tangles. To this end, we introduce two concepts: the number of tolerable delayed transactions and the minimum transaction approval rate.

5.2.1. Number of Tolerable Delayed Transactions

The queue backlog of new incoming transactions is studied to calculate the loss probability of arrival transactions P and its corresponding decay rate $H\left(q\right)$. Furthermore, critical factors are found to prevent the loss of arrival transactions and reduce orphan tangles.

Generally, each IOTA node has the computing power to validate transactions and maintain the tangle. Thus, the stability of $F_i\left(t\right)$ can satisfy the waiting delay requirements of incoming transactions. However, a small probability of events violating the above waiting delay still exists. Thus, we determine the cumulative backlog of tolerable delayed transactions of node i ($i\in \{1,2,\dots ,n\}$) by leveraging the large deviation theory, that is, the number of tolerable delayed transactions. In Section 5.1, $r_i\left(t\right)$ and $a_i\left(t\right)$ are the issuing rate of new transactions and the approval rate of the transactions of node i, respectively (taking time slots as the time unit). In light of the occurrence of small-probability events, this needs to satisfy $r_i\left(t\right)>a_i\left(t\right)>0$. To maintain the stability of the queue, $r_i\left(t\right)-a_i\left(t\right)<a_i\left(t\right)·H$ is required, that is, $r_i\left(t\right)<a_i\left(t\right)(1+H)$. Let h represent the average time between an arriving transaction and its approval. Based on [17], we suppose that $H=2h$ to ensure that the number of terminal transactions in the tangle for each time slot tends to a constant value. According to Equation (4), we can derive another expression for $F_i\left(t\right)$:

$$\begin{array}{c}\hfill F_t={\epsilon }_t-a_t·H\forall t\end{array}$$

(23)

in which ${\epsilon }_t$ and $a_t$ indicate the actual length of ${\epsilon }_i\left(t\right)$ for node i and the actual transaction approval quantity of node i in time slot t, respectively. Notably, $F_t$ can be negative in this part. Let ${\beta }_i$ represent the number of delayed transactions that node i can tolerate. As our main concern is the maximum number of transactions unapproved in time, we concentrate on $X={sup}_{t\ge 0}{F}_t$, which denotes the maximum value of $F_t$. As this is also the crux of analyzing the robustness of IOTA, it is imperative to analyze the probability of $Y>{\beta }_i$. ${\beta }_i$ is defined as follows.

Definition 1 (The number of tolerable delayed transactions (${\beta }_i$)).

If the number of issuing transactions from node i is greater than the number of transaction approvals by the node in time slot t, node i can still accept the number of transactions for which the latency requirement could not be satisfied.

Due to the above definition, we know that larger ${\beta }_i$ means that node i can tolerate more delayed transactions, in other words, node i can endure more delayed transactions as ${\beta }_i$ increases. When the difference between the number of delayed and approved transactions for node i is at its highest, delayed transactions overflow easily; therefore, the value of X can be analyzed to determine whether there is an overflow of delayed transactions. If $X>{\beta }_i$, then the incoming transactions overflow due to delay, and vice versa. Thus, we study probability $P(X>{\beta }_i)$ by discussing the relationship between X and $F_t$ to solve the overflow degree of delayed transactions reaching node i.

Leveraging Cramer’s theorem [28,34,35], we deduce the delayed transactions overflow probability of node i. Let ${\beta }_i=sq(s>0,q>0)$. When $s\to \infty$, $P(X>{\beta }_i)$ can be expressed as $P(X>{\beta }_i)\sim e^{-sH\left(q\right)}$; thus, we have

$$\underset{s\to \infty }{lim}{\displaystyle \frac{1}{s}}logP({\displaystyle \frac{X}{s}}>q)=-H\left(q\right)$$

(24)

where

$$H\left(q\right)=\underset{d\ge 0}{inf}t{\Lambda }^{*}\left({\displaystyle \frac{q}{d}}\right)$$

(25)

and

$${\Lambda }^{*}\left(x\right)=\underset{{\beta }_i\in R}{sup}\{{\beta }_{i}x-\Lambda \left({\beta }_i\right)\}.$$

(26)

Here, ${\Lambda }^{*}(·)$ is the Fenchel–Legendre transform of $\Lambda (·)$. The logarithmic moment generating function of $F_t$ is

$$\Lambda \left({\beta }_i\right)=\underset{d\to \infty }{lim}{\displaystyle \frac{1}{d}}logE{e}^{{\beta }_i{F}_t}.$$

(27)

Next, let ${\Lambda }_{\epsilon }(·)$ and ${\Lambda }_a(·)$ express the logarithmic moment generating function of ${\epsilon }_t$ and $a_t·H$, respectively. According to Equation (27), we obtain

$$\Lambda \left({\beta }_i\right)={\Lambda }_{\epsilon }\left({\beta }_i\right)+{\Lambda }_a(-{\beta }_i).$$

(28)

In light of [36] and combined with Equation (28), we can deduce that

$${\Lambda }_{\epsilon }\left({\beta }_i\right)=[r_i\left(t\right)-a_i\left(t\right)]·(e^{{\beta }_i}-1),$$

(29)

$${\Lambda }_a\left({\beta }_i\right)=a_i\left(t\right)·H·(e^{{\beta }_i}-1).$$

(30)

According to Equations (26) and (29), we have

$${\Lambda }_{\epsilon }^{*}\left({\beta }_i\right)=\left\{\begin{array}{ccc}xlog{\displaystyle \frac{x}{r_i\left(t\right)-a_i\left(t\right)}}+r_i\left(t\right)-a_i\left(t\right)-x\hfill & & x\ge 0\hfill \\ \infty \hfill & & o.w.\hfill \end{array}\right.$$

(31)

Similarly, according to Equations (26) and (30), we have

$${\Lambda }_a^{*}\left({\beta }_i\right)=\left\{\begin{array}{ccc}xlog{\displaystyle \frac{x}{a_i\left(t\right)·H}}+a_i\left(t\right)·H-x\hfill & & x\ge 0\hfill \\ \infty \hfill & & o.w.\hfill \end{array}\right.$$

(32)

To solve ${\Lambda }^{*}\left(x\right)$, we need to deform the function. According to [34], it is known that ${\Lambda }^{*}\left(x\right)={\Lambda }_{\epsilon }^{*}\left(r\right)+{\Lambda }_a^{*}(r-x)$. Let $G={\Lambda }_{\epsilon }^{*}\left(r\right)+{\Lambda }_a^{*}(r-x)=\underset{{\beta }_i\in R}{sup}\{{\beta }_{i}r-[r_i\left(t\right)-a_i\left(t\right)]·(e^{{\beta }_i}-1)\}+\underset{{\beta }_i\in R}{sup}\{{\beta }_i(r-x)-a_i\left(t\right)·H·(e^{-{\beta }_i}-1)\}$. Substituting r and $r-x$ into Equations (31) and (32), we have $G=rlog{\displaystyle \frac{r}{r_i\left(t\right)-a_i\left(t\right)}}+(r-x)log{\displaystyle \frac{r-x}{a_i\left(t\right)·H}}-2r+x+[r_i\left(t\right)-a_i\left(t\right)]+a_i\left(t\right)·H$. We calculate the first and second derivatives of G, that is, ${\displaystyle \frac{\partial G}{\partial r}}=log{\displaystyle \frac{r}{r_i\left(t\right)-a_i\left(t\right)}}+log{\displaystyle \frac{r-x}{a_i\left(t\right)·H}}$ and ${\displaystyle \frac{{\partial }^{2}G}{\partial r^2}}={\displaystyle \frac{1}{r}}+{\displaystyle \frac{1}{r-x}}$, respectively. When $r>x\ge 0$, we can know ${\displaystyle \frac{{\partial }^{2}G}{\partial r^2}}>0$. This indicates that G has a minimum. Letting ${\displaystyle \frac{\partial G}{\partial r}}=0$, we have $r={\displaystyle \frac{x+\sqrt{x^2+4[r_i\left(t\right)-a_i\left(t\right)]·a_i\left(t\right)·H}}{2}}$, which we can put into G to obtain the minimization of G:

$$\begin{array}{cc}\hfill G_{min}& ={\Lambda }_{min}^{*}\left(x\right)=[r_i\left(t\right)-a_i\left(t\right)]+a_i\left(t\right)·H\hfill \\ \hfill & -\sqrt{x^2+4[r_i\left(t\right)-a_i\left(t\right)]a_i\left(t\right)·H}\hfill \\ \hfill & +{\displaystyle \frac{1}{2}}(\sqrt{x^2+4[r_i\left(t\right)-a_i\left(t\right)]a_i\left(t\right)·H}+x)\hfill \\ \hfill & ·log{\displaystyle \frac{\sqrt{x^2+4[r_i\left(t\right)-a_i\left(t\right)]a_i\left(t\right)·H}+x}{2[r_i\left(t\right)-a_i\left(t\right)]}}\hfill \\ \hfill & +{\displaystyle \frac{1}{2}}(\sqrt{x^2+4[r_i\left(t\right)-a_i\left(t\right)]a_i\left(t\right)·H}-x)\hfill \\ \hfill & ·log{\displaystyle \frac{\sqrt{x^2+4[r_i\left(t\right)-a_i\left(t\right)]a_i\left(t\right)·H}-x}{2a_i\left(t\right)·H}}.\hfill \end{array}$$

(33)

Let $x={\displaystyle \frac{q}{d}}$. After transformation, we obtain $d={\displaystyle \frac{q}{x}}$; thus, $A=d{\Lambda }^{*}\left({\displaystyle \frac{q}{d}}\right)={\displaystyle \frac{q}{x}}{\Lambda }_{min}^{*}\left(x\right)$. When $d={\displaystyle \frac{q}{a_i\left(t\right)·H-[r_i\left(t\right)-a_i\left(t\right)]}}$, where $a_i\left(t\right)·H>r_i\left(t\right)-a_i\left(t\right)$, A has the minimum value. Combining this with Equation (25), we can derive $H\left(q\right)$ as follows:

$$H\left(q\right)=qlog{\displaystyle \frac{a_i\left(t\right)·H}{r_i\left(t\right)-a_i\left(t\right)}}$$

(34)

in which $H\left(q\right)$ is recognized as the exponential decay rate function of $P(X>{\beta }_i)$. Notably, $H\left(q\right)$ is an important index reflecting the loss of delayed transactions. Next, we present another definition.

Definition 2 (Number of effective tolerable delayed transactions (${\beta }_i^{*}$)).

If the number of issuing transactions from node i is greater than the number of transactions approved by the node in time slot t, node i can still accept the minimum number of transactions for which the latency requirement could not be satisfied.

This value should satisfy the condition that the probability of the maximum difference between the number of delayed and approved transactions be less than or equal to the given threshold $\theta \in (0,1]$. This requirement can be mathematically described as ${\beta }_i^{*}\left(\theta \right)=min\{{\beta }_i:P(X>{\beta }_i)\le \theta \}$. Given $a_i\left(t\right)·H>r_i\left(t\right)-a_i\left(t\right)>0$, $\theta \in (0,1]$, and $s>>1$, we can derive ${\beta }_i^{*}$ as follows:

$${\beta }_i^{*}=-{\displaystyle \frac{log\theta }{log\frac{a_i\left(t\right)·H}{r_i\left(t\right)-a_i\left(t\right)}}}.$$

(35)

Proof. 

Inspired by Equation (24), when $s\to \infty$, we can estimate $P(X>{\beta }_i)$ by $e^{-sH\left(q\right)}$. Through calculating $P(X>{\beta }_i)\le \theta$, we can obtain $H\left(q\right)\ge -{\displaystyle \frac{log\left(\theta \right)}{s}}$. Then, by substitution into Equation (34), we obtain $qs\ge -{\displaystyle \frac{log\theta }{log\frac{a_i\left(t\right)·H}{r_i\left(t\right)-a_i\left(t\right)}}}$. Taking ${\beta }_i^{*}=min\left\{qs\right\}$, Equation (35) holds.    □

Although large q offers high efficiency in accepting more delayed transactions, it leads to long delays in transactions and takes up a great deal of storage space. We can also consider another factor affecting $H\left(q\right)$, which is the transaction approval rate. In this case, we should answer the fundamental question of how much computational power an IOTA node needs to approve tips. To address the problem, we introduce the following definition.

Definition 3 (Minimum transaction approval rate ($a_i^{*}$)).

This rate refers to the minimum value of the transaction approval rate of node i to ensure that the loss probability of delayed transactions is less than or equal to the given threshold $\theta \in (0,1]$.

We can know $a_i^{*}\left(\theta \right)=min\{a_i\left(t\right):P(X>{\beta }_i)\le \theta \}$. For $a_i\left(t\right)·H>r_i\left(t\right)-a_i\left(t\right)>0$, ${\beta }_i>0$, and $\theta \in (0,1]$, we have

$$a_i^{*}={\displaystyle \frac{[r_i\left(t\right)-a_i\left(t\right)]e^{-\frac{log\left(\theta \right)}{{\beta }_i}}}{H}}.$$

(36)

The proof is similar to Equation (35), and is not repeated here. The related algorithm is shown in Algorithm 2.

Algorithm 2 Minimum transaction approval rate.

Input: Time slot, t; number of new transactions received in time slot t, $r_i\left(t\right)$; number of transaction approvals in time slot t, $a_i\left(t\right)$; maximum delayed approval time of a transaction, H; number of effective and tolerable delayed transactions, ${\beta }_i^{*}$; given threshold, $\theta$. Output: $a_i^{*}$.  Determine H and $\theta$ by the committee;  Obtain $r_i\left(t\right)$ and $a_i\left(t\right)$;  ${\beta }_i^{*}=-{\displaystyle \frac{log\theta }{log\frac{a_i\left(t\right)·H}{r_i\left(t\right)-a_i\left(t\right)}}}$;  $a_i^{*}={\displaystyle \frac{[r_i\left(t\right)-a_i\left(t\right)]e^{-\frac{log\left(\theta \right)}{{\beta }_i^{*}}}}{H}}$;  Return $a_i^{*}$;

Next, we consider how to determine the cost of computational optimization. In light of the above analysis, the optimal transaction approval rate in real time should be close or equal to the threshold in Equation (22) and greater than the value of Equation (36). Under such circumstances, we can effectively reduce the cost of IOTA nodes while reducing the existence of orphan tangles.

5.2.2. Rate Control

Based on the analysis in the previous subsection, the transaction rate control problem can be transformed into the problem of adjusting the PoW difficulty of Tangless in IOTA, which is related to $F_t$ and $r_i\left(t\right)$. Here, $F_t$ indicates the cumulative backlog of new transactions for which node i cannot meet the approval demand in time slot t. By monitoring the change in the $F_t$ value in each time slot, we propose a method for colculating the difficulty of Tangless. While each node in IOTA has a different calculation power, the node must provide greater than ${\beta }_i^{*}$ space for tolerable delayed transactions in order to reduce overflow. We expect that ${\beta }_i^{*}\ge F_t$ for stable growth of the tangle; thus, we discuss the change in $F_t$. Specifically, $F_t>0$ indicates that the current difficulty of Tangless is too high, while $F_t=0$ shows that the number of new transaction arrivals of a node and the number of transaction approvals of the node match in time slot t, which is the optimum operating state of the IOTA node. Therefore, we do not need to adjust the difficulty of Tangless. If $F_t<0$, then the network load is small. Let $d_i\left(t\right)$ represent the difficulty of Tangless in node i in time slot t. The expression is

$$d_i\left(t\right)=d_0-{\displaystyle \frac{F_t}{r_i\left(t\right)}}\forall i,t,$$

(37)

where $d_0$ is the basic difficulty value. We set ${\rho }_t={\displaystyle \frac{F_t}{r_i\left(t\right)}}$, which we call the variation in the difficulty of node i in every time slot. When ${\rho }_t=0$, the rate control of Tangless will degenerate the fixed PoW, which is the same as IOTA $1.5$. Algorithm 3 shows the details of the rate control algorithm of Tangless. The algorithm balances transaction traffic and IOTA node tolerance to reduce the generation of orphan tangles, decrease waste of computing resources, and hinder network congestion.

Algorithm 3 Optimized transaction rate control algorithm.

Input: Time slot, t; number of time slots, d; number of new transactions received in time slot t, $r_i\left(t\right)$; number of transaction approvals after optimization in time slot t, $a_i^{*}\left(t\right)$; basic difficulty value of Tangless rate control, $d_0$; difficulty value of Tangless rate control in time slot t, $d_i\left(t\right)$; transaction backlog queue in time slot t, ${\epsilon }_i\left(t\right)$; cumulative backlog of new transactions for which IOTA node i cannot meet the delayed demand t, $F_i\left(t\right)$; maximum transaction delay time, H; number of effective and tolerable delayed transactions, ${\beta }_i^{*}$. Output: Difficulty of node i in each time slot, $d_i\left(\right)$.  Initialize all parameters;  Determine $a_i^{*}\left(t\right)$ by Equations (22) and (36);  for $t=1$ to d        if $t>0$              ${\epsilon }_i\left(t\right)=max[{\epsilon }_i(t-1)-a_i^{*}\left(t\right)+r_i\left(t\right),0]$;        else              ${\epsilon }_i\left(t\right)=max[-a_i^{*}\left(t\right)+r_i\left(t\right),0]$;        $F_i\left(t\right)={\epsilon }_i\left(t\right)-a_i^{*}\left(t\right)·H$;        if $F_i\left(t\right)>0$              if $F_i\left(t\right)\le {\beta }_i^{*}$                    $d_i\left(t\right)=d_0-{\displaystyle \frac{F_i\left(t\right)}{r_i\left(t\right)}}$;                    if $d_i\left(t\right)<d_0$                          $d_i\left(t\right)=d_0$;              Else suspend receiving transactions until                    $F_i\left(t\right)\le {\beta }_i^{*}$;        else if $F_i\left(t\right)<0$              $d_i\left(t\right)=d_0-{\displaystyle \frac{F_i\left(t\right)}{r_i\left(t\right)}}$;  Return $d_i\left(\right)$;

5.3. Effective Width of the Tangle

With new transactions coming in continuously, it is important to control the throughput to ensure that it always fluctuate around the number of approved transactions that the IOTA network can tolerate. In the previous subsection, we determined the rate of each IOTA node. Algorithm 3 is an improvement of adaptive PoW [24] and is directed against each single IOTA node. In this subsection, we study the change in the transaction throughput of the IOTA system from a macro-level perspective to ensure the stable growth of the tangle, reduce cost optimization frequency, and avoid unnecessary waste of resources.

Monitoring whether the throughput is within the tolerance range of IOTA is proposed mainly to save on IOTA system costs. Specifically, incoming transaction rates that are too fast will place some new transactions at risk of being abandoned due to network congestion. If many terminal transactions are not approved timely, it can produce some orphan tangles. Either situation leads to considerable wastes in the IOTA system. We use the proposed Tangless scheme to address the above issues. Importantly, if nodes were to implement Tangless in every time slot, this would incur a great deal of cost, as the time complexity of the related algorithm is $\mathcal{O}\left(nd\right)$. To solve the issue from an overall perspective, we propose a definition for the effective width of the tangle. We first compare the effective width with the corresponding throughput, then decide whether to implement Tangless for the next step, thereby avoiding resource wastage caused by unnecessarily frequent optimization.

Note that the effective width of the tangle is determined by the committee rather than by all IOTA nodes. By studying the matching degree between the effective width of the tangle and the throughput, we determine whether to necessarily implement the next round of cost optimization and transaction rate control. If the difference between them is within the tolerance of the IOTA system, this indicates that the growth of the tangle is stable. If the throughput is much greater than the effective width of the tangle, that is, beyond the tolerance of the IOTA system, it indicates that the current throughput needs adjustment and that we need to trigger Tangless again. Thus, the definition of the effective width of the tangle is as follows.

Definition 4 (Effective Width of the tangle).

The number of approved transactions per unit of time.

In communication, the effective bandwidth theory can describe the performance of burst traffic in a unified form. A popular method is log moment generating function transformation [34,37], which can be used to solve the effective bandwidth in a communication network. In our work, we regard incoming transactions as data transmitted by the IOTA network and the effective width of the tangle as the effective bandwidth. Thus, the effective width of the tangle can be calculated through the transformation of the log moment generating function. This approach allows us to study the actions to be taken by IOTA in the case of a sudden change in transaction volume.

Consider the case where new transactions are constantly attached to the tangle from moment 0. Let $A(0,t]$ be the total number of new transaction arrivals in the interval between $(0,t](t\in n)$ and $A(0,t]=\Delta A_1+\dots +\Delta A_t$. Suppose that $\Delta A_i(i=1,2,\dots t)$ denote the number of new transaction arrivals in the i-th unit, and are i.i.d. According to [34,38,39], we can conclude that the effective width of the tangle is

$$\alpha \left(\gamma \right)=\lfloor {\displaystyle \frac{1}{\gamma t}}logE{e}^{\gamma A(0,t]}\rfloor ,$$

(38)

where is the log moment generating function of $A(0,t]$ and $\gamma$ is some given tail decay parameter (sometimes called an approval quality parameter), with $\gamma >0$.

Assume that $\overline{r}$ is the average rate at which new transactions arrive (assuming that all nodes have the same computing power), which is assumed to obey a Poisson distribution and to satisfy $\overline{r}\approx {\displaystyle \frac{\Delta A_1+\Delta A_2+\dots +\Delta A_t}{t}}$ and $\overline{r}>0$; then, $\alpha \left(\gamma \right)$ can also be expressed as follows:

$$\alpha \left(\gamma \right)=\lfloor {\displaystyle \frac{1}{\gamma }}log\left(\sum _{k=0}^{\infty }{\displaystyle \frac{{\overline{r}}^k{e}^{-\overline{r}}}{k!}}{e}^{\gamma k}\right)\rfloor .$$

(39)

Proof. 

According to Equation (38), we can obtain

$$\begin{array}{cc}\hfill \alpha \left(\gamma \right)& =\lfloor {\displaystyle \frac{1}{\gamma t}}logE(e^{\gamma \Delta A_1}·e^{\gamma \Delta A_2}·\dots \dots ·e^{\gamma \Delta A_t})\rfloor \hfill \\ \hfill & =\lfloor {\displaystyle \frac{1}{\gamma t}}log{\left(E\left(e^{\gamma \Delta A_t}\right)\right)}^t\rfloor \hfill \\ \hfill & ==\lfloor {\displaystyle \frac{1}{\gamma }}logE\left(e^{\gamma \Delta A_t}\right)\rfloor .\hfill \end{array}$$

(40)

Based on the expectation of a Poisson distribution, we know that

$$\begin{array}{c}\hfill E\left(e^{\gamma \Delta A_t}\right)=\sum _{k=0}^{\infty }{\displaystyle \frac{{\overline{r}}^k{e}^{-\overline{r}}}{k!}}{e}^{\gamma k}.\end{array}$$

(41)

Thus, we have

$$\begin{array}{c}\hfill \alpha \left(\gamma \right)=\lfloor {\displaystyle \frac{1}{\gamma }}log\left(\sum _{k=0}^{\infty }{\displaystyle \frac{{\overline{r}}^k{e}^{-\overline{r}}}{k!}}{e}^{\gamma k}\right)\rfloor .\end{array}$$

(42)

   □

Assuming $\overline{r}=10$, this shows that $\alpha \left(\gamma \right)$ is increasing with $\gamma$, as shown in Figure 3. According to [34], we can see that $\alpha \left(\gamma \right)$ lies between the mean rate $E(\Delta A_t)$ and the peak rate, which is ess. sup. $\Delta A_t=inf\{x:P(\Delta A_t\le x)=1\}$. Here, we can consider x as the number of active nodes in the IOTA network.

Figure 3. $\alpha \left(\gamma \right)$ along with $\gamma$ changing trend.

Notably, the approval quality parameter is determined and maintained by the committee. Specifically, after optimizing the costs of IOTA nodes, we need to sum the thresholds of the transaction approval rates of all nodes to obtain the transaction throughput in time slot t. Next, the committee members adjust the parameter $\gamma$ of $\alpha \left(\gamma \right)$ according to the throughput using the numerical analysis method and determine $\gamma$. Significantly, if we know the approval quality parameter, then we can deduce the effective width of the tangle in subsequent time slots. Therefore, in the next time slot, we can first calculate the value of $\alpha \left(\gamma \right)$ compare it with the current throughput, then decide whether to continue to optimize the costs of IOTA nodes.

As long as the number of IOTA nodes and the nodes’ status both remain unchanged, the approval quality parameter will remain unchanged. Thus, we can obtain the throughput that the network can tolerate. Nevertheless, if Tangless is started in each time slot, resources will be wasted and the efficiencies of nodes will be too low. Motivated by this observation, if the effective width of the tangle does not match the actual throughput in the next time slot (for example, if the fluctuation exceeds $5\%$), then we can start Tangless again. The details of the comparison algorithm are provided in Algorithm 4. The time complexity of this algorithm is less than $\mathcal{O}\left(nd\right)$.

Algorithm 4 Throughput adjustment algorithm.

Input: Time slot, t; number of IOTA nodes, n; optimal approval rate, $r_i$; effective width of the tangle, $\alpha \left(\gamma \right)$; throughput, $throu$. Output: The result of the adjustment;  Start and initialize the IOTA system. Suppose IOTA enters the stable state in time slot t;  $sum=0$;  Again:  //In time slot t;  For ($i=1$, $i\le n$, $i++$)        Run Algorithm 1 to get the threshold of transaction        approval rate;        Run Algorithm 2 to get the minimum transaction        approval rate;        Determine the optimal approval rate $r_i$ of each node;        $sum=sum+r_i$;  $throu=sum$; //Actual throughput  $\alpha \left(\gamma \right)$ = $throu$;  According to $throu$, $\gamma$ can be determined by the committee;  //In time slot $t+1$;  Calculate $\alpha \left(\gamma \right)$ according to Equation (39);  Get $throu$ in the current time slot;  If $\alpha \left(\gamma \right)$! = $throu\ast (1\pm 0.05)$  //$0.05$ is the tolerance fluctuation range of the system throughput.        goto Again;  Else continue;  Return;

In this work, we assume that all approved transactions are terminal transactions. The transaction attachment strategy (i.e., the tip selection algorithm) can solve and ensure this situation; however, this is not discussed in our paper.

In light of the above observations, we are also motivated to calculate the expected time for the first approval of the transaction. Let $\tilde{h}$ represent the average time that a node needs to perform the calculations required to issue a transaction. We assume that all devices have approximately the same computing power, with $\lambda$ representing the rate of that Poisson process; for simplicity, we assume that this rate remains constant in time. According to [17], we suppose that when any node issues a transaction, the state before $\tilde{h}$ time units is observed instead of the tangle’s current state, that is, the transaction connected to the tangle at time $\tilde{t}$ is only visible to the network until $\tilde{t}+\tilde{h}$. At a given time $\tilde{t}$, there are approximately $\lambda \tilde{h}$ “hidden tips” and $\tilde{r}$ “exposed tips”, meaning that $L=\tilde{r}+\lambda \tilde{h}$. Among these, “hidden tips” are not visible at time $\tilde{t}$, as they connect to the tangle in the time interval $[\tilde{t}-\tilde{h},\tilde{t}])$, while“exposed tips” are still tips at time $\tilde{t}$, having attached to the tangle before time $\tilde{t}-\tilde{h}$. According to stationarity, we can assume that there are $\lambda \tilde{h}$ tips in the tangle at time $\tilde{t}-\tilde{h}$ and no longer tips until time $\tilde{t}$. Now, when a new transaction arrives, the probability of a tip being approved is $\tilde{r}/(\tilde{r}+\lambda \tilde{h})$; thus, the average number of selected tips is $2\tilde{r}/(\tilde{r}+\lambda \tilde{h})$. In the steady state, the average number of selected tips should equal 1, meaning that $L=2\lambda \tilde{h}$. The expected time of the first approvals is about $\tilde{h}+L/\left(2\lambda \right)=2\tilde{h}$. When the load is high, the maximum number of tips that can be approved is $\alpha \left(\gamma \right)$ at time $\tilde{t}$. Thus, the expected time of the first approved transaction should be no more than $\tilde{h}+\alpha \left(\gamma \right)/\left(2\lambda \right)$.

6. Evaluation

In this section, we demonstrate the effectiveness of Tangless by contrasting it with adaptive PoW [24] to demonstrate the resulting improvement. Specifically, we first compare the resource costs of nodes obtained by non-optimization and Lyapunov optimization, then prove the effectiveness of the optimized transaction rate control algorithm. Our scheme was implemented in Python 3.10.2 on a laptop with an 11th-Gen Intel(R) Core(TM) $\mathrm{i}7$-$11390\mathrm{H}$ processor and 16 GB RAM.

Our experimental simulations, we used the following parameter settings: the IOTA network had n nodes, with $n=100$, $d=100$, $a+c+f+g=0.04$, $b=0.01$, $H=1$, and $v=0.5$. We randomly selected three nodes for analysis, and $r_i\left(t\right)$ followed a Poisson distribution. Non-optimized $\epsilon$ queues and non-optimized F queues are shown in Figure 4a,c, while optimized $\epsilon$ queues and optimized F queues are shown in Figure 4b,d. The results indicate that the optimized queues change steadily with time. In particular, the accumulated backlog of new transactions fluctuates in a small range after optimization, as shown in Figure 4d [1]. Under the same conditions, the optimized cost of nodes (solid line) is lower than the cost without optimization (dashed line), as shown in Figure 5. According to these results, the computational optimization algorithm of Tangless reduces the resource costs of nodes (see Table 2).

Figure 4. Comparison of queues before and after optimization.

Figure 5. The comparison of the cost of nodes before and after optimization.

Table 2. Cost optimization parameters.

Parameter	Value
n	100
d	100
$a+c+f+g$	0.04
b	0.01
H	1
V	0.5

In addition, we focused on evaluating Tangless’ optimized transaction rate control algorithm. First, the influence of relevant parameters was verified using the decay rate $H\left(q\right)$ of $P(X>{\beta }_i)$. From large deviation theory, we know that increasing the factors of q or $a_i\left(t\right)·H-[r_i\left(t\right)-a_i\left(t\right)]$ can increase the decay rate $H\left(q\right)$. The change in the decay rate $H\left(q\right)$ with q and $a_i\left(t\right)·H-[r_i\left(t\right)-a_i\left(t\right)]$ is illustrated in Figure 6 [1]. The figure indicates that $H\left(q\right)$ increases linearly with q, while it increases logarithmically with $a_i\left(t\right)·H-[r_i\left(t\right)-a_i\left(t\right)]$. Hence, orphan tangles can be further hindered by adjusting the factors of $H\left(q\right)$. Then, we can determine the range of $F_t$ based on the obtained ${\beta }_i^{*}$ value and the threshold of the transaction approval rate in order to control the transaction rate.

Figure 6. $H\left(q\right)$ (decay rate of $P(X>{\beta }_i)$); to simplify the expression, we use diff for $a_i\left(t\right)·H-[r_i\left(t\right)-a_i\left(t\right)]$.

In [24], Serguei Popov et al. proposed the adaptive PoW algorithm to control the transaction rate. However, the adaptive PoW is linked to the mana of nodes, which can lead to some unfairness. In this paper, we ran the optimized transaction rate control algorithm of our Tangless scheme and the adaptive PoW algorithm on a single node to prove the effectiveness of Tangless. Let $r_i\left(t\right)$ follow the Poisson distribution, and let its expected value be 90, with $a_i\left(t\right)$ as the rate of the IOTA system approving transactions within $[70,110]$. The other parameter settings are $d=1000$, $t=1000$ ms, $mana=0.1$, and $difficulty=10$ (i.e., basic difficulty).

The comparative analysis is carried out from two aspects. First, we compare some parameters of the adaptive PoW algorithm before and after cost optimization. Second, we compare some parameters of Algorithm 3 before and after cost optimization. Specifically, Figure 7 shows the difficulty contrast of adaptive PoW, while Figure 8 indicates the difficulty contrast of Algorithm 3. It can be seen that the change frequency of the adaptive PoW difficulty value decreases, while the change frequency of the difficulty value of our proposed algorithm increases. In addition, Figure 9 and Figure 10 express the contrast of the backlogs of ${\epsilon }_i\left(t\right)$ and $F_t$ before and after cost optimization, respectively. After cost optimization, ${\epsilon }_i\left(t\right)$ and $F_t$ obviously tend to be stable. Moreover, Figure 10 illustrates the optimal transaction approval rate. It can be observed that the range of this rate’s change is smaller than before optimization, indicating the role of Algorithm 3. Overall, the trend of the optimal transaction approval rate is consistent with the corresponding parameters. These results further prove that Tangless keeps the IOTA system stable while optimizing resource costs. Tangless can dynamically adjust the PoW difficulty depending on the change in transaction flow to match the actual network situation in the next time slot. In light of the above, our proposed Tangless scheme can be considered effective (see Figure 11).

Figure 7. Rate control without cost optimization.

Figure 8. Rate control of cost optimization.

Figure 9. Rate control without cost optimization.

Figure 10. Rate control of cost optimization.

Figure 11. Rate control of cost optimization.

7. Conclusions

In this paper, we develop a new optimization scheme called Tangless based on Lyapunov optimization theory. First, we design a computational optimization algorithm to reduce the expenditure costs of IOTA nodes. Next, we use large deviation theory to provide an optimized transaction rate control algorithm for eliminating orphan tangles that waste computational costs. Finally, we define and deduce the effective width of the tangle, which can help to monitor the total throughput and reduce the frequency of cost optimization, thereby avoiding unnecessary waste of resources. Tangless can lay a solid technical foundation for promising blockchain-based IoT applications. Our simulation results demonstrate the effectiveness of the proposed Tangless scheme.