RE-BPFT: An Improved PBFT Consensus Algorithm for Consortium Blockchain Based on Node Credibility and ID3-Based Classification

Abstract

Practical Byzantine Fault Tolerance (PBFT) has been widely used in consortium blockchain systems; however, it suffers from performance degradation and susceptibility to Byzantine faults in complex environments. To overcome these limitations, this paper proposes RE-BPFT, an enhanced consensus algorithm that integrates a nuanced node credibility model considering direct interactions, indirect reputations, and historical behavior. Additionally, we adopt an optimized ID3 decision-tree method for node classification, dynamically identifying high-performing, trustworthy, ordinary, and malicious nodes based on real-time data. To address issues related to centralization risk in leader selection, we introduce a weighted random primary node election mechanism. We implemented a prototype of the RE-BPFT algorithm in Python and conducted extensive evaluations across diverse network scales and transaction scenarios. Experimental results indicate that RE-BPFT markedly reduces consensus latency and communication costs while achieving higher throughput and better scalability than classical PBFT, RBFT, and PPoR algorithms. Thus, RE-BPFT demonstrates significant advantages for large-scale and high-demand consortium blockchain use cases, particularly in areas like digital traceability and forensic data management. The insights gained from this study offer valuable improvements for ensuring node reliability, consensus performance, and overall system resilience.

1. Introduction

With blockchain technology maturing rapidly, consortium blockchains have emerged as a compelling hybrid solution, combining strengths from both public and private blockchain models [1]. They achieve decentralization, transparent data governance, and immutability while offering substantial benefits in privacy preservation, precise access control, and efficient resource sharing. Consequently, consortium blockchains are receiving increased attention across a diverse range of sectors.

This widespread adoption is evidenced by impactful real-world applications. For instance, in the realm of humanitarian aid, the United Nations World Food Programme’s “Building Blocks” project utilizes a consortium blockchain to securely and efficiently distribute cash assistance to refugees, significantly reducing transaction costs and enhancing transparency [2]. Similarly, driven by stringent regulations such as the U.S. Drug Supply Chain Security Act (DSCSA), the pharmaceutical industry has established consortia like MediLedger to ensure the traceability and verification of prescription drugs, combating counterfeiting and improving patient safety. In the energy sector, major players like Shell and BP have backed the VAKT platform, which leverages a consortium blockchain to streamline post-trade processing for physical energy commodities, increasing efficiency and reducing the risk of errors [3]. These examples highlight the technology’s growing role in financial institutions, governmental sectors, and academia [4].

At the heart of consortium blockchain functionality are consensus algorithms, which are essential for maintaining data consistency, system reliability, and overall security [5]. The choice and performance of these consensus mechanisms significantly impact the practical effectiveness of consortium blockchains, particularly in domains demanding high reliability, such as financial services, e-government platforms, and supply chain management systems [6]. Efficient and secure consensus processes directly influence operational continuity and user confidence.

Practical Byzantine Fault Tolerance (PBFT) has become a widely adopted consensus protocol for consortium blockchains due to its deterministic nature, rapid finality, low computational demands, and energy efficiency. PBFT ensures consensus and data verification through iterative interactions among known network nodes, making it particularly suitable for stable network environments [7]. However, the original PBFT protocol exhibits critical limitations. Firstly, as the network scales, PBFT suffers from exponential growth in message complexity and communication overhead, drastically increasing consensus latency and hindering performance in large-scale deployments. Secondly, PBFT inherently lacks an effective mechanism to dynamically evaluate and manage node credibility, making it vulnerable to malicious or underperforming nodes. This deficiency reduces proactive governance and node incentivization, compromising both performance and system security [8]. Lastly, the conventional PBFT employs a simplistic round-robin mechanism for selecting primary nodes, inadvertently causing primary node centralization risks. Prolonged dominance by a small subset of nodes can introduce security vulnerabilities and limit adaptive network management [9].

Considering these inherent limitations, there is a clear need to enhance the existing PBFT algorithm. Therefore, this study aims to tackle three crucial research questions:

• What kind of node reputation evaluation and classification mechanism can effectively and dynamically manage node behaviors, thus boosting overall system performance and security?
• How can the primary node selection process be refined to mitigate risks of centralization and enhance resilience against Byzantine failures?
• What methods can practically reduce communication complexity and consensus latency when applying PBFT algorithms in large-scale networks?

To overcome these limitations, we propose an enhanced consensus algorithm called RE-BPFT, which integrates a sophisticated node reputation evaluation framework. This model comprehensively captures multiple aspects of node behavior, including direct interactions, indirect feedback, and historical performance, and leverages the ID3 decision tree approach to dynamically classify nodes based on their reliability. Moreover, we introduce a reputation-based, weighted-random mechanism for electing primary nodes, significantly reducing centralization risks and improving fault tolerance.

The main contributions of our work can be summarized as follows:

• Development of a multi-faceted node reputation evaluation model enabling dynamic assessment and effective management of nodes.
• Application of an optimized ID3 decision tree algorithm for precise and automated node classification.
• Introduction of a novel weighted-random primary node election strategy to prevent centralization issues and enhance network robustness.
• Empirical validation through extensive experiments demonstrating RE-BPFT’s superior performance over traditional algorithms (PBFT, RBFT, and PPoR) in terms of reduced communication overhead, lower consensus latency, and increased throughput.

The remainder of this paper is structured as follows. In Section 2, we critically review existing literature related to consensus mechanisms and node reputation models. Section 3 elaborates on the design principles and implementation details of our proposed RE-BPFT algorithm, highlighting both the reputation evaluation framework and the node classification methodology. Section 4 presents comprehensive experimental results, thoroughly analyzing the performance of RE-BPFT under varying conditions. Finally, Section 5 summarizes our findings and outlines potential directions for future research.

2. Related Work and Background

2.1. Consortium Blockchain Technology Overview

Blockchain technology, first introduced by Nakamoto in 2008 to support Bitcoin transactions [10], has evolved substantially with innovations like Ethereum’s smart contracts. This evolution has propelled blockchain applications beyond financial services, reaching sectors such as healthcare, supply chains, the Internet of Things (IoT), and public transportation [11]. Although public blockchains excel in decentralization and transparency, challenges in scalability, data privacy, and regulatory compliance have driven greater interest in consortium blockchains [12]. These specialized networks limit participation to selected organizations and authorized nodes, thus offering enhanced security controls, better privacy measures, and improved operational efficiency.

