![gridcoin.png](https://steemitimages.com/DQmWY2XiQBG2xVKJvFpgkWhse4vF2dtaXqiyn2dxpXkttwC/gridcoin.png)

I’ve been thinking recently about forking and network reliability of Gridcoin. Without too much politics, here is a simple math algorithm that should do the job and completely eliminate needs for master nodes. Moreover, it’s very simplistic approach but very effective one.
____

- Solve forking once for all.
- Provide much better reliability of network.
- Decentralize network even further.
- Protect potential intentional forking abuse.
- Full alternative for master nodes with simple and elegant approach.

____

- Assuming node is connected to N other nodes.
- Measure latency of each, multiply that by the factor of rejected blocks, assign that value as ‘a score’.
- Perform ranking of nodes based on score in descend order.

Network Level Routing.

- The one with score 1 (best latency, minimal rejected blocks ) get’s most of the traffic (30%)
- Grade two (score 2 from top) get’s 28%
- Grade three, get’s 25%
And so on…(proportionally, or logarithmic - even better  )
- The forking one will still get 0.1% just to check if it stopped forking and give it a chance to climb back.

## Once in 10 minutes, re-sort the list giving the new scores and priorities, based on results in previous 10 minutes.
<br>

What’s the point here, and how it solve forking?

Assuming node started to fork (or it’s just unreliable), it get’s to the bottom automatically, but still get’s some very small amount of traffic. Why? - Because we are testing if it got out of fork in the meantime. If it’s not forking, and performing well, it will climb up with ranking. The same applies to one that performs best, but for any reason starts to fork. It will automatically go down.

If the good node becomes bad, it gets to the bottom where it can’t cause trouble, but still being tested with very small amount of blocks, just to check if “the behavior is improved”.

No forking, Stable Network, Automated Testing and many more.

Self testing, self-healing system, that makes best possible reliability to all the users on it's own.
The algorithm is as simple as it could be. This would not only solve many problems, but would be also look nice in magazines ;)

Pseudo code:

```
t = Now + 10 minutes

While (1) {
1. Measuring rejected blocks and latency during t - 10 period per node.
2. Scoring
3. Ranking
4. Sorting
   while(NOW > t){
         5. P2P distribution according to proportion.
   }
}
```
Each t interval is not only using the best possible nodes and prevent forking, but also gathers the sample for generating next round of distribution.

<br>
Ranking factor could be simply calculated as 1/√score to generate distribution percentage that will match the Quality / Distribution ratio automatically and proportionally.

____

Looking forward for opinions. (Please think twice, sometimes very simple things could be answer to very complicated problems.)