i have a few questions:
Until yesterday I thought UTXO commitments were a good idea. After the discussion here I oppose it for 2 reasons:
when you say "commitment", you mean by requiring a UTXO hash to be embedded into a block?
yes. I hope I'm using the term correctly.
- It gives additional capabilities to a 51% attacker
you mean that because the UTXO hash is embedded (committed) into blocks, it leaves room to be manipulated? how so?
thezerg explained an approach and I think the implications are valid here (bolding mine):
If the above is useful, next we create a soft-fork new op code that identifies this as a hash of the UTXO and miners don't accept block with an invalid UTXO. Miners must put this UTXO hash in every (block number%31 ==0). Clients don't use the most recent UTXO hash but the prior one.
So now we can have a very small client that is also trustless (well, a single miner would have to find 32 blocks in a row or 51% the network to fool a client). Small clients could use even older UTXO sets if they are less trusting of the diversity of the miner network.
The only problem with the above is that today 51%ing the network only lets you get all the newly minted coins and deny the ability of others to spend. This is a pretty cool feature
But with the above a 51% miner could "mint" new coins (at least from the perspective of the small clients) and remove existing ones by creating a fake UTXO set. You'd have to remove existing UTXOs or the # of coins would not match the coinbase issue rate. But if a 51%er ever did this, the non-small clients would see it instantly and so there would presumably be a huge PSA. So this idea is acceptable within the "weak" validation model...
I'm really no sure about this point after re-reading what thezerg said. If it only applies to SPV clients, then it doesn't make much difference because these have to trust the miners anyways. I might be slightly confused.
Yes, it only applies to thin clients. A full client calculates the UTXO set and Merkle hash from the complete history, compares it to a new block's UTXO hash and rejects the block if they don't match.
A 51% attack could create a longer chain of malicious UTXO sets than the longest valid chain. But the full nodes reject the chain because it is not correct (incorrect UTXO hash). However "light" clients (I'm not calling them SPV because SPV refers to a specific algorithm), can't validate the UTXO hash so they assume that it is correct and therefore use the longest (and incorrect) chain.
Honestly in practice you would simply code up "light" client that refuses to do any TXNs if there are 2 competing chains that forked > 64 (for example) blocks ago. Bitcoin's natural forks resolve quickly...
Note that it doesn't have to be all or none either... a client could keep X years of back revision history and just assume if the coin is older than that then it is valid. This might be very important when Bitcoin is 20+ years old.
- Since the UTXO set is actually an implementation detail, making it part of the bitcoin protocol seems inelegant and uneccessarily cluttering
by implementation detail, do you mean that the UTXO set is maintained at the client level and is never actually used in the protocol?
yes, that. That's not a very strong reason, though.
Once upon a time revision control systems stored each revision as the difference between the prior rev and the next one. This is bitcoin today. As files changed hundreds of times it took a long time to "check out" the file because all the revs had to be read and applied. Then people realized that there is a better way: store the current file and the reverse difference -- that is the changes needed to get BACK to the prior rev. This made a lot more sense because the current file is what is used 99% of the time.
This idea to store the UTXO Merkle tree hash is the evolution of the network to the back-revision method -- we only need the "current state" because blocks are symmetric. So technically you are correct; this is redundant data. But what it actually is a smooth transformation from one structure/protocol to another.