lbrycrd/src/undo.h

112 lines
3.3 KiB
C
Raw Normal View History

2014-10-18 19:53:37 +02:00
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
2014-10-18 19:53:37 +02:00
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
2014-11-03 16:16:40 +01:00
#ifndef BITCOIN_UNDO_H
#define BITCOIN_UNDO_H
2014-10-18 19:53:37 +02:00
#include "compressor.h"
#include "consensus/consensus.h"
2014-11-18 22:03:02 +01:00
#include "primitives/transaction.h"
2014-10-18 19:53:37 +02:00
#include "serialize.h"
/** Undo information for a CTxIn
*
* Contains the prevout's CTxOut being spent, and its metadata as well
* (coinbase or not, height). The serialization contains a dummy value of
* zero. This is be compatible with older versions which expect to see
* the transaction version there.
2014-10-18 19:53:37 +02:00
*/
class TxInUndoSerializer
2014-10-18 19:53:37 +02:00
{
const Coin* txout;
2014-10-18 19:53:37 +02:00
public:
2014-10-18 19:53:37 +02:00
template<typename Stream>
void Serialize(Stream &s) const {
::Serialize(s, VARINT(txout->nHeight * 2 + (txout->fCoinBase ? 1 : 0)));
if (txout->nHeight > 0) {
// Required to maintain compatibility with older undo format.
::Serialize(s, (unsigned char)0);
}
::Serialize(s, CTxOutCompressor(REF(txout->out)));
2014-10-18 19:53:37 +02:00
}
TxInUndoSerializer(const Coin* coin) : txout(coin) {}
};
class TxInUndoDeserializer
{
Coin* txout;
public:
2014-10-18 19:53:37 +02:00
template<typename Stream>
void Unserialize(Stream &s) {
2014-10-18 19:53:37 +02:00
unsigned int nCode = 0;
::Unserialize(s, VARINT(nCode));
txout->nHeight = nCode / 2;
txout->fCoinBase = nCode & 1;
if (txout->nHeight > 0) {
// Old versions stored the version number for the last spend of
// a transaction's outputs. Non-final spends were indicated with
// height = 0.
int nVersionDummy;
::Unserialize(s, VARINT(nVersionDummy));
}
::Unserialize(s, REF(CTxOutCompressor(REF(txout->out))));
2014-10-18 19:53:37 +02:00
}
TxInUndoDeserializer(Coin* coin) : txout(coin) {}
2014-10-18 19:53:37 +02:00
};
static const size_t MAX_INPUTS_PER_BLOCK = MAX_BLOCK_BASE_SIZE / ::GetSerializeSize(CTxIn(), SER_NETWORK, PROTOCOL_VERSION);
2014-10-18 19:53:37 +02:00
/** Undo information for a CTransaction */
class CTxUndo
{
public:
// undo information for all txins
std::vector<Coin> vprevout;
2014-10-18 19:53:37 +02:00
template <typename Stream>
void Serialize(Stream& s) const {
// TODO: avoid reimplementing vector serializer
uint64_t count = vprevout.size();
::Serialize(s, COMPACTSIZE(REF(count)));
for (const auto& prevout : vprevout) {
::Serialize(s, REF(TxInUndoSerializer(&prevout)));
}
}
2014-10-18 19:53:37 +02:00
template <typename Stream>
void Unserialize(Stream& s) {
// TODO: avoid reimplementing vector deserializer
uint64_t count = 0;
::Unserialize(s, COMPACTSIZE(count));
if (count > MAX_INPUTS_PER_BLOCK) {
throw std::ios_base::failure("Too many input undo records");
}
vprevout.resize(count);
for (auto& prevout : vprevout) {
::Unserialize(s, REF(TxInUndoDeserializer(&prevout)));
}
2014-10-18 19:53:37 +02:00
}
};
/** Undo information for a CBlock */
class CBlockUndo
{
public:
std::vector<CTxUndo> vtxundo; // for all but the coinbase
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(vtxundo);
}
};
2014-11-03 16:16:40 +01:00
#endif // BITCOIN_UNDO_H