/*

validator centralization model

​

purpose

- test assumptions about mev auctions solving pool centralization due to mev extraction

​

description

- enter percentage starting allocations for staking pools on ethereum (poolStartingAllocations)

- set mev extraction efficiency for each pool (poolMevEfficiency, 1 = all possible mev extracted, 0 = no mev extracted)

- define whether you want to use mev auctions or not (useMevAuctions)

- define how much mev has been mitigated as a percentage (mevMitigated, 1 = no mev mitigated, 0.5 = half mev mitigated)

- iterates blocks over a 50 year period choosing block producers proportional to their stake

- adds staking rewards and mev per block:

    no mev auctions: the producer extracts mev at their own level of efficiency

    with mev auctions: the producer gets the winning bid, the extractor wins the difference between the mev they can extract and the nearest competitor bid

- assumes all rewards and mev are reinvested into staking

- select preset tests to run (test = 0,1,...)

​

author: Pmcgoohan

email: pmcgoohan9435@gmail.com

twitter: @pmcgoohanCrypto

*/

​

using System;

using System.Linq;

​

double[] poolStartingAllocations; // the percentage of the total staked eth for each pool

double[] poolMevEfficiency; // how efficient each pool is at extracting mev on their own (won't go much below 0.7 even for home stakers due to MEV extraction by GPA)

bool useMevAuctions; // use mev auctions or not

double mevMitigated; // percentage of mev mitigated (eg: by non-optional threshold encryption)

​

// parameters

poolStartingAllocations = new double[] { 0.3, 0.15, 0.14, 0.09, 0.06, 0.03, 0.23 }; // percentage of total staked eth owned by each pool

poolMevEfficiency = new double[] { 1, 0.9, 0.85, 0.8, 0.75, 0.75, 0.7 }; // pools about as good as each other at mev, but bigger ones are a little better

//poolMevEfficiency = new double[] { 1, 0.85, 0.8, 0.75, 0.7, 0.7, 0.7 }; // dominant pool is much better than the others at mev

int test = 4; // select test to run from below

​

const int BlocksPerDay = 7200;

const int BlocksPerYear = BlocksPerDay * 365;

const int EpochsPerYear = 82180; // https://pintail.xyz/posts/beacon-chain-validator-rewards/

const double MevPerBlock = 0.185; // https://hackmd.io/@flashbots/mev-in-eth2

const double StakedEth = 13000000; // total eth staked in the network

​

switch (test)

{

    case 0:

        Console.WriteLine("pbs");

        useMevAuctions = true;

        mevMitigated = 0;

        break;

​

    case 1:

        Console.WriteLine("no pbs");

        useMevAuctions = false;

        mevMitigated = 0;

        break;

​

    case 2:

        Console.WriteLine("no pbs or toxic mev");

        useMevAuctions = false;

        mevMitigated = 0.4; // most toxic mev mitigated (eg: non-optional threshold encrpytion)

        break;

​

    case 3:

        Console.WriteLine("pbs dominant pool builder");

        useMevAuctions = true;

        mevMitigated = 0;

        poolMevEfficiency[0] *= 1.1; // add 10% to represent private order flow to the dominant extractor/pool (needs work)

        break;

    case 4:

        Console.WriteLine("pbs no pool builder");

        useMevAuctions = true;

        mevMitigated = 0;

        poolMevEfficiency = new double[] { 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9 }; // no pool extracts mev, they get equal returns from pbs

        break;      

​

    default:

        return;

}

​

// find best and nearest competing extractors (by how good they are at extracting mev)

var numbers = poolMevEfficiency.OrderByDescending(x => x).Take(2);

int bestExtractor = Array.FindIndex<double>(poolMevEfficiency, x => x == numbers.First());

int competingExtractor = Array.FindIndex<double>(poolMevEfficiency, x => x == numbers.Last());

​

var poolStakes = poolStartingAllocations.Select(x => x * StakedEth).ToArray<double>();

var rnd = new Random();

double sumPoolStakes = poolStakes.Sum();

double unmitigatedMev = 1 - mevMitigated;

int sample = 0;

int countdown = 0;

​

// write header

Console.Write("year");

for (int i = 0; i < poolStakes.Length; i++)

    Console.Write($",pool {(char)((byte)'a' + i)}");

Console.WriteLine("");

​

// iterate blocks

for (int b = 0; b <= BlocksPerYear * 50; b++)

{

    // write rows yearly

    if (--countdown <= 0)

    {

        var allocations = poolStakes.Select(x => Math.Round(x / sumPoolStakes, 5)).ToArray<double>();

        Console.WriteLine("{0},{1}", sample++, string.Join(",", allocations));

        countdown = BlocksPerYear;

    }

​

    // randomly select block producer

    double pickPool = rnd.NextDouble() * sumPoolStakes;

    double s = 0;

    int blockProducer = poolStakes.Length - 1;

    for (int p = 0; p < poolStakes.Length; p++)

    {

        s += poolStakes[p];

        if (s >= pickPool)

        {

            blockProducer = p;

            break;

        }

    }

​

    // add rewards

    double blockReward = StakingRewardPerBlock(sumPoolStakes);

    AddToPoolStake(blockProducer, blockReward, sumPoolStakes, poolStakes);

​

    // add mev

    double mev = MevPerBlock * unmitigatedMev;

    if (!useMevAuctions)

    {

        // without mev auctions, the block producer block extracts the mev at their own level of efficiency

        sumPoolStakes = AddToPoolStake(blockProducer, mev * poolMevEfficiency[blockProducer], sumPoolStakes, poolStakes);

    }

    else

    {

        // note: where the block producer is also the best extractor, they get all the mev

​

        // with mev auctions, the block producer gets the winning bid

        sumPoolStakes = AddToPoolStake(blockProducer, mev * poolMevEfficiency[competingExtractor], sumPoolStakes, poolStakes);

​

        // and the extractor wins the difference between the mev they can extract and the nearest competitor bid

        sumPoolStakes = AddToPoolStake(bestExtractor, mev * (poolMevEfficiency[bestExtractor] - poolMevEfficiency[competingExtractor]), sumPoolStakes, poolStakes);

    }

}

​

static double AddToPoolStake(int poolIndex, double adjustment, double sumPoolStakes, double[] poolStakes)

{

    poolStakes[poolIndex] += adjustment;

    return sumPoolStakes + adjustment;

}

​

static double StakingRewardPerBlock(double sumPoolStakes)

{

    double validators = sumPoolStakes / 32;

    double annualized = EpochsPerYear * 512 / Math.Sqrt(validators * 32e9);

    double baseRewardPerBlock = annualized / BlocksPerYear;

    return baseRewardPerBlock * 4;

}