From b5a3ca8040b15cf1c5d323ceb906c60b2d26d084 Mon Sep 17 00:00:00 2001 From: satyakoneru <15652887+satyakoneru@users.noreply.github.com> Date: Fri, 17 Apr 2020 04:59:11 +0000 Subject: [PATCH] CLANG code format --- .../peerplays_sidechain/bitcoin/bech32.cpp | 281 +++++------ .../bitcoin/bitcoin_address.cpp | 328 ++++++------ .../bitcoin/bitcoin_script.cpp | 58 +-- .../bitcoin/bitcoin_transaction.cpp | 305 ++++++------ .../bitcoin/segwit_addr.cpp | 87 ++-- .../bitcoin/sign_bitcoin_transaction.cpp | 155 +++--- .../peerplays_sidechain/bitcoin/utils.cpp | 51 +- .../peerplays_sidechain/bitcoin_utils.cpp | 2 +- .../peerplays_sidechain/bitcoin/bech32.hpp | 6 +- .../bitcoin/bitcoin_address.hpp | 132 ++--- .../bitcoin/bitcoin_script.hpp | 23 +- .../bitcoin/bitcoin_transaction.hpp | 61 +-- .../bitcoin/segwit_addr.hpp | 8 +- .../peerplays_sidechain/bitcoin/serialize.hpp | 465 +++++++++--------- .../bitcoin/sign_bitcoin_transaction.hpp | 28 +- .../peerplays_sidechain/bitcoin/types.hpp | 33 +- .../peerplays_sidechain/bitcoin/utils.hpp | 16 +- .../peerplays_sidechain_plugin.cpp | 2 +- .../sidechain_net_handler_bitcoin.cpp | 72 ++- 19 files changed, 1015 insertions(+), 1098 deletions(-) mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/bitcoin/bech32.cpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_address.cpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/bitcoin/segwit_addr.cpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/bitcoin/utils.cpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bech32.hpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/segwit_addr.hpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/types.hpp mode change 100755 => 100644 libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/utils.hpp diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/bech32.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/bech32.cpp old mode 100755 new mode 100644 index 614a6231..69d157e4 --- a/libraries/plugins/peerplays_sidechain/bitcoin/bech32.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/bech32.cpp @@ -6,138 +6,135 @@ // #include -namespace -{ +namespace { typedef std::vector data; /** The Bech32 character set for encoding. */ -const char* CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"; +const char *CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"; /** The Bech32 character set for decoding. */ const int8_t CHARSET_REV[128] = { - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1, - -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, - 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1, - -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, - 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1 -}; + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1, + -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, + 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1, + -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, + 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1}; /** Concatenate two byte arrays. */ -data Cat(data x, const data& y) -{ - x.insert(x.end(), y.begin(), y.end()); - return x; +data Cat(data x, const data &y) { + x.insert(x.end(), y.begin(), y.end()); + return x; } /** This function will compute what 6 5-bit values to XOR into the last 6 input values, in order to * make the checksum 0. These 6 values are packed together in a single 30-bit integer. The higher * bits correspond to earlier values. */ -uint32_t PolyMod(const data& v) -{ - // The input is interpreted as a list of coefficients of a polynomial over F = GF(32), with an - // implicit 1 in front. If the input is [v0,v1,v2,v3,v4], that polynomial is v(x) = - // 1*x^5 + v0*x^4 + v1*x^3 + v2*x^2 + v3*x + v4. The implicit 1 guarantees that - // [v0,v1,v2,...] has a distinct checksum from [0,v0,v1,v2,...]. +uint32_t PolyMod(const data &v) { + // The input is interpreted as a list of coefficients of a polynomial over F = GF(32), with an + // implicit 1 in front. If the input is [v0,v1,v2,v3,v4], that polynomial is v(x) = + // 1*x^5 + v0*x^4 + v1*x^3 + v2*x^2 + v3*x + v4. The implicit 1 guarantees that + // [v0,v1,v2,...] has a distinct checksum from [0,v0,v1,v2,...]. - // The output is a 30-bit integer whose 5-bit groups are the coefficients of the remainder of - // v(x) mod g(x), where g(x) is the Bech32 generator, - // x^6 + {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}. g(x) is chosen in such a way - // that the resulting code is a BCH code, guaranteeing detection of up to 3 errors within a - // window of 1023 characters. Among the various possible BCH codes, one was selected to in - // fact guarantee detection of up to 4 errors within a window of 89 characters. + // The output is a 30-bit integer whose 5-bit groups are the coefficients of the remainder of + // v(x) mod g(x), where g(x) is the Bech32 generator, + // x^6 + {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}. g(x) is chosen in such a way + // that the resulting code is a BCH code, guaranteeing detection of up to 3 errors within a + // window of 1023 characters. Among the various possible BCH codes, one was selected to in + // fact guarantee detection of up to 4 errors within a window of 89 characters. - // Note that the coefficients are elements of GF(32), here represented as decimal numbers - // between {}. In this finite field, addition is just XOR of the corresponding numbers. For - // example, {27} + {13} = {27 ^ 13} = {22}. Multiplication is more complicated, and requires - // treating the bits of values themselves as coefficients of a polynomial over a smaller field, - // GF(2), and multiplying those polynomials mod a^5 + a^3 + 1. For example, {5} * {26} = - // (a^2 + 1) * (a^4 + a^3 + a) = (a^4 + a^3 + a) * a^2 + (a^4 + a^3 + a) = a^6 + a^5 + a^4 + a - // = a^3 + 1 (mod a^5 + a^3 + 1) = {9}. + // Note that the coefficients are elements of GF(32), here represented as decimal numbers + // between {}. In this finite field, addition is just XOR of the corresponding numbers. For + // example, {27} + {13} = {27 ^ 13} = {22}. Multiplication is more complicated, and requires + // treating the bits of values themselves as coefficients of a polynomial over a smaller field, + // GF(2), and multiplying those polynomials mod a^5 + a^3 + 1. For example, {5} * {26} = + // (a^2 + 1) * (a^4 + a^3 + a) = (a^4 + a^3 + a) * a^2 + (a^4 + a^3 + a) = a^6 + a^5 + a^4 + a + // = a^3 + 1 (mod a^5 + a^3 + 1) = {9}. - // During the course of the loop below, `c` contains the bitpacked coefficients of the - // polynomial constructed from just the values of v that were processed so far, mod g(x). In - // the above example, `c` initially corresponds to 1 mod (x), and after processing 2 inputs of - // v, it corresponds to x^2 + v0*x + v1 mod g(x). As 1 mod g(x) = 1, that is the starting value - // for `c`. - uint32_t c = 1; - for (auto v_i : v) { - // We want to update `c` to correspond to a polynomial with one extra term. If the initial - // value of `c` consists of the coefficients of c(x) = f(x) mod g(x), we modify it to - // correspond to c'(x) = (f(x) * x + v_i) mod g(x), where v_i is the next input to - // process. Simplifying: - // c'(x) = (f(x) * x + v_i) mod g(x) - // ((f(x) mod g(x)) * x + v_i) mod g(x) - // (c(x) * x + v_i) mod g(x) - // If c(x) = c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5, we want to compute - // c'(x) = (c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5) * x + v_i mod g(x) - // = c0*x^6 + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i mod g(x) - // = c0*(x^6 mod g(x)) + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i - // If we call (x^6 mod g(x)) = k(x), this can be written as - // c'(x) = (c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i) + c0*k(x) + // During the course of the loop below, `c` contains the bitpacked coefficients of the + // polynomial constructed from just the values of v that were processed so far, mod g(x). In + // the above example, `c` initially corresponds to 1 mod (x), and after processing 2 inputs of + // v, it corresponds to x^2 + v0*x + v1 mod g(x). As 1 mod g(x) = 1, that is the starting value + // for `c`. + uint32_t c = 1; + for (auto v_i : v) { + // We want to update `c` to correspond to a polynomial with one extra term. If the initial + // value of `c` consists of the coefficients of c(x) = f(x) mod g(x), we modify it to + // correspond to c'(x) = (f(x) * x + v_i) mod g(x), where v_i is the next input to + // process. Simplifying: + // c'(x) = (f(x) * x + v_i) mod g(x) + // ((f(x) mod g(x)) * x + v_i) mod g(x) + // (c(x) * x + v_i) mod g(x) + // If c(x) = c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5, we want to compute + // c'(x) = (c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5) * x + v_i mod g(x) + // = c0*x^6 + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i mod g(x) + // = c0*(x^6 mod g(x)) + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i + // If we call (x^6 mod g(x)) = k(x), this can be written as + // c'(x) = (c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i) + c0*k(x) - // First, determine the value of c0: - uint8_t c0 = c >> 25; + // First, determine the value of c0: + uint8_t c0 = c >> 25; - // Then compute c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i: - c = ((c & 0x1ffffff) << 5) ^ v_i; + // Then compute c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i: + c = ((c & 0x1ffffff) << 5) ^ v_i; - // Finally, for each set bit n in c0, conditionally add {2^n}k(x): - if (c0 & 1) c ^= 0x3b6a57b2; // k(x) = {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18} - if (c0 & 2) c ^= 0x26508e6d; // {2}k(x) = {19}x^5 + {5}x^4 + x^3 + {3}x^2 + {19}x + {13} - if (c0 & 4) c ^= 0x1ea119fa; // {4}k(x) = {15}x^5 + {10}x^4 + {2}x^3 + {6}x^2 + {15}x + {26} - if (c0 & 8) c ^= 0x3d4233dd; // {8}k(x) = {30}x^5 + {20}x^4 + {4}x^3 + {12}x^2 + {30}x + {29} - if (c0 & 16) c ^= 0x2a1462b3; // {16}k(x) = {21}x^5 + x^4 + {8}x^3 + {24}x^2 + {21}x + {19} - } - return c; + // Finally, for each set bit n in c0, conditionally add {2^n}k(x): + if (c0 & 1) + c ^= 0x3b6a57b2; // k(x) = {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18} + if (c0 & 2) + c ^= 0x26508e6d; // {2}k(x) = {19}x^5 + {5}x^4 + x^3 + {3}x^2 + {19}x + {13} + if (c0 & 4) + c ^= 0x1ea119fa; // {4}k(x) = {15}x^5 + {10}x^4 + {2}x^3 + {6}x^2 + {15}x + {26} + if (c0 & 8) + c ^= 0x3d4233dd; // {8}k(x) = {30}x^5 + {20}x^4 + {4}x^3 + {12}x^2 + {30}x + {29} + if (c0 & 16) + c ^= 0x2a1462b3; // {16}k(x) = {21}x^5 + x^4 + {8}x^3 + {24}x^2 + {21}x + {19} + } + return c; } /** Convert to lower case. */ -inline unsigned char LowerCase(unsigned char c) -{ - return (c >= 'A' && c <= 'Z') ? (c - 'A') + 'a' : c; +inline unsigned char LowerCase(unsigned char c) { + return (c >= 'A' && c <= 'Z') ? (c - 'A') + 'a' : c; } /** Expand a HRP for use in checksum computation. */ -data ExpandHRP(const std::string& hrp) -{ - data ret; - ret.reserve(hrp.size() + 90); - ret.resize(hrp.size() * 2 + 1); - for (size_t i = 0; i < hrp.size(); ++i) { - unsigned char c = hrp[i]; - ret[i] = c >> 5; - ret[i + hrp.size() + 1] = c & 0x1f; - } - ret[hrp.size()] = 0; - return ret; +data ExpandHRP(const std::string &hrp) { + data ret; + ret.reserve(hrp.size() + 90); + ret.resize(hrp.size() * 2 + 1); + for (size_t i = 0; i < hrp.size(); ++i) { + unsigned char c = hrp[i]; + ret[i] = c >> 5; + ret[i + hrp.size() + 1] = c & 0x1f; + } + ret[hrp.size()] = 0; + return ret; } /** Verify a checksum. */ -bool VerifyChecksum(const std::string& hrp, const data& values) -{ - // PolyMod computes what value to xor into the final values to make the checksum 0. However, - // if we required that the checksum was 0, it would be the case that appending a 0 to a valid - // list of values would result in a new valid list. For that reason, Bech32 requires the - // resulting checksum to be 1 instead. - return PolyMod(Cat(ExpandHRP(hrp), values)) == 1; +bool VerifyChecksum(const std::string &hrp, const data &values) { + // PolyMod computes what value to xor into the final values to make the checksum 0. However, + // if we required that the checksum was 0, it would be the case that appending a 0 to a valid + // list of values would result in a new valid list. For that reason, Bech32 requires the + // resulting checksum to be 1 instead. + return PolyMod(Cat(ExpandHRP(hrp), values)) == 1; } /** Create a checksum. */ -data CreateChecksum(const std::string& hrp, const data& values) -{ - data enc = Cat(ExpandHRP(hrp), values); - enc.resize(enc.size() + 6); // Append 6 zeroes - uint32_t mod = PolyMod(enc) ^ 1; // Determine what to XOR into those 6 zeroes. - data ret(6); - for (size_t i = 0; i < 6; ++i) { - // Convert the 5-bit groups in mod to checksum values. - ret[i] = (mod >> (5 * (5 - i))) & 31; - } - return ret; +data CreateChecksum(const std::string &hrp, const data &values) { + data enc = Cat(ExpandHRP(hrp), values); + enc.resize(enc.size() + 6); // Append 6 zeroes + uint32_t mod = PolyMod(enc) ^ 1; // Determine what to XOR into those 6 zeroes. + data ret(6); + for (size_t i = 0; i < 6; ++i) { + // Convert the 5-bit groups in mod to checksum values. + ret[i] = (mod >> (5 * (5 - i))) & 31; + } + return ret; } } // namespace @@ -145,48 +142,52 @@ data CreateChecksum(const std::string& hrp, const data& values) namespace graphene { namespace peerplays_sidechain { namespace bitcoin { namespace bech32 { /** Encode a Bech32 string. */ -std::string Encode(const std::string& hrp, const data& values) { - data checksum = CreateChecksum(hrp, values); - data combined = Cat(values, checksum); - std::string ret = hrp + '1'; - ret.reserve(ret.size() + combined.size()); - for (auto c : combined) { - ret += CHARSET[c]; - } - return ret; +std::string Encode(const std::string &hrp, const data &values) { + data checksum = CreateChecksum(hrp, values); + data combined = Cat(values, checksum); + std::string ret = hrp + '1'; + ret.reserve(ret.size() + combined.size()); + for (auto c : combined) { + ret += CHARSET[c]; + } + return ret; } /** Decode a Bech32 string. */ -std::pair Decode(const std::string& str) { - bool lower = false, upper = false; - for (size_t i = 0; i < str.size(); ++i) { - unsigned char c = str[i]; - if (c < 33 || c > 126) return {}; - if (c >= 'a' && c <= 'z') lower = true; - if (c >= 'A' && c <= 'Z') upper = true; - } - if (lower && upper) return {}; - size_t pos = str.rfind('1'); - if (str.size() > 90 || pos == str.npos || pos == 0 || pos + 7 > str.size()) { - return {}; - } - data values(str.size() - 1 - pos); - for (size_t i = 0; i < str.size() - 1 - pos; ++i) { - unsigned char c = str[i + pos + 1]; - int8_t rev = (c < 33 || c > 126) ? -1 : CHARSET_REV[c]; - if (rev == -1) { - return {}; - } - values[i] = rev; - } - std::string hrp; - for (size_t i = 0; i < pos; ++i) { - hrp += LowerCase(str[i]); - } - if (!VerifyChecksum(hrp, values)) { - return {}; - } - return {hrp, data(values.begin(), values.end() - 6)}; +std::pair Decode(const std::string &str) { + bool lower = false, upper = false; + for (size_t i = 0; i < str.size(); ++i) { + unsigned char c = str[i]; + if (c < 33 || c > 126) + return {}; + if (c >= 'a' && c <= 'z') + lower = true; + if (c >= 'A' && c <= 'Z') + upper = true; + } + if (lower && upper) + return {}; + size_t pos = str.rfind('1'); + if (str.size() > 90 || pos == str.npos || pos == 0 || pos + 7 > str.size()) { + return {}; + } + data values(str.size() - 1 - pos); + for (size_t i = 0; i < str.size() - 1 - pos; ++i) { + unsigned char c = str[i + pos + 1]; + int8_t rev = (c < 33 || c > 126) ? -1 : CHARSET_REV[c]; + if (rev == -1) { + return {}; + } + values[i] = rev; + } + std::string hrp; + for (size_t i = 0; i < pos; ++i) { + hrp += LowerCase(str[i]); + } + if (!VerifyChecksum(hrp, values)) { + return {}; + } + return {hrp, data(values.begin(), values.end() - 6)}; } -} } } }// namespace sidechain::bech32 +}}}} // namespace graphene::peerplays_sidechain::bitcoin::bech32 diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_address.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_address.cpp old mode 100755 new mode 100644 index b13208b8..a45bf9b0 --- a/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_address.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_address.cpp @@ -1,93 +1,89 @@ -#include -#include #include -#include +#include #include +#include +#include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -bool bitcoin_address::operator==( const bitcoin_address& btc_addr ) const { - return ( this->address == btc_addr.address ) && - ( this->type == btc_addr.type ) && - ( this->raw_address == btc_addr.raw_address ) && - ( this->network_type == btc_addr.network_type); +bool bitcoin_address::operator==(const bitcoin_address &btc_addr) const { + return (this->address == btc_addr.address) && + (this->type == btc_addr.type) && + (this->raw_address == btc_addr.raw_address) && + (this->network_type == btc_addr.network_type); } -bytes bitcoin_address::get_script() const -{ - switch ( type ) { - case payment_type::NULLDATA: - return script_builder() << op::RETURN << raw_address; - case payment_type::P2PK: - return script_builder() << raw_address << op::CHECKSIG; - case payment_type::P2PKH: - return script_builder() << op::DUP << op::HASH160 << raw_address << op::EQUALVERIFY << op::CHECKSIG; - case payment_type::P2SH: - case payment_type::P2SH_WPKH: - case payment_type::P2SH_WSH: - return script_builder() << op::HASH160 << raw_address << op::EQUAL; - case payment_type::P2WPKH: - case payment_type::P2WSH: - return script_builder() << op::_0 << raw_address; - default: - return raw_address; - } +bytes bitcoin_address::get_script() const { + switch (type) { + case payment_type::NULLDATA: + return script_builder() << op::RETURN << raw_address; + case payment_type::P2PK: + return script_builder() << raw_address << op::CHECKSIG; + case payment_type::P2PKH: + return script_builder() << op::DUP << op::HASH160 << raw_address << op::EQUALVERIFY << op::CHECKSIG; + case payment_type::P2SH: + case payment_type::P2SH_WPKH: + case payment_type::P2SH_WSH: + return script_builder() << op::HASH160 << raw_address << op::EQUAL; + case payment_type::P2WPKH: + case payment_type::P2WSH: + return script_builder() << op::_0 << raw_address; + default: + return raw_address; + } } -payment_type bitcoin_address::determine_type() -{ - if( is_p2pk() ) { +payment_type bitcoin_address::determine_type() { + if (is_p2pk()) { return payment_type::P2PK; - } else if( is_p2wpkh() ) { + } else if (is_p2wpkh()) { return payment_type::P2WPKH; - } else if( is_p2wsh() ) { + } else if (is_p2wsh()) { return payment_type::P2WSH; - } else if( is_p2pkh() ) { + } else if (is_p2pkh()) { return payment_type::P2PKH; - } else if( is_p2sh() ) { + } else if (is_p2sh()) { return payment_type::P2SH; } else { return payment_type::NULLDATA; } } -bytes bitcoin_address::determine_raw_address() -{ +bytes bitcoin_address::determine_raw_address() { bytes result; - switch( type ) { - case payment_type::P2PK : { - result = parse_hex( address ); - break; - } - case payment_type::P2WPKH : - case payment_type::P2WSH : { - std::string prefix( address.compare(0,4,"bcrt") == 0 ? std::string( address.begin(), address.begin() + 4 ) : - std::string( address.begin(), address.begin() + 2 ) ); - const auto& decode_bech32 = segwit_addr::decode( prefix, address ); - result = bytes( decode_bech32.second.begin(), decode_bech32.second.end() ); - break; - } - case payment_type::P2SH_WPKH : - case payment_type::P2SH_WSH : - case payment_type::P2PKH : - case payment_type::P2SH : { - bytes hex_addr = fc::from_base58( address ); - result = bytes( hex_addr.begin() + 1, hex_addr.begin() + 21 ); - break; - } - case payment_type::NULLDATA : return result; + switch (type) { + case payment_type::P2PK: { + result = parse_hex(address); + break; + } + case payment_type::P2WPKH: + case payment_type::P2WSH: { + std::string prefix(address.compare(0, 4, "bcrt") == 0 ? std::string(address.begin(), address.begin() + 4) : std::string(address.begin(), address.begin() + 2)); + const auto &decode_bech32 = segwit_addr::decode(prefix, address); + result = bytes(decode_bech32.second.begin(), decode_bech32.second.end()); + break; + } + case payment_type::P2SH_WPKH: + case payment_type::P2SH_WSH: + case payment_type::P2PKH: + case payment_type::P2SH: { + bytes hex_addr = fc::from_base58(address); + result = bytes(hex_addr.begin() + 1, hex_addr.begin() + 21); + break; + } + case payment_type::NULLDATA: + return result; } return result; } -bool bitcoin_address::check_segwit_address( const size_segwit_address& size ) const { - if( !address.compare(0,4,"bcrt") || !address.compare(0,2,"bc") || !address.compare(0,2,"tb") ) { - std::string prefix( !address.compare(0,4,"bcrt") ? std::string(address.begin(), address.begin() + 4) : - std::string(address.begin(), address.begin() + 2) ); +bool bitcoin_address::check_segwit_address(const size_segwit_address &size) const { + if (!address.compare(0, 4, "bcrt") || !address.compare(0, 2, "bc") || !address.compare(0, 2, "tb")) { + std::string prefix(!address.compare(0, 4, "bcrt") ? std::string(address.begin(), address.begin() + 4) : std::string(address.begin(), address.begin() + 2)); - const auto& decode_bech32 = segwit_addr::decode( prefix, address ); - - if( decode_bech32.first == -1 || decode_bech32.second.size() != size ) { + const auto &decode_bech32 = segwit_addr::decode(prefix, address); + + if (decode_bech32.first == -1 || decode_bech32.second.size() != size) { return false; } @@ -96,170 +92,156 @@ bool bitcoin_address::check_segwit_address( const size_segwit_address& size ) co return false; } -bool bitcoin_address::is_p2pk() const -{ +bool bitcoin_address::is_p2pk() const { try { - bool prefix = !address.compare(0,2,"02") || !address.compare(0,2,"03"); - if( address.size() == 66 && prefix ) { - parse_hex( address ); + bool prefix = !address.compare(0, 2, "02") || !address.compare(0, 2, "03"); + if (address.size() == 66 && prefix) { + parse_hex(address); return true; } - } catch( fc::exception e ) { + } catch (fc::exception e) { return false; } return false; } -bool bitcoin_address::is_p2wpkh() const -{ - return check_segwit_address( size_segwit_address::P2WPKH ); +bool bitcoin_address::is_p2wpkh() const { + return check_segwit_address(size_segwit_address::P2WPKH); } -bool bitcoin_address::is_p2wsh() const -{ - return check_segwit_address( size_segwit_address::P2WSH ); +bool bitcoin_address::is_p2wsh() const { + return check_segwit_address(size_segwit_address::P2WSH); } -bool bitcoin_address::is_p2pkh() const -{ +bool bitcoin_address::is_p2pkh() const { try { - bytes hex_addr = fc::from_base58( address ); - if( hex_addr.size() == 25 && ( static_cast( hex_addr[0] ) == 0x00 || - static_cast( hex_addr[0] ) == 0x6f ) ) { + bytes hex_addr = fc::from_base58(address); + if (hex_addr.size() == 25 && (static_cast(hex_addr[0]) == 0x00 || + static_cast(hex_addr[0]) == 0x6f)) { return true; } return false; - } catch( fc::exception e ) { + } catch (fc::exception e) { return false; } } -bool bitcoin_address::is_p2sh() const -{ +bool bitcoin_address::is_p2sh() const { try { - bytes hex_addr = fc::from_base58( address ); - if( hex_addr.size() == 25 && ( static_cast( hex_addr[0] ) == 0x05 || - static_cast( hex_addr[0] ) == 0xc4 ) ) { + bytes hex_addr = fc::from_base58(address); + if (hex_addr.size() == 25 && (static_cast(hex_addr[0]) == 0x05 || + static_cast(hex_addr[0]) == 0xc4)) { return true; } return false; - } catch( fc::exception e ) { + } catch (fc::exception e) { return false; } } -btc_multisig_address::btc_multisig_address( const size_t n_required, const accounts_keys& keys ) : - keys_required ( n_required ), witnesses_keys( keys ) -{ +btc_multisig_address::btc_multisig_address(const size_t n_required, const accounts_keys &keys) : + keys_required(n_required), + witnesses_keys(keys) { create_redeem_script(); create_address(); type = payment_type::P2SH; } -size_t btc_multisig_address::count_intersection( const accounts_keys& keys ) const -{ - FC_ASSERT( keys.size() > 0 ); - +size_t btc_multisig_address::count_intersection(const accounts_keys &keys) const { + FC_ASSERT(keys.size() > 0); + int intersections_count = 0; - for( auto& key : keys ) { - auto witness_key = witnesses_keys.find( key.first ); - if( witness_key == witnesses_keys.end() ) continue; - if( key.second == witness_key->second ) + for (auto &key : keys) { + auto witness_key = witnesses_keys.find(key.first); + if (witness_key == witnesses_keys.end()) + continue; + if (key.second == witness_key->second) intersections_count++; } return intersections_count; } -void btc_multisig_address::create_redeem_script() -{ - FC_ASSERT( keys_required > 0 ); - FC_ASSERT( keys_required < witnesses_keys.size() ); +void btc_multisig_address::create_redeem_script() { + FC_ASSERT(keys_required > 0); + FC_ASSERT(keys_required < witnesses_keys.size()); redeem_script.clear(); - redeem_script.push_back( op_num[keys_required - 1] ); - for( const auto& key : witnesses_keys ) { + redeem_script.push_back(op_num[keys_required - 1]); + for (const auto &key : witnesses_keys) { std::stringstream ss; ss << std::hex << key.second.key_data.size(); - auto key_size_hex = parse_hex( ss.str() ); - redeem_script.insert( redeem_script.end(), key_size_hex.begin(), key_size_hex.end() ); - redeem_script.insert( redeem_script.end(), key.second.key_data.begin(), key.second.key_data.end() ); + auto key_size_hex = parse_hex(ss.str()); + redeem_script.insert(redeem_script.end(), key_size_hex.begin(), key_size_hex.end()); + redeem_script.insert(redeem_script.end(), key.second.key_data.begin(), key.second.key_data.end()); } - redeem_script.push_back( op_num[witnesses_keys.size() - 1] ); - redeem_script.push_back( OP_CHECKMULTISIG ); + redeem_script.push_back(op_num[witnesses_keys.size() - 1]); + redeem_script.push_back(OP_CHECKMULTISIG); } -void btc_multisig_address::create_address() -{ - FC_ASSERT( redeem_script.size() > 0 ); +void btc_multisig_address::create_address() { + FC_ASSERT(redeem_script.size() > 0); raw_address.clear(); - fc::sha256 hash256 = fc::sha256::hash( redeem_script.data(), redeem_script.size() ); - fc::ripemd160 hash160 = fc::ripemd160::hash( hash256.data(), hash256.data_size() ); - bytes temp_addr_hash( parse_hex( hash160.str() ) ); + fc::sha256 hash256 = fc::sha256::hash(redeem_script.data(), redeem_script.size()); + fc::ripemd160 hash160 = fc::ripemd160::hash(hash256.data(), hash256.data_size()); + bytes temp_addr_hash(parse_hex(hash160.str())); - raw_address.push_back( OP_HASH160 ); + raw_address.push_back(OP_HASH160); std::stringstream ss; ss << std::hex << temp_addr_hash.size(); - auto address_size_hex = parse_hex( ss.str() ); - raw_address.insert( raw_address.end(), address_size_hex.begin(), address_size_hex.end() ); - raw_address.insert( raw_address.end(), temp_addr_hash.begin(), temp_addr_hash.end() ); - raw_address.push_back( OP_EQUAL ); + auto address_size_hex = parse_hex(ss.str()); + raw_address.insert(raw_address.end(), address_size_hex.begin(), address_size_hex.end()); + raw_address.insert(raw_address.end(), temp_addr_hash.begin(), temp_addr_hash.end()); + raw_address.push_back(OP_EQUAL); } -btc_multisig_segwit_address::btc_multisig_segwit_address( const size_t n_required, const accounts_keys& keys ) : - btc_multisig_address( n_required, keys ) -{ +btc_multisig_segwit_address::btc_multisig_segwit_address(const size_t n_required, const accounts_keys &keys) : + btc_multisig_address(n_required, keys) { create_witness_script(); create_segwit_address(); type = payment_type::P2SH; } -bool btc_multisig_segwit_address::operator==( const btc_multisig_segwit_address& addr ) const -{ - if( address != addr.address || redeem_script != addr.redeem_script || +bool btc_multisig_segwit_address::operator==(const btc_multisig_segwit_address &addr) const { + if (address != addr.address || redeem_script != addr.redeem_script || witnesses_keys != addr.witnesses_keys || witness_script != addr.witness_script || - raw_address != addr.raw_address ) + raw_address != addr.raw_address) return false; return true; } std::vector btc_multisig_segwit_address::get_keys() { std::vector keys; - for( const auto& k : witnesses_keys ) { - keys.push_back( k.second ); + for (const auto &k : witnesses_keys) { + keys.push_back(k.second); } return keys; } -void btc_multisig_segwit_address::create_witness_script() -{ - const auto redeem_sha256 = fc::sha256::hash( redeem_script.data(), redeem_script.size() ); - witness_script.push_back( OP_0 ); - witness_script.push_back( 0x20 ); // PUSH_32 - witness_script.insert( witness_script.end(), redeem_sha256.data(), redeem_sha256.data() + redeem_sha256.data_size() ); +void btc_multisig_segwit_address::create_witness_script() { + const auto redeem_sha256 = fc::sha256::hash(redeem_script.data(), redeem_script.size()); + witness_script.push_back(OP_0); + witness_script.push_back(0x20); // PUSH_32 + witness_script.insert(witness_script.end(), redeem_sha256.data(), redeem_sha256.data() + redeem_sha256.data_size()); } -void btc_multisig_segwit_address::create_segwit_address() -{ - fc::sha256 hash256 = fc::sha256::hash( witness_script.data(), witness_script.size() ); - fc::ripemd160 hash160 = fc::ripemd160::hash( hash256.data(), hash256.data_size() ); - - raw_address = bytes(hash160.data(), hash160.data() + hash160.data_size() ); - address = fc::to_base58( get_address_bytes( raw_address ) ); +void btc_multisig_segwit_address::create_segwit_address() { + fc::sha256 hash256 = fc::sha256::hash(witness_script.data(), witness_script.size()); + fc::ripemd160 hash160 = fc::ripemd160::hash(hash256.data(), hash256.data_size()); + + raw_address = bytes(hash160.data(), hash160.data() + hash160.data_size()); + address = fc::to_base58(get_address_bytes(raw_address)); } -bytes btc_multisig_segwit_address::get_address_bytes( const bytes& script_hash ) -{ - bytes address_bytes( 1, TESTNET_SCRIPT ); // 1 byte version - address_bytes.insert( address_bytes.end(), script_hash.begin(), script_hash.end() ); - fc::sha256 hash256 = fc::sha256::hash( fc::sha256::hash( address_bytes.data(), address_bytes.size() ) ); - address_bytes.insert( address_bytes.end(), hash256.data(), hash256.data() + 4 ); // 4 byte checksum - +bytes btc_multisig_segwit_address::get_address_bytes(const bytes &script_hash) { + bytes address_bytes(1, TESTNET_SCRIPT); // 1 byte version + address_bytes.insert(address_bytes.end(), script_hash.begin(), script_hash.end()); + fc::sha256 hash256 = fc::sha256::hash(fc::sha256::hash(address_bytes.data(), address_bytes.size())); + address_bytes.insert(address_bytes.end(), hash256.data(), hash256.data() + 4); // 4 byte checksum + return address_bytes; } - -btc_weighted_multisig_address::btc_weighted_multisig_address(const std::vector > &keys_data, - network ntype) -{ +btc_weighted_multisig_address::btc_weighted_multisig_address(const std::vector> &keys_data, + network ntype) { network_type = ntype; create_redeem_script(keys_data); create_witness_script(); @@ -267,8 +249,7 @@ btc_weighted_multisig_address::btc_weighted_multisig_address(const std::vector>& keys_data) -{ +void btc_weighted_multisig_address::create_redeem_script(const std::vector> &keys_data) { script_builder builder; uint32_t total_weight = 0; builder << uint32_t(0); @@ -292,27 +273,24 @@ void btc_weighted_multisig_address::create_redeem_script(const std::vector > &keys_data, - bitcoin_address::network ntype) -{ + const std::vector> &keys_data, + bitcoin_address::network ntype) { network_type = ntype; create_redeem_script(user_key_data, keys_data); create_witness_script(); @@ -383,8 +360,7 @@ btc_one_or_weighted_multisig_address::btc_one_or_weighted_multisig_address(const type = payment_type::P2WSH; } -void btc_one_or_weighted_multisig_address::create_redeem_script(const fc::ecc::public_key &user_key_data, const std::vector > &keys_data) -{ +void btc_one_or_weighted_multisig_address::create_redeem_script(const fc::ecc::public_key &user_key_data, const std::vector> &keys_data) { script_builder builder; builder << user_key_data.serialize(); builder << op::CHECKSIG; @@ -412,16 +388,14 @@ void btc_one_or_weighted_multisig_address::create_redeem_script(const fc::ecc::p raw_address = bytes(sh.data(), sh.data() + sh.data_size()); } -void btc_one_or_weighted_multisig_address::create_witness_script() -{ +void btc_one_or_weighted_multisig_address::create_witness_script() { script_builder builder; builder << op::_0; builder << fc::sha256::hash(redeem_script_.data(), redeem_script_.size()); witness_script_ = builder; } -void btc_one_or_weighted_multisig_address::create_segwit_address() -{ +void btc_one_or_weighted_multisig_address::create_segwit_address() { std::string hrp; switch (network_type) { case (network::mainnet): @@ -439,4 +413,4 @@ void btc_one_or_weighted_multisig_address::create_segwit_address() address = segwit_addr::encode(hrp, 0, hash_data); } -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_script.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_script.cpp index d13a76c7..07078147 100644 --- a/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_script.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_script.cpp @@ -3,21 +3,19 @@ namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -script_builder& script_builder::operator<<( op opcode ) -{ - const auto op_byte = static_cast( opcode ); - if ( op_byte < 0 || op_byte > 0xff ) - throw std::runtime_error( "script_builder::operator<<(OP): invalid opcode" ); - script.push_back( op_byte ); +script_builder &script_builder::operator<<(op opcode) { + const auto op_byte = static_cast(opcode); + if (op_byte < 0 || op_byte > 0xff) + throw std::runtime_error("script_builder::operator<<(OP): invalid opcode"); + script.push_back(op_byte); return *this; } -script_builder& script_builder::operator<<( uint32_t number ) -{ - if ( number == 0 ) { - script.push_back( static_cast( op::_0 ) ); - } else if ( number <= 16) { - script.push_back( static_cast( op::_1 ) + number - 1 ); +script_builder &script_builder::operator<<(uint32_t number) { + if (number == 0) { + script.push_back(static_cast(op::_0)); + } else if (number <= 16) { + script.push_back(static_cast(op::_1) + number - 1); } else { bytes pack_buf; while (number) { @@ -28,44 +26,40 @@ script_builder& script_builder::operator<<( uint32_t number ) // new zero-byte to make the significant byte < 0x80 again. So, the result can // be 5 bytes max. if (pack_buf.back() & 0x80) - pack_buf.push_back(0); + pack_buf.push_back(0); *this << pack_buf; } return *this; } -script_builder& script_builder::operator<<( size_t size ) -{ - write_compact_size( script, size ); +script_builder &script_builder::operator<<(size_t size) { + write_compact_size(script, size); return *this; } -script_builder& script_builder::operator<<( const bytes& sc ) { - write_compact_size( script, sc.size() ); - script.insert( script.end(), sc.begin(), sc.end() ); +script_builder &script_builder::operator<<(const bytes &sc) { + write_compact_size(script, sc.size()); + script.insert(script.end(), sc.begin(), sc.end()); return *this; } -script_builder& script_builder::operator<<( const fc::sha256& hash ) -{ - write_compact_size( script, hash.data_size() ); - script.insert( script.end(), hash.data(), hash.data() + hash.data_size() ); +script_builder &script_builder::operator<<(const fc::sha256 &hash) { + write_compact_size(script, hash.data_size()); + script.insert(script.end(), hash.data(), hash.data() + hash.data_size()); return *this; } -script_builder& script_builder::operator<<( const fc::ripemd160& hash ) -{ - write_compact_size( script, hash.data_size() ); - script.insert( script.end(), hash.data(), hash.data() + hash.data_size() ); +script_builder &script_builder::operator<<(const fc::ripemd160 &hash) { + write_compact_size(script, hash.data_size()); + script.insert(script.end(), hash.data(), hash.data() + hash.data_size()); return *this; } -script_builder& script_builder::operator<<( const fc::ecc::public_key_data& pubkey_data ) -{ - write_compact_size( script, pubkey_data.size() ); - script.insert( script.end(), pubkey_data.begin(), pubkey_data.begin() + pubkey_data.size() ); +script_builder &script_builder::operator<<(const fc::ecc::public_key_data &pubkey_data) { + write_compact_size(script, pubkey_data.size()); + script.insert(script.end(), pubkey_data.begin(), pubkey_data.begin() + pubkey_data.size()); return *this; } -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_transaction.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_transaction.cpp index cc0b108c..524a7ead 100644 --- a/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_transaction.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_transaction.cpp @@ -1,153 +1,133 @@ -#include #include #include +#include #include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -bool out_point::operator==( const out_point& op ) const -{ - if( this->hash == op.hash && - this->n == op.n ) - { +bool out_point::operator==(const out_point &op) const { + if (this->hash == op.hash && + this->n == op.n) { return true; } return false; } -bool tx_in::operator==( const tx_in& ti ) const -{ - if( this->prevout == ti.prevout && +bool tx_in::operator==(const tx_in &ti) const { + if (this->prevout == ti.prevout && this->scriptSig == ti.scriptSig && - this->nSequence == ti.nSequence ) - { + this->nSequence == ti.nSequence) { return true; } return false; } -bool tx_out::operator==( const tx_out& to ) const -{ - if( this->value == to.value && - this->scriptPubKey == to.scriptPubKey ) - { +bool tx_out::operator==(const tx_out &to) const { + if (this->value == to.value && + this->scriptPubKey == to.scriptPubKey) { return true; } return false; } -bool tx_out::is_p2wsh() const -{ - if( scriptPubKey.size() == 34 && scriptPubKey[0] == static_cast(0x00) && scriptPubKey[1] == static_cast(0x20) ) { +bool tx_out::is_p2wsh() const { + if (scriptPubKey.size() == 34 && scriptPubKey[0] == static_cast(0x00) && scriptPubKey[1] == static_cast(0x20)) { return true; } return false; } -bool tx_out::is_p2wpkh() const -{ - if( scriptPubKey.size() == 22 && scriptPubKey[0] == static_cast(0x00) && scriptPubKey[1] == static_cast(0x14) ) { +bool tx_out::is_p2wpkh() const { + if (scriptPubKey.size() == 22 && scriptPubKey[0] == static_cast(0x00) && scriptPubKey[1] == static_cast(0x14)) { return true; } return false; } -bool tx_out::is_p2pkh() const -{ - if( scriptPubKey.size() == 25 && scriptPubKey[0] == static_cast(0x76) && scriptPubKey[1] == static_cast(0xa9) && - scriptPubKey[2] == static_cast(0x14) && scriptPubKey[23] == static_cast(0x88) && scriptPubKey[24] == static_cast(0xac) ) { - return true; - } - return false; -} - -bool tx_out::is_p2sh() const -{ - if( scriptPubKey.size() == 23 && scriptPubKey[0] == static_cast(0xa9) && - scriptPubKey[1] == static_cast(0x14) && scriptPubKey[22] == static_cast(0x87) ) { - return true; - } - return false; -} - -bool tx_out::is_p2pk() const -{ - if( scriptPubKey.size() == 35 && scriptPubKey[0] == static_cast(0x21) && scriptPubKey[34] == static_cast(0xac) ) { +bool tx_out::is_p2pkh() const { + if (scriptPubKey.size() == 25 && scriptPubKey[0] == static_cast(0x76) && scriptPubKey[1] == static_cast(0xa9) && + scriptPubKey[2] == static_cast(0x14) && scriptPubKey[23] == static_cast(0x88) && scriptPubKey[24] == static_cast(0xac)) { return true; } return false; } -bytes tx_out::get_data_or_script() const -{ - if( is_p2pkh() ) { - return bytes( scriptPubKey.begin() + 3, scriptPubKey.begin() + 23 ); - } else if( is_p2sh() || is_p2wpkh() ) { - return bytes( scriptPubKey.begin() + 2, scriptPubKey.begin() + 22 ); - } else if( is_p2wsh() ) { - return bytes( scriptPubKey.begin() + 2, scriptPubKey.begin() + 34 ); - } else if( is_p2pk() ) { - return bytes( scriptPubKey.begin() + 1, scriptPubKey.begin() + 34 ); +bool tx_out::is_p2sh() const { + if (scriptPubKey.size() == 23 && scriptPubKey[0] == static_cast(0xa9) && + scriptPubKey[1] == static_cast(0x14) && scriptPubKey[22] == static_cast(0x87)) { + return true; + } + return false; +} + +bool tx_out::is_p2pk() const { + if (scriptPubKey.size() == 35 && scriptPubKey[0] == static_cast(0x21) && scriptPubKey[34] == static_cast(0xac)) { + return true; + } + return false; +} + +bytes tx_out::get_data_or_script() const { + if (is_p2pkh()) { + return bytes(scriptPubKey.begin() + 3, scriptPubKey.begin() + 23); + } else if (is_p2sh() || is_p2wpkh()) { + return bytes(scriptPubKey.begin() + 2, scriptPubKey.begin() + 22); + } else if (is_p2wsh()) { + return bytes(scriptPubKey.begin() + 2, scriptPubKey.begin() + 34); + } else if (is_p2pk()) { + return bytes(scriptPubKey.begin() + 1, scriptPubKey.begin() + 34); } return scriptPubKey; } -bool bitcoin_transaction::operator!=( const bitcoin_transaction& bt ) const -{ - if( this->nVersion != bt.nVersion || - this->vin != bt.vin || - this->vout != bt.vout || - this->nLockTime != bt.nLockTime ) - { +bool bitcoin_transaction::operator!=(const bitcoin_transaction &bt) const { + if (this->nVersion != bt.nVersion || + this->vin != bt.vin || + this->vout != bt.vout || + this->nLockTime != bt.nLockTime) { return true; } return false; } -fc::sha256 bitcoin_transaction::get_hash() const -{ - const auto bytes = pack( *this, true) ; - const auto hash = fc::sha256::hash( fc::sha256::hash(bytes.data(), bytes.size()) ); - std::reverse( hash.data(), hash.data() + hash.data_size() ); +fc::sha256 bitcoin_transaction::get_hash() const { + const auto bytes = pack(*this, true); + const auto hash = fc::sha256::hash(fc::sha256::hash(bytes.data(), bytes.size())); + std::reverse(hash.data(), hash.data() + hash.data_size()); return hash; } -fc::sha256 bitcoin_transaction::get_txid() const -{ - const auto bytes = pack( *this, false ); - const auto hash = fc::sha256::hash( fc::sha256::hash(bytes.data(), bytes.size()) ); - std::reverse( hash.data(), hash.data() + hash.data_size() ); +fc::sha256 bitcoin_transaction::get_txid() const { + const auto bytes = pack(*this, false); + const auto hash = fc::sha256::hash(fc::sha256::hash(bytes.data(), bytes.size())); + std::reverse(hash.data(), hash.data() + hash.data_size()); return hash; } -size_t bitcoin_transaction::get_vsize() const -{ +size_t bitcoin_transaction::get_vsize() const { static const auto witness_scale_factor = 4; fc::datastream no_wit_ds; - pack( no_wit_ds, *this, false ); + pack(no_wit_ds, *this, false); fc::datastream wit_ds; - pack( wit_ds, *this, true ); + pack(wit_ds, *this, true); - const size_t weight = no_wit_ds.tellp() * ( witness_scale_factor - 1 ) + wit_ds.tellp(); - const size_t vsize = ( weight + witness_scale_factor - 1 ) / witness_scale_factor; + const size_t weight = no_wit_ds.tellp() * (witness_scale_factor - 1) + wit_ds.tellp(); + const size_t vsize = (weight + witness_scale_factor - 1) / witness_scale_factor; return vsize; } -void bitcoin_transaction_builder::set_version( int32_t version ) -{ - tx.nVersion = version; +void bitcoin_transaction_builder::set_version(int32_t version) { + tx.nVersion = version; } -void bitcoin_transaction_builder::set_locktime(uint32_t lock_time) -{ - tx.nLockTime = lock_time; +void bitcoin_transaction_builder::set_locktime(uint32_t lock_time) { + tx.nLockTime = lock_time; } -void bitcoin_transaction_builder::add_in( payment_type type, const fc::sha256& txid, uint32_t n_out, const bytes& script_code, bool front, uint32_t sequence ) -{ +void bitcoin_transaction_builder::add_in(payment_type type, const fc::sha256 &txid, uint32_t n_out, const bytes &script_code, bool front, uint32_t sequence) { out_point prevout; prevout.hash = txid; prevout.n = n_out; @@ -156,97 +136,91 @@ void bitcoin_transaction_builder::add_in( payment_type type, const fc::sha256& t txin.prevout = prevout; txin.nSequence = sequence; - add_in( type, txin, script_code, front ); + add_in(type, txin, script_code, front); } -void bitcoin_transaction_builder::add_in( payment_type type, tx_in txin, const bytes& script_code, bool front ) -{ - switch ( type ) { - case payment_type::P2SH_WPKH: - case payment_type::P2SH_WSH: - FC_ASSERT( script_code != bytes() ); +void bitcoin_transaction_builder::add_in(payment_type type, tx_in txin, const bytes &script_code, bool front) { + switch (type) { + case payment_type::P2SH_WPKH: + case payment_type::P2SH_WSH: + FC_ASSERT(script_code != bytes()); + txin.scriptSig = script_code; + break; + default: { + if (txin.prevout.hash == fc::sha256("0000000000000000000000000000000000000000000000000000000000000000")) { //coinbase + FC_ASSERT(script_code != bytes()); txin.scriptSig = script_code; - break; - default:{ - if( txin.prevout.hash == fc::sha256("0000000000000000000000000000000000000000000000000000000000000000") ) { //coinbase - FC_ASSERT( script_code != bytes() ); - txin.scriptSig = script_code; - } - break; } + break; + } } - if( front ) { - tx.vin.insert( tx.vin.begin(), txin ); + if (front) { + tx.vin.insert(tx.vin.begin(), txin); } else { - tx.vin.push_back( txin ); + tx.vin.push_back(txin); } } -void bitcoin_transaction_builder::add_out( payment_type type, int64_t amount, const std::string& base58_address, bool front ) -{ +void bitcoin_transaction_builder::add_out(payment_type type, int64_t amount, const std::string &base58_address, bool front) { // TODO: add checks const auto address_bytes = fc::from_base58(base58_address); - add_out( type, amount, bytes( address_bytes.begin() + 1, address_bytes.begin() + 1 + 20 ), front ); + add_out(type, amount, bytes(address_bytes.begin() + 1, address_bytes.begin() + 1 + 20), front); } -void bitcoin_transaction_builder::add_out( payment_type type, int64_t amount, const fc::ecc::public_key_data& pubkey, bool front ) -{ - FC_ASSERT( is_payment_to_pubkey( type ) ); +void bitcoin_transaction_builder::add_out(payment_type type, int64_t amount, const fc::ecc::public_key_data &pubkey, bool front) { + FC_ASSERT(is_payment_to_pubkey(type)); - if ( type == payment_type::P2PK ) { - const auto pubkey_bytes = bytes( pubkey.begin(), pubkey.begin() + pubkey.size() ); - add_out( type, amount, pubkey_bytes, front ); + if (type == payment_type::P2PK) { + const auto pubkey_bytes = bytes(pubkey.begin(), pubkey.begin() + pubkey.size()); + add_out(type, amount, pubkey_bytes, front); } else { - const auto hash256 = fc::sha256::hash( pubkey.begin(), pubkey.size() ); - const auto hash160 = fc::ripemd160::hash( hash256.data(), hash256.data_size() ); - add_out( type, amount, bytes( hash160.data(), hash160.data() + hash160.data_size() ), front ); + const auto hash256 = fc::sha256::hash(pubkey.begin(), pubkey.size()); + const auto hash160 = fc::ripemd160::hash(hash256.data(), hash256.data_size()); + add_out(type, amount, bytes(hash160.data(), hash160.data() + hash160.data_size()), front); } } -void bitcoin_transaction_builder::add_out( payment_type type, int64_t amount, const bytes& script_code, bool front ) -{ +void bitcoin_transaction_builder::add_out(payment_type type, int64_t amount, const bytes &script_code, bool front) { tx_out out; out.value = amount; - out.scriptPubKey = get_script_pubkey( type, script_code ); + out.scriptPubKey = get_script_pubkey(type, script_code); - if( front ) { - tx.vout.insert( tx.vout.begin(), out ); + if (front) { + tx.vout.insert(tx.vout.begin(), out); } else { - tx.vout.push_back( out ); + tx.vout.push_back(out); } } -void bitcoin_transaction_builder::add_out_all_type( const uint64_t& amount, const bitcoin_address& address, bool front ) -{ - switch( address.get_type() ) { - case payment_type::P2PK: { - bytes raw_address( address.get_raw_address() ); - fc::ecc::public_key_data public_key; - std::copy( raw_address.begin(), raw_address.end(), public_key.begin() ); - add_out( address.get_type(), amount, public_key, front ); - break; - } - case payment_type::P2PKH: - case payment_type::P2SH: - case payment_type::P2SH_WPKH: - case payment_type::P2SH_WSH: { - add_out( address.get_type(), amount, address.get_address(), front ); - break; - } - case payment_type::P2WPKH: - case payment_type::P2WSH: { - add_out( address.get_type(), amount, address.get_raw_address(), front ); - break; - } - default: - break; +void bitcoin_transaction_builder::add_out_all_type(const uint64_t &amount, const bitcoin_address &address, bool front) { + switch (address.get_type()) { + case payment_type::P2PK: { + bytes raw_address(address.get_raw_address()); + fc::ecc::public_key_data public_key; + std::copy(raw_address.begin(), raw_address.end(), public_key.begin()); + add_out(address.get_type(), amount, public_key, front); + break; + } + case payment_type::P2PKH: + case payment_type::P2SH: + case payment_type::P2SH_WPKH: + case payment_type::P2SH_WSH: { + add_out(address.get_type(), amount, address.get_address(), front); + break; + } + case payment_type::P2WPKH: + case payment_type::P2WSH: { + add_out(address.get_type(), amount, address.get_raw_address(), front); + break; + } + default: + break; } } -inline bool bitcoin_transaction_builder::is_payment_to_pubkey( payment_type type ) -{ - switch ( type ) { +inline bool bitcoin_transaction_builder::is_payment_to_pubkey(payment_type type) { + switch (type) { case payment_type::P2PK: case payment_type::P2PKH: case payment_type::P2WPKH: @@ -257,25 +231,24 @@ inline bool bitcoin_transaction_builder::is_payment_to_pubkey( payment_type type } } -bytes bitcoin_transaction_builder::get_script_pubkey( payment_type type, const bytes& script_code ) -{ - switch ( type ) { - case payment_type::NULLDATA: - return script_builder() << op::RETURN << script_code; - case payment_type::P2PK: - return script_builder() << script_code << op::CHECKSIG; - case payment_type::P2PKH: - return script_builder() << op::DUP << op::HASH160 << script_code << op::EQUALVERIFY << op::CHECKSIG; - case payment_type::P2SH: - case payment_type::P2SH_WPKH: - case payment_type::P2SH_WSH: - return script_builder() << op::HASH160 << script_code << op::EQUAL; - case payment_type::P2WPKH: - case payment_type::P2WSH: - return script_builder() << op::_0 << script_code; - default: - return script_code; - } +bytes bitcoin_transaction_builder::get_script_pubkey(payment_type type, const bytes &script_code) { + switch (type) { + case payment_type::NULLDATA: + return script_builder() << op::RETURN << script_code; + case payment_type::P2PK: + return script_builder() << script_code << op::CHECKSIG; + case payment_type::P2PKH: + return script_builder() << op::DUP << op::HASH160 << script_code << op::EQUALVERIFY << op::CHECKSIG; + case payment_type::P2SH: + case payment_type::P2SH_WPKH: + case payment_type::P2SH_WSH: + return script_builder() << op::HASH160 << script_code << op::EQUAL; + case payment_type::P2WPKH: + case payment_type::P2WSH: + return script_builder() << op::_0 << script_code; + default: + return script_code; + } } -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/segwit_addr.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/segwit_addr.cpp old mode 100755 new mode 100644 index 2a926a66..2fd9be43 --- a/libraries/plugins/peerplays_sidechain/bitcoin/segwit_addr.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/segwit_addr.cpp @@ -19,63 +19,64 @@ * THE SOFTWARE. */ -#include #include +#include -namespace -{ +namespace { typedef std::vector data; /** Convert from one power-of-2 number base to another. */ -template -bool convertbits(data& out, const data& in) { - int acc = 0; - int bits = 0; - const int maxv = (1 << tobits) - 1; - const int max_acc = (1 << (frombits + tobits - 1)) - 1; - for (size_t i = 0; i < in.size(); ++i) { - int value = in[i]; - acc = ((acc << frombits) | value) & max_acc; - bits += frombits; - while (bits >= tobits) { - bits -= tobits; - out.push_back((acc >> bits) & maxv); - } - } - if (pad) { - if (bits) out.push_back((acc << (tobits - bits)) & maxv); - } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) { - return false; - } - return true; +template +bool convertbits(data &out, const data &in) { + int acc = 0; + int bits = 0; + const int maxv = (1 << tobits) - 1; + const int max_acc = (1 << (frombits + tobits - 1)) - 1; + for (size_t i = 0; i < in.size(); ++i) { + int value = in[i]; + acc = ((acc << frombits) | value) & max_acc; + bits += frombits; + while (bits >= tobits) { + bits -= tobits; + out.push_back((acc >> bits) & maxv); + } + } + if (pad) { + if (bits) + out.push_back((acc << (tobits - bits)) & maxv); + } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) { + return false; + } + return true; } -} +} // namespace namespace graphene { namespace peerplays_sidechain { namespace bitcoin { namespace segwit_addr { /** Decode a SegWit address. */ -std::pair decode(const std::string& hrp, const std::string& addr) { - std::pair dec = bech32::Decode(addr); - if (dec.first != hrp || dec.second.size() < 1) return std::make_pair(-1, data()); - data conv; - if (!convertbits<5, 8, false>(conv, data(dec.second.begin() + 1, dec.second.end())) || - conv.size() < 2 || conv.size() > 40 || dec.second[0] > 16 || (dec.second[0] == 0 && - conv.size() != 20 && conv.size() != 32)) { - return std::make_pair(-1, data()); - } - return std::make_pair(dec.second[0], conv); +std::pair decode(const std::string &hrp, const std::string &addr) { + std::pair dec = bech32::Decode(addr); + if (dec.first != hrp || dec.second.size() < 1) + return std::make_pair(-1, data()); + data conv; + if (!convertbits<5, 8, false>(conv, data(dec.second.begin() + 1, dec.second.end())) || + conv.size() < 2 || conv.size() > 40 || dec.second[0] > 16 || (dec.second[0] == 0 && conv.size() != 20 && conv.size() != 32)) { + return std::make_pair(-1, data()); + } + return std::make_pair(dec.second[0], conv); } /** Encode a SegWit address. */ -std::string encode(const std::string& hrp, int witver, const data& witprog) { - data enc; - enc.push_back(witver); - convertbits<8, 5, true>(enc, witprog); - std::string ret = bech32::Encode(hrp, enc); - if (decode(hrp, ret).first == -1) return ""; - return ret; +std::string encode(const std::string &hrp, int witver, const data &witprog) { + data enc; + enc.push_back(witver); + convertbits<8, 5, true>(enc, witprog); + std::string ret = bech32::Encode(hrp, enc); + if (decode(hrp, ret).first == -1) + return ""; + return ret; } -} } } } +}}}} // namespace graphene::peerplays_sidechain::bitcoin::segwit_addr diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.cpp index 5fae29f0..bf953800 100644 --- a/libraries/plugins/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.cpp @@ -1,136 +1,130 @@ -#include #include +#include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -const secp256k1_context_t *btc_context() -{ +const secp256k1_context_t *btc_context() { static secp256k1_context_t *ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN); return ctx; } -fc::sha256 get_signature_hash( const bitcoin_transaction& tx, const bytes& scriptCode, int64_t amount, - size_t in_index, int hash_type, bool is_witness ) -{ +fc::sha256 get_signature_hash(const bitcoin_transaction &tx, const bytes &scriptCode, int64_t amount, + size_t in_index, int hash_type, bool is_witness) { fc::datastream ps; - if ( is_witness ) - pack_tx_witness_signature( ps, scriptCode, tx, in_index, amount, hash_type ); + if (is_witness) + pack_tx_witness_signature(ps, scriptCode, tx, in_index, amount, hash_type); else - pack_tx_signature( ps, scriptCode, tx, in_index, hash_type ); + pack_tx_signature(ps, scriptCode, tx, in_index, hash_type); - std::vector vec( ps.tellp() ); - if ( !vec.empty() ) { - fc::datastream ds( vec.data(), vec.size() ); - if ( is_witness ) - pack_tx_witness_signature( ds, scriptCode, tx, in_index, amount, hash_type ); + std::vector vec(ps.tellp()); + if (!vec.empty()) { + fc::datastream ds(vec.data(), vec.size()); + if (is_witness) + pack_tx_witness_signature(ds, scriptCode, tx, in_index, amount, hash_type); else - pack_tx_signature( ds, scriptCode, tx, in_index, hash_type ); + pack_tx_signature(ds, scriptCode, tx, in_index, hash_type); } - return fc::sha256::hash( fc::sha256::hash( vec.data(), vec.size() ) ); + return fc::sha256::hash(fc::sha256::hash(vec.data(), vec.size())); } -std::vector privkey_sign( const bytes& privkey, const fc::sha256 &hash, const secp256k1_context_t* context_sign ) -{ +std::vector privkey_sign(const bytes &privkey, const fc::sha256 &hash, const secp256k1_context_t *context_sign) { bytes sig; - sig.resize( 72 ); + sig.resize(72); int sig_len = sig.size(); - FC_ASSERT( secp256k1_ecdsa_sign( - context_sign, - reinterpret_cast( hash.data() ), - reinterpret_cast( sig.data() ), - &sig_len, - reinterpret_cast( privkey.data() ), - secp256k1_nonce_function_rfc6979, - nullptr ) ); // TODO: replace assert with exception + FC_ASSERT(secp256k1_ecdsa_sign( + context_sign, + reinterpret_cast(hash.data()), + reinterpret_cast(sig.data()), + &sig_len, + reinterpret_cast(privkey.data()), + secp256k1_nonce_function_rfc6979, + nullptr)); // TODO: replace assert with exception - sig.resize( sig_len ); + sig.resize(sig_len); return sig; } -std::vector sign_witness_transaction_part( const bitcoin_transaction& tx, const std::vector& redeem_scripts, - const std::vector& amounts, const bytes& privkey, - const secp256k1_context_t* context_sign, int hash_type ) -{ - FC_ASSERT( tx.vin.size() == redeem_scripts.size() && tx.vin.size() == amounts.size() ); - FC_ASSERT( !privkey.empty() ); - - std::vector< bytes > signatures; - for( size_t i = 0; i < tx.vin.size(); i++ ) { - const auto sighash = get_signature_hash( tx, redeem_scripts[i], static_cast( amounts[i] ), i, hash_type, true ); - auto sig = privkey_sign( privkey, sighash, context_sign ); - sig.push_back( static_cast( hash_type ) ); +std::vector sign_witness_transaction_part(const bitcoin_transaction &tx, const std::vector &redeem_scripts, + const std::vector &amounts, const bytes &privkey, + const secp256k1_context_t *context_sign, int hash_type) { + FC_ASSERT(tx.vin.size() == redeem_scripts.size() && tx.vin.size() == amounts.size()); + FC_ASSERT(!privkey.empty()); - signatures.push_back( sig ); + std::vector signatures; + for (size_t i = 0; i < tx.vin.size(); i++) { + const auto sighash = get_signature_hash(tx, redeem_scripts[i], static_cast(amounts[i]), i, hash_type, true); + auto sig = privkey_sign(privkey, sighash, context_sign); + sig.push_back(static_cast(hash_type)); + + signatures.push_back(sig); } return signatures; } -void sign_witness_transaction_finalize( bitcoin_transaction& tx, const std::vector& redeem_scripts, bool use_mulisig_workaround ) -{ - FC_ASSERT( tx.vin.size() == redeem_scripts.size() ); - - for( size_t i = 0; i < tx.vin.size(); i++ ) { +void sign_witness_transaction_finalize(bitcoin_transaction &tx, const std::vector &redeem_scripts, bool use_mulisig_workaround) { + FC_ASSERT(tx.vin.size() == redeem_scripts.size()); + + for (size_t i = 0; i < tx.vin.size(); i++) { if (use_mulisig_workaround) - tx.vin[i].scriptWitness.insert( tx.vin[i].scriptWitness.begin(), bytes() ); // Bitcoin workaround CHECKMULTISIG bug - tx.vin[i].scriptWitness.push_back( redeem_scripts[i] ); + tx.vin[i].scriptWitness.insert(tx.vin[i].scriptWitness.begin(), bytes()); // Bitcoin workaround CHECKMULTISIG bug + tx.vin[i].scriptWitness.push_back(redeem_scripts[i]); } } -bool verify_sig( const bytes& sig, const bytes& pubkey, const bytes& msg, const secp256k1_context_t* context ) -{ - std::vector sig_temp( sig.begin(), sig.end() ); - std::vector pubkey_temp( pubkey.begin(), pubkey.end() ); - std::vector msg_temp( msg.begin(), msg.end() ); +bool verify_sig(const bytes &sig, const bytes &pubkey, const bytes &msg, const secp256k1_context_t *context) { + std::vector sig_temp(sig.begin(), sig.end()); + std::vector pubkey_temp(pubkey.begin(), pubkey.end()); + std::vector msg_temp(msg.begin(), msg.end()); - int result = secp256k1_ecdsa_verify( context, msg_temp.data(), sig_temp.data(), sig_temp.size(), pubkey_temp.data(), pubkey_temp.size() ); + int result = secp256k1_ecdsa_verify(context, msg_temp.data(), sig_temp.data(), sig_temp.size(), pubkey_temp.data(), pubkey_temp.size()); return result == 1; } -std::vector> sort_sigs( const bitcoin_transaction& tx, const std::vector& redeem_scripts, - const std::vector& amounts, const secp256k1_context_t* context ) -{ - FC_ASSERT( redeem_scripts.size() == amounts.size() ); +std::vector> sort_sigs(const bitcoin_transaction &tx, const std::vector &redeem_scripts, + const std::vector &amounts, const secp256k1_context_t *context) { + FC_ASSERT(redeem_scripts.size() == amounts.size()); using data = std::pair; struct comp { - bool operator() (const data& lhs, const data& rhs) const { return lhs.first < rhs.first; } + bool operator()(const data &lhs, const data &rhs) const { + return lhs.first < rhs.first; + } }; std::vector> new_stacks; - for( size_t i = 0; i < redeem_scripts.size(); i++ ) { - const std::vector& keys = get_pubkey_from_redeemScript( redeem_scripts[i] ); - const auto& sighash = get_signature_hash( tx, redeem_scripts[i], static_cast( amounts[i] ), i, 1, true ).str(); - bytes sighash_temp( parse_hex( sighash ) ); + for (size_t i = 0; i < redeem_scripts.size(); i++) { + const std::vector &keys = get_pubkey_from_redeemScript(redeem_scripts[i]); + const auto &sighash = get_signature_hash(tx, redeem_scripts[i], static_cast(amounts[i]), i, 1, true).str(); + bytes sighash_temp(parse_hex(sighash)); - std::vector stack( tx.vin[i].scriptWitness ); - std::vector marker( tx.vin[i].scriptWitness.size(), false ); + std::vector stack(tx.vin[i].scriptWitness); + std::vector marker(tx.vin[i].scriptWitness.size(), false); std::set sigs; - for( size_t j = 0; j < keys.size(); j++ ) { - for( size_t l = 0; l < stack.size(); l++ ) { - if( !verify_sig( stack[l], keys[j], sighash_temp, context ) || marker[l] ) - continue; - sigs.insert(std::make_pair(j, stack[l])); - marker[l] = true; - break; - } + for (size_t j = 0; j < keys.size(); j++) { + for (size_t l = 0; l < stack.size(); l++) { + if (!verify_sig(stack[l], keys[j], sighash_temp, context) || marker[l]) + continue; + sigs.insert(std::make_pair(j, stack[l])); + marker[l] = true; + break; + } } std::vector temp_sig; - for( auto s : sigs ) { - temp_sig.push_back( s.second ); + for (auto s : sigs) { + temp_sig.push_back(s.second); } - new_stacks.push_back( temp_sig ); + new_stacks.push_back(temp_sig); } return new_stacks; } -void add_signatures_to_transaction_multisig( bitcoin_transaction &tx, std::vector> &signature_set ) -{ +void add_signatures_to_transaction_multisig(bitcoin_transaction &tx, std::vector> &signature_set) { for (unsigned int i = 0; i < signature_set.size(); i++) { std::vector signatures = signature_set[i]; FC_ASSERT(signatures.size() == tx.vin.size(), "Invalid signatures number"); @@ -139,8 +133,7 @@ void add_signatures_to_transaction_multisig( bitcoin_transaction &tx, std::vecto } } -void add_signatures_to_transaction_weighted_multisig(bitcoin_transaction &tx, std::vector> &signature_set) -{ +void add_signatures_to_transaction_weighted_multisig(bitcoin_transaction &tx, std::vector> &signature_set) { for (unsigned int i = 0; i < signature_set.size(); i++) { std::vector signatures = signature_set[i]; FC_ASSERT(signatures.size() == tx.vin.size(), "Invalid signatures number"); @@ -150,4 +143,4 @@ void add_signatures_to_transaction_weighted_multisig(bitcoin_transaction &tx, st } } -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/bitcoin/utils.cpp b/libraries/plugins/peerplays_sidechain/bitcoin/utils.cpp old mode 100755 new mode 100644 index 139baf85..fddcd6a0 --- a/libraries/plugins/peerplays_sidechain/bitcoin/utils.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin/utils.cpp @@ -1,53 +1,48 @@ -#include #include +#include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -fc::ecc::public_key_data create_public_key_data( const std::vector& public_key ) -{ - FC_ASSERT( public_key.size() == 33 ); +fc::ecc::public_key_data create_public_key_data(const std::vector &public_key) { + FC_ASSERT(public_key.size() == 33); fc::ecc::public_key_data key; - for(size_t i = 0; i < 33; i++) { + for (size_t i = 0; i < 33; i++) { key.at(i) = public_key[i]; } return key; } -bytes get_privkey_bytes( const std::string& privkey_base58 ) -{ - const auto privkey = fc::from_base58( privkey_base58 ); +bytes get_privkey_bytes(const std::string &privkey_base58) { + const auto privkey = fc::from_base58(privkey_base58); // Remove version and hash - return bytes( privkey.cbegin() + 1, privkey.cbegin() + 1 + 32 ); + return bytes(privkey.cbegin() + 1, privkey.cbegin() + 1 + 32); } -bytes parse_hex( const std::string& str ) -{ - bytes vec( str.size() / 2 ); - fc::from_hex( str, vec.data(), vec.size() ); - return vec; +bytes parse_hex(const std::string &str) { + bytes vec(str.size() / 2); + fc::from_hex(str, vec.data(), vec.size()); + return vec; } -std::vector get_pubkey_from_redeemScript( bytes script ) -{ - FC_ASSERT( script.size() >= 37 ); +std::vector get_pubkey_from_redeemScript(bytes script) { + FC_ASSERT(script.size() >= 37); - script.erase( script.begin() ); - script.erase( script.end() - 2, script.end() ); + script.erase(script.begin()); + script.erase(script.end() - 2, script.end()); std::vector result; uint64_t count = script.size() / 34; - for( size_t i = 0; i < count; i++ ) { - result.push_back( bytes( script.begin() + (34 * i) + 1, script.begin() + (34 * (i + 1)) ) ); + for (size_t i = 0; i < count; i++) { + result.push_back(bytes(script.begin() + (34 * i) + 1, script.begin() + (34 * (i + 1)))); } return result; } -bytes public_key_data_to_bytes( const fc::ecc::public_key_data& key ) -{ - bytes result; - result.resize( key.size() ); - std::copy( key.begin(), key.end(), result.begin() ); - return result; +bytes public_key_data_to_bytes(const fc::ecc::public_key_data &key) { + bytes result; + result.resize(key.size()); + std::copy(key.begin(), key.end(), result.begin()); + return result; } -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/bitcoin_utils.cpp b/libraries/plugins/peerplays_sidechain/bitcoin_utils.cpp index 45d7d6e6..bcc3954c 100644 --- a/libraries/plugins/peerplays_sidechain/bitcoin_utils.cpp +++ b/libraries/plugins/peerplays_sidechain/bitcoin_utils.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -5,7 +6,6 @@ #include #include #include -#include namespace graphene { namespace peerplays_sidechain { diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bech32.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bech32.hpp old mode 100755 new mode 100644 index 220d83e0..c98d22bf --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bech32.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bech32.hpp @@ -16,9 +16,9 @@ namespace graphene { namespace peerplays_sidechain { namespace bitcoin { namespace bech32 { /** Encode a Bech32 string. Returns the empty string in case of failure. */ -std::string Encode(const std::string& hrp, const std::vector& values); +std::string Encode(const std::string &hrp, const std::vector &values); /** Decode a Bech32 string. Returns (hrp, data). Empty hrp means failure. */ -std::pair> Decode(const std::string& str); +std::pair> Decode(const std::string &str); -} } } } // namespace sidechain::bech32 +}}}} // namespace graphene::peerplays_sidechain::bitcoin::bech32 diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp old mode 100755 new mode 100644 index df467ceb..cf71fdfa --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp @@ -7,10 +7,9 @@ using namespace graphene::chain; namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -const bytes op_num = {0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f}; // OP_1 - OP_15 +const bytes op_num = {0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}; // OP_1 - OP_15 -class bitcoin_address -{ +class bitcoin_address { public: enum network { @@ -21,31 +20,42 @@ public: bitcoin_address() = default; - bitcoin_address( const std::string& addr, network ntype = network::regtest ) : address( addr ), type( determine_type() ), - raw_address( determine_raw_address() ), network_type(ntype) {} + bitcoin_address(const std::string &addr, network ntype = network::regtest) : + address(addr), + type(determine_type()), + raw_address(determine_raw_address()), + network_type(ntype) { + } - bool operator==( const bitcoin_address& btc_addr ) const; + bool operator==(const bitcoin_address &btc_addr) const; - payment_type get_type() const { return type; } + payment_type get_type() const { + return type; + } - std::string get_address() const { return address; } + std::string get_address() const { + return address; + } - bytes get_raw_address() const { return raw_address; } + bytes get_raw_address() const { + return raw_address; + } bytes get_script() const; network get_network_type() const { return network_type; } -private: - enum size_segwit_address { P2WSH = 32, P2WPKH = 20 }; +private: + enum size_segwit_address { P2WSH = 32, + P2WPKH = 20 }; payment_type determine_type(); bytes determine_raw_address(); - bool check_segwit_address( const size_segwit_address& size ) const; + bool check_segwit_address(const size_segwit_address &size) const; bool is_p2pk() const; @@ -58,7 +68,6 @@ private: bool is_p2sh() const; public: - std::string address; payment_type type; @@ -66,87 +75,87 @@ public: bytes raw_address; network network_type; - }; -class btc_multisig_address : public bitcoin_address -{ +class btc_multisig_address : public bitcoin_address { public: - btc_multisig_address() = default; - btc_multisig_address( const size_t n_required, const accounts_keys& keys ); + btc_multisig_address(const size_t n_required, const accounts_keys &keys); - size_t count_intersection( const accounts_keys& keys ) const; + size_t count_intersection(const accounts_keys &keys) const; - bytes get_redeem_script() const { return redeem_script; } + bytes get_redeem_script() const { + return redeem_script; + } private: - void create_redeem_script(); void create_address(); public: + enum address_types { MAINNET_SCRIPT = 5, + TESTNET_SCRIPT = 196 }; - enum address_types { MAINNET_SCRIPT = 5, TESTNET_SCRIPT = 196 }; + enum { OP_0 = 0x00, + OP_EQUAL = 0x87, + OP_HASH160 = 0xa9, + OP_CHECKMULTISIG = 0xae }; - enum { OP_0 = 0x00, OP_EQUAL = 0x87, OP_HASH160 = 0xa9, OP_CHECKMULTISIG = 0xae }; - bytes redeem_script; size_t keys_required = 0; accounts_keys witnesses_keys; - }; // multisig segwit address (P2WSH) // https://0bin.net/paste/nfnSf0HcBqBUGDto#7zJMRUhGEBkyh-eASQPEwKfNHgQ4D5KrUJRsk8MTPSa -class btc_multisig_segwit_address : public btc_multisig_address -{ +class btc_multisig_segwit_address : public btc_multisig_address { public: - btc_multisig_segwit_address() = default; - btc_multisig_segwit_address( const size_t n_required, const accounts_keys& keys ); + btc_multisig_segwit_address(const size_t n_required, const accounts_keys &keys); - bool operator==( const btc_multisig_segwit_address& addr ) const; + bool operator==(const btc_multisig_segwit_address &addr) const; - bytes get_witness_script() const { return witness_script; } + bytes get_witness_script() const { + return witness_script; + } std::vector get_keys(); private: - void create_witness_script(); void create_segwit_address(); - bytes get_address_bytes( const bytes& script_hash ); + bytes get_address_bytes(const bytes &script_hash); public: - bytes witness_script; - }; -class btc_weighted_multisig_address : public bitcoin_address -{ +class btc_weighted_multisig_address : public bitcoin_address { public: btc_weighted_multisig_address() = default; - btc_weighted_multisig_address( const std::vector>& keys_data, - network network_type = network::regtest); + btc_weighted_multisig_address(const std::vector> &keys_data, + network network_type = network::regtest); + + bytes get_redeem_script() const { + return redeem_script_; + } + bytes get_witness_script() const { + return witness_script_; + } - bytes get_redeem_script() const { return redeem_script_; } - bytes get_witness_script() const { return witness_script_; } private: - - void create_redeem_script(const std::vector>& keys_data); + void create_redeem_script(const std::vector> &keys_data); void create_witness_script(); void create_segwit_address(); @@ -166,10 +175,12 @@ public: bytes get_witness_script() const { return witness_script_; } + private: void create_redeem_script(const fc::ecc::public_key &user_key_data, const uint8_t nrequired, const std::vector &keys_data); void create_witness_script(); void create_segwit_address(); + public: bytes redeem_script_; bytes witness_script_; @@ -178,42 +189,41 @@ public: class btc_one_or_weighted_multisig_address : public bitcoin_address { public: btc_one_or_weighted_multisig_address() = default; - btc_one_or_weighted_multisig_address(const fc::ecc::public_key &user_key_data, const std::vector>& keys_data, - network network_type = network::regtest); + btc_one_or_weighted_multisig_address(const fc::ecc::public_key &user_key_data, const std::vector> &keys_data, + network network_type = network::regtest); bytes get_redeem_script() const { return redeem_script_; } bytes get_witness_script() const { return witness_script_; } + private: - void create_redeem_script(const fc::ecc::public_key &user_key_data, const std::vector>& keys_data); + void create_redeem_script(const fc::ecc::public_key &user_key_data, const std::vector> &keys_data); void create_witness_script(); void create_segwit_address(); + public: bytes redeem_script_; bytes witness_script_; }; -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin FC_REFLECT_ENUM(graphene::peerplays_sidechain::bitcoin::bitcoin_address::network, - (mainnet) - (testnet) - (regtest) - ) + (mainnet)(testnet)(regtest)) -FC_REFLECT( graphene::peerplays_sidechain::bitcoin::bitcoin_address, (address)(type)(raw_address)(network_type) ); +FC_REFLECT(graphene::peerplays_sidechain::bitcoin::bitcoin_address, (address)(type)(raw_address)(network_type)); -FC_REFLECT_DERIVED( graphene::peerplays_sidechain::bitcoin::btc_multisig_address, (graphene::peerplays_sidechain::bitcoin::bitcoin_address), - (redeem_script)(keys_required)(witnesses_keys) ); +FC_REFLECT_DERIVED(graphene::peerplays_sidechain::bitcoin::btc_multisig_address, (graphene::peerplays_sidechain::bitcoin::bitcoin_address), + (redeem_script)(keys_required)(witnesses_keys)); -FC_REFLECT_DERIVED( graphene::peerplays_sidechain::bitcoin::btc_multisig_segwit_address, (graphene::peerplays_sidechain::bitcoin::btc_multisig_address), (witness_script) ); +FC_REFLECT_DERIVED(graphene::peerplays_sidechain::bitcoin::btc_multisig_segwit_address, (graphene::peerplays_sidechain::bitcoin::btc_multisig_address), (witness_script)); -FC_REFLECT_DERIVED( graphene::peerplays_sidechain::bitcoin::btc_weighted_multisig_address, - (graphene::peerplays_sidechain::bitcoin::bitcoin_address), - (redeem_script_)(witness_script_) ); +FC_REFLECT_DERIVED(graphene::peerplays_sidechain::bitcoin::btc_weighted_multisig_address, + (graphene::peerplays_sidechain::bitcoin::bitcoin_address), + (redeem_script_)(witness_script_)); -FC_REFLECT_DERIVED( graphene::peerplays_sidechain::bitcoin::btc_one_or_m_of_n_multisig_address, - (graphene::peerplays_sidechain::bitcoin::bitcoin_address), - (redeem_script_)(witness_script_) ); +FC_REFLECT_DERIVED(graphene::peerplays_sidechain::bitcoin::btc_one_or_m_of_n_multisig_address, + (graphene::peerplays_sidechain::bitcoin::bitcoin_address), + (redeem_script_)(witness_script_)); diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_script.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_script.hpp index 99227440..afea853f 100644 --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_script.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_script.hpp @@ -54,27 +54,26 @@ enum class op { class script_builder { public: + script_builder &operator<<(op opcode); - script_builder& operator<<( op opcode ); + script_builder &operator<<(uint32_t number); - script_builder& operator<<( uint32_t number ); + script_builder &operator<<(size_t size); - script_builder& operator<<( size_t size ); + script_builder &operator<<(const bytes &sc); - script_builder& operator<<( const bytes& sc ); + script_builder &operator<<(const fc::sha256 &hash); - script_builder& operator<<( const fc::sha256& hash ); + script_builder &operator<<(const fc::ripemd160 &hash); - script_builder& operator<<( const fc::ripemd160& hash ); + script_builder &operator<<(const fc::ecc::public_key_data &pubkey_data); - script_builder& operator<<( const fc::ecc::public_key_data& pubkey_data ); - - operator bytes() const { return std::move( script ); } + operator bytes() const { + return std::move(script); + } private: - bytes script; - }; -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_transaction.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_transaction.hpp index b300e4ff..5c5c74a0 100644 --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_transaction.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_transaction.hpp @@ -7,13 +7,16 @@ struct out_point { fc::sha256 hash; uint32_t n = 0; out_point() = default; - out_point( fc::sha256 _hash, uint32_t _n ) : hash( _hash ), n( _n ) {} - bool operator==( const out_point& op ) const; + out_point(fc::sha256 _hash, uint32_t _n) : + hash(_hash), + n(_n) { + } + bool operator==(const out_point &op) const; }; struct tx_in { - bool operator==( const tx_in& ti ) const; + bool operator==(const tx_in &ti) const; out_point prevout; bytes scriptSig; @@ -25,7 +28,7 @@ struct tx_out { int64_t value = 0; bytes scriptPubKey; - bool operator==( const tx_out& to ) const; + bool operator==(const tx_out &to) const; bool is_p2wsh() const; @@ -42,7 +45,7 @@ struct tx_out { struct bitcoin_transaction { - bool operator!=( const bitcoin_transaction& bt ) const; + bool operator!=(const bitcoin_transaction &bt) const; int32_t nVersion = 1; std::vector vin; @@ -54,47 +57,47 @@ struct bitcoin_transaction { size_t get_vsize() const; }; -class bitcoin_transaction_builder -{ +class bitcoin_transaction_builder { public: - bitcoin_transaction_builder() = default; - bitcoin_transaction_builder( const bitcoin_transaction _tx ) : tx( _tx ) {} + bitcoin_transaction_builder(const bitcoin_transaction _tx) : + tx(_tx) { + } - void set_version( int32_t version ); + void set_version(int32_t version); - void set_locktime( uint32_t lock_time ); + void set_locktime(uint32_t lock_time); - void add_in( payment_type type, const fc::sha256& txid, uint32_t n_out, - const bytes& script_code, bool front = false, uint32_t sequence = 0xffffffff ); - - void add_in( payment_type type, tx_in txin, const bytes& script_code, bool front = false ); + void add_in(payment_type type, const fc::sha256 &txid, uint32_t n_out, + const bytes &script_code, bool front = false, uint32_t sequence = 0xffffffff); - void add_out( payment_type type, int64_t amount, const std::string& base58_address, bool front = false ); + void add_in(payment_type type, tx_in txin, const bytes &script_code, bool front = false); - void add_out( payment_type type, int64_t amount, const fc::ecc::public_key_data& pubkey, bool front = false ); + void add_out(payment_type type, int64_t amount, const std::string &base58_address, bool front = false); - void add_out( payment_type type, int64_t amount, const bytes& script_code, bool front = false ); + void add_out(payment_type type, int64_t amount, const fc::ecc::public_key_data &pubkey, bool front = false); - void add_out_all_type( const uint64_t& amount, const bitcoin_address& address, bool front = false ); + void add_out(payment_type type, int64_t amount, const bytes &script_code, bool front = false); - bitcoin_transaction get_transaction() const { return tx; } + void add_out_all_type(const uint64_t &amount, const bitcoin_address &address, bool front = false); + + bitcoin_transaction get_transaction() const { + return tx; + } private: + inline bool is_payment_to_pubkey(payment_type type); - inline bool is_payment_to_pubkey( payment_type type ); - - bytes get_script_pubkey( payment_type type, const bytes& script_code ); + bytes get_script_pubkey(payment_type type, const bytes &script_code); bitcoin_transaction tx; - }; -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin -FC_REFLECT( graphene::peerplays_sidechain::bitcoin::out_point, (hash)(n) ) -FC_REFLECT( graphene::peerplays_sidechain::bitcoin::tx_in, (prevout)(scriptSig)(nSequence)(scriptWitness) ) -FC_REFLECT( graphene::peerplays_sidechain::bitcoin::tx_out, (value)(scriptPubKey) ) -FC_REFLECT( graphene::peerplays_sidechain::bitcoin::bitcoin_transaction, (nVersion)(vin)(vout)(nLockTime) ) +FC_REFLECT(graphene::peerplays_sidechain::bitcoin::out_point, (hash)(n)) +FC_REFLECT(graphene::peerplays_sidechain::bitcoin::tx_in, (prevout)(scriptSig)(nSequence)(scriptWitness)) +FC_REFLECT(graphene::peerplays_sidechain::bitcoin::tx_out, (value)(scriptPubKey)) +FC_REFLECT(graphene::peerplays_sidechain::bitcoin::bitcoin_transaction, (nVersion)(vin)(vout)(nLockTime)) diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/segwit_addr.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/segwit_addr.hpp old mode 100755 new mode 100644 index 651ffd74..b7f2748e --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/segwit_addr.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/segwit_addr.hpp @@ -20,15 +20,15 @@ */ #include -#include #include +#include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { namespace segwit_addr { /** Decode a SegWit address. Returns (witver, witprog). witver = -1 means failure. */ -std::pair > decode(const std::string& hrp, const std::string& addr); +std::pair> decode(const std::string &hrp, const std::string &addr); /** Encode a SegWit address. Empty string means failure. */ -std::string encode(const std::string& hrp, int witver, const std::vector& witprog); +std::string encode(const std::string &hrp, int witver, const std::vector &witprog); -} } } } \ No newline at end of file +}}}} // namespace graphene::peerplays_sidechain::bitcoin::segwit_addr \ No newline at end of file diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/serialize.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/serialize.hpp index c1ff6483..2f1dfffe 100644 --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/serialize.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/serialize.hpp @@ -1,305 +1,292 @@ #pragma once -#include #include +#include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -inline void write_compact_size( bytes& vec, size_t size ) -{ +inline void write_compact_size(bytes &vec, size_t size) { bytes sb; - sb.reserve( 2 ); - if ( size < 253 ) { - sb.insert( sb.end(), static_cast( size ) ); - } else if ( size <= std::numeric_limits::max() ) { - uint16_t tmp = htole16( static_cast( size ) ); - sb.insert( sb.end(), static_cast( 253 ) ); - sb.insert( sb.end(), reinterpret_cast( tmp ), reinterpret_cast( tmp ) + sizeof( tmp ) ); - } else if ( size <= std::numeric_limits::max() ) { - uint32_t tmp = htole32( static_cast( size ) ); - sb.insert( sb.end(), static_cast( 254 ) ); - sb.insert( sb.end(), reinterpret_cast( tmp ), reinterpret_cast( tmp ) + sizeof( tmp ) ); + sb.reserve(2); + if (size < 253) { + sb.insert(sb.end(), static_cast(size)); + } else if (size <= std::numeric_limits::max()) { + uint16_t tmp = htole16(static_cast(size)); + sb.insert(sb.end(), static_cast(253)); + sb.insert(sb.end(), reinterpret_cast(tmp), reinterpret_cast(tmp) + sizeof(tmp)); + } else if (size <= std::numeric_limits::max()) { + uint32_t tmp = htole32(static_cast(size)); + sb.insert(sb.end(), static_cast(254)); + sb.insert(sb.end(), reinterpret_cast(tmp), reinterpret_cast(tmp) + sizeof(tmp)); } else { - uint64_t tmp = htole64( static_cast( size ) ); - sb.insert( sb.end(), static_cast( 255 ) ); - sb.insert( sb.end(), reinterpret_cast( tmp ), reinterpret_cast( tmp ) + sizeof( tmp ) ); + uint64_t tmp = htole64(static_cast(size)); + sb.insert(sb.end(), static_cast(255)); + sb.insert(sb.end(), reinterpret_cast(tmp), reinterpret_cast(tmp) + sizeof(tmp)); } - vec.insert( vec.end(), sb.begin(), sb.end() ); + vec.insert(vec.end(), sb.begin(), sb.end()); } -template -inline void pack_compact_size(Stream& s, size_t size) -{ - if ( size < 253 ) { - fc::raw::pack( s, static_cast( size ) ); - } else if ( size <= std::numeric_limits::max() ) { - fc::raw::pack( s, static_cast( 253 ) ); - fc::raw::pack( s, htole16( static_cast( size ) ) ); - } else if ( size <= std::numeric_limits::max() ) { - fc::raw::pack( s, static_cast( 254 ) ); - fc::raw::pack( s, htole32(static_cast( size ) ) ); +template +inline void pack_compact_size(Stream &s, size_t size) { + if (size < 253) { + fc::raw::pack(s, static_cast(size)); + } else if (size <= std::numeric_limits::max()) { + fc::raw::pack(s, static_cast(253)); + fc::raw::pack(s, htole16(static_cast(size))); + } else if (size <= std::numeric_limits::max()) { + fc::raw::pack(s, static_cast(254)); + fc::raw::pack(s, htole32(static_cast(size))); } else { - fc::raw::pack( s, static_cast( 255 ) ); - fc::raw::pack( s, htole64( static_cast( size ) ) ); + fc::raw::pack(s, static_cast(255)); + fc::raw::pack(s, htole64(static_cast(size))); } } -template -inline uint64_t unpack_compact_size( Stream& s ) -{ +template +inline uint64_t unpack_compact_size(Stream &s) { uint8_t size; uint64_t size_ret; - fc::raw::unpack( s, size ); + fc::raw::unpack(s, size); if (size < 253) { size_ret = size; - } else if ( size == 253 ) { + } else if (size == 253) { uint16_t tmp; - fc::raw::unpack( s, tmp ); - size_ret = le16toh( tmp ); - if ( size_ret < 253 ) - FC_THROW_EXCEPTION( fc::parse_error_exception, "non-canonical unpack_compact_size()" ); - } else if ( size == 254 ) { + fc::raw::unpack(s, tmp); + size_ret = le16toh(tmp); + if (size_ret < 253) + FC_THROW_EXCEPTION(fc::parse_error_exception, "non-canonical unpack_compact_size()"); + } else if (size == 254) { uint32_t tmp; - fc::raw::unpack( s, tmp ); - size_ret = le32toh( tmp ); - if ( size_ret < 0x10000u ) - FC_THROW_EXCEPTION( fc::parse_error_exception, "non-canonical unpack_compact_size()" ); + fc::raw::unpack(s, tmp); + size_ret = le32toh(tmp); + if (size_ret < 0x10000u) + FC_THROW_EXCEPTION(fc::parse_error_exception, "non-canonical unpack_compact_size()"); } else { uint32_t tmp; - fc::raw::unpack( s, tmp ); - size_ret = le64toh( tmp ); - if ( size_ret < 0x100000000ULL ) - FC_THROW_EXCEPTION( fc::parse_error_exception, "non-canonical unpack_compact_size()" ); + fc::raw::unpack(s, tmp); + size_ret = le64toh(tmp); + if (size_ret < 0x100000000ULL) + FC_THROW_EXCEPTION(fc::parse_error_exception, "non-canonical unpack_compact_size()"); } - if ( size_ret > 0x08000000 ) - FC_THROW_EXCEPTION( fc::parse_error_exception, "unpack_compact_size(): size too large" ); + if (size_ret > 0x08000000) + FC_THROW_EXCEPTION(fc::parse_error_exception, "unpack_compact_size(): size too large"); return size_ret; } - -template -inline void unpack( Stream& s, int64_t& u, uint32_t _max_depth=FC_PACK_MAX_DEPTH ) { s.read( (char*)&u, sizeof(u) ); } - -template -inline void unpack( Stream& s, int32_t& u, uint32_t _max_depth=FC_PACK_MAX_DEPTH ) { s.read( (char*)&u, sizeof(u) ); } - -template -inline void pack( Stream& s, const std::vector& v ) -{ - pack_compact_size( s, v.size() ); - if ( !v.empty() ) - s.write( v.data(), v.size() ); +template +inline void unpack(Stream &s, int64_t &u, uint32_t _max_depth = FC_PACK_MAX_DEPTH) { + s.read((char *)&u, sizeof(u)); } -template -inline void unpack( Stream& s, std::vector& v ) -{ - const auto size = unpack_compact_size( s ); - v.resize( size ); - if ( size ) - s.read( v.data(), size ); +template +inline void unpack(Stream &s, int32_t &u, uint32_t _max_depth = FC_PACK_MAX_DEPTH) { + s.read((char *)&u, sizeof(u)); } -template -inline void pack( Stream& s, const T& val ) -{ - fc::raw::pack( s, val ); +template +inline void pack(Stream &s, const std::vector &v) { + pack_compact_size(s, v.size()); + if (!v.empty()) + s.write(v.data(), v.size()); } -template -inline void unpack( Stream& s, T& val ) -{ - fc::raw::unpack( s, val ); +template +inline void unpack(Stream &s, std::vector &v) { + const auto size = unpack_compact_size(s); + v.resize(size); + if (size) + s.read(v.data(), size); } -template -inline void pack( Stream& s, const out_point& op ) -{ - fc::sha256 reversed( op.hash ); - std::reverse( reversed.data(), reversed.data() + reversed.data_size() ); - s.write( reversed.data(), reversed.data_size() ); - pack( s, op.n ); +template +inline void pack(Stream &s, const T &val) { + fc::raw::pack(s, val); } -template -inline void unpack( Stream& s, out_point& op ) -{ +template +inline void unpack(Stream &s, T &val) { + fc::raw::unpack(s, val); +} + +template +inline void pack(Stream &s, const out_point &op) { + fc::sha256 reversed(op.hash); + std::reverse(reversed.data(), reversed.data() + reversed.data_size()); + s.write(reversed.data(), reversed.data_size()); + pack(s, op.n); +} + +template +inline void unpack(Stream &s, out_point &op) { uint64_t hash_size = op.hash.data_size(); - std::unique_ptr hash_data( new char[hash_size] ); - s.read( hash_data.get(), hash_size ); - std::reverse( hash_data.get(), hash_data.get() + hash_size ); + std::unique_ptr hash_data(new char[hash_size]); + s.read(hash_data.get(), hash_size); + std::reverse(hash_data.get(), hash_data.get() + hash_size); - op.hash = fc::sha256( hash_data.get(), hash_size ); - unpack( s, op.n ); + op.hash = fc::sha256(hash_data.get(), hash_size); + unpack(s, op.n); } -template -inline void pack( Stream& s, const tx_in& in ) -{ - pack( s, in.prevout ); - pack( s, in.scriptSig ); - pack( s, in.nSequence ); +template +inline void pack(Stream &s, const tx_in &in) { + pack(s, in.prevout); + pack(s, in.scriptSig); + pack(s, in.nSequence); } -template -inline void unpack( Stream& s, tx_in& in ) -{ - unpack( s, in.prevout ); - unpack( s, in.scriptSig ); - unpack( s, in.nSequence ); +template +inline void unpack(Stream &s, tx_in &in) { + unpack(s, in.prevout); + unpack(s, in.scriptSig); + unpack(s, in.nSequence); } -template -inline void pack( Stream& s, const tx_out& out ) -{ - pack( s, out.value ); - pack( s, out.scriptPubKey ); +template +inline void pack(Stream &s, const tx_out &out) { + pack(s, out.value); + pack(s, out.scriptPubKey); } -template -inline void unpack( Stream& s, tx_out& out ) -{ - unpack( s, out.value ); - unpack( s, out.scriptPubKey ); +template +inline void unpack(Stream &s, tx_out &out) { + unpack(s, out.value); + unpack(s, out.scriptPubKey); } -template -inline void pack( Stream& s, const bitcoin_transaction& tx, bool with_witness = true ) -{ +template +inline void pack(Stream &s, const bitcoin_transaction &tx, bool with_witness = true) { uint8_t flags = 0; - if ( with_witness ) { - for ( const auto& in : tx.vin ) { - if ( !in.scriptWitness.empty() ) { + if (with_witness) { + for (const auto &in : tx.vin) { + if (!in.scriptWitness.empty()) { flags |= 1; break; } } } - pack( s, tx.nVersion ); + pack(s, tx.nVersion); - if ( flags ) { - pack_compact_size( s, 0 ); - pack( s, flags ); + if (flags) { + pack_compact_size(s, 0); + pack(s, flags); } - pack_compact_size( s, tx.vin.size() ); - for ( const auto& in : tx.vin ) - pack( s, in ); + pack_compact_size(s, tx.vin.size()); + for (const auto &in : tx.vin) + pack(s, in); - pack_compact_size( s, tx.vout.size() ); - for ( const auto& out : tx.vout ) - pack( s, out ); + pack_compact_size(s, tx.vout.size()); + for (const auto &out : tx.vout) + pack(s, out); - if ( flags & 1 ) { - for ( const auto in : tx.vin ) { - pack_compact_size( s, in.scriptWitness.size() ); - for ( const auto& sc : in.scriptWitness ) - pack( s, sc ); + if (flags & 1) { + for (const auto in : tx.vin) { + pack_compact_size(s, in.scriptWitness.size()); + for (const auto &sc : in.scriptWitness) + pack(s, sc); } } - pack( s, tx.nLockTime ); + pack(s, tx.nLockTime); } -template -inline void unpack( Stream& s, bitcoin_transaction& tx ) -{ +template +inline void unpack(Stream &s, bitcoin_transaction &tx) { uint8_t flags = 0; - unpack( s, tx.nVersion ); + unpack(s, tx.nVersion); - auto vin_size = unpack_compact_size( s ); - if ( vin_size == 0 ) { - unpack( s, flags ); - vin_size = unpack_compact_size( s ); + auto vin_size = unpack_compact_size(s); + if (vin_size == 0) { + unpack(s, flags); + vin_size = unpack_compact_size(s); } - tx.vin.reserve( vin_size ); - for ( size_t i = 0; i < vin_size; i++ ) { + tx.vin.reserve(vin_size); + for (size_t i = 0; i < vin_size; i++) { tx_in in; - unpack( s, in ); - tx.vin.push_back( in ); + unpack(s, in); + tx.vin.push_back(in); } - const auto vout_size = unpack_compact_size( s ); - tx.vout.reserve( vout_size ); - for ( size_t i = 0; i < vout_size; i++ ) { + const auto vout_size = unpack_compact_size(s); + tx.vout.reserve(vout_size); + for (size_t i = 0; i < vout_size; i++) { tx_out out; - unpack( s, out ); - tx.vout.push_back( out ); + unpack(s, out); + tx.vout.push_back(out); } - if ( flags & 1 ) { - for ( auto& in : tx.vin ) { - uint64_t stack_size = unpack_compact_size( s ); - in.scriptWitness.reserve( stack_size ); - for ( uint64_t i = 0; i < stack_size; i++ ) { + if (flags & 1) { + for (auto &in : tx.vin) { + uint64_t stack_size = unpack_compact_size(s); + in.scriptWitness.reserve(stack_size); + for (uint64_t i = 0; i < stack_size; i++) { std::vector script; - unpack( s, script ); - in.scriptWitness.push_back( script ); + unpack(s, script); + in.scriptWitness.push_back(script); } } } - unpack( s, tx.nLockTime ); + unpack(s, tx.nLockTime); } -inline std::vector pack( const bitcoin_transaction& v, bool with_witness = true ) -{ +inline std::vector pack(const bitcoin_transaction &v, bool with_witness = true) { fc::datastream ps; - pack( ps, v, with_witness ); - std::vector vec( ps.tellp() ); + pack(ps, v, with_witness); + std::vector vec(ps.tellp()); - if( !vec.empty() ) { - fc::datastream ds( vec.data(), size_t( vec.size() ) ); - pack( ds, v, with_witness ); + if (!vec.empty()) { + fc::datastream ds(vec.data(), size_t(vec.size())); + pack(ds, v, with_witness); } return vec; } -inline bitcoin_transaction unpack( const std::vector& s ) -{ try { - bitcoin_transaction tmp; - if( !s.empty() ) { - fc::datastream ds( s.data(), size_t( s.size() ) ); - unpack(ds, tmp); +inline bitcoin_transaction unpack(const std::vector &s) { + try { + bitcoin_transaction tmp; + if (!s.empty()) { + fc::datastream ds(s.data(), size_t(s.size())); + unpack(ds, tmp); + } + return tmp; } - return tmp; -} FC_RETHROW_EXCEPTIONS( warn, "error unpacking ${type}", ("type","transaction" ) ) } - -template -inline void pack_tx_signature( Stream& s, const std::vector& scriptPubKey, const bitcoin_transaction& tx, unsigned int in_index, int hash_type ) -{ - pack( s, tx.nVersion ); - - pack_compact_size( s, tx.vin.size() ); - for ( size_t i = 0; i < tx.vin.size(); i++ ) { - const auto& in = tx.vin[i]; - pack( s, in.prevout ); - if ( i == in_index ) - pack( s, scriptPubKey ); - else - pack_compact_size( s, 0 ); // Blank signature - pack( s, in.nSequence ); - } - - pack_compact_size( s, tx.vout.size() ); - for ( const auto& out : tx.vout ) - pack( s, out ); - - pack( s, tx.nLockTime ); - pack( s, hash_type ); + FC_RETHROW_EXCEPTIONS(warn, "error unpacking ${type}", ("type", "transaction")) } -template -inline void pack_tx_witness_signature( Stream& s, const std::vector& scriptCode, const bitcoin_transaction& tx, unsigned int in_index, int64_t amount, int hash_type ) -{ +template +inline void pack_tx_signature(Stream &s, const std::vector &scriptPubKey, const bitcoin_transaction &tx, unsigned int in_index, int hash_type) { + pack(s, tx.nVersion); + + pack_compact_size(s, tx.vin.size()); + for (size_t i = 0; i < tx.vin.size(); i++) { + const auto &in = tx.vin[i]; + pack(s, in.prevout); + if (i == in_index) + pack(s, scriptPubKey); + else + pack_compact_size(s, 0); // Blank signature + pack(s, in.nSequence); + } + + pack_compact_size(s, tx.vout.size()); + for (const auto &out : tx.vout) + pack(s, out); + + pack(s, tx.nLockTime); + pack(s, hash_type); +} + +template +inline void pack_tx_witness_signature(Stream &s, const std::vector &scriptCode, const bitcoin_transaction &tx, unsigned int in_index, int64_t amount, int hash_type) { fc::sha256 hash_prevouts; fc::sha256 hash_sequence; @@ -307,61 +294,61 @@ inline void pack_tx_witness_signature( Stream& s, const std::vector& scrip { fc::datastream ps; - for ( const auto in : tx.vin ) - pack( ps, in.prevout ); + for (const auto in : tx.vin) + pack(ps, in.prevout); - std::vector vec( ps.tellp() ); - if ( vec.size() ) { - fc::datastream ds( vec.data(), size_t( vec.size() ) ); - for ( const auto in : tx.vin ) - pack( ds, in.prevout ); + std::vector vec(ps.tellp()); + if (vec.size()) { + fc::datastream ds(vec.data(), size_t(vec.size())); + for (const auto in : tx.vin) + pack(ds, in.prevout); } - hash_prevouts = fc::sha256::hash( fc::sha256::hash( vec.data(), vec.size() ) ); + hash_prevouts = fc::sha256::hash(fc::sha256::hash(vec.data(), vec.size())); } { fc::datastream ps; - for ( const auto in : tx.vin ) - pack( ps, in.nSequence ); + for (const auto in : tx.vin) + pack(ps, in.nSequence); - std::vector vec( ps.tellp() ); - if ( vec.size() ) { - fc::datastream ds( vec.data(), size_t( vec.size() ) ); - for ( const auto in : tx.vin ) - pack( ds, in.nSequence ); + std::vector vec(ps.tellp()); + if (vec.size()) { + fc::datastream ds(vec.data(), size_t(vec.size())); + for (const auto in : tx.vin) + pack(ds, in.nSequence); } - hash_sequence = fc::sha256::hash( fc::sha256::hash( vec.data(), vec.size() ) ); + hash_sequence = fc::sha256::hash(fc::sha256::hash(vec.data(), vec.size())); }; { fc::datastream ps; - for ( const auto out : tx.vout ) - pack( ps, out ); + for (const auto out : tx.vout) + pack(ps, out); - std::vector vec( ps.tellp() ); - if ( vec.size() ) { - fc::datastream ds( vec.data(), size_t( vec.size() ) ); - for ( const auto out : tx.vout ) - pack( ds, out ); + std::vector vec(ps.tellp()); + if (vec.size()) { + fc::datastream ds(vec.data(), size_t(vec.size())); + for (const auto out : tx.vout) + pack(ds, out); } - hash_output = fc::sha256::hash( fc::sha256::hash( vec.data(), vec.size() ) ); + hash_output = fc::sha256::hash(fc::sha256::hash(vec.data(), vec.size())); } - pack( s, tx.nVersion ); - pack( s, hash_prevouts ); - pack( s, hash_sequence ); + pack(s, tx.nVersion); + pack(s, hash_prevouts); + pack(s, hash_sequence); - pack( s, tx.vin[in_index].prevout ); - pack( s, scriptCode ); - pack( s, amount ); - pack( s, tx.vin[in_index].nSequence ); + pack(s, tx.vin[in_index].prevout); + pack(s, scriptCode); + pack(s, amount); + pack(s, tx.vin[in_index].nSequence); - pack( s, hash_output ); - pack( s, tx.nLockTime ); - pack( s, hash_type ); + pack(s, hash_output); + pack(s, tx.nLockTime); + pack(s, hash_type); } -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.hpp index 9417ea00..51844e4c 100644 --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/sign_bitcoin_transaction.hpp @@ -1,7 +1,7 @@ #pragma once -#include #include +#include #include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { @@ -10,24 +10,24 @@ class bitcoin_transaction; const secp256k1_context_t *btc_context(); -fc::sha256 get_signature_hash( const bitcoin_transaction& tx, const bytes& scriptPubKey, int64_t amount, - size_t in_index, int hash_type, bool is_witness ); +fc::sha256 get_signature_hash(const bitcoin_transaction &tx, const bytes &scriptPubKey, int64_t amount, + size_t in_index, int hash_type, bool is_witness); -std::vector privkey_sign( const bytes& privkey, const fc::sha256 &hash, const secp256k1_context_t* context_sign = nullptr ); +std::vector privkey_sign(const bytes &privkey, const fc::sha256 &hash, const secp256k1_context_t *context_sign = nullptr); -std::vector sign_witness_transaction_part( const bitcoin_transaction& tx, const std::vector& redeem_scripts, - const std::vector& amounts, const bytes& privkey, - const secp256k1_context_t* context_sign = nullptr, int hash_type = 1 ); +std::vector sign_witness_transaction_part(const bitcoin_transaction &tx, const std::vector &redeem_scripts, + const std::vector &amounts, const bytes &privkey, + const secp256k1_context_t *context_sign = nullptr, int hash_type = 1); -void sign_witness_transaction_finalize( bitcoin_transaction& tx, const std::vector& redeem_scripts, bool use_mulisig_workaround = true ); +void sign_witness_transaction_finalize(bitcoin_transaction &tx, const std::vector &redeem_scripts, bool use_mulisig_workaround = true); -bool verify_sig( const bytes& sig, const bytes& pubkey, const bytes& msg, const secp256k1_context_t* context ); +bool verify_sig(const bytes &sig, const bytes &pubkey, const bytes &msg, const secp256k1_context_t *context); -std::vector> sort_sigs( const bitcoin_transaction& tx, const std::vector& redeem_scripts, - const std::vector& amounts, const secp256k1_context_t* context ); +std::vector> sort_sigs(const bitcoin_transaction &tx, const std::vector &redeem_scripts, + const std::vector &amounts, const secp256k1_context_t *context); -void add_signatures_to_transaction_multisig( bitcoin_transaction &tx, std::vector> &signature_set ); +void add_signatures_to_transaction_multisig(bitcoin_transaction &tx, std::vector> &signature_set); -void add_signatures_to_transaction_weighted_multisig( bitcoin_transaction &tx, std::vector> &signature_set ); +void add_signatures_to_transaction_weighted_multisig(bitcoin_transaction &tx, std::vector> &signature_set); -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/types.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/types.hpp old mode 100755 new mode 100644 index fe5f2bbd..0997194b --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/types.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/types.hpp @@ -1,9 +1,9 @@ #pragma once -#include -#include -#include #include +#include +#include +#include #include @@ -12,11 +12,10 @@ namespace graphene { namespace peerplays_sidechain { namespace bitcoin { class bitcoin_transaction; using bytes = std::vector; -using accounts_keys = std::map< graphene::chain::son_id_type, graphene::chain::public_key_type >; +using accounts_keys = std::map; using full_btc_transaction = std::pair; -enum class payment_type -{ +enum class payment_type { NULLDATA, P2PK, P2PKH, @@ -27,21 +26,17 @@ enum class payment_type P2SH_WSH }; -enum class sidechain_proposal_type -{ +enum class sidechain_proposal_type { ISSUE_BTC, SEND_BTC_TRANSACTION, REVERT_BTC_TRANSACTION }; -struct prev_out -{ - bool operator!=( const prev_out& obj ) const - { - if( this->hash_tx != obj.hash_tx || +struct prev_out { + bool operator!=(const prev_out &obj) const { + if (this->hash_tx != obj.hash_tx || this->n_vout != obj.n_vout || - this->amount != obj.amount ) - { + this->amount != obj.amount) { return true; } return false; @@ -52,8 +47,8 @@ struct prev_out uint64_t amount; }; -} } } +}}} // namespace graphene::peerplays_sidechain::bitcoin -FC_REFLECT_ENUM( graphene::peerplays_sidechain::bitcoin::payment_type, (NULLDATA)(P2PK)(P2PKH)(P2SH)(P2WPKH)(P2WSH)(P2SH_WPKH)(P2SH_WSH) ); -FC_REFLECT_ENUM( graphene::peerplays_sidechain::bitcoin::sidechain_proposal_type, (ISSUE_BTC)(SEND_BTC_TRANSACTION)(REVERT_BTC_TRANSACTION) ); -FC_REFLECT( graphene::peerplays_sidechain::bitcoin::prev_out, (hash_tx)(n_vout)(amount) ); +FC_REFLECT_ENUM(graphene::peerplays_sidechain::bitcoin::payment_type, (NULLDATA)(P2PK)(P2PKH)(P2SH)(P2WPKH)(P2WSH)(P2SH_WPKH)(P2SH_WSH)); +FC_REFLECT_ENUM(graphene::peerplays_sidechain::bitcoin::sidechain_proposal_type, (ISSUE_BTC)(SEND_BTC_TRANSACTION)(REVERT_BTC_TRANSACTION)); +FC_REFLECT(graphene::peerplays_sidechain::bitcoin::prev_out, (hash_tx)(n_vout)(amount)); diff --git a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/utils.hpp b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/utils.hpp old mode 100755 new mode 100644 index a9ed2ca8..a1aa7d08 --- a/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/utils.hpp +++ b/libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/utils.hpp @@ -1,18 +1,18 @@ #pragma once -#include -#include #include +#include +#include namespace graphene { namespace peerplays_sidechain { namespace bitcoin { -fc::ecc::public_key_data create_public_key_data( const std::vector& public_key ); +fc::ecc::public_key_data create_public_key_data(const std::vector &public_key); -bytes get_privkey_bytes( const std::string& privkey_base58 ); +bytes get_privkey_bytes(const std::string &privkey_base58); -bytes parse_hex( const std::string& str ); +bytes parse_hex(const std::string &str); -std::vector get_pubkey_from_redeemScript( bytes script ); +std::vector get_pubkey_from_redeemScript(bytes script); -bytes public_key_data_to_bytes( const fc::ecc::public_key_data& key ); +bytes public_key_data_to_bytes(const fc::ecc::public_key_data &key); -} } } \ No newline at end of file +}}} // namespace graphene::peerplays_sidechain::bitcoin \ No newline at end of file diff --git a/libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp b/libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp index b51354a1..491d516b 100644 --- a/libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp +++ b/libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp @@ -274,7 +274,7 @@ bool peerplays_sidechain_plugin_impl::is_son_deleted(son_id_type son_id) { auto son_obj = idx.find(son_id); if (son_obj == idx.end()) return true; - + return false; } diff --git a/libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp b/libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp index 00aae0af..077b855c 100644 --- a/libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp +++ b/libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp @@ -1278,10 +1278,10 @@ std::string sidechain_net_handler_bitcoin::send_sidechain_transaction(const side std::string sidechain_net_handler_bitcoin::create_multisig_address_standalone(const std::vector &son_pubkeys) { using namespace bitcoin; - std::vector > pubkey_weights; - for (auto &son: son_pubkeys) { + std::vector> pubkey_weights; + for (auto &son : son_pubkeys) { std::string pub_key_str = son.sidechain_public_keys.at(sidechain_type::bitcoin); - auto pub_key = fc::ecc::public_key(create_public_key_data( parse_hex(pub_key_str) )); + auto pub_key = fc::ecc::public_key(create_public_key_data(parse_hex(pub_key_str))); pubkey_weights.push_back(std::make_pair(pub_key, son.weight)); } @@ -1293,7 +1293,7 @@ std::string sidechain_net_handler_bitcoin::create_multisig_address_standalone(co << "}, \"error\":null}"; std::string res = ss.str(); - ilog("Weighted Multisig Address = ${a}",("a", res)); + ilog("Weighted Multisig Address = ${a}", ("a", res)); return res; } @@ -1454,29 +1454,26 @@ std::string sidechain_net_handler_bitcoin::send_transaction(const sidechain_tran } } -std::vector read_byte_arrays_from_string(const std::string &string_buf) -{ +std::vector read_byte_arrays_from_string(const std::string &string_buf) { std::stringstream ss(string_buf); boost::property_tree::ptree json; boost::property_tree::read_json(ss, json); std::vector data; - for(auto &v: json) - { + for (auto &v : json) { std::string hex = v.second.data(); bitcoin::bytes item; item.resize(hex.size() / 2); - fc::from_hex(hex, (char*)&item[0], item.size()); + fc::from_hex(hex, (char *)&item[0], item.size()); data.push_back(item); } return data; } -std::string write_byte_arrays_to_string(const std::vector& data) -{ +std::string write_byte_arrays_to_string(const std::vector &data) { std::string res = "["; for (unsigned int idx = 0; idx < data.size(); ++idx) { - res += "\"" + fc::to_hex((char*)&data[idx][0], data[idx].size()) + "\""; + res += "\"" + fc::to_hex((char *)&data[idx][0], data[idx].size()) + "\""; if (idx != data.size() - 1) res += ","; } @@ -1484,34 +1481,31 @@ std::string write_byte_arrays_to_string(const std::vector& data) return res; } -void read_tx_data_from_string(const std::string &string_buf, std::vector &tx, std::vector &in_amounts) -{ +void read_tx_data_from_string(const std::string &string_buf, std::vector &tx, std::vector &in_amounts) { std::stringstream ss(string_buf); boost::property_tree::ptree json; boost::property_tree::read_json(ss, json); std::string tx_hex = json.get("tx_hex"); tx.clear(); tx.resize(tx_hex.size() / 2); - fc::from_hex(tx_hex, (char*)&tx[0], tx.size()); + fc::from_hex(tx_hex, (char *)&tx[0], tx.size()); in_amounts.clear(); - for(auto &v: json.get_child("in_amounts")) + for (auto &v : json.get_child("in_amounts")) in_amounts.push_back(fc::to_uint64(v.second.data())); } -void read_tx_data_from_string(const std::string &string_buf, std::string &tx_hex, std::vector &in_amounts) -{ +void read_tx_data_from_string(const std::string &string_buf, std::string &tx_hex, std::vector &in_amounts) { std::stringstream ss(string_buf); boost::property_tree::ptree json; boost::property_tree::read_json(ss, json); tx_hex = json.get("tx_hex"); in_amounts.clear(); - for(auto &v: json.get_child("in_amounts")) + for (auto &v : json.get_child("in_amounts")) in_amounts.push_back(fc::to_uint64(v.second.data())); } -std::string save_tx_data_to_string(const std::vector &tx, const std::vector &in_amounts) -{ - std::string res = "{\"tx_hex\":\"" + fc::to_hex((const char*)&tx[0], tx.size()) + "\",\"in_amounts\":["; +std::string save_tx_data_to_string(const std::vector &tx, const std::vector &in_amounts) { + std::string res = "{\"tx_hex\":\"" + fc::to_hex((const char *)&tx[0], tx.size()) + "\",\"in_amounts\":["; for (unsigned int idx = 0; idx < in_amounts.size(); ++idx) { res += fc::to_string(in_amounts[idx]); if (idx != in_amounts.size() - 1) @@ -1521,8 +1515,7 @@ std::string save_tx_data_to_string(const std::vector &tx, const s return res; } -std::string save_tx_data_to_string(const std::string &tx, const std::vector &in_amounts) -{ +std::string save_tx_data_to_string(const std::string &tx, const std::vector &in_amounts) { std::string res = "{\"tx_hex\":\"" + tx + "\",\"in_amounts\":["; for (unsigned int idx = 0; idx < in_amounts.size(); ++idx) { res += fc::to_string(in_amounts[idx]); @@ -1543,25 +1536,25 @@ std::string sidechain_net_handler_bitcoin::create_transaction_psbt(const std::ve std::string sidechain_net_handler_bitcoin::create_transaction_standalone(const std::vector &inputs, const fc::flat_map outputs) { using namespace bitcoin; - + bitcoin_transaction_builder tb; std::vector in_amounts; - tb.set_version( 2 ); + tb.set_version(2); for (auto in : inputs) { - tb.add_in( payment_type::P2WSH, fc::sha256(in.txid_), in.out_num_, bitcoin::bytes() ); + tb.add_in(payment_type::P2WSH, fc::sha256(in.txid_), in.out_num_, bitcoin::bytes()); in_amounts.push_back(in.amount_); } for (auto out : outputs) { uint64_t satoshis = out.second * 100000000.0; - tb.add_out_all_type( satoshis, out.first); + tb.add_out_all_type(satoshis, out.first); //tb.add_out( bitcoin_address( out.first ).get_type(), satoshis, out.first); } const auto tx = tb.get_transaction(); - std::string hex_tx = fc::to_hex( pack( tx ) ); + std::string hex_tx = fc::to_hex(pack(tx)); std::string tx_raw = save_tx_data_to_string(hex_tx, in_amounts); @@ -1767,8 +1760,7 @@ std::string sidechain_net_handler_bitcoin::sign_transaction_standalone(const sid //const auto privkey_signing = get_privkey_bytes( prvkey ); fc::optional btc_private_key = graphene::utilities::wif_to_key(prvkey); - if (!btc_private_key) - { + if (!btc_private_key) { elog("Invalid private key ${pk}", ("pk", prvkey)); return ""; } @@ -1780,10 +1772,10 @@ std::string sidechain_net_handler_bitcoin::sign_transaction_standalone(const sid ilog("Sign transaction retreived: ${s}", ("s", tx_hex)); - std::vector > pubkey_weights; - for (auto &son: sto.signers) { + std::vector> pubkey_weights; + for (auto &son : sto.signers) { std::string pub_key_str = son.sidechain_public_keys.at(sidechain_type::bitcoin); - auto pub_key = fc::ecc::public_key(create_public_key_data( parse_hex(pub_key_str) )); + auto pub_key = fc::ecc::public_key(create_public_key_data(parse_hex(pub_key_str))); pubkey_weights.push_back(std::make_pair(pub_key, son.weight)); } @@ -1795,7 +1787,7 @@ std::string sidechain_net_handler_bitcoin::sign_transaction_standalone(const sid std::vector redeem_scripts(tx.vin.size(), rscript); - auto sigs = sign_witness_transaction_part( tx, redeem_scripts, in_amounts, privkey_signing, btc_context(), 1 ); + auto sigs = sign_witness_transaction_part(tx, redeem_scripts, in_amounts, privkey_signing, btc_context(), 1); std::string tx_signature = write_byte_arrays_to_string(sigs); @@ -1906,10 +1898,10 @@ std::string sidechain_net_handler_bitcoin::send_transaction_standalone(const sid ilog("Send transaction retreived: ${s}", ("s", tx_hex)); - std::vector > pubkey_weights; - for (auto &son: sto.signers) { + std::vector> pubkey_weights; + for (auto &son : sto.signers) { std::string pub_key_str = son.sidechain_public_keys.at(sidechain_type::bitcoin); - auto pub_key = fc::ecc::public_key(create_public_key_data( parse_hex(pub_key_str) )); + auto pub_key = fc::ecc::public_key(create_public_key_data(parse_hex(pub_key_str))); pubkey_weights.push_back(std::make_pair(pub_key, son.weight)); } @@ -1927,7 +1919,7 @@ std::string sidechain_net_handler_bitcoin::send_transaction_standalone(const sid vector> signatures; for (unsigned idx = 0; idx < sto.signatures.size(); ++idx) { - if(sto.signatures[idx].second.empty()) + if (sto.signatures[idx].second.empty()) signatures.push_back(dummy); else signatures.push_back(read_byte_arrays_from_string(sto.signatures[idx].second)); @@ -1937,7 +1929,7 @@ std::string sidechain_net_handler_bitcoin::send_transaction_standalone(const sid sign_witness_transaction_finalize(tx, redeem_scripts, false); - std::string final_tx_hex = fc::to_hex( pack( tx ) ); + std::string final_tx_hex = fc::to_hex(pack(tx)); std::string res = bitcoin_client->sendrawtransaction(final_tx_hex);