Bootstrapping Protocol

Introduction:

Bootstrapping is a crucial step in the lifecycle of a node within a decentralized network. It ensures that a node, when joining the network for the first time or after a prolonged offline period, can quickly and securely synchronize with the current network state. This protocol helps maintain the network's overall health, ensures data integrity, and reduces the risk of malicious interference.

Math Formulas:

1. Probability of Choosing a Genuine Peer: If $P$ is the percentage of honest nodes in the network and $N$ is the number of nodes a new node contacts during bootstrapping, the probability $Pg$ of choosing at least one genuine peer is:

   $Pg=1−(1−P)N$

2. Data Redundancy Check: Let $R$ be the number of redundant copies of a piece of data that a node retrieves from the network. The probability $Pr$ that at least one of these copies is genuine, given $P$ percentage of honest nodes, is:

   $Pr=1−(1−P)R$

Code Example:

#include <iostream>
#include <vector>
#include <cmath>

double probabilityGenuinePeer(double P, int N) {
    return 1 - std::pow((1-P), N);
}

double dataRedundancyCheck(double P, int R) {
    return 1 - std::pow((1-P), R);
}

int main() {
    double P = 0.8;  // Assuming 80% of nodes in the network are honest
    int N = 5;       // Number of nodes contacted during bootstrapping
    int R = 3;       // Number of redundant copies retrieved

    double P_g = probabilityGenuinePeer(P, N);
    double P_r = dataRedundancyCheck(P, R);

    std::cout << "Probability of choosing at least one genuine peer: " << P_g * 100 << "%" << std::endl;
    std::cout << "Probability that at least one data copy is genuine: " << P_r * 100 << "%" << std::endl;

    return 0;
}

Parameters:

• Honest Nodes Percentage ( $P$ ): Represents the fraction of nodes in the network that are honest. This value is critical as it determines the security of the bootstrapping process.

• Nodes Contacted During Bootstrapping ( $N$ ): The number of initial nodes a newcomer contacts. Increasing this number typically increases the chances of contacting a genuine node.

• Redundant Copies Retrieved ( $R$ ): The number of copies of data a node retrieves to cross-check for consistency. Increasing this number can improve data integrity checks.

Optimization

1. Trusted Peer List

Introduction:

The Trusted Peer List is a powerful enhancement to the bootstrapping protocol. It serves as a curated list of reliable and genuine nodes that a new node can connect to during the bootstrapping process. Utilizing a Trusted Peer List helps mitigate risks associated with malicious or unreliable nodes and expedites the process of connecting to the network.

Math Formulas:

The reliability $Rt$ of using a Trusted Peer List, given $T$ as the number of trusted peers and $Pt$ as the probability of a trusted peer being genuine, is:

$Rt=1−(1−Pt)T$

Code Example:

double trustedPeerReliability(double P_t, int T) {
    return 1 - std::pow((1-P_t), T);
}

Parameters:

• Trusted Peers ( $T$ ): The number of peers in the Trusted Peer List.

• Genuine Probability of a Trusted Peer ( $Pt$ ): The likelihood that a peer on the Trusted Peer List is honest.

2. Parallel Retrieval

Introduction:

Parallel Retrieval is the process of obtaining data from multiple nodes simultaneously during the bootstrapping phase. This approach speeds up data synchronization and provides additional security by cross-verifying data from different sources.

Math Formulas:

The time savings $S$ achieved through parallel retrieval, given $D$ as the total data to retrieve and $N$ as the number of parallel retrievals, assuming uniform distribution of data, is:

$S=DN$

Code Example:

int totalData = 1000; // Example total data
int parallelRetrievals = 5;
int timeSaved = totalData / parallelRetrievals; // Time saved through parallel retrieval

Parameters:

• Total Data ( $D$ ): The amount of data to be retrieved.

• Parallel Retrievals ( $N$ ): The number of simultaneous data retrievals.

3. Periodic Updates

Introduction:

Periodic Updates are a continuous process of updating the node list and Trusted Peer List. Regular maintenance ensures that the list reflects the network's current state, eliminating outdated or malicious entries and incorporating new and reliable nodes.

Math Formulas:

Let $F$ be the frequency of updates, $Na$ be the number of active nodes, and $Ni$ be the number of inactive or malicious nodes. The effectiveness $E$ of periodic updates is:

$E=NaNa+Ni×F$

Code Example:

double periodicUpdateEffectiveness(int N_a, int N_i, double F) {
    return (double(N_a) / (N_a + N_i)) * F;
}

Parameters:

• Frequency of Updates ( $F$ ): How often the list of nodes is updated.

• Active Nodes ( $Na$ ): Number of active and reliable nodes.

• Inactive/Malicious Nodes ( $Ni$ ): Number of inactive or malicious nodes.