Do not forward 0-writes to SHA256
Import LevelDB 1.5, it will be used for the transaction database.
Leveldb Windows port by Edouard Alligand, adapted for MingW by me.
Disable libsnappy detection in LevelDB
Do not force -std=c++0x for MingW builds
Makefile integration of LevelDB
Check for canonical public keys and signatures

Disabled for now.
Compact serialization for variable-length integers

This commit introduces a new variable-length encoding for arbitrary integers.
They use a least-significant-digit-first base 128 encoding, where each byte
contains 7 bits of information, and one bit denoting whether another byte
follows. To avoid redundancy, however, all bytes except the first one
select a value in the range 1-128 instead of 0-127.

Thus, the byte sequence a[] where all but the last has bit 128 set, encodes
the number (a[0] & 0x7F) + sum(i=1..n, 128^i*((a[i] & 0x7F)+1)).
Compact serialization for variable-length integers: tests
Add CCoins: pruned list of transaction outputs

The CCoins class represents a pruned set of transaction outputs from
a given transaction. It only retains information about its height in
the block chain, whether it was a coinbase transaction, and its
unspent outputs (script + amount).

It has a custom serializer that has very low redundancy.
Compact serialization for scripts

Special serializers for script which detect common cases and encode
them much more efficiently. 3 special cases are defined:
* Pay to pubkey hash (encoded as 21 bytes)
* Pay to script hash (encoded as 21 bytes)
* Pay to pubkey starting with 0x02, 0x03 or 0x04 (encoded as 33 bytes)

Other scripts up to 121 bytes require 1 byte + script length. Above
that, scripts up to 16505 bytes require 2 bytes + script length.
Compact serialization for amounts

Special serializer/deserializer for amount values. It is optimized for
values which have few non-zero digits in decimal representation. Most
amounts currently in the txout set take only 1 or 2 bytes to
represent.
Compact serialization for amounts: tests

Test cases to verify the correctness of the custom amount serializer.
Add CTxUndo: transaction undo information

The CTxUndo class encapsulates data necessary to undo the effects of
a transaction on the txout set, namely the previous outputs consumed
by it (script + amount).
One file per block

Refactor of the block storage code, which now stores one file per block.
This will allow easier pruning, as blocks can be removed individually.
Preliminary undo file creation

Create files (one per block) with undo information for the transactions
in it.
Multiple blocks per file

Change the block storage layer again, this time with multiple files
per block, but tracked by txindex.dat database entries. The file
format is exactly the same as the earlier blk00001.dat, but with
smaller files (128 MiB for now).

The database entries track how many bytes each block file already
uses, how many blocks are in it, which range of heights is present
and which range of dates.
Pre-allocate block and undo files in chunks

Introduce a AllocateFileRange() function in util, which wipes or
at least allocates a given range of a file. It can be overriden
by more efficient OS-dependent versions if necessary.

Block and undo files are now allocated in chunks of 16 and 1 MiB,
respectively.
Do not store hashNext on disk

Instead of trusting the hashNest stored in the serialized CDiskBlockIndex
entries, use just the hashBestChain pointer to represent the active chain.

This means the block connection logic does not need to touch the block
index entries anymore, and will allow for easier separation of this database
in two independent parts (data about the block tree, and data about the
active chain).
Batch block connection during IBD

During the initial block download (or -loadblock), delay connection
of new blocks a bit, and perform them in a single action. This reduces
the load on the database engine, as subsequent blocks often update an
earlier block's transaction already.