1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#ifndef BITCOIN_COMPRESSOR_H
7#define BITCOIN_COMPRESSOR_H
8
9#include <prevector.h>
10#include <primitives/transaction.h>
11#include <script/script.h>
12#include <serialize.h>
13#include <span.h>
14
15/**
16 * This saves us from making many heap allocations when serializing
17 * and deserializing compressed scripts.
18 *
19 * This prevector size is determined by the largest .resize() in the
20 * CompressScript function. The largest compressed script format is a
21 * compressed public key, which is 33 bytes.
22 */
23using CompressedScript = prevector<33, unsigned char>;
24
25
26bool CompressScript(const CScript& script, CompressedScript& out);
27unsigned int GetSpecialScriptSize(unsigned int nSize);
28bool DecompressScript(CScript& script, unsigned int nSize, const CompressedScript& in);
29
30/**
31 * Compress amount.
32 *
33 * nAmount is of type uint64_t and thus cannot be negative. If you're passing in
34 * a CAmount (int64_t), make sure to properly handle the case where the amount
35 * is negative before calling CompressAmount(...).
36 *
37 * @pre Function defined only for 0 <= nAmount <= MAX_MONEY.
38 */
39uint64_t CompressAmount(uint64_t nAmount);
40
41uint64_t DecompressAmount(uint64_t nAmount);
42
43/** Compact serializer for scripts.
44 *
45 *  It detects common cases and encodes them much more efficiently.
46 *  3 special cases are defined:
47 *  * Pay to pubkey hash (encoded as 21 bytes)
48 *  * Pay to script hash (encoded as 21 bytes)
49 *  * Pay to pubkey starting with 0x02, 0x03 or 0x04 (encoded as 33 bytes)
50 *
51 *  Other scripts up to 121 bytes require 1 byte + script length. Above
52 *  that, scripts up to 16505 bytes require 2 bytes + script length.
53 */
54struct ScriptCompression
55{
56    /**
57     * make this static for now (there are only 6 special scripts defined)
58     * this can potentially be extended together with a new version for
59     * transactions, in which case this value becomes dependent on version
60     * and nHeight of the enclosing transaction.
61     */
62    static constexpr unsigned int nSpecialScripts{6};
63
64    template<typename Stream>
65    void Ser(Stream &s, const CScript& script) {
66        CompressedScript compr;
67        if (CompressScript(script, compr)) {
68            s << std::span{compr};
69            return;
70        }
71        unsigned int nSize = script.size() + nSpecialScripts;
72        s << VARINT(nSize);
73        s << std::span{script};
74    }
75
76    template<typename Stream>
77    void Unser(Stream &s, CScript& script) {
78        unsigned int nSize = 0;
79        s >> VARINT(nSize);
80        if (nSize < nSpecialScripts) {
81            CompressedScript vch(GetSpecialScriptSize(nSize), 0x00);
82            s >> std::span{vch};
83            DecompressScript(script, nSize, vch);
84            return;
85        }
86        nSize -= nSpecialScripts;
87        if (nSize > MAX_SCRIPT_SIZE) {
88            // Overly long script, replace with a short invalid one
89            script << OP_RETURN;
90            s.ignore(nSize);
91        } else {
92            script.resize(nSize);
93            s >> std::span{script};
94        }
95    }
96};
97
98struct AmountCompression
99{
100    template<typename Stream, typename I> void Ser(Stream& s, I val)
101    {
102        s << VARINT(CompressAmount(val));
103    }
104    template<typename Stream, typename I> void Unser(Stream& s, I& val)
105    {
106        uint64_t v;
107        s >> VARINT(v);
108        val = DecompressAmount(v);
109    }
110};
111
112/** wrapper for CTxOut that provides a more compact serialization */
113struct TxOutCompression
114{
115    FORMATTER_METHODS(CTxOut, obj) { READWRITE(Using<AmountCompression>(obj.nValue), Using<ScriptCompression>(obj.scriptPubKey)); }
116};
117
118#endif // BITCOIN_COMPRESSOR_H
119