I completely agree with the problem being addressed here, but I disagree with the root cause, and expect that just addressing pennying in isolation creates more bad incentives than it removes.
You get what you reward
I think the root cause is that the rewards are mispriced. The vast majority (by count) of batches that settle, have a lot of solvers submitting solutions that are very close. Eg, where the top solutions have utilities within 1 USD (in real terms) of each other. Thing is, only the top solution wins the reward. This reward maybe 9$ or more depending on cow price and number of trades in the batch etc.
In other words, the strategy of taking a loss to increase win probability is completely overpowered for the average batch. Pennying as described in loose terms above, is just the most effective way to do so, both in terms of gas/surplus generated and in terms of implementation difficulty. I don’t want to give people ideas unnecessarily, but there are definitely other ways to ‘lose money to win the batch’, using more gas and perhaps having higher capital requirements (not good for decentralization).
This does not mean that having extra solvers doesn’t help the protocol. I have seen batches where number 1 had a solution with an objective functions 100s of USD higher than number 2. However, those cases are rare (frequency-wise). They may contribute a lot to the overall surplus, but they make up very few cases. And rewards are paid out roughly by number of batches won, not so much overall marginal contribution to the utility generated.
Also, note that pennying becomes pointless in cases where the 1st and 2nd solutions are further apart than the reward to be gained (you would go negative EV if you’d try to penny your way to the top).
IMO the solution should focus on addressing the incentives directly. In any case this would involve reducing cow subsidies for crowded batches, and use it to reward solvers that find particularly exotic solutions, or solutions with high delta compared to the rest.
How to fix
There have been earlier suggestions to reward solvers for incrementality more. I opposed these, because they involve distributing a fixed reward weekly based on ranking, but letting cost accrue to solvers with every batch as it the case. This generates a way more complex meta game than we have now.
The simplest way that I can think of that will completely remove any strategic behavior would be to use some form of second price auction mechanism. Could look as simple as this.
- Solvers submit batch as they do now, plus they quote a price they need to cover failed tx cost and net slippage if they win (this number could be negative, if slippage is expected to be sufficiently positive on average)
- The solutions are ranked by objective - quoted price
- The top solvers get the batch, the reward is the quoted price + difference in utility between top and second best solution
Note this mechanism is truthful in the sense that solvers should report their true expected cost: if you are not winning when you quote truthfully and you penny to gain the batch, you will lose money on average. If you already won the batch then pennying won’t increase your payoff any further.
There are some drawbacks to this approach:
- one is that it might require an unbounded amount of subsidy from the cow protocol. I don’t have a good suggestion of the top of my head, but maybe there is something we could do there.
- The second is that the protocol values redundancy, but redundant solvers mean that margin will tend to 0. I think this latter problem is elegantly solved by picking a random auction winner instead of always picking the top one, like they do in at rook protocol. One way to implement it for cow would be to add Gaussian noise with some fixed standard deviation to the utility (eg 1USD worth), and pick the top solution afterwards. This forces the equilibrium strategy to have positive margin even under perfectly identical solvers.
I am not married to this particular approach, but I do believe any solution should involve having the rewards set by the market more, instead of banning specific ways to exploit mispricing. The latter will just trigger an race to find new ways that might be even more negative sum .
We shouldn’t ban pennying
On thing to note about the pennying observations posted by Harris above, is that the observation is about median/mode (I think they are pretty close here). Ie, the ‘pennying’ solvers are not reporting values equal to the median token flows. This says nothing about expected token flows though, and that number is the only one that matters for the bottom line. In particular, the solvers that are not pennying may have vastly positive of negative expected slippage, and I am sure we have seen examples of both.
In particular, you could have one solver that has $0 slippage 99% of the time and -$1K slippage 1% of the time for an average loss of 10$ per transaction, while the other solver has -$1 slippage 99% of the time and +$99 slippage 1% of the time, which would create an average loss of $0. By the median logic, the latter solver is pennying, but we really should prefer it over the former.
This is not an artificial problem either. It pops up when choosing to route certain multi leg paths through 0x or 1inch. These will typically give the same return if you route it on historical blocks, while the 1inch contract is more gas efficient (by a tiny amount, I think it’s a few thousand gas). However, the 1inch contract keeps slippage above a certain threshold, which adds up to a lot over time. (Think someone estimated it to be above $750K lost across all solvers so far?)
In particular, you’d want an efficient solver to detect when routing to 0x and pennying the difference in gas is more efficient than routing through 1inch after taking into account expected slippage and gas price and the rest of the batch etc.
Just to be clear, I agree that pennying is used just as much for burning rewards as for the legitimate case described here! It’s just that these cases are not distinguishable from the outside, so you are throwing away a lot of value if you ban pennying entirely.
If we really want to ban pennying
I’ve mentioned this elsewhere before, but if we really want to force solvers to report the median, I would suggest the following approach:
simply refund gas but don’t award any further rewards if there is negative slippage in the settled batch. The risk here is very straightforward to understand and manage for solvers, ie you just need to factor in that x% of the batches don’t deliver a reward if you report simulation on latest block, where x is small.