GlcoinCore/elements
1
0
Fork 0
mirror of https://github.com/ElementsProject/elements.git synced 2026-08-14 12:43:40 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge c1607b5df4 into merged_master (Bitcoin PR #17957)

Browse source
This commit is contained in:
Andrew Poelstra 2020-11-14 16:52:13 +00:00
commit 0feee2ea2d
6 changed files with 87 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/coins.h
View file

@ -61,7 +61,7 @@ public:
assert(!IsSpent());
uint32_t code = nHeight * 2 + fCoinBase;
::Serialize(s, VARINT(code));
::Serialize(s, CTxOutCompressor(REF(out)));
::Serialize(s, Using<TxOutCompression>(out));
}
template<typename Stream>
@ -70,7 +70,7 @@ public:
::Unserialize(s, VARINT(code));
nHeight = code >> 1;
fCoinBase = code & 1;
::Unserialize(s, CTxOutCompressor(out));
::Unserialize(s, Using<TxOutCompression>(out));
}
bool IsSpent() const {

111
src/compressor.h
View file

@ -11,10 +11,6 @@
#include <serialize.h>
#include <span.h>
class CKeyID;
class CPubKey;
class CScriptID;
bool CompressScript(const CScript& script, std::vector<unsigned char> &out);
unsigned int GetSpecialScriptSize(unsigned int nSize);
bool DecompressScript(CScript& script, unsigned int nSize, const std::vector<unsigned char> &out);
@ -33,9 +29,8 @@ uint64_t DecompressAmount(uint64_t nAmount);
* Other scripts up to 121 bytes require 1 byte + script length. Above
* that, scripts up to 16505 bytes require 2 bytes + script length.
*/
class CScriptCompressor
struct ScriptCompression
{
private:
/**
* make this static for now (there are only 6 special scripts defined)
* this can potentially be extended together with a new nVersion for
@ -44,12 +39,8 @@ private:
*/
static const unsigned int nSpecialScripts = 6;
CScript &script;
public:
explicit CScriptCompressor(CScript &scriptIn) : script(scriptIn) { }
template<typename Stream>
void Serialize(Stream &s) const {
void Ser(Stream &s, const CScript& script) {
std::vector<unsigned char> compr;
if (CompressScript(script, compr)) {
s << MakeSpan(compr);
@ -61,7 +52,7 @@ public:
}
template<typename Stream>
void Unserialize(Stream &s) {
void Unser(Stream &s, CScript& script) {
unsigned int nSize = 0;
s >> VARINT(nSize);
if (nSize < nSpecialScripts) {
@ -82,58 +73,64 @@ public:
}
};
/** wrapper for CTxOut that provides a more compact serialization */
class CTxOutCompressor
struct AmountCompression
{
private:
CTxOut &txout;
public:
explicit CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action) {
template<typename Stream, typename I> void Ser(Stream& s, I val)
{
if (g_con_elementsmode) {
if (!ser_action.ForRead()) {
if (txout.nValue.IsExplicit()) {
uint8_t b = 0;
READWRITE(b);
uint64_t nVal = CompressAmount(txout.nValue.GetAmount());
READWRITE(VARINT(nVal));
} else {
uint8_t b = 1;
READWRITE(b);
READWRITE(txout.nValue);
}
if (val.IsExplicit()) {
uint8_t b = 0;
s << b;
s << VARINT(CompressAmount(val.GetAmount()));
} else {
uint8_t type = 0;
READWRITE(type);
if (type == 0) {
uint64_t nVal = 0;
READWRITE(VARINT(nVal));
txout.nValue = DecompressAmount(nVal);
} else {
READWRITE(txout.nValue);
}
uint8_t b = 1;
s << b;
s << val;
}
READWRITE(txout.nAsset);
} else {
if (!ser_action.ForRead()) {
assert(txout.nValue.IsExplicit());
uint64_t nVal = CompressAmount(txout.nValue.GetAmount());
READWRITE(VARINT(nVal));
} else {
uint64_t nVal = 0;
READWRITE(VARINT(nVal));
txout.nValue = DecompressAmount(nVal);
}
assert(val.IsExplicit());
s << VARINT(CompressAmount(val.GetAmount()));
}
}
template<typename Stream, typename I> void Unser(Stream& s, I& val)
{
if (g_con_elementsmode) {
uint8_t type = 0;
s >> type;
if (type == 0) {
uint64_t v = 0;
s >> VARINT(v);
val = DecompressAmount(v);
} else {
s >> val;
}
} else {
uint64_t v;
s >> VARINT(v);
val = DecompressAmount(v);
}
CScriptCompressor cscript(REF(txout.scriptPubKey));
READWRITE(cscript);
}
};
struct AssetCompression {
template<typename Stream, typename I> void Ser(Stream& s, I val)
{
if (g_con_elementsmode) {
s << val;
}
}
template<typename Stream, typename I> void Unser(Stream& s, I& val)
{
if (g_con_elementsmode) {
s >> val;
}
}
};
/** wrapper for CTxOut that provides a more compact serialization */
struct TxOutCompression
{
FORMATTER_METHODS(CTxOut, obj) { READWRITE(Using<AmountCompression>(obj.nValue), Using<AssetCompression>(obj.nAsset), Using<ScriptCompression>(obj.scriptPubKey)); }
};
#endif // BITCOIN_COMPRESSOR_H

32
src/serialize.h
View file

@ -199,6 +199,30 @@ template<typename X> const X& ReadWriteAsHelper(const X& x) { return x; }
SerializationOp(s, CSerActionUnserialize()); \
}
/**
* Implement the Ser and Unser methods needed for implementing a formatter (see Using below).
*
* Both Ser and Unser are delegated to a single static method SerializationOps, which is polymorphic
* in the serialized/deserialized type (allowing it to be const when serializing, and non-const when
* deserializing).
*
* Example use:
* struct FooFormatter {
* FORMATTER_METHODS(Class, obj) { READWRITE(obj.val1, VARINT(obj.val2)); }
* }
* would define a class FooFormatter that defines a serialization of Class objects consisting
* of serializing its val1 member using the default serialization, and its val2 member using
* VARINT serialization. That FooFormatter can then be used in statements like
* READWRITE(Using<FooFormatter>(obj.bla)).
*/
#define FORMATTER_METHODS(cls, obj) \
template<typename Stream> \
static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, CSerActionSerialize()); } \
template<typename Stream> \
static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, CSerActionUnserialize()); } \
template<typename Stream, typename Type, typename Operation> \
static inline void SerializationOps(Type& obj, Stream& s, Operation ser_action) \
/**
* Implement the Serialize and Unserialize methods by delegating to a single templated
* static method that takes the to-be-(de)serialized object as a parameter. This approach
@ -211,17 +235,15 @@ template<typename X> const X& ReadWriteAsHelper(const X& x) { return x; }
void Serialize(Stream& s) const \
{ \
static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
SerializationOps(*this, s, CSerActionSerialize()); \
Ser(s, *this); \
} \
template<typename Stream> \
void Unserialize(Stream& s) \
{ \
static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch"); \
SerializationOps(*this, s, CSerActionUnserialize()); \
Unser(s, *this); \
} \
template<typename Stream, typename Type, typename Operation> \
static inline void SerializationOps(Type& obj, Stream& s, Operation ser_action) \
FORMATTER_METHODS(cls, obj)
#ifndef CHAR_EQUALS_INT8
template<typename Stream> inline void Serialize(Stream& s, char a ) { ser_writedata8(s, a); } // TODO Get rid of bare char

2
src/test/fuzz/deserialize.cpp
View file

@ -206,7 +206,7 @@ void test_one_input(const std::vector<uint8_t>& buffer)
DeserializeFromFuzzingInput(buffer, dbi);
#elif TXOUTCOMPRESSOR_DESERIALIZE
CTxOut to;
CTxOutCompressor toc(to);
auto toc = Using<TxOutCompression>(to);
DeserializeFromFuzzingInput(buffer, toc);
#elif BLOCKTRANSACTIONS_DESERIALIZE
BlockTransactions bt;

2
src/txdb.cpp
View file

@ -387,7 +387,7 @@ public:
vout.assign(vAvail.size(), CTxOut());
for (unsigned int i = 0; i < vAvail.size(); i++) {
if (vAvail[i])
::Unserialize(s, CTxOutCompressor(vout[i]));
::Unserialize(s, Using<TxOutCompression>(vout[i]));
}
// coinbase height
::Unserialize(s, VARINT(nHeight, VarIntMode::NONNEGATIVE_SIGNED));

4
src/undo.h
View file

@ -32,7 +32,7 @@ public:
// Required to maintain compatibility with older undo format.
::Serialize(s, (unsigned char)0);
}
::Serialize(s, CTxOutCompressor(REF(txout->out)));
::Serialize(s, Using<TxOutCompression>(REF(txout->out)));
}
explicit TxInUndoSerializer(const Coin* coin) : txout(coin) {}
@ -56,7 +56,7 @@ public:
unsigned int nVersionDummy;
::Unserialize(s, VARINT(nVersionDummy));
}
::Unserialize(s, CTxOutCompressor(REF(txout->out)));
::Unserialize(s, Using<TxOutCompression>(REF(txout->out)));
}
explicit TxInUndoDeserializer(Coin* coin) : txout(coin) {}