Sorry if what I say here repeats an idea that’s already been dealt with. I’ve read many posts here carefully, but certainly not the entire thread.
@Eswak I know that early on some people confused your proposal with a proposal to batch sell pressure and sell it on the incentivized uniswap pool immediately after a reweight, before any bot get’s a chance to dump their bag.
The limitations of this idea are clear: if too many people pool, they will get a raw deal; they will end up selling their FEI considerably under $1 in a way that’s out of their control.
But, in principle, it has two virtues: (1) it interacts simply with the existing design; (2) it’s not a price floor, whereas FIP-1? (with a question mark) is. It’s obvious why the first is a virtue. The virtue of the second is a little more subtle. My argument is that it is a virtue because we’re only likely to implement something like this if FIP-1 (without a question mark) doesn’t pass. In that case, the community will have clearly expressed its vote against a price floor.
I think one of the most attractive goals of your proposal is that it protects the interests of small bags from the actions of bots and whales. And I think any proposal that promises to achieve this will be overwhelmingly popular.
So here’s the idea, imprecisely stated:
Instead of implementing a new contract that simply batches all of the sell pressure, we implement a contract that continually batches sell pressure, stratified by the price that each seller is willing to accept.
This contract is very flexible. At any time, anyone that’s wants to sell FEI above $0.99 can send the FEI to the contract, telling it this much. Anyone that’s willing to sell FEI above $0.98 can send the FEI to the contract, telling it this much. Anyone that’s willing to sell FEI above $0.97 can send the FEI to the contract, telling it this much. And so on… Similarly, as long as the contract hasn’t sold their FEI, anyone that’s sent FEI to the contract can redeem it, paying only the ethereum network fees involved.
By the time a reweight happens, the contract will have a pool of FEI it can sell above $0.99, a pool of FEI it can sell above $0.98, a pool of FEI it can sell above $0.97, and so on. Considering the liquidity in the incentivized pool and the effects of direct incentives, it will determine that it can batch x FEI and sell them above $0.99. If there are more than x FEI in the pool of FEI it can sell above $0.99, it will pick x FEI from that pool, according to a random distribution that is lightly weighted by how long each FEI has sat in the pool. And it will sell those FEI on the incentivized market. Otherwise, it will take all of the FEI in the pool of FEI it can sell above $0.99, and as many more FEI as it can take from the pools with fewer constraints. And it will sell those FEI on the incentivized market. Then it will determine that it can still sell y FEI above $0.98. And it will do the analogous steps to determine which FEI to sell above $0.98. And so on: it will do this with each strata (>$0.99, >$0.98, >$0.97, etc) until it reaches an empty strata.
I have enough understanding of solidity to understand that safe random algorithms are a difficulty, but I don’t have enough of an understanding of solidity to know if it’s possible to implement safe random algorithms. But I think randomness is important. For if we were simply to sell the FEI according to the time at which it reached each pool, then bots would still have an advantage in terms of how quickly they can dump their FEI onto this intermediate contract.
In principle, though I have by no means proved this to myself, this design should constrain all of the complexity to one or a few helper contracts without messing with existing contracts. And it should remove the current advantage that bots and whales have in the instants after reweight.
What do you think?