In practice, consortium blockchains have already shown impressive capabilities across multiple industries. For instance, financial platforms such as R3’s Corda effectively streamline inter-bank transactions and asset exchanges, enhancing security and reducing operational friction [13]. In supply chain contexts, Hyperledger Fabric has significantly improved transparency and built stronger trust among participants, resulting in increased overall efficiency [14]. Within the IoT ecosystem, Le et al. introduced BIFF, a blockchain solution emphasizing data privacy and efficient IoT management [15]. Moreover, Trofimov et al. demonstrated the feasibility of a decentralized public transportation management system based on consortium blockchain technology, utilizing smart contracts for real-time vehicle status monitoring, thereby improving safety and operational effectiveness [16].

Consequently, given their distinct advantages in security, privacy, and regulatory compliance, consortium blockchains have emerged as pivotal for broadening blockchain technology adoption across diverse sectors.

2.2. PBFT Algorithm and Its Improvements

Practical Byzantine Fault Tolerance (PBFT) is a prominent consensus mechanism widely adopted in consortium blockchain environments due to its deterministic nature, quick finality, low computational overhead, and minimal energy consumption [17]. Despite these strengths, the original PBFT protocol faces critical issues, such as excessive communication complexity, limited scalability, inadequate evaluation of node reputation, and potential centralization stemming from simplistic leader rotation schemes. In response to these shortcomings, researchers have proposed various enhancements to PBFT in recent literature. To clearly illustrate the differences among these improvements, a detailed comparative analysis is presented in

Table 1. Analysis of PBFT algorithms and their improvements.

Reference	Algorithm Name	Main Improvement	Advantages	Disadvantages
Ren et al. [18]	Node Role Division PBFT	Division of nodes into specific roles	Clear role assignment and improved efficiency	Complex role management
Liu et al. [19]	Grouping and Credit PBFT	Node grouping and credit grading	Efficient consensus and reduced overhead	Difficulty in accurate initial grouping
Hussain et al. [20]	Trust-based Leader Selection PBFT	Leader selection based on node trust	Reduced leader centralization risk, enhanced fault tolerance	Dependence on trust evaluation accuracy
Gao et al. [21]	PBFT for Microgrid	Optimized PBFT consensus for electricity transactions	High efficiency, secure energy transactions	Limited to energy transaction scenarios
Chen et al. [22]	Large-Scale Consortium PBFT	Improved scalability for large-scale networks	Better scalability, reduced latency	Higher complexity in node management
Hussain et al. [23]	Reputation-Voting PBFT	Reputation-based leader selection with voting mechanism	Enhanced fairness and robustness	Complex reputation voting processes
Xu et al. [24]	Vague Sets PBFT	Integration of vague sets theory	Improved robustness under uncertainty	Increased computational complexity
Abishu et al. [25]	Proof of Power Reputation (PPoR)	Reputation and power-based node selection for V2V energy trading	Efficient consensus, reduced latency, fair node selection mechanism	Complexity in reputation evaluation

.

This table clearly outlines the main innovations and corresponding advantages and disadvantages of each improved PBFT algorithm variant, providing a structured basis for the further development proposed by this research.

2.3. ID3 Decision Tree Algorithm

The ID3 (Iterative Dichotomiser 3) algorithm, proposed by Quinlan, is a widely used supervised learning approach for classification and decision-making tasks [26]. The algorithm constructs decision trees using a top-down, greedy strategy based on information entropy and information gain. It recursively partitions the dataset by selecting attributes that maximize information gain, thereby effectively minimizing decision tree complexity and enabling efficient classification. Two key metrics underpin the ID3 algorithm: information entropy and information gain. Information entropy quantifies uncertainty in a dataset and is mathematically defined as follows:

$$Entropy \left(D\right)=-\sum _{i=1}^m{p}_i\times {\log }_2{p}_i$$

(1)

where $D$ represents the dataset, $m$ indicates the number of distinct classes, and $p_i$ denotes the probability of class $i$ within dataset $D$.

Information gain measures entropy reduction following dataset partitioning based on an attribute $A$, expressed as

$$\mathrm{Gain}\left(D,A\right)=\mathrm{Entropy}\left(D\right)-\sum _{v\in \mathrm{Values}\left(A\right)}{\displaystyle \frac{\left|D_v\right|}{\left|D\right|}}\times \mathrm{Entropy}\left(D_v\right)$$

(2)

Here, $Values(A)$ is the set of all possible values for attribute $A$, and $D_v$ denotes the subset of dataset $D$ where attribute $A$ equals value $v$.

The ID3 algorithm exhibits several advantages, such as simplicity, interpretability, and ease of implementation, making it widely applicable in practical classification scenarios. However, it also presents limitations, including susceptibility to overfitting, especially with limited datasets having numerous attributes; necessity for discretization of continuous data; and sensitivity to noisy data, potentially reducing classification accuracy.

Due to its interpretability and efficiency, the ID3 algorithm is increasingly integrated into blockchain consensus frameworks. Particularly in consortium blockchain systems, ID3 has been effectively utilized for dynamic node reputation assessment and precise node classification, contributing significantly to enhancing consensus reliability and automation [27].

3. Improved RE-BPFT Blockchain Consensus Algorithm

3.1. Node Credit Calculation

The node credit evaluation metrics designed in this paper are divided into three categories: direct credit value, indirect credit value, and historical credit value. The direct credit value is related to the node’s voting behavior and consensus completion status; the indirect credit value is related to the node’s status in various groups and its credit ranking; while the historical credit value is related to the node’s accumulated credit value.

Definition 1.

Consensus credit $C_{con}$. Used to evaluate the degree of consensus completion by a node. The consensus credit $i$ of node $Cco{n}_i$ is calculated by the following formula:

$$C_{{\mathrm{con}}_i}={\displaystyle \frac{Nu{m}_{c_i}}{TNu{m}_{c_i}+\epsilon }}$$

(3)

Here,$Nu{m}_{c_i}$denotes how many times node $i$ has successfully reached consensus, while $TNu{m}_{c_i}$represents the total consensus rounds in which node $i$ participated. The parameter $\epsilon$ Varepsilon ε is introduced as an infinitesimally small positive value to avoid division by zero. The capability of nodes to successfully achieve consensus serves as the primary criterion for evaluating node reliability. Consequently, successful consensus participation significantly affects the node’s credibility assessment, being assigned the greatest importance among evaluation metrics. Simply put, nodes gain higher credibility scores as they achieve consensus successfully more frequently. This mechanism allows nodes within the master node group to sustain their positions over extended periods while simultaneously motivating nodes in the consensus group to enhance their performance and seek advancement to the master node group, thus enabling their participation in subsequent master node elections.

Definition 2.

Voting credit $C_{vot}$. This metric evaluates how effectively a node completes voting tasks. The voting credit $C_{vo{t}_i}$ for node $i$ is computed using the formula below:

$$C_{{\mathrm{vot}}_i}={\displaystyle \frac{Nu{m}_{v_i}}{TNu{m}_{v_i}+\epsilon }}$$

(4)

Here, $Nu{m}_{v_i}$ indicates the count of successful voting completions by node $i$, while $TNu{m}_{v_i}$ represents the total voting rounds node $i$ participated in. Notably, a higher number of successful voting completions results in a greater voting credit score. Such a credit mechanism effectively motivates nodes in the consensus group to proactively engage in voting, thereby boosting their credibility and creating opportunities to advance into the master node group. Similarly, observer nodes can also leverage active participation in voting processes to join the consensus group, gaining enhanced privileges within the network.

Definition 3.

Direct credit value $C_{dir}$. This metric assesses the behavioral performance of a node during the consensus activities. Specifically, the primary actions influencing this evaluation are the node’s participation in achieving consensus and engaging in voting procedures. Thus, the direct credit value of a node is obtained by calculating a weighted combination of its consensus credit and voting credit scores. The direct credit value $C_{di{r}_i}$for node $i$ is formulated as follows:

$$C_{{\mathrm{dir}}_i}=\lambda \times C_{{\mathrm{con}}_i}+\mu \times C_{{\mathrm{vot}}_i}$$

(5)

where $\lambda$ is the weight of consensus credit, $\mu$ is the weight of voting credit, which should be flexibly set according to system policies. These two weights satisfy $\lambda +\mu =1$.

Definition 4.

Activity credit $C_{act}$. Used to calculate the activity level of node $i$ during the consensus process, assigning higher weights to recently participated behaviors. It combines the node’s performance across different rounds with a time decay factor through weighted averaging to compute the node’s activity credit. The activity credit $C_{ac{t}_i}$ of node $i$ is calculated by the following formula:

$$C_{{\mathrm{act}}_i}={\displaystyle \frac{{\displaystyle \sum _{r=1}^R\left[\gamma \times G{M}_i(r)+(1-\gamma )\times G{C}_i(r)\right]}\times e^{-\lambda (R-r)}}{{\displaystyle \sum _{r=1}^R{e}^{-\lambda (R-r)}}}}$$

(6)

Here, $R$ represents the total number of consensus rounds the current system is in, $r$ denotes the index from historical round 1 to round $R$. $GMi(r)$ indicates whether node $i$ serves as the primary node in round $r$ (1 if yes, 0 otherwise); $G{C}_i(r)$ shows whether node $i$ is a consensus node in round $r$ (1 if yes, 0 otherwise). $\gamma$ represents the weight coefficient for the primary node’s participation, reflecting its importance in consensus, with a value range of (0.5, 1). $e^{-\lambda (R-r)}$ is the time decay factor, which attenuates participation behavior in round $r$, giving higher weight to recent actions.

Definition 5.

Incentive credit value $C_{inc}$. The incentive credit evaluation aims to motivate low-credit nodes to work actively, hence it correlates with node credit rankings. The incentive credit value $C_{in{c}_i}$of node $i$ is calculated by the following formula:

$$C_{{\mathrm{inc}}_i}=C_{\min }+(C_{\max }-C_{\min })\times \left(1-e^{-a\times {\displaystyle \frac{C_{{\mathrm{rank}}_i}-1}{n-1}}}\right)$$

(7)

Here, $n$ is the total number of nodes currently participating in consensus, $C_{ran{k}_i}$ represents the ranking of node $i$, with a value range of $[1, n]$. $a$ is the exponential decay factor, controlling the rate of incentive reduction. The parameter $a$ can be adjusted based on the total number of nodes, system volatility, or the desired incentive curve. This formula ensures excellent boundary controllability. Specifically, when node $i$ ranks first in credit ($C_{ran{k}_i}=1$) in the current round, the exponential term becomes ${\mathrm{e}}^0=1$, resulting in $C_{in{c}_i}\to C_{min}$; when the node ranks last ($C_{ran{k}_i}=\mathrm{n}$), the exponential term approaches 0, leading to $C_{in{c}_i}\to C_{\max }$. Thus, the formula guarantees that the incentive value always stays within the preset interval and provides explicit control over boundary behaviors.

Definition 6.

Indirect credit value $C_{idir}$. The indirect credit value indirectly assesses a node’s behavior in consensus activities by rewarding nodes with consistent high performance over time and encouraging nodes with lower credit scores to enhance their involvement. This metric is calculated as a weighted combination of active credit and incentive credit values. Specifically, the indirect credit value $C_{idi{r}_i}$ of node $i$ is determined by the formula below:

$$C_{{\mathrm{idir}}_i}=\alpha \times C_{{\mathrm{act}}_i}+\beta \times C_{{\mathrm{inc}}_i}$$

(8)

In this formula, $\alpha$ denotes the weight assigned to active credit, and $\beta$ denotes the weight assigned to incentive credit, with the constraint that $\alpha +\beta =1$.

Definition 7.

Historical credit value $C_{his}$. The historical credit value measures the consistency and stability of a node’s long-term behavior, employing a moving average strategy. The indirect credit value $C_{hi{s}_{\mathrm{i}}}$ of node $i$ is calculated by the following formula:

$$C_{{\mathrm{his}}_i}={\displaystyle \frac{1}{T}}\times {\displaystyle \sum _{t=1}^T{C}_i^{(t)}}$$

(9)

where $C_i^{(t)}$ represents the comprehensive score in round $t$, and $T$ is the sliding window size.

Definition 8.

Comprehensive credit value $C$. The comprehensive credit value represents an integrated assessment of a node’s performance by considering direct, indirect, and historical behaviors. Its main purpose is to provide credit rewards to consistently reliable nodes while imposing credit deductions on nodes demonstrating malicious or detrimental actions. Specifically, this comprehensive metric combines direct credit, indirect credit, and historical credit values, each assigned distinct weights. The comprehensive credit value $C_{\mathrm{i}}$ for node $\mathrm{i}$ is calculated as follows:

$$C_i=\left\{\begin{array}{ll}{\beta }_1\times C_{{\mathrm{dir}}_i}+{\beta }_2\times C_{{\mathrm{idir}}_i}+{\beta }_3\times C_{{\mathrm{his}}_i},\hfill & Normal Node\hfill \\ {\displaystyle \frac{1}{2}}\times C_{{\mathrm{his}}_i},\hfill & Malicious Node\hfill \end{array}\right.$$

(10)

where ${\beta }_1$ controls the influence of a node’s immediate behavior in the comprehensive score, ${\beta }_2$ reflects the importance of trend-based participation behavior, ${\beta }_3$ measures the contribution ratio of long-term stability, and ${\beta }_1$, ${\beta }_2$, ${\beta }_3$ satisfies ${\beta }_1+{\beta }_2+{\beta }_3=1$. For example, in dynamic network environments that require higher participation, ${\beta }_1, {\beta }_2, {\beta }_3$ can be set to strengthen the selection priority of “immediate response” nodes, while in government scenarios emphasizing long-term trust and stability, the weight of ${\beta }_3$ can be increased.

Definition 9.

Credit value normalization. After calculating the comprehensive credit value, data normalization is applied to confine it within the range of $[0,1]$. The normalization result is

$${\widehat{C}}_i={\displaystyle \frac{C_i-{\min }_T(C)}{{\max }_T(C)-{\min }_T(C)+\epsilon }}$$

(11)

Here, $ma{x}_T (C)$ represents the maximum comprehensive credit value of nodes in each consensus round, $mi{n}_T (C)$ represents the minimum comprehensive credit value, and $\epsilon$ is a tiny constant to prevent division by zero.

Typically, by dynamically adjusting the values of $\lambda , \mu , \alpha , \beta$ and $\eta$, the direct credit value, indirect credit value, and historical credit value can be regulated. Additionally, it must be noted that each weight must satisfy $\lambda +\mu +\alpha +\beta +\eta =1$ and $\lambda +\mu >\alpha +\beta$, where $\lambda$ is the maximum weight. The explanation of each credit evaluation index is shown in

Table 2. Node credit evaluation—primary and secondary indicators.

Node Type	Primary Indicator	Symbol	Weight	Secondary Indicator	Symbol	Weight	Description
Excellent Node, Good Node, Ordinary Node	Direct Credit Value	$C_{dir}$	$\lambda +\mu$	Consensus Credit	$C_{con}$	$\lambda$	Measures a node’s ability to successfully complete consensus processes, reflecting its core contribution.
				Voting Credit	$C_{vot}$	$\mu$	Evaluates a node’s active participation in voting processes, rewarding successful voting behavior.
	Indirect Credit Value	$C_{idir}$	$\alpha +\beta$	Activity Credit	$C_{act}$	$\alpha$	Assesses the node’s engagement by counting participations as master or consensus node, weighted by recent activity.
				Incentive Credit	$C_{inc}$	$\beta$	Provides additional rewards based on node credit rankings to stimulate low-credit nodes to perform better.
	Historical Credit Value	$C_{his}$	$\eta$	-	-	-	Reflects the node’s long-term behavioral stability by applying a moving average across T consensus rounds.
Malicious Node	Historical Credit Value	${\displaystyle \frac{1}{2}}\times C_{his}$	-	-	-	-	Reduces the historical credit score by half for nodes identified as malicious, penalizing improper behavior.

and

Table 3. Node Credit Evaluation—Secondary and Tertiary Indicators.

Secondary Indicator	Tertiary Indicator	Symbol	Weight	Description
Consensus Credit	Number of successful consensus rounds	$Nu{m}_{C_i}$	-	Successful completion count; more completions enhance the node’s consensus credit
	Total number of consensus rounds	$TNu{m}_{C_i}$	-	Total times participated in consensus rounds for normalization
Voting Credit	Number of successful voting rounds	$Nu{m}_{V_i}$	-	Count of successful voting rounds completed by the node
	Total number of voting rounds	$TNu{m}_{V_i}$	-	Total voting participations for normalization
Active Credit	Number of master node participation	$GMi(r)$	$\gamma$	Times the node acted as a master node, with higher weight
	Number of consensus node participations	$G{C}_i(r)$	$1-\gamma$	Times the node was a consensus node, with lower weight
Incentive Credit	Credit Ranking	$Cra{n}_{k_i}$	-	Node’s current ranking position among all nodes
	Number of nodes	$n$	-	Total number of nodes participating in consensus

.

3.2. Node Classification

Decision trees exhibit strong interpretability, adaptability, automatic feature selection, robustness, and computational efficiency in machine learning, making them well-suited for node classification tasks within consortium blockchain environments. Among various decision tree algorithms, the ID3 algorithm is commonly employed for solving classification problems in machine learning and data mining. It builds decision trees by recursively choosing optimal features to divide datasets. Central to the ID3 algorithm is its use of information gain, derived from entropy—a measure of uncertainty in datasets—as the primary feature-selection criterion. By continuously choosing features that maximize information gain, the algorithm quickly reduces the uncertainty within the data.

Incorporating the ID3 decision tree algorithm into node classification processes for consortium blockchain consensus significantly enhances model interpretability. The algorithm clearly visualizes decision-making rules, facilitating the transparency and explainability of the classification process, which is especially beneficial in consortium blockchain applications that require traceability. Furthermore, ID3 efficiently manages discrete feature sets, which commonly appear in consortium blockchain consensus systems. It can also handle datasets containing missing values, thereby enabling effective classification despite incomplete node information. Finally, the algorithm’s low computational overhead and rapid execution capabilities make ID3 particularly advantageous for classifying nodes in consortium blockchain consensus scenarios.

Thus, the ID3 decision tree algorithm possesses distinct advantages over alternative node classification approaches employed in blockchain consensus algorithms. Unlike the K-Nearest Neighbors (KNN) method, ID3 effectively processes discrete attributes and generates decision trees with superior interpretability. In comparison to Support Vector Machines (SVM), ID3 has significantly lower computational demands, while SVM necessitates complicated parameter adjustments and kernel function selections. Additionally, compared with neural network methods, ID3 does not require extensive training datasets or iterative training cycles, making it easier to deploy and more intuitive to interpret. Utilizing the ID3 decision tree algorithm for node classification in consortium blockchain consensus systems offers substantial benefits, including excellent interpretability, efficient handling of discrete features and missing data, and rapid computational performance. These advantages contribute positively to the security and reliability of consensus mechanisms.

Within the enhanced RE-PBFT consensus approach, this paper integrates a decision tree-based classification algorithm. After every consensus round, nodes are categorized into “excellent”, “good”, “average”, or “malicious” classes according to their comprehensive credit values. Initially, the consortium blockchain aggregates and organizes node attribute information. Subsequently, a primary node election is conducted via a view-change mechanism, concurrently validating nodes throughout this process. Finally, nodes exhibiting problematic behaviors are identified and removed. Excluded Byzantine nodes lose their eligibility to participate in subsequent consensus rounds, and their readmission requires explicit approval from consortium blockchain administrators. To further improve node classification discrimination and reinforce security control in dynamic consortium blockchain environments, this research systematically refines the information entropy and information gain calculations inherent in the traditional ID3 algorithm. The detailed implementation process is presented in Algorithm 1.

Algorithm 1: ID3 Decision Tree-Based Consortium Blockchain Node Classification Algorithm

$\mathrm{Input}: \mathrm{Node} \mathrm{set} D=\{d1 ,d2 ,\dots ,dn \}$$, \mathrm{Information} \mathrm{gain} \mathrm{threshold} T_{ig}$$, \mathrm{Initial} \mathrm{reputation} \mathrm{value} C_{init}$  Output: Classified node sets: Excellent node set $D_{excellent}$, Good node set $D_{good}$, Normal node set $D_{ordinary}$, Malicious node set $D_{Malicious}$

1. Initialize node attribute sets: Reputation score $Credi{t}_i$, Continuous consensus count $Consecutiv{e}_i$, Downtime countDowntime $Downtim{e}_i$, Communication error count $Erro{r}_i$, Node activity level $Activit{y}_i$

2. Create decision tree training dataset $Dataset\leftarrow \varnothing$

3. for each node $d_i\in D$ do

4.     Calculate node $d_i$$’\mathrm{s} \mathrm{reputation} \mathrm{score} Credi{t}_i$, continuous consensus count $Consecutiv{e}_i$, downtime count $Downtim{e}_i$, communication error count $Erro{r}_i$, activity level $Activit{y}_i$

5.     Extract node features and add to $Dataset$

6. end for

7. Calculate information entropy $IE(S)$ of each attribute based on dataset $Dataset$

8. Calculate information gain $IG(S,T)$ of each attribute according to formula

9. if maximum information gain $I{G}_{max}\ge T_{ig}$ then

10. Partition dataset using attribute with maximum information gain to construct decision tree

11. Predict the category of each node based on the decision tree model

12.     if the node category is ‘Excellent’ then

13.         add the node to $D_{excellent}$

14.     else if the node category is ‘Good’ then

15.         add the node to $D_{good}$

16.     else if the node category is ‘Average’ then

17.         add the node to $D_{ordinary}$

18.     else

19.         add the node to $D_{Malicious}$

20.     end if

21. else

22.     Output warning: “Unable to effectively classify, insufficient information gain”

23. end if

24. Return the classified node set $(D_{excellent} ,D_{good} ,D_{ordinary },D_{Malicious} )$

The decision tree construction process begins by calculating the information entropy, which measures the uniformity of sample categorization within a dataset. Suppose the probabilities that samples in the current training set belong to the categories of excellent, good, ordinary, and malicious nodes are denoted as P1, P2, P3, and P4, respectively; the entropy of category information derived from the training dataset is expressed as shown in Formula (12).

$$IE(S)=-{\displaystyle \sum _{i=1}^n(w_i\times P_i+ϵ){\log }_2(w_i\times P_i+ϵ)}$$

(12)

Here, $n$ represents the number of categories, $w_i$ denotes the importance weight of the i-th category node in the system, and $\sum w_i =1$. $ϵ$ is a smoothing factor to prevent $\log 0$, typically set to $ϵ={10}^{-6}$. The introduction of category weight $w_i$ and smoothing factor $ϵ$ addresses the imbalance in information entropy calculation under scenarios like rare malicious nodes, thereby enhancing the sensitivity of malicious node identification.

Next, the algorithm calculates the information gain, reflecting how much uncertainty in the data is reduced. Within the training dataset, an attribute feature vector $T$ is selected to divide the sample set. The chosen attribute vector $T$ includes five distinct features: the node’s comprehensive credit score, number of consecutive consensus attempts, number of downtime events, number of faulty communication occurrences, and the overall activity level of the node. The method for computing the information gain obtained from splitting the sample set $S$ based on attribute feature vector $T$ is illustrated in Formula (13).

$$IG(S,T)=I{E}^{\prime }(S)-{\displaystyle \sum _{v=1}^m\frac{\left|S_v\right|}{\left|S\right|}}I{E}^{\prime }(S_v)-\alpha \times {\displaystyle \frac{\left|T_v\right|}{\left|T\right|}}$$

(13)

Here, $S$ represents the current sample set, $S_v$ denotes the subset corresponding to the $v$-th value of attribute $T$, and $\left|S_v\right|$ and $\left|S\right|$ are the sample counts of the subset and the full set, respectively. Information gain measures the change in uncertainty of the sample set before and after attribute partitioning. To avoid bias toward multi-value attributes, this paper introduces a structural penalty term in the information gain calculation, enhancing the algorithm’s robustness in handling high-dimensional discrete features.

3.3. Consensus Protocol

RE-PBFT retains all phases of PBFT while eliminating communication between network nodes, thereby reducing bandwidth usage. The algorithm selects normal or higher-tier nodes as consensus participants to ensure system reliability and security. The consensus protocol flow is illustrated in Figure 1.

In the request phase, client $C$ sends a consensus request message $<REQUEST,M,t,CID,Sig{n}_C>$ to the current primary node $PN$. The message includes the pending state machine operation $M$, current timestamp $t$, and client identifier $CID$. After validating the request, the primary node proceeds to the next phase.

In the pre-prepare phase, the primary node assigns a unique sequence number $N$ to the client request and computes its digest $DIGEST=Hash(M)$. Simultaneously, it calculates a credit value $CREDI{T}_{PN}$ based on the node reputation scoring model, then generates a hash: $OUTCOME=Hash(CREDI{T}_{PN})$. The primary node then constructs and broadcasts a pre-prepare message to all consensus nodes: $<PRE-PREPARE,V,N,DIGEST,OUTCOME,CREDI{T}_{PN},M>$, where $V$ is the current view number and $M$ contains the client request. Recording OUTCOME enables traceability and consistency verification of consensus behavior in subsequent phases.

During the preparation phase, after receiving the pre-prepare message from the primary node, the consensus nodes first verify the integrity and consistency of the message, including the view number, digest, reputation score, etc. If the verification passes, the consensus node generates a prepare message and broadcasts it to other consensus nodes. The message format is $<PREPARE,V,N,DIGEST,i,CREDI{T}_{i }>$, where $i$ is the identifier of the sending consensus node, and ${\mathrm{CREDIT}}_i$ is its current reputation score. After receiving the PREPARE messages from other consensus nodes, if the number of valid PREPARE messages exceeds $2f$ (where $f$ is the maximum number of Byzantine nodes tolerated by the system), the primary node considers the preparation phase successful and proceeds to the commit phase. If the number is insufficient, the primary node triggers the View Change protocol, transferring its authority to the newly elected node with the highest reputation, and broadcasts a failure message: $<VIEW-CHANGE,V+1,reason>$. The original primary node is then demoted to a regular node, losing its leadership in subsequent consensus rounds.

During the commit phase, after the preparation phase is completed, the primary node performs a consistency check on all received prepare messages. If all messages are consistent, it generates a commit message and broadcasts: $<COMMIT,V,N,DIGEST,CONFIRM>$. Upon receiving the COMMIT message, the consensus nodes perform final confirmation and submit the new block generated by the request to their local ledger. Subsequently, the primary node sends the transaction processing result to the client, indicating the completion of the current consensus round. If more than $f$ consensus nodes submit prepare messages inconsistent with the primary node during this phase, the system determines that consensus has not been reached and triggers the demotion and penalty mechanism:

(1)

All consensus nodes with inconsistencies will have their reputation scores deducted;

(2)

If the number of dissenting nodes $\ge f+1$ the current primary node will also be demoted, and the consensus process will be restarted.

3.4. View Change Protocol

To ensure system continuity and consistency when primary node $PN$ fails, this paper designs a view change protocol incorporating a reputation scoring mechanism. The view change process is triggered when any of the following abnormal conditions occurs in the primary node:

(1)

Fails to receive at least $2f+1$ valid PREPARE messages within timeout period $T_1$;

(2)

Fails to successfully package and broadcast new block $(T_2>T_1)$ within maximum tolerance time $T_2$.

To prevent Byzantine primary nodes from repeatedly disrupting consensus, the system adopts a reputation-weighted primary node election strategy during view changes. Specifically, the system selects highly reputable and active nodes from the “excellent node set” excel as candidate primary nodes. The new primary node election no longer uses simple modulo rotation logic but introduces weighted randomness to prevent “oligarch nodes” from dominating the system long-term. The improved primary node selection formula is as follows:

$$prim=argma{x}_{i\in excel}\left(credi{t}_i\cdot ran{d}_i\right)$$

(14)

where credit $i$ represents the current reputation score of candidate node $i$, and $ran{d}_i\in (0,1)$ is a pseudo-random factor generated based on system seed. This strategy introduces a degree of randomness while maintaining reputation priority, effectively mitigating the issue of high-reputation nodes monopolizing the primary node role. The detailed algorithm is presented in Algorithm 2.

Algorithm 2: Consensus Protocol Algorithm

Input: Client request message $msg$, view number $v$, node set $N$, system fault tolerance node count $f$ Output: Client response result, node ledger update

1. The client sends a consensus request $msg$ (containing operation, timestamp, client identifier) to the primary node $PN$ //Client request phase

2. The primary node $PN$ assigns a number to $msg$ and calculates the digest $d\leftarrow Digest(msg)$

3. Calculate the primary node’s reputation value $credi{t}_{PN}$ and generate the hash digest $OUTCOME\leftarrow Hash(credi{t}_{PN}\times ran{d}_{PN})$

4. Construct the pre-prepare message $M_{preprepare}\leftarrow (v,d,msg,OUTCOME)$

5. $PN$ broadcasts $M_{preprepare}$ to all consensus nodes

6. for each consensus node $n_i\in N$ do//Consensus node preparation phase

7.    $\mathrm{Verify} M_{preprepare}$ (validate $v$, $d$$, OUTCOME$)

8.     if verification passes then

9.       Calculate local reputation value $credi{t}_i$$, \mathrm{construct} M_{prepare}\leftarrow (v,d,OUTCOME,credi{t}_i)$

10.    $\mathrm{Broadcast} M_{prepare}$ to other consensus nodes

11.    end if

12. end for

13. $\mathrm{Master} \mathrm{node} PN$$\mathrm{collects} M_{prepare}$$\mathrm{message} \mathrm{set} S_{prepare}$ Master node collects prepare messages

14. If $\left|S_{prepare}\right|\ge 2f+1$ then

15.    $\mathbf{if} \mathrm{all} M_{prepare}$ contents are consistent then

16.        $\mathrm{Construct} \mathrm{confirmation} \mathrm{message} M_{commit}\leftarrow (v,d)$

17.       $PN$$\mathrm{broadcasts} M_{commit}$ to consensus nodes

18.   else

19.          $\mathrm{Mark} \mathrm{conflicting} \mathrm{nodes} \mathrm{and} \mathrm{execute} \mathrm{penalty} credi{t}_i\downarrow$

20.        $\mathbf{if} \mathrm{number} \mathrm{of} \mathrm{dissenting} \mathrm{nodes} \ge f+1$ then

21.              $PN$ is demoted; triggers view change

22.         end if

23.    end if

24. else

25.   $\mathrm{Insufficient} \mathrm{preparation} \mathrm{messages}, PN$ was demoted, triggering view change

26.     $\mathrm{Elect} \mathrm{new} \mathrm{primary} \mathrm{node} \mathrm{from} \mathrm{excellent} \mathrm{nodes} \mathrm{based} \mathrm{on} credit\times rand$

27. end if

28. for $\mathrm{each} \mathrm{consensus} \mathrm{node} n_i\in N$ do//Block commit phase

29.   $\mathbf{if} \mathrm{received} \mathrm{valid} \mathrm{and} \mathrm{consistent} M_{commit}$ then

30.           Commit new block to local ledger

31.   end if

32. end for

33. $\mathrm{Primary} \mathrm{node} PN$ returns transaction processing result to client, ending consensus process//Client feedback phase

4. Experimental Verification and Analysis

To evaluate the performance of the proposed improved RE-PBFT consensus algorithm, a consortium blockchain system was constructed and simulated using Python 3.9 on a computer equipped with an Intel Core i5-10400 processor, 16 GB RAM, and Windows 10 operating system. The experiment compared RE-PBFT against classical PBFT [17], RBFT [28], and PPoR [29] across three key performance metrics: communication overhead, system throughput, and transaction latency. To reflect realistic transaction behaviors in large-scale consortium blockchain applications, particularly traceability scenarios, the experiment simulated transaction data across multiple business phases. Scalability tests were conducted by increasing the number of nodes in the system from 10 to 60. All nodes were initially assigned a trust value of 70. After system startup, clients submitted a total of 200 transaction request sets to the network. Each experimental configuration was repeated 20 times, and the average results were recorded as the final performance data. Detailed hardware and software experimental settings are provided in

Table 4. Experiment configuration.

Experimental Setup	Configuration
Operating System	Windows 10 64-bit Professional Edition
Experimental Platform	Python 3.9
Processor	Intel (R) Core (TM) i5-10400
Memory	16 GB RAM
Number of Nodes	10–60 nodes
Network Model	Local area network simulating network latency

.

In this experiment, the system’s throughput was determined by counting the transactions successfully completed. The metric “transactions per second” (TPS) was used to quantify throughput performance. By gradually increasing concurrent transaction volumes and recording the number of transactions processed successfully per unit of time, the system’s overall throughput was measured. Transaction latency was assessed by logging the interval between transaction initiation and final execution confirmation. Various transaction concurrency scenarios were simulated, and the execution time for each transaction was captured, enabling the calculation of average transaction latency. To examine the communication overhead, we recorded the number and size of messages exchanged between nodes during the consensus process. Node communications were monitored throughout the experiment, with message counts logged and analyzed, providing insight into the communication overhead incurred by the system.

4.1. Consensus Latency

Consensus Latency (CL) is a critical performance metric for consensus mechanisms, typically representing the time required for a blockchain network to confirm a transaction after its initiation. A lower CL indicates higher consensus efficiency in a blockchain system. We define the period from the selection of consensus nodes to the completion of transaction confirmation as $CL$. The calculation formula for $CL$ is as follows:

$$CL=T_{\mathrm{c}}-T_r$$

(15)

Here, $T_c$ denotes confirmation time, and $T_r$ represents initiation time. To comprehensively evaluate the CL of different consensus mechanisms, we measured the CL under varying node counts with transaction sizes of 1, 10, 50, and 100 KB. For clearer experimental presentation, single transactions of different sizes were used to measure CL. Figure 2 displays the CL of PBFT, RBFT, and PPoR under different experimental conditions. When the number of consensus nodes and transaction size were identical, RE-PBFT demonstrated significantly lower latency than PBFT and RBFT, outperforming PPoR as well. As shown in Figure 2, while the node count increased from 10 to 60, RE-PBFT consistently maintained a low latency level, whereas PBFT’s Consensus Latency (CL) rose sharply with the growing number of nodes. The graph reveals that when the network node count exceeded 30, both PBFT and RBFT exhibited notable upward trends in CL, while RE-PBFT’s CL increased more gradually, showing relative stability and stronger scalability. For instance, with a transaction size of 100 KB and 60 nodes, PBFT’s CL reached 164.2 ms, whereas RE-PBFT’s CL was only 71.6 ms—a reduction of approximately 56.4%, highlighting its exceptional latency control capability. Moreover, as transaction size grew from 1 KB to 100 KB, PBFT’s CL increased significantly, while RE-PBFT consistently maintained the lowest latency across all transaction sizes, demonstrating superior handling capacity for large transactions. In conclusion, RE-PBFT efficiently achieves consensus even in complex environments with numerous nodes and large transaction data, proving its superior latency performance and scalability in large-scale blockchain systems.

Figure 3 shows the box plot of consensus latency obtained from 20 independent experiments conducted by four consensus algorithms in a consortium blockchain scenario with a transaction size of 100 KB and node counts ranging from 10 to 60. As observed, the latency of the PBFT algorithm increases most significantly with the growth of node count, exhibiting a wide distribution range and certain volatility. RBFT shows improvement over PBFT in terms of overall latency and volatility but still demonstrates some instability. The PPoR algorithm maintains good stability and low latency under most node scales. The proposed RE-PBFT algorithm achieves the lowest mean latency and smallest fluctuation range across all node scales, demonstrating superior consensus efficiency and stability. Overall, RE-PBFT exhibits stronger performance robustness and scalability compared with other algorithms when handling large-scale transaction loads and node growth.

4.2. Throughput Testing

A series of comparative experiments was conducted to evaluate the throughput performance of RE-PBFT against the traditional PBFT, RBFT, and PPoR algorithms, considering different node scales. Throughput, defined as the number of consensus requests a system can handle within a specific timeframe, indicates the processing capability of the consensus algorithm and overall system capacity. Higher throughput suggests greater efficiency in handling requests or transactions. In these tests, node counts in the consortium blockchain were incrementally raised from 10 to 60. For each scenario, the average throughput of all four algorithms was collected and analyzed.

Figure 4 illustrates the throughput variations of PBFT, RBFT, PPoR, and the proposed RE-PBFT as the number of nodes in the network increases. The x-axis values in Figure 4 represent the number of network nodes, while the y-axis values denote the network throughput. The results indicate that under identical experimental conditions, RE-PBFT demonstrates overall superior throughput compared with the other three algorithms. With an initial node count of 10, RE-PBFT achieves a throughput of 850 TPS, slightly higher than PPoR (840 TPS) and significantly surpassing PBFT (820 TPS) and RBFT (830 TPS). As the number of nodes increases from 10 to 60, all algorithms exhibit a declining throughput trend, albeit with varying degrees of reduction. Among them, PBFT experiences the fastest throughput drop, decreasing from 820 to 300 TPS, making it the weakest performer. In contrast, RE-PBFT demonstrates strong stability throughout the node expansion process, with the smallest throughput decline, ultimately maintaining 380 TPS—slightly higher than PPoR (370 TPS) and notably superior to RBFT (320 TPS) and PBFT (300 TPS).

The experimental results demonstrate that RE-PBFT not only achieves higher throughput when fewer nodes are involved but also exhibits outstanding scalability as the number of nodes increases. These findings imply that the RE-PBFT algorithm offers superior concurrent processing and consensus efficiency, making it highly suitable for large-scale blockchain environments that require high throughput. The notable throughput improvements of RE-PBFT can be attributed primarily to the optimized reputation evaluation strategy, which reduces unnecessary message exchanges and improves verification efficiency. Additionally, simplifications within the enhanced consensus mechanism contribute to quicker consensus decisions, further elevating throughput performance.

4.3. Communication Overhead Testing

In terms of communication load, this section presents comparative experimental results for PBFT, RBFT, PPoR, and the proposed RE-PBFT algorithm. Through multiple experiments under varying operational scenarios, communication overhead was evaluated. By adjusting node numbers within the consortium blockchain, network traffic generated during the consensus process was measured. Communication overhead—the resource and cost expenditure associated with message transmissions and inter-node communications—was employed as a crucial indicator for consensus algorithm efficiency. A lower communication overhead indicates a more efficient consensus protocol, reducing network load and resource usage. Specifically, message counts transmitted throughout the algorithm execution were recorded and compared across the different consensus methods.

Figure 5 illustrates the trend of communication overhead changes for four consensus algorithms as the number of system nodes gradually increases. The x-axis represents the number of nodes in the network, while the y-axis denotes the communication overhead. Experimental results demonstrate that RE-PBFT consistently exhibits significantly lower communication overhead than other comparative algorithms across all node counts, reflecting higher communication efficiency. When the number of nodes is small (e.g., 10 or 20), the communication overhead differences among algorithms are minimal. However, as the node count increases, PBFT and RBFT show rapid upward trends in communication overhead, with PBFT displaying the most pronounced growth. At 60 nodes, PBFT’s communication overhead reaches 6480 instances, whereas RE-PBFT requires only 1880 instances—a reduction of approximately 70.99%. Similarly, RBFT and PPoR exhibit communication overheads of 4900 and 3550, respectively, at 60 nodes, compared with which RE-PBFT reduces communication load by 61.63% and 47.04%. These data indicate that RE-PBFT effectively decreases the frequency of message exchanges between nodes, significantly lowering system communication costs while maintaining consensus efficiency, with particularly notable advantages in large-scale network environments.

The improved communication efficiency observed in RE-PBFT largely arises from refinements to the underlying consensus protocol, reducing communication redundancy in practical operations. Minimizing communication load is essential for large-scale consortium blockchain deployments, as it alleviates network congestion, reduces bandwidth demands, and enhances overall resource efficiency. All experimental data verify RE-PBFT’s advantage in communication load performance. The reduced communication requirements make RE-PBFT especially suitable for applications emphasizing efficient network resource utilization.

Overall experimental outcomes highlight that RE-PBFT demonstrates strong adaptability and reliability, particularly in highly dynamic network conditions or in scenarios requiring stringent system reliability, such as traceability applications in large-scale consortium environments. The node credit assessment mechanism incorporated within RE-PBFT comprehensively integrates factors like node performance, consensus participation stability, and node behavior, dynamically reflecting node trustworthiness. Consequently, RE-PBFT adeptly accommodates frequent changes in node states and sustains efficient consensus operations in fluctuating network conditions. Furthermore, the introduced node credit evaluation framework and decision tree classification algorithm effectively mitigate risks associated with Byzantine nodes, significantly bolstering system reliability and security.

5. Conclusions

In this research, we introduced RE-PBFT, an enhanced consensus protocol designed with a sophisticated node credit assessment framework and an optimized decision-tree classification method. The algorithm dynamically evaluates node behaviors, accurately identifying and selecting trustworthy nodes to prevent Byzantine failures. This strategy significantly cuts down the number of messages and associated communication costs required to reach a consensus. Experimental results indicate that the proposed RE-PBFT method notably surpasses existing algorithms such as PBFT, RBFT, and PPoR, delivering substantial improvements in system throughput, reducing transaction latency, and decreasing communication overhead.

Although RE-PBFT exhibits strong resilience against Byzantine node behaviors, its capability to address other fault scenarios, such as crash faults or latency-related issues, remains limited. Therefore, future studies will explore additional strategies to handle diverse fault conditions, aiming to further enhance the robustness and fault tolerance of the system. Moreover, ongoing refinement of the proposed algorithm and its practical application across broader scenarios will be pursued to ensure more reliable and efficient distributed consensus.