eigen-trust 0.1.0

A library for managing trust in a distributed network with zero-knowledge features.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// Unwrap is allowed while testing
#![allow(clippy::unwrap_used)]

use eigen_trust::{
	network::{Network, NetworkConfig},
	peer::TransactionRating,
};
use rand::{thread_rng, Rng};

#[derive(Debug)]
struct Network16Config;
impl NetworkConfig for Network16Config {
	const DELTA: f64 = 0.0001;
	const MANAGER_PER_PEER: usize = 2;
	const MAX_ITERATIONS: usize = 1000;
	const PRE_TRUST_WEIGHT: f64 = 0.5;
	const SIZE: usize = 16;
}

#[test]
fn simulate_converging_16_peers() {
	let rng = &mut thread_rng();
	let num_peers: usize = Network16Config::SIZE;

	let mut pre_trust_scores = vec![0.0; num_peers];
	pre_trust_scores[0] = 0.25;
	pre_trust_scores[1] = 0.25;
	pre_trust_scores[2] = 0.25;
	pre_trust_scores[3] = 0.25;

	let mut network = Network::<Network16Config>::bootstrap(pre_trust_scores).unwrap();

	// Boost peer 5
	for i in 0..num_peers {
		network
			.mock_transaction(i, 5, TransactionRating::Positive)
			.unwrap();
	}

	network.converge(rng).unwrap();
	let global_trust_scores = network.get_global_trust_scores();
	println!("");
	println!(
		"Global trust scores after round 1: {:?}",
		global_trust_scores
	);

	// Boost peer 6
	for i in 0..num_peers {
		network
			.mock_transaction(i, 6, TransactionRating::Positive)
			.unwrap();
	}

	network.converge(rng).unwrap();
	let global_trust_scores = network.get_global_trust_scores();
	println!("");
	println!(
		"Global trust scores after round 2: {:?}",
		global_trust_scores
	);

	// Boost peer 7
	for i in 0..num_peers {
		network
			.mock_transaction(i, 7, TransactionRating::Positive)
			.unwrap();
	}

	network.converge(rng).unwrap();
	let global_trust_scores = network.get_global_trust_scores();
	println!("");
	println!(
		"Global trust scores after round 3: {:?}",
		global_trust_scores
	);
}

#[derive(Debug)]
struct Network256Config;
impl NetworkConfig for Network256Config {
	const DELTA: f64 = 0.0001;
	const MANAGER_PER_PEER: usize = 2;
	const MAX_ITERATIONS: usize = 5000;
	const PRE_TRUST_WEIGHT: f64 = 0.3;
	const SIZE: usize = 256;
}

#[test]
fn simulate_converging_256_peers() {
	let rng = &mut thread_rng();
	let num_peers: usize = Network256Config::SIZE;

	let num_pre_trusted_peers = 12;
	let defalt_score = 1. / num_pre_trusted_peers as f64;
	let mut pre_trust_scores = vec![0.0; num_peers];
	for i in 0..num_pre_trusted_peers {
		pre_trust_scores[i] = defalt_score;
	}

	let mut network = Network::<Network256Config>::bootstrap(pre_trust_scores).unwrap();

	// Boosting 5 random peers
	for cycle in 0..5 {
		let rnd_index: usize = rng.gen_range(num_pre_trusted_peers..num_peers);
		for i in 0..num_pre_trusted_peers {
			network
				.mock_transaction(i, rnd_index, TransactionRating::Positive)
				.unwrap();
		}

		println!("");
		println!("Boosting {} in cycle: {}", rnd_index, cycle);
		network.converge(rng).unwrap();
		let global_trust_scores = network.get_global_trust_scores();
		println!("{:?}", global_trust_scores);
	}
}