If you want to prove me wrong, go and calculate the savings that this would currently provide, along with the savings of block pruning. Bonus points if you model out, simulate, and calculate this on projected future growth.
I wrote some test code to produce a vector of all unspent outputs (Basically the ledger).
#include <list>
#include <set>
#include <utility>
template < typename KeyType, typename MappedType,
typename Comp = std::less< KeyType > >
struct linked_map {
typedef KeyType key_type;
typedef MappedType mapped_type;
typedef std::pair< const key_type, mapped_type > value_type;
private:
typedef std::list< value_type > list_type;
typedef typename list_type::iterator list_iterator;
struct compare_keys {
Comp the_order;
compare_keys ( Comp o )
: the_order ( o )
{}
bool operator() ( list_iterator lhs, list_iterator rhs ) const {
return ( the_order( lhs->first, rhs->first ) );
}
};
typedef std::set< list_iterator, compare_keys > set_type;
typedef typename set_type::iterator set_iterator;
list_type the_list;
set_type the_set;
public:
typedef list_iterator iterator;
typedef typename set_type::size_type size_type;
linked_map ( Comp o = Comp() )
: the_list()
, the_set ( compare_keys( o ) )
{}
iterator find ( key_type const & key ) {
value_type dummy_value ( key, mapped_type() );
list_type dummy_list;
dummy_list.push_back( dummy_value );
set_iterator where = the_set.find( dummy_list.begin() );
if ( where == the_set.end() ) {
return ( the_list.end() );
}
return ( *where );
}
iterator insert ( value_type const & value ) {
list_type dummy;
dummy.push_back( value );
set_iterator where = the_set.find( dummy.begin() );
if ( where == the_set.end() ) {
the_list.push_back( value );
list_iterator pos = the_list.end();
-- pos;
the_set.insert( pos );
return ( pos );
} else {
(*where)->second = value.second;
return ( *where );
}
}
iterator erase ( iterator where ) {
the_set.erase( where );
return ( the_list.erase( where ) );
}
iterator begin ( void ) {
return ( the_list.begin() );
}
iterator end ( void ) {
return ( the_list.end() );
}
size_type size ( void ) const {
return ( the_set.size() );
}
mapped_type & operator[] ( key_type const & key ) {
iterator pos = insert( std::make_pair( key, mapped_type() ) );
return ( pos->second );
}
};
void buildTestLedger() {
cout << "Building Test Ledger" << endl;
float start = time(NULL);
vector<pair<int, CBlockIndex*> > vSortedByHeight;
vSortedByHeight.reserve(mapBlockIndex.size());
BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
{
CBlockIndex* pindex = item.second;
vSortedByHeight.push_back(make_pair(pindex->nHeight, pindex));
}
sort(vSortedByHeight.begin(), vSortedByHeight.end());
linked_map< COutPoint, CTxOut > unspent;
long originalSize = 0;
BOOST_FOREACH(const PAIRTYPE(int, CBlockIndex*)& item, vSortedByHeight)
{
CBlockIndex* pindex = item.second;
CBlock block;
block.ReadFromDisk(pindex);
originalSize += GetSerializeSize(block, SER_DISK);
BOOST_FOREACH(CTransaction & tx, block.vtx) {
//Check each input and remove spent
BOOST_FOREACH(CTxIn & in, tx.vin) {
linked_map< COutPoint, CTxOut >::iterator it = unspent.find(in.prevout);
if (it != unspent.end()) {
unspent.erase(it);
}
}
int ii = 0;
//Add each output to unspent
BOOST_FOREACH(CTxOut & out, tx.vout) {
COutPoint point(tx.GetHash(), ii);
linked_map<COutPoint, CTxOut>::iterator it = unspent.insert(make_pair(point, out));
++ii;
}
}
}
//Here you would write the ledger to disk
float end = time(NULL);
long ledgerSize = unspent.size() * (sizeof(COutPoint) + sizeof(CTxOut));
cout << "Ledger generation took " << end - start << "s" << endl;
cout << "Original disk size " << originalSize / 1024.f / 1024.f << "MB" << endl;
cout << "Number of unspent outputs " << unspent.size() << " Ledger size " << ledgerSize / 1024.f / 1024.f << "MB" << endl;
cout << (ledgerSize / (double)originalSize) * 100 << "% of the original size" << endl;
}
+ You would need to hold a certain number of recent blocks, at least until all chain forks can be resolved or 2016 to calculate the difficulty target. Your probably looking at 85% reduction in disk size and the same in block validation time. I wouldn't even know where to begin calculating an for estimate for merkel pruning would you have to download the full merkel trees?
Edit: Come to think about it, assuming the requirement of a correct balance ledger was enforced you don't even need the latest full blocks. You could take the latest balance ledger from any chain head and download the block headers only to verify the proof of work. That way your looking at more than 85% reduction in chain size.
