It is absolutely possible to write DeFi protocols (and much more) while relying on ZKPs for privacy - this is exactly what Miden was designed to do. The main trick is to reimagine how the state works and instead of using a monolithic state adapt the Actor Model (something used in distributed systems for decades).
Then we can have private actors that can interact with public actors which control the shared state. Or we could have semi-private actors (the state is known to some set of users, but not to the entire network) and these can also interact both with fully private actor or public actors.
This is a very powerful model that covers a large number of DeFi use cases - from anonymous AMMs and CLBOs, to private compliant stablecoins.
And one other nice thing: to write these DeFi protocol, we don't need engineers who understand ZKPs - you can write everything in Rust.
I do like FHE - really cool technology and it does enable a few use cases which ZKPs cannot address (i.e., having truly private shared state) - but it also comes with huge performance overhead for the network.
The beauty of ZKPs is that they actually reduce the network load - a transaction proven locally does not need to be executed by the network (verifying ZK proofs is very cheap) - we call this concept the Edge blockchain. While with FHE, every transaction becomes 100x (or 1000x) more expensive for the network. ASICs will help here for sure, but this also means that every validating node will need to run these ASICs or otherwise they won't be able to follow the network. And requiring every node to have an ASIC is kind of like requiring every Bitcoin node to be a miner.
6/
b) is the most subtle and hardest to understand. This is where ZK fails
To understand why, let's consider the simplest privacy app: zcash (no defi).
When you submit a shielded zcash transaction, you produce a proof that says, roughly "I am sending coins such that my balance remains >0 after this transaction."
Well, if you aggregate 1000 of those transactions and then look at the state of the chain as an outsider, what do you know about the state? Nothing
Now imagine trying to do DeFi on top of that. How do you do DeFi if your transaction literally cannot see or interact with anyone else's assets
A bunch of teams have been trying to address this over the last decade, including Aztec, Aleo, and probably quite a few more that I cannot recall atm.
The fundamental challenge each of these teams has to contend with is the challenge described above. Basically, how do you design ZKPs to allow for selective information to be seen by the outside world (eg how much collateral is backing a loan)
Now consider being a DeFi developer. You have to not only design your DeFi protocol, you have to do so 1) in a partially hamstrung way, and 2) you have to understand how ZKPs work. Who wants to be the developer building a DeFi system that has 9 or 10-figures in it with all of these additional risks. This is scary stuff
Many of the zk DeFi teams have been working to try to make this stuff more understandable, but the underlying reality is just extremely difficult to contend with.
Moreover, this requires rebuilding every DeFi primitive from the ground up.
The fundamental challenge here is that DeFi as we currently know it *requires the ability to reason about globally shared state.*
Perhaps there is a way to rebuild DeFi from the ground up with selective reasoning, but I am extremely skeptical of that claim. And demonstrating that claim to the world at large in a way that everyone else will believe it will be a decade long endeavor given how much technical risk is there with dozens of bespoke zk circuits.
So what is FHE? FHE allows you compute over encrypted data. This has been considered the holy grail of cryptography for decades.
Thinking about private DeFi using FHE as the primary cryptographic construction is actually quite simple. You think about it the same as if it was transparent! It's just that magically, everything is not transparent, but you can still compute over it anyways
Yes, this is magic