ATX incentivization

[mathcrypto]

We want to incentivize smeshers to use a smaller number of larger identities. One way to do this is to implement a per-ATX penalty, fee, or tax, based on the size/complexity of the ATX, to account for the cost to the network to transmit, store, and process that ATX.

For more see these research forum threads:

ATX reward with a sliding window Non-trivial Improvements to PoST UX and large ATX incentivization (private) Reward formula that compensates for wasted ticks (private) Naive ATX combining (private) See https://github.com/spacemeshos/go-spacemesh/issues/4219

[mathcrypto]

According to #381, smaller miners waste less ticks in every epoch than larger miners and thus in makes sense to give greater spacetime weight through a reward formula. However,

1. If the reward formula errs gives an x-percentage smaller amount of extra weight compared to what the miners deserve: a) big miners will get an x-percentage worse deal than what’s fair (more ATX splitting) b) smaller miners get a better deal relative to the large miners for large x.
2. If the reward formula errs gives an x-percentage greater amount of extra weight compared to what the miners deserve: a) The big miners will get an x-percentage better deal than what’s fair (less ATX splitting) b) The smaller miners are unhappy because the large miners get an unfair advantage

This method incentivizes large ATXs but it doesn't solve the problem that you're doing a lot of work because it doesn't reduce the work you do, it just pays you for the work you do. It also introduces a new problem

Problem

Small miners are incentivized to join pools (extra reward)

Possible solution

Non-trivial Improvements to PoST UX and large ATX incentivization

The method of increasing K2 would be better with distributed verification The distributed verification method requires more research so we can start without it for now

Optimisation

Using naive ATX combining method which combines multiple post-proofs into a single ATX. which saves bytes or megabytes (optimisation) so instead of collecting ATXs from every individual node, you just collect their post-proofs and you put them in a single list. This naïve ATX combining is not saving the ATX overhead. Those are still individual post-proofs, but it is saving all the ballots like they get combined into a single ballot and all of them. An advantage of this naive combining method is to improve the efficiency of the network

[mathcrypto]

Currently, the main reason why smeshers want to use lots of small ATXs instead of large one is because they get much lower variance with small ATXs and so they don't lose ATX every once in a while.

• The main thing we want to do is just reduce the proof of work and this will solve both the variance problem and the incentive

• One way to allow smaller K2POW with less variance is to use VDF style construction.

• With VDFs, you know exactly how many times it takes because it's a very sequential operation, and you can't grind on it because there's just one right answer.

• The current VDFs do have very large proofs and they're quite expensive to verify. -We don't need necessarily a VDF, we need the proof that you correctly computed a function. You could also, say, compute a hash or like a regular proof of work and a zero knowledge proof that it was correctly computed.

• If you had a deterministic POW(VDF is deterministic), you know exactly if your system can do the work or not. If it can do it, you're fine. If it cannot do it, then okay, you know, you need to upgrade your system or to do less, but you know exactly what you need. And so this is exactly the kind of thing that will help you decide rationally to use a large ATX.

• Can we have arbitrarily, low variance, non grindable proof of work with only random oracles?