Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

clang-format formatting

Browse source
This commit is contained in:
Srdjan Obucina 2020-02-28 23:29:02 +01:00
parent 47c10f0db0
commit 001f92127b
13 changed files with 911 additions and 1064 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

212
libraries/plugins/peerplays_sidechain/bitcoin_utils.cpp
View file

@ -1,9 +1,9 @@
#include <graphene/peerplays_sidechain/bitcoin_utils.hpp>
#include <fc/io/raw.hpp>
#include <fc/crypto/base58.hpp> #include <fc/crypto/base58.hpp>
#include <fc/crypto/elliptic.hpp> #include <fc/crypto/elliptic.hpp>
#include <fc/crypto/ripemd160.hpp> #include <fc/crypto/ripemd160.hpp>
#include <fc/crypto/sha256.hpp> #include <fc/crypto/sha256.hpp>
#include <fc/io/raw.hpp>
#include <graphene/peerplays_sidechain/bitcoin_utils.hpp>
#include <secp256k1.h> #include <secp256k1.h>
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
@ -37,7 +37,9 @@ static const unsigned char OP_CHECKSIG = 0xac;
class WriteBytesStream { class WriteBytesStream {
public: public:
WriteBytesStream(bytes& buffer) : storage_(buffer) {} WriteBytesStream(bytes &buffer) :
storage_(buffer) {
}
void write(const unsigned char *d, size_t s) { void write(const unsigned char *d, size_t s) {
storage_.insert(storage_.end(), d, d + s); storage_.insert(storage_.end(), d, d + s);
@ -48,68 +50,61 @@ public:
return true; return true;
} }
void writedata8(uint8_t obj) void writedata8(uint8_t obj) {
{
write((unsigned char *)&obj, 1); write((unsigned char *)&obj, 1);
} }
void writedata16(uint16_t obj) void writedata16(uint16_t obj) {
{
obj = htole16(obj); obj = htole16(obj);
write((unsigned char *)&obj, 2); write((unsigned char *)&obj, 2);
} }
void writedata32(uint32_t obj) void writedata32(uint32_t obj) {
{
obj = htole32(obj); obj = htole32(obj);
write((unsigned char *)&obj, 4); write((unsigned char *)&obj, 4);
} }
void writedata64(uint64_t obj) void writedata64(uint64_t obj) {
{
obj = htole64(obj); obj = htole64(obj);
write((unsigned char *)&obj, 8); write((unsigned char *)&obj, 8);
} }
void write_compact_int(uint64_t val) void write_compact_int(uint64_t val) {
{ if (val < 253) {
if (val < 253)
{
writedata8(val); writedata8(val);
} } else if (val <= std::numeric_limits<unsigned short>::max()) {
else if (val <= std::numeric_limits<unsigned short>::max())
{
writedata8(253); writedata8(253);
writedata16(val); writedata16(val);
} } else if (val <= std::numeric_limits<unsigned int>::max()) {
else if (val <= std::numeric_limits<unsigned int>::max())
{
writedata8(254); writedata8(254);
writedata32(val); writedata32(val);
} } else {
else
{
writedata8(255); writedata8(255);
writedata64(val); writedata64(val);
} }
} }
void writedata(const bytes& data) void writedata(const bytes &data) {
{
write_compact_int(data.size()); write_compact_int(data.size());
write(&data[0], data.size()); write(&data[0], data.size());
} }
private: private:
bytes &storage_; bytes &storage_;
}; };
class ReadBytesStream { class ReadBytesStream {
public: public:
ReadBytesStream(const bytes& buffer, size_t pos = 0) : storage_(buffer), pos_(pos), end_(buffer.size()) {} ReadBytesStream(const bytes &buffer, size_t pos = 0) :
storage_(buffer),
pos_(pos),
end_(buffer.size()) {
}
size_t current_pos() const { return pos_; } size_t current_pos() const {
void set_pos(size_t pos) return pos_;
{ }
void set_pos(size_t pos) {
if (pos > end_) if (pos > end_)
FC_THROW("Invalid position in BTC tx buffer"); FC_THROW("Invalid position in BTC tx buffer");
pos_ = pos; pos_ = pos;
@ -124,8 +119,7 @@ public:
FC_THROW("invalid bitcoin tx buffer"); FC_THROW("invalid bitcoin tx buffer");
} }
inline bool get( unsigned char& c ) inline bool get(unsigned char &c) {
{
if (pos_ < end_) { if (pos_ < end_) {
c = storage_[pos_++]; c = storage_[pos_++];
return true; return true;
@ -133,53 +127,41 @@ public:
FC_THROW("invalid bitcoin tx buffer"); FC_THROW("invalid bitcoin tx buffer");
} }
uint8_t readdata8() uint8_t readdata8() {
{
uint8_t obj; uint8_t obj;
read((unsigned char *)&obj, 1); read((unsigned char *)&obj, 1);
return obj; return obj;
} }
uint16_t readdata16() uint16_t readdata16() {
{
uint16_t obj; uint16_t obj;
read((unsigned char *)&obj, 2); read((unsigned char *)&obj, 2);
return le16toh(obj); return le16toh(obj);
} }
uint32_t readdata32() uint32_t readdata32() {
{
uint32_t obj; uint32_t obj;
read((unsigned char *)&obj, 4); read((unsigned char *)&obj, 4);
return le32toh(obj); return le32toh(obj);
} }
uint64_t readdata64() uint64_t readdata64() {
{
uint64_t obj; uint64_t obj;
read((unsigned char *)&obj, 8); read((unsigned char *)&obj, 8);
return le64toh(obj); return le64toh(obj);
} }
uint64_t read_compact_int() uint64_t read_compact_int() {
{
uint8_t size = readdata8(); uint8_t size = readdata8();
uint64_t ret = 0; uint64_t ret = 0;
if (size < 253) if (size < 253) {
{
ret = size; ret = size;
} } else if (size == 253) {
else if (size == 253)
{
ret = readdata16(); ret = readdata16();
if (ret < 253) if (ret < 253)
FC_THROW("non-canonical ReadCompactSize()"); FC_THROW("non-canonical ReadCompactSize()");
} } else if (size == 254) {
else if (size == 254)
{
ret = readdata32(); ret = readdata32();
if (ret < 0x10000u) if (ret < 0x10000u)
FC_THROW("non-canonical ReadCompactSize()"); FC_THROW("non-canonical ReadCompactSize()");
} } else {
else
{
ret = readdata64(); ret = readdata64();
if (ret < 0x100000000ULL) if (ret < 0x100000000ULL)
FC_THROW("non-canonical ReadCompactSize()"); FC_THROW("non-canonical ReadCompactSize()");
@ -189,8 +171,7 @@ public:
return ret; return ret;
} }
void readdata(bytes& data) void readdata(bytes &data) {
{
size_t s = read_compact_int(); size_t s = read_compact_int();
data.clear(); data.clear();
data.resize(s); data.resize(s);
@ -203,16 +184,14 @@ private:
size_t end_; size_t end_;
}; };
void btc_outpoint::to_bytes(bytes& stream) const void btc_outpoint::to_bytes(bytes &stream) const {
{
WriteBytesStream str(stream); WriteBytesStream str(stream);
// TODO: write size? // TODO: write size?
str.write((unsigned char *)hash.data(), hash.data_size()); str.write((unsigned char *)hash.data(), hash.data_size());
str.writedata32(n); str.writedata32(n);
} }
size_t btc_outpoint::fill_from_bytes(const bytes& data, size_t pos) size_t btc_outpoint::fill_from_bytes(const bytes &data, size_t pos) {
{
ReadBytesStream str(data, pos); ReadBytesStream str(data, pos);
// TODO: read size? // TODO: read size?
str.read((unsigned char *)hash.data(), hash.data_size()); str.read((unsigned char *)hash.data(), hash.data_size());
@ -220,16 +199,14 @@ size_t btc_outpoint::fill_from_bytes(const bytes& data, size_t pos)
return str.current_pos(); return str.current_pos();
} }
void btc_in::to_bytes(bytes& stream) const void btc_in::to_bytes(bytes &stream) const {
{
prevout.to_bytes(stream); prevout.to_bytes(stream);
WriteBytesStream str(stream); WriteBytesStream str(stream);
str.writedata(scriptSig); str.writedata(scriptSig);
str.writedata32(nSequence); str.writedata32(nSequence);
} }
size_t btc_in::fill_from_bytes(const bytes& data, size_t pos) size_t btc_in::fill_from_bytes(const bytes &data, size_t pos) {
{
pos = prevout.fill_from_bytes(data, pos); pos = prevout.fill_from_bytes(data, pos);
ReadBytesStream str(data, pos); ReadBytesStream str(data, pos);
str.readdata(scriptSig); str.readdata(scriptSig);
@ -237,27 +214,23 @@ size_t btc_in::fill_from_bytes(const bytes& data, size_t pos)
return str.current_pos(); return str.current_pos();
} }
void btc_out::to_bytes(bytes& stream) const void btc_out::to_bytes(bytes &stream) const {
{
WriteBytesStream str(stream); WriteBytesStream str(stream);
str.writedata64(nValue); str.writedata64(nValue);
str.writedata(scriptPubKey); str.writedata(scriptPubKey);
} }
size_t btc_out::fill_from_bytes(const bytes& data, size_t pos) size_t btc_out::fill_from_bytes(const bytes &data, size_t pos) {
{
ReadBytesStream str(data, pos); ReadBytesStream str(data, pos);
nValue = str.readdata64(); nValue = str.readdata64();
str.readdata(scriptPubKey); str.readdata(scriptPubKey);
return str.current_pos(); return str.current_pos();
} }
void btc_tx::to_bytes(bytes& stream) const void btc_tx::to_bytes(bytes &stream) const {
{
WriteBytesStream str(stream); WriteBytesStream str(stream);
str.writedata32(nVersion); str.writedata32(nVersion);
if(hasWitness) if (hasWitness) {
{
// write dummy inputs and flag // write dummy inputs and flag
str.write_compact_int(0); str.write_compact_int(0);
unsigned char flags = 1; unsigned char flags = 1;
@ -269,10 +242,8 @@ void btc_tx::to_bytes(bytes& stream) const
str.write_compact_int(vout.size()); str.write_compact_int(vout.size());
for (const auto &out : vout) for (const auto &out : vout)
out.to_bytes(stream); out.to_bytes(stream);
if(hasWitness) if (hasWitness) {
{ for (const auto &in : vin) {
for(const auto& in: vin)
{
str.write_compact_int(in.scriptWitness.size()); str.write_compact_int(in.scriptWitness.size());
for (const auto &stack_item : in.scriptWitness) for (const auto &stack_item : in.scriptWitness)
str.writedata(stack_item); str.writedata(stack_item);
@ -281,8 +252,7 @@ void btc_tx::to_bytes(bytes& stream) const
str.writedata32(nLockTime); str.writedata32(nLockTime);
} }
size_t btc_tx::fill_from_bytes(const bytes& data, size_t pos) size_t btc_tx::fill_from_bytes(const bytes &data, size_t pos) {
{
ReadBytesStream ds(data, pos); ReadBytesStream ds(data, pos);
nVersion = ds.readdata32(); nVersion = ds.readdata32();
unsigned char flags = 0; unsigned char flags = 0;
@ -325,8 +295,7 @@ size_t btc_tx::fill_from_bytes(const bytes& data, size_t pos)
} }
if (hasWitness) { if (hasWitness) {
/* The witness flag is present, and we support witnesses. */ /* The witness flag is present, and we support witnesses. */
for (auto& in: vin) for (auto &in : vin) {
{
unsigned int size = ds.read_compact_int(); unsigned int size = ds.read_compact_int();
in.scriptWitness.resize(size); in.scriptWitness.resize(size);
for (auto &stack_item : in.scriptWitness) for (auto &stack_item : in.scriptWitness)
@ -337,15 +306,12 @@ size_t btc_tx::fill_from_bytes(const bytes& data, size_t pos)
return ds.current_pos(); return ds.current_pos();
} }
void add_data_to_script(bytes &script, const bytes &data) {
void add_data_to_script(bytes& script, const bytes& data)
{
WriteBytesStream str(script); WriteBytesStream str(script);
str.writedata(data); str.writedata(data);
} }
void add_number_to_script(bytes& script, unsigned char data) void add_number_to_script(bytes &script, unsigned char data) {
{
WriteBytesStream str(script); WriteBytesStream str(script);
if (data == 0) if (data == 0)
str.put(OP_0); str.put(OP_0);
@ -385,13 +351,11 @@ void add_number_to_script(bytes& script, unsigned char data)
add_data_to_script(script, {data}); add_data_to_script(script, {data});
} }
bytes generate_redeem_script(std::vector<std::pair<fc::ecc::public_key, int> > key_data) bytes generate_redeem_script(std::vector<std::pair<fc::ecc::public_key, int>> key_data) {
{
int total_weight = 0; int total_weight = 0;
bytes result; bytes result;
add_number_to_script(result, 0); add_number_to_script(result, 0);
for(auto& p: key_data) for (auto &p : key_data) {
{
total_weight += p.second; total_weight += p.second;
result.push_back(OP_SWAP); result.push_back(OP_SWAP);
auto raw_data = p.first.serialize(); auto raw_data = p.first.serialize();
@ -487,7 +451,8 @@ bool convertbits(bytes& out, const bytes& in) {
} }
} }
if (pad) { if (pad) {
if (bits) out.push_back((acc << (tobits - bits)) & maxv); if (bits)
out.push_back((acc << (tobits - bits)) & maxv);
} else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) { } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
return false; return false;
} }
@ -503,8 +468,7 @@ std::string segwit_addr_encode(const std::string& hrp, uint8_t witver, const byt
return ret; return ret;
} }
std::string p2wsh_address_from_redeem_script(const bytes& script, bitcoin_network network) std::string p2wsh_address_from_redeem_script(const bytes &script, bitcoin_network network) {
{
// calc script hash // calc script hash
fc::sha256 sh = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.size()); fc::sha256 sh = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.size());
bytes wp(sh.data(), sh.data() + sh.data_size()); bytes wp(sh.data(), sh.data() + sh.data_size());
@ -520,8 +484,7 @@ std::string p2wsh_address_from_redeem_script(const bytes& script, bitcoin_networ
FC_THROW("Unknown bitcoin network type"); FC_THROW("Unknown bitcoin network type");
} }
bytes lock_script_for_redeem_script(const bytes &script) bytes lock_script_for_redeem_script(const bytes &script) {
{
bytes result; bytes result;
result.push_back(OP_0); result.push_back(OP_0);
fc::sha256 h = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.size()); fc::sha256 h = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.size());
@ -530,11 +493,9 @@ bytes lock_script_for_redeem_script(const bytes &script)
return result; return result;
} }
bytes hash_prevouts(const btc_tx& unsigned_tx) bytes hash_prevouts(const btc_tx &unsigned_tx) {
{
fc::sha256::encoder hasher; fc::sha256::encoder hasher;
for(const auto& in: unsigned_tx.vin) for (const auto &in : unsigned_tx.vin) {
{
bytes data; bytes data;
in.prevout.to_bytes(data); in.prevout.to_bytes(data);
hasher.write(reinterpret_cast<const char *>(&data[0]), data.size()); hasher.write(reinterpret_cast<const char *>(&data[0]), data.size());
@ -543,22 +504,18 @@ bytes hash_prevouts(const btc_tx& unsigned_tx)
return bytes(res.data(), res.data() + res.data_size()); return bytes(res.data(), res.data() + res.data_size());
} }
bytes hash_sequence(const btc_tx& unsigned_tx) bytes hash_sequence(const btc_tx &unsigned_tx) {
{
fc::sha256::encoder hasher; fc::sha256::encoder hasher;
for(const auto& in: unsigned_tx.vin) for (const auto &in : unsigned_tx.vin) {
{
hasher.write(reinterpret_cast<const char *>(&in.nSequence), sizeof(in.nSequence)); hasher.write(reinterpret_cast<const char *>(&in.nSequence), sizeof(in.nSequence));
} }
fc::sha256 res = fc::sha256::hash(hasher.result()); fc::sha256 res = fc::sha256::hash(hasher.result());
return bytes(res.data(), res.data() + res.data_size()); return bytes(res.data(), res.data() + res.data_size());
} }
bytes hash_outputs(const btc_tx& unsigned_tx) bytes hash_outputs(const btc_tx &unsigned_tx) {
{
fc::sha256::encoder hasher; fc::sha256::encoder hasher;
for(const auto& out: unsigned_tx.vout) for (const auto &out : unsigned_tx.vout) {
{
bytes data; bytes data;
out.to_bytes(data); out.to_bytes(data);
hasher.write(reinterpret_cast<const char *>(&data[0]), data.size()); hasher.write(reinterpret_cast<const char *>(&data[0]), data.size());
@ -572,8 +529,7 @@ const secp256k1_context_t* btc_get_context() {
return ctx; return ctx;
} }
bytes der_sign(const fc::ecc::private_key& priv_key, const fc::sha256& digest) bytes der_sign(const fc::ecc::private_key &priv_key, const fc::sha256 &digest) {
{
fc::ecc::signature result; fc::ecc::signature result;
int size = result.size(); int size = result.size();
FC_ASSERT(secp256k1_ecdsa_sign(btc_get_context(), FC_ASSERT(secp256k1_ecdsa_sign(btc_get_context(),
@ -589,8 +545,7 @@ bytes der_sign(const fc::ecc::private_key& priv_key, const fc::sha256& digest)
std::vector<bytes> signatures_for_raw_transaction(const bytes &unsigned_tx, std::vector<bytes> signatures_for_raw_transaction(const bytes &unsigned_tx,
std::vector<uint64_t> in_amounts, std::vector<uint64_t> in_amounts,
const bytes &redeem_script, const bytes &redeem_script,
const fc::ecc::private_key& priv_key) const fc::ecc::private_key &priv_key) {
{
btc_tx tx; btc_tx tx;
tx.fill_from_bytes(unsigned_tx); tx.fill_from_bytes(unsigned_tx);
@ -604,8 +559,7 @@ std::vector<bytes> signatures_for_raw_transaction(const bytes& unsigned_tx,
bytes hashOutputs = hash_outputs(tx); bytes hashOutputs = hash_outputs(tx);
// calc digest for every input according to BIP143 // calc digest for every input according to BIP143
// implement SIGHASH_ALL scheme // implement SIGHASH_ALL scheme
for(const auto& in: tx.vin) for (const auto &in : tx.vin) {
{
fc::sha256::encoder hasher; fc::sha256::encoder hasher;
hasher.write(reinterpret_cast<const char *>(&tx.nVersion), sizeof(tx.nVersion)); hasher.write(reinterpret_cast<const char *>(&tx.nVersion), sizeof(tx.nVersion));
hasher.write(reinterpret_cast<const char *>(&hashPrevouts[0]), hashPrevouts.size()); hasher.write(reinterpret_cast<const char *>(&hashPrevouts[0]), hashPrevouts.size());
@ -636,30 +590,24 @@ std::vector<bytes> signatures_for_raw_transaction(const bytes& unsigned_tx,
return results; return results;
} }
bytes sign_pw_transfer_transaction(const bytes &unsigned_tx, std::vector<uint64_t> in_amounts, const bytes& redeem_script, const std::vector<fc::optional<fc::ecc::private_key> > &priv_keys) bytes sign_pw_transfer_transaction(const bytes &unsigned_tx, std::vector<uint64_t> in_amounts, const bytes &redeem_script, const std::vector<fc::optional<fc::ecc::private_key>> &priv_keys) {
{
btc_tx tx; btc_tx tx;
tx.fill_from_bytes(unsigned_tx); tx.fill_from_bytes(unsigned_tx);
bytes dummy_data; bytes dummy_data;
for(auto key: priv_keys) for (auto key : priv_keys) {
{ if (key) {
if(key)
{
std::vector<bytes> signatures = signatures_for_raw_transaction(unsigned_tx, in_amounts, redeem_script, *key); std::vector<bytes> signatures = signatures_for_raw_transaction(unsigned_tx, in_amounts, redeem_script, *key);
FC_ASSERT(signatures.size() == tx.vin.size(), "Invalid signatures number"); FC_ASSERT(signatures.size() == tx.vin.size(), "Invalid signatures number");
// push signatures in reverse order because script starts to check the top signature on the stack first // push signatures in reverse order because script starts to check the top signature on the stack first
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
tx.vin[i].scriptWitness.insert(tx.vin[i].scriptWitness.begin(), signatures[i]); tx.vin[i].scriptWitness.insert(tx.vin[i].scriptWitness.begin(), signatures[i]);
} } else {
else
{
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
tx.vin[i].scriptWitness.push_back(dummy_data); tx.vin[i].scriptWitness.push_back(dummy_data);
} }
} }
for(auto& in: tx.vin) for (auto &in : tx.vin) {
{
in.scriptWitness.push_back(redeem_script); in.scriptWitness.push_back(redeem_script);
} }
@ -671,14 +619,12 @@ bytes sign_pw_transfer_transaction(const bytes &unsigned_tx, std::vector<uint64_
bytes add_dummy_signatures_for_pw_transfer(const bytes &unsigned_tx, bytes add_dummy_signatures_for_pw_transfer(const bytes &unsigned_tx,
const bytes &redeem_script, const bytes &redeem_script,
unsigned int key_count) unsigned int key_count) {
{
btc_tx tx; btc_tx tx;
tx.fill_from_bytes(unsigned_tx); tx.fill_from_bytes(unsigned_tx);
bytes dummy_data; bytes dummy_data;
for(auto& in: tx.vin) for (auto &in : tx.vin) {
{
for (unsigned i = 0; i < key_count; i++) for (unsigned i = 0; i < key_count; i++)
in.scriptWitness.push_back(dummy_data); in.scriptWitness.push_back(dummy_data);
in.scriptWitness.push_back(redeem_script); in.scriptWitness.push_back(redeem_script);
@ -693,8 +639,7 @@ bytes add_dummy_signatures_for_pw_transfer(const bytes& unsigned_tx,
bytes partially_sign_pw_transfer_transaction(const bytes &partially_signed_tx, bytes partially_sign_pw_transfer_transaction(const bytes &partially_signed_tx,
std::vector<uint64_t> in_amounts, std::vector<uint64_t> in_amounts,
const fc::ecc::private_key &priv_key, const fc::ecc::private_key &priv_key,
unsigned int key_idx) unsigned int key_idx) {
{
btc_tx tx; btc_tx tx;
tx.fill_from_bytes(partially_signed_tx); tx.fill_from_bytes(partially_signed_tx);
FC_ASSERT(tx.vin.size() > 0); FC_ASSERT(tx.vin.size() > 0);
@ -710,13 +655,11 @@ bytes partially_sign_pw_transfer_transaction(const bytes& partially_signed_tx,
return ret; return ret;
} }
bytes add_signatures_to_unsigned_tx(const bytes &unsigned_tx, const std::vector<std::vector<bytes> > &signature_set, const bytes &redeem_script) bytes add_signatures_to_unsigned_tx(const bytes &unsigned_tx, const std::vector<std::vector<bytes>> &signature_set, const bytes &redeem_script) {
{
btc_tx tx; btc_tx tx;
tx.fill_from_bytes(unsigned_tx); tx.fill_from_bytes(unsigned_tx);
bytes dummy_data; bytes dummy_data;
for(unsigned int i = 0; i < signature_set.size(); i++) for (unsigned int i = 0; i < signature_set.size(); i++) {
{
std::vector<bytes> signatures = signature_set[i]; std::vector<bytes> signatures = signature_set[i];
FC_ASSERT(signatures.size() == tx.vin.size(), "Invalid signatures number"); FC_ASSERT(signatures.size() == tx.vin.size(), "Invalid signatures number");
// push signatures in reverse order because script starts to check the top signature on the stack first // push signatures in reverse order because script starts to check the top signature on the stack first
@ -724,8 +667,7 @@ bytes add_signatures_to_unsigned_tx(const bytes &unsigned_tx, const std::vector<
tx.vin[i].scriptWitness.insert(tx.vin[i].scriptWitness.begin(), signatures[i]); tx.vin[i].scriptWitness.insert(tx.vin[i].scriptWitness.begin(), signatures[i]);
} }
for(auto& in: tx.vin) for (auto &in : tx.vin) {
{
in.scriptWitness.push_back(redeem_script); in.scriptWitness.push_back(redeem_script);
} }
@ -735,4 +677,4 @@ bytes add_signatures_to_unsigned_tx(const bytes &unsigned_tx, const std::vector<
return ret; return ret;
} }
}} }} // namespace graphene::peerplays_sidechain

18
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin_utils.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <graphene/peerplays_sidechain/defs.hpp>
#include <fc/optional.hpp> #include <fc/optional.hpp>
#include <graphene/peerplays_sidechain/defs.hpp>
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
@ -14,7 +14,6 @@ bytes generate_redeem_script(std::vector<std::pair<fc::ecc::public_key, int> > k
std::string p2wsh_address_from_redeem_script(const bytes &script, bitcoin_network network = mainnet); std::string p2wsh_address_from_redeem_script(const bytes &script, bitcoin_network network = mainnet);
bytes lock_script_for_redeem_script(const bytes &script); bytes lock_script_for_redeem_script(const bytes &script);
std::vector<bytes> signatures_for_raw_transaction(const bytes &unsigned_tx, std::vector<bytes> signatures_for_raw_transaction(const bytes &unsigned_tx,
std::vector<uint64_t> in_amounts, std::vector<uint64_t> in_amounts,
const bytes &redeem_script, const bytes &redeem_script,
@ -65,8 +64,7 @@ bytes add_signatures_to_unsigned_tx(const bytes& unsigned_tx,
const std::vector<std::vector<bytes>> &signatures, const std::vector<std::vector<bytes>> &signatures,
const bytes &redeem_script); const bytes &redeem_script);
struct btc_outpoint struct btc_outpoint {
{
fc::uint256 hash; fc::uint256 hash;
uint32_t n; uint32_t n;
@ -74,8 +72,7 @@ struct btc_outpoint
size_t fill_from_bytes(const bytes &data, size_t pos = 0); size_t fill_from_bytes(const bytes &data, size_t pos = 0);
}; };
struct btc_in struct btc_in {
{
btc_outpoint prevout; btc_outpoint prevout;
bytes scriptSig; bytes scriptSig;
uint32_t nSequence; uint32_t nSequence;
@ -85,8 +82,7 @@ struct btc_in
size_t fill_from_bytes(const bytes &data, size_t pos = 0); size_t fill_from_bytes(const bytes &data, size_t pos = 0);
}; };
struct btc_out struct btc_out {
{
int64_t nValue; int64_t nValue;
bytes scriptPubKey; bytes scriptPubKey;
@ -94,8 +90,7 @@ struct btc_out
size_t fill_from_bytes(const bytes &data, size_t pos = 0); size_t fill_from_bytes(const bytes &data, size_t pos = 0);
}; };
struct btc_tx struct btc_tx {
{
std::vector<btc_in> vin; std::vector<btc_in> vin;
std::vector<btc_out> vout; std::vector<btc_out> vout;
int32_t nVersion; int32_t nVersion;
@ -106,5 +101,4 @@ struct btc_tx
size_t fill_from_bytes(const bytes &data, size_t pos = 0); size_t fill_from_bytes(const bytes &data, size_t pos = 0);
}; };
}} }} // namespace graphene::peerplays_sidechain

16
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/defs.hpp
View file

@ -4,9 +4,9 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <fc/crypto/sha256.hpp>
#include <fc/safe.hpp> #include <fc/safe.hpp>
#include <fc/time.hpp> #include <fc/time.hpp>
#include <fc/crypto/sha256.hpp>
#include <graphene/chain/protocol/asset.hpp> #include <graphene/chain/protocol/asset.hpp>
#include <graphene/chain/protocol/types.hpp> #include <graphene/chain/protocol/types.hpp>
@ -22,14 +22,11 @@ enum class sidechain_type {
using bytes = std::vector<unsigned char>; using bytes = std::vector<unsigned char>;
struct prev_out struct prev_out {
{ bool operator!=(const prev_out &obj) const {
bool operator!=( const prev_out& obj ) const
{
if (this->hash_tx != obj.hash_tx || if (this->hash_tx != obj.hash_tx ||
this->n_vout != obj.n_vout || this->n_vout != obj.n_vout ||
this->amount != obj.amount ) this->amount != obj.amount) {
{
return true; return true;
} }
return false; return false;
@ -40,8 +37,7 @@ struct prev_out
uint64_t amount; uint64_t amount;
}; };
struct info_for_vin struct info_for_vin {
{
info_for_vin() = default; info_for_vin() = default;
info_for_vin(const prev_out &_out, const std::string &_address, bytes _script = bytes(), bool _resend = false); info_for_vin(const prev_out &_out, const std::string &_address, bytes _script = bytes(), bool _resend = false);
@ -79,6 +75,6 @@ struct sidechain_event_data {
chain::asset peerplays_asset; chain::asset peerplays_asset;
}; };
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain
FC_REFLECT_ENUM(graphene::peerplays_sidechain::sidechain_type, (bitcoin)(ethereum)(eos)(peerplays)) FC_REFLECT_ENUM(graphene::peerplays_sidechain::sidechain_type, (bitcoin)(ethereum)(eos)(peerplays))

9
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/peerplays_sidechain_plugin.hpp
View file

@ -7,13 +7,11 @@
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
using namespace chain; using namespace chain;
namespace detail namespace detail {
{
class peerplays_sidechain_plugin_impl; class peerplays_sidechain_plugin_impl;
} }
class peerplays_sidechain_plugin : public graphene::app::plugin class peerplays_sidechain_plugin : public graphene::app::plugin {
{
public: public:
peerplays_sidechain_plugin(); peerplays_sidechain_plugin();
virtual ~peerplays_sidechain_plugin(); virtual ~peerplays_sidechain_plugin();
@ -35,5 +33,4 @@ class peerplays_sidechain_plugin : public graphene::app::plugin
fc::ecc::private_key get_private_key(chain::public_key_type public_key); fc::ecc::private_key get_private_key(chain::public_key_type public_key);
}; };
} } //graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

4
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler.hpp
View file

@ -41,8 +41,6 @@ protected:
virtual std::string send_transaction(const std::string &transaction) = 0; virtual std::string send_transaction(const std::string &transaction) = 0;
private: private:
}; };
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

14
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_bitcoin.hpp
View file

@ -5,15 +5,14 @@
#include <string> #include <string>
#include <zmq.hpp> #include <zmq.hpp>
#include <fc/signals.hpp>
#include <fc/network/http/connection.hpp> #include <fc/network/http/connection.hpp>
#include <fc/signals.hpp>
#include <graphene/chain/son_wallet_deposit_object.hpp> #include <graphene/chain/son_wallet_deposit_object.hpp>
#include <graphene/chain/son_wallet_withdraw_object.hpp> #include <graphene/chain/son_wallet_withdraw_object.hpp>
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
class btc_txout class btc_txout {
{
public: public:
std::string txid_; std::string txid_;
unsigned int out_num_; unsigned int out_num_;
@ -37,7 +36,6 @@ public:
std::string signrawtransactionwithwallet(const std::string &tx_hash); std::string signrawtransactionwithwallet(const std::string &tx_hash);
private: private:
fc::http::reply send_post_request(std::string body); fc::http::reply send_post_request(std::string body);
std::string ip; std::string ip;
@ -55,9 +53,12 @@ private:
class zmq_listener { class zmq_listener {
public: public:
zmq_listener(std::string _ip, uint32_t _zmq); zmq_listener(std::string _ip, uint32_t _zmq);
bool connection_is_not_defined() const { return zmq_port == 0; } bool connection_is_not_defined() const {
return zmq_port == 0;
}
fc::signal<void(const std::string &)> event_received; fc::signal<void(const std::string &)> event_received;
private: private:
void handle_zmq(); void handle_zmq();
std::vector<zmq::message_t> receive_multipart(); std::vector<zmq::message_t> receive_multipart();
@ -105,5 +106,4 @@ private:
std::vector<info_for_vin> extract_info_from_block(const std::string &_block); std::vector<info_for_vin> extract_info_from_block(const std::string &_block);
}; };
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

5
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_peerplays.hpp
View file

@ -18,15 +18,12 @@ public:
void process_withdrawal(const son_wallet_withdraw_object &swwo); void process_withdrawal(const son_wallet_withdraw_object &swwo);
private: private:
std::string create_multisignature_wallet(const std::vector<std::string> public_keys); std::string create_multisignature_wallet(const std::vector<std::string> public_keys);
std::string transfer(const std::string &from, const std::string &to, const uint64_t amount); std::string transfer(const std::string &from, const std::string &to, const uint64_t amount);
std::string sign_transaction(const std::string &transaction); std::string sign_transaction(const std::string &transaction);
std::string send_transaction(const std::string &transaction); std::string send_transaction(const std::string &transaction);
void on_applied_block(const signed_block &b); void on_applied_block(const signed_block &b);
}; };
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

5
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_manager.hpp
View file

@ -19,12 +19,11 @@ public:
void recreate_primary_wallet(); void recreate_primary_wallet();
void process_deposits(); void process_deposits();
void process_withdrawals(); void process_withdrawals();
private: private:
peerplays_sidechain_plugin &plugin; peerplays_sidechain_plugin &plugin;
graphene::chain::database &database; graphene::chain::database &database;
std::vector<std::unique_ptr<sidechain_net_handler>> net_handlers; std::vector<std::unique_ptr<sidechain_net_handler>> net_handlers;
}; };
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

207
libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp
View file

@ -1,17 +1,17 @@
#include <graphene/peerplays_sidechain/peerplays_sidechain_plugin.hpp> #include <graphene/peerplays_sidechain/peerplays_sidechain_plugin.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp> #include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/range/algorithm_ext/insert.hpp> #include <boost/range/algorithm_ext/insert.hpp>
#include <fc/log/logger.hpp> #include <fc/log/logger.hpp>
#include <fc/smart_ref_impl.hpp> #include <fc/smart_ref_impl.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
#include <graphene/chain/protocol/transfer.hpp>
#include <graphene/chain/sidechain_address_object.hpp> #include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/son_wallet_object.hpp> #include <graphene/chain/son_wallet_object.hpp>
#include <graphene/chain/son_wallet_withdraw_object.hpp> #include <graphene/chain/son_wallet_withdraw_object.hpp>
#include <graphene/chain/protocol/transfer.hpp>
#include <graphene/peerplays_sidechain/sidechain_net_manager.hpp> #include <graphene/peerplays_sidechain/sidechain_net_manager.hpp>
#include <graphene/utilities/key_conversion.hpp> #include <graphene/utilities/key_conversion.hpp>
@ -19,11 +19,9 @@ namespace bpo = boost::program_options;
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
namespace detail namespace detail {
{
class peerplays_sidechain_plugin_impl class peerplays_sidechain_plugin_impl {
{
public: public:
peerplays_sidechain_plugin_impl(peerplays_sidechain_plugin &_plugin); peerplays_sidechain_plugin_impl(peerplays_sidechain_plugin &_plugin);
virtual ~peerplays_sidechain_plugin_impl(); virtual ~peerplays_sidechain_plugin_impl();
@ -68,7 +66,6 @@ class peerplays_sidechain_plugin_impl
fc::future<void> _son_processing_task; fc::future<void> _son_processing_task;
void on_applied_block(const signed_block &b); void on_applied_block(const signed_block &b);
}; };
peerplays_sidechain_plugin_impl::peerplays_sidechain_plugin_impl(peerplays_sidechain_plugin &_plugin) : peerplays_sidechain_plugin_impl::peerplays_sidechain_plugin_impl(peerplays_sidechain_plugin &_plugin) :
@ -77,12 +74,10 @@ peerplays_sidechain_plugin_impl::peerplays_sidechain_plugin_impl(peerplays_sidec
config_ready_bitcoin(false), config_ready_bitcoin(false),
config_ready_peerplays(false), config_ready_peerplays(false),
current_son_id(son_id_type(std::numeric_limits<uint32_t>().max())), current_son_id(son_id_type(std::numeric_limits<uint32_t>().max())),
net_manager(nullptr) net_manager(nullptr) {
{
} }
peerplays_sidechain_plugin_impl::~peerplays_sidechain_plugin_impl() peerplays_sidechain_plugin_impl::~peerplays_sidechain_plugin_impl() {
{
try { try {
if (_heartbeat_task.valid()) if (_heartbeat_task.valid())
_heartbeat_task.cancel_and_wait(__FUNCTION__); _heartbeat_task.cancel_and_wait(__FUNCTION__);
@ -104,43 +99,28 @@ peerplays_sidechain_plugin_impl::~peerplays_sidechain_plugin_impl()
void peerplays_sidechain_plugin_impl::plugin_set_program_options( void peerplays_sidechain_plugin_impl::plugin_set_program_options(
boost::program_options::options_description &cli, boost::program_options::options_description &cli,
boost::program_options::options_description& cfg) boost::program_options::options_description &cfg) {
{
auto default_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(std::string("nathan"))); auto default_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(std::string("nathan")));
string son_id_example = fc::json::to_string(chain::son_id_type(5)); string son_id_example = fc::json::to_string(chain::son_id_type(5));
string son_id_example2 = fc::json::to_string(chain::son_id_type(6)); string son_id_example2 = fc::json::to_string(chain::son_id_type(6));
cli.add_options() cli.add_options()("son-id", bpo::value<vector<string>>(), ("ID of SON controlled by this node (e.g. " + son_id_example + ", quotes are required)").c_str());
("son-id", bpo::value<vector<string>>(), ("ID of SON controlled by this node (e.g. " + son_id_example + ", quotes are required)").c_str()); cli.add_options()("son-ids", bpo::value<string>(), ("IDs of multiple SONs controlled by this node (e.g. [" + son_id_example + ", " + son_id_example2 + "], quotes are required)").c_str());
cli.add_options() cli.add_options()("peerplays-private-key", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR(std::make_pair(chain::public_key_type(default_priv_key.get_public_key()), graphene::utilities::key_to_wif(default_priv_key))),
("son-ids", bpo::value<string>(), ("IDs of multiple SONs controlled by this node (e.g. [" + son_id_example + ", " + son_id_example2 + "], quotes are required)").c_str());
cli.add_options()
("peerplays-private-key", bpo::value<vector<string>>()->composing()->multitoken()->
DEFAULT_VALUE_VECTOR(std::make_pair(chain::public_key_type(default_priv_key.get_public_key()), graphene::utilities::key_to_wif(default_priv_key))),
"Tuple of [PublicKey, WIF private key] (may specify multiple times)"); "Tuple of [PublicKey, WIF private key] (may specify multiple times)");
cli.add_options() cli.add_options()("bitcoin-node-ip", bpo::value<string>()->default_value("99.79.189.95"), "IP address of Bitcoin node");
("bitcoin-node-ip", bpo::value<string>()->default_value("99.79.189.95"), "IP address of Bitcoin node"); cli.add_options()("bitcoin-node-zmq-port", bpo::value<uint32_t>()->default_value(11111), "ZMQ port of Bitcoin node");
cli.add_options() cli.add_options()("bitcoin-node-rpc-port", bpo::value<uint32_t>()->default_value(22222), "RPC port of Bitcoin node");
("bitcoin-node-zmq-port", bpo::value<uint32_t>()->default_value(11111), "ZMQ port of Bitcoin node"); cli.add_options()("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user");
cli.add_options() cli.add_options()("bitcoin-node-rpc-password", bpo::value<string>()->default_value("1"), "Bitcoin RPC password");
("bitcoin-node-rpc-port", bpo::value<uint32_t>()->default_value(22222), "RPC port of Bitcoin node"); cli.add_options()("bitcoin-wallet", bpo::value<string>(), "Bitcoin wallet");
cli.add_options() cli.add_options()("bitcoin-wallet-password", bpo::value<string>(), "Bitcoin wallet password");
("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user"); cli.add_options()("bitcoin-private-key", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR(std::make_pair("02d0f137e717fb3aab7aff99904001d49a0a636c5e1342f8927a4ba2eaee8e9772", "cVN31uC9sTEr392DLVUEjrtMgLA8Yb3fpYmTRj7bomTm6nn2ANPr")),
cli.add_options()
("bitcoin-node-rpc-password", bpo::value<string>()->default_value("1"), "Bitcoin RPC password");
cli.add_options()
("bitcoin-wallet", bpo::value<string>(), "Bitcoin wallet");
cli.add_options()
("bitcoin-wallet-password", bpo::value<string>(), "Bitcoin wallet password");
cli.add_options()
("bitcoin-private-key", bpo::value<vector<string>>()->composing()->multitoken()->
DEFAULT_VALUE_VECTOR(std::make_pair("02d0f137e717fb3aab7aff99904001d49a0a636c5e1342f8927a4ba2eaee8e9772", "cVN31uC9sTEr392DLVUEjrtMgLA8Yb3fpYmTRj7bomTm6nn2ANPr")),
"Tuple of [Bitcoin public key, Bitcoin private key] (may specify multiple times)"); "Tuple of [Bitcoin public key, Bitcoin private key] (may specify multiple times)");
cfg.add(cli); cfg.add(cli);
} }
void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_options::variables_map& options) void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_options::variables_map &options) {
{
config_ready_son = (options.count("son-id") || options.count("son-ids")) && options.count("peerplays-private-key"); config_ready_son = (options.count("son-id") || options.count("son-ids")) && options.count("peerplays-private-key");
if (config_ready_son) { if (config_ready_son) {
LOAD_VALUE_SET(options, "son-id", _sons, chain::son_id_type) LOAD_VALUE_SET(options, "son-id", _sons, chain::son_id_type)
@ -152,24 +132,18 @@ void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_opt
FC_ASSERT(_sons.size() == 1, "Multiple SONs not supported"); FC_ASSERT(_sons.size() == 1, "Multiple SONs not supported");
#endif #endif
if( options.count("peerplays-private-key") ) if (options.count("peerplays-private-key")) {
{
const std::vector<std::string> key_id_to_wif_pair_strings = options["peerplays-private-key"].as<std::vector<std::string>>(); const std::vector<std::string> key_id_to_wif_pair_strings = options["peerplays-private-key"].as<std::vector<std::string>>();
for (const std::string& key_id_to_wif_pair_string : key_id_to_wif_pair_strings) for (const std::string &key_id_to_wif_pair_string : key_id_to_wif_pair_strings) {
{
auto key_id_to_wif_pair = graphene::app::dejsonify<std::pair<chain::public_key_type, std::string>>(key_id_to_wif_pair_string, 5); auto key_id_to_wif_pair = graphene::app::dejsonify<std::pair<chain::public_key_type, std::string>>(key_id_to_wif_pair_string, 5);
ilog("Public Key: ${public}", ("public", key_id_to_wif_pair.first)); ilog("Public Key: ${public}", ("public", key_id_to_wif_pair.first));
fc::optional<fc::ecc::private_key> private_key = graphene::utilities::wif_to_key(key_id_to_wif_pair.second); fc::optional<fc::ecc::private_key> private_key = graphene::utilities::wif_to_key(key_id_to_wif_pair.second);
if (!private_key) if (!private_key) {
{
// the key isn't in WIF format; see if they are still passing the old native private key format. This is // the key isn't in WIF format; see if they are still passing the old native private key format. This is
// just here to ease the transition, can be removed soon // just here to ease the transition, can be removed soon
try try {
{
private_key = fc::variant(key_id_to_wif_pair.second, 2).as<fc::ecc::private_key>(1); private_key = fc::variant(key_id_to_wif_pair.second, 2).as<fc::ecc::private_key>(1);
} } catch (const fc::exception &) {
catch (const fc::exception&)
{
FC_THROW("Invalid WIF-format private key ${key_string}", ("key_string", key_id_to_wif_pair.second)); FC_THROW("Invalid WIF-format private key ${key_string}", ("key_string", key_id_to_wif_pair.second));
} }
} }
@ -181,7 +155,9 @@ void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_opt
throw; throw;
} }
plugin.database().applied_block.connect( [&] (const signed_block& b) { on_applied_block(b); } ); plugin.database().applied_block.connect([&](const signed_block &b) {
on_applied_block(b);
});
net_manager = std::unique_ptr<sidechain_net_manager>(new sidechain_net_manager(plugin)); net_manager = std::unique_ptr<sidechain_net_manager>(new sidechain_net_manager(plugin));
@ -220,8 +196,7 @@ void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_opt
} }
} }
void peerplays_sidechain_plugin_impl::plugin_startup() void peerplays_sidechain_plugin_impl::plugin_startup() {
{
if (config_ready_son) { if (config_ready_son) {
ilog("Starting ${n} SON instances", ("n", _sons.size())); ilog("Starting ${n} SON instances", ("n", _sons.size()));
@ -243,8 +218,7 @@ void peerplays_sidechain_plugin_impl::plugin_startup()
} }
} }
std::set<chain::son_id_type>& peerplays_sidechain_plugin_impl::get_sons() std::set<chain::son_id_type> &peerplays_sidechain_plugin_impl::get_sons() {
{
return _sons; return _sons;
} }
@ -252,8 +226,7 @@ son_id_type& peerplays_sidechain_plugin_impl::get_current_son_id() {
return current_son_id; return current_son_id;
} }
son_object peerplays_sidechain_plugin_impl::get_son_object(son_id_type son_id) son_object peerplays_sidechain_plugin_impl::get_son_object(son_id_type son_id) {
{
const auto &idx = plugin.database().get_index_type<chain::son_index>().indices().get<by_id>(); const auto &idx = plugin.database().get_index_type<chain::son_index>().indices().get<by_id>();
auto son_obj = idx.find(son_id); auto son_obj = idx.find(son_id);
if (son_obj == idx.end()) if (son_obj == idx.end())
@ -261,8 +234,7 @@ son_object peerplays_sidechain_plugin_impl::get_son_object(son_id_type son_id)
return *son_obj; return *son_obj;
} }
bool peerplays_sidechain_plugin_impl::is_active_son(son_id_type son_id) bool peerplays_sidechain_plugin_impl::is_active_son(son_id_type son_id) {
{
const auto &idx = plugin.database().get_index_type<chain::son_index>().indices().get<by_id>(); const auto &idx = plugin.database().get_index_type<chain::son_index>().indices().get<by_id>();
auto son_obj = idx.find(son_id); auto son_obj = idx.find(son_id);
if (son_obj == idx.end()) if (son_obj == idx.end())
@ -282,13 +254,11 @@ bool peerplays_sidechain_plugin_impl::is_active_son(son_id_type son_id)
return (it != active_son_ids.end()); return (it != active_son_ids.end());
} }
fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(son_id_type son_id) fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(son_id_type son_id) {
{
return get_private_key(get_son_object(son_id).signing_key); return get_private_key(get_son_object(son_id).signing_key);
} }
fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(chain::public_key_type public_key) fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(chain::public_key_type public_key) {
{
auto private_key_itr = private_keys.find(public_key); auto private_key_itr = private_keys.find(public_key);
if (private_key_itr != private_keys.end()) { if (private_key_itr != private_keys.end()) {
return private_key_itr->second; return private_key_itr->second;
@ -296,19 +266,19 @@ fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(chain::pub
return {}; return {};
} }
void peerplays_sidechain_plugin_impl::schedule_heartbeat_loop() void peerplays_sidechain_plugin_impl::schedule_heartbeat_loop() {
{
fc::time_point now = fc::time_point::now(); fc::time_point now = fc::time_point::now();
int64_t time_to_next_heartbeat = plugin.database().get_global_properties().parameters.son_heartbeat_frequency(); int64_t time_to_next_heartbeat = plugin.database().get_global_properties().parameters.son_heartbeat_frequency();
fc::time_point next_wakeup(now + fc::seconds(time_to_next_heartbeat)); fc::time_point next_wakeup(now + fc::seconds(time_to_next_heartbeat));
_heartbeat_task = fc::schedule([this]{heartbeat_loop();}, _heartbeat_task = fc::schedule([this] {
heartbeat_loop();
},
next_wakeup, "SON Heartbeat Production"); next_wakeup, "SON Heartbeat Production");
} }
void peerplays_sidechain_plugin_impl::heartbeat_loop() void peerplays_sidechain_plugin_impl::heartbeat_loop() {
{
schedule_heartbeat_loop(); schedule_heartbeat_loop();
chain::database &d = plugin.database(); chain::database &d = plugin.database();
@ -337,19 +307,19 @@ void peerplays_sidechain_plugin_impl::heartbeat_loop()
} }
} }
void peerplays_sidechain_plugin_impl::schedule_son_processing() void peerplays_sidechain_plugin_impl::schedule_son_processing() {
{
fc::time_point now = fc::time_point::now(); fc::time_point now = fc::time_point::now();
int64_t time_to_next_son_processing = 500000; int64_t time_to_next_son_processing = 500000;
fc::time_point next_wakeup(now + fc::microseconds(time_to_next_son_processing)); fc::time_point next_wakeup(now + fc::microseconds(time_to_next_son_processing));
_son_processing_task = fc::schedule([this]{son_processing();}, _son_processing_task = fc::schedule([this] {
son_processing();
},
next_wakeup, "SON Processing"); next_wakeup, "SON Processing");
} }
void peerplays_sidechain_plugin_impl::son_processing() void peerplays_sidechain_plugin_impl::son_processing() {
{
if (plugin.database().get_global_properties().active_sons.size() <= 0) { if (plugin.database().get_global_properties().active_sons.size() <= 0) {
return; return;
} }
@ -373,15 +343,12 @@ void peerplays_sidechain_plugin_impl::son_processing()
process_deposits(); process_deposits();
process_withdrawals(); process_withdrawals();
} }
} }
void peerplays_sidechain_plugin_impl::approve_proposals() void peerplays_sidechain_plugin_impl::approve_proposals() {
{
auto approve_proposal = [ & ]( const chain::son_id_type& son_id, const chain::proposal_id_type& proposal_id ) auto approve_proposal = [&](const chain::son_id_type &son_id, const chain::proposal_id_type &proposal_id) {
{
ilog("peerplays_sidechain_plugin: sending approval for ${p} from ${s}", ("p", proposal_id)("s", son_id)); ilog("peerplays_sidechain_plugin: sending approval for ${p} from ${s}", ("p", proposal_id)("s", son_id));
chain::proposal_update_operation puo; chain::proposal_update_operation puo;
puo.fee_paying_account = get_son_object(son_id).son_account; puo.fee_paying_account = get_son_object(son_id).son_account;
@ -413,38 +380,32 @@ void peerplays_sidechain_plugin_impl::approve_proposals()
continue; continue;
} }
if(proposal.proposed_transaction.operations.size() == 1 if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_report_down_operation>::value) {
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_report_down_operation>::value) {
approve_proposal(son_id, proposal.id); approve_proposal(son_id, proposal.id);
continue; continue;
} }
if(proposal.proposed_transaction.operations.size() == 1 if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_update_operation>::value) {
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_update_operation>::value) {
approve_proposal(son_id, proposal.id); approve_proposal(son_id, proposal.id);
continue; continue;
} }
if(proposal.proposed_transaction.operations.size() == 1 if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_create_operation>::value) {
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_create_operation>::value) {
approve_proposal(son_id, proposal.id); approve_proposal(son_id, proposal.id);
continue; continue;
} }
if(proposal.proposed_transaction.operations.size() == 1 if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_process_operation>::value) {
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_process_operation>::value) {
approve_proposal(son_id, proposal.id); approve_proposal(son_id, proposal.id);
continue; continue;
} }
if(proposal.proposed_transaction.operations.size() == 1 if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_create_operation>::value) {
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_create_operation>::value) {
approve_proposal(son_id, proposal.id); approve_proposal(son_id, proposal.id);
continue; continue;
} }
if(proposal.proposed_transaction.operations.size() == 1 if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_process_operation>::value) {
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_process_operation>::value) {
approve_proposal(son_id, proposal.id); approve_proposal(son_id, proposal.id);
continue; continue;
} }
@ -452,26 +413,21 @@ void peerplays_sidechain_plugin_impl::approve_proposals()
} }
} }
void peerplays_sidechain_plugin_impl::create_son_deregister_proposals() void peerplays_sidechain_plugin_impl::create_son_deregister_proposals() {
{
chain::database &d = plugin.database(); chain::database &d = plugin.database();
std::set<son_id_type> sons_to_be_dereg = d.get_sons_to_be_deregistered(); std::set<son_id_type> sons_to_be_dereg = d.get_sons_to_be_deregistered();
chain::son_id_type my_son_id = get_current_son_id(); chain::son_id_type my_son_id = get_current_son_id();
if(sons_to_be_dereg.size() > 0) if (sons_to_be_dereg.size() > 0) {
{
// We shouldn't raise proposals for the SONs for which a de-reg // We shouldn't raise proposals for the SONs for which a de-reg
// proposal is already raised. // proposal is already raised.
std::set<son_id_type> sons_being_dereg = d.get_sons_being_deregistered(); std::set<son_id_type> sons_being_dereg = d.get_sons_being_deregistered();
for( auto& son : sons_to_be_dereg) for (auto &son : sons_to_be_dereg) {
{
// New SON to be deregistered // New SON to be deregistered
if(sons_being_dereg.find(son) == sons_being_dereg.end() && my_son_id != son) if (sons_being_dereg.find(son) == sons_being_dereg.end() && my_son_id != son) {
{
// Creating the de-reg proposal // Creating the de-reg proposal
auto op = d.create_son_deregister_proposal(son, get_son_object(my_son_id).son_account); auto op = d.create_son_deregister_proposal(son, get_son_object(my_son_id).son_account);
if(op.valid()) if (op.valid()) {
{
// Signing and pushing into the txs to be included in the block // Signing and pushing into the txs to be included in the block
ilog("peerplays_sidechain_plugin: sending son deregister proposal for ${p} from ${s}", ("p", son)("s", my_son_id)); ilog("peerplays_sidechain_plugin: sending son deregister proposal for ${p} from ${s}", ("p", son)("s", my_son_id));
chain::signed_transaction trx = d.create_signed_transaction(plugin.get_private_key(get_son_object(my_son_id).signing_key), *op); chain::signed_transaction trx = d.create_signed_transaction(plugin.get_private_key(get_son_object(my_son_id).signing_key), *op);
@ -493,8 +449,7 @@ void peerplays_sidechain_plugin_impl::create_son_deregister_proposals()
} }
} }
void peerplays_sidechain_plugin_impl::create_son_down_proposals() void peerplays_sidechain_plugin_impl::create_son_down_proposals() {
{
auto create_son_down_proposal = [&](chain::son_id_type son_id, fc::time_point_sec last_active_ts) { auto create_son_down_proposal = [&](chain::son_id_type son_id, fc::time_point_sec last_active_ts) {
chain::database &d = plugin.database(); chain::database &d = plugin.database();
const chain::global_property_object &gpo = d.get_global_properties(); const chain::global_property_object &gpo = d.get_global_properties();
@ -548,64 +503,53 @@ void peerplays_sidechain_plugin_impl::create_son_down_proposals()
} }
} }
void peerplays_sidechain_plugin_impl::recreate_primary_wallet() void peerplays_sidechain_plugin_impl::recreate_primary_wallet() {
{
net_manager->recreate_primary_wallet(); net_manager->recreate_primary_wallet();
} }
void peerplays_sidechain_plugin_impl::process_deposits() void peerplays_sidechain_plugin_impl::process_deposits() {
{
net_manager->process_deposits(); net_manager->process_deposits();
} }
void peerplays_sidechain_plugin_impl::process_withdrawals() void peerplays_sidechain_plugin_impl::process_withdrawals() {
{
net_manager->process_withdrawals(); net_manager->process_withdrawals();
} }
void peerplays_sidechain_plugin_impl::on_applied_block( const signed_block& b ) void peerplays_sidechain_plugin_impl::on_applied_block(const signed_block &b) {
{
schedule_son_processing(); schedule_son_processing();
} }
} // end namespace detail } // end namespace detail
peerplays_sidechain_plugin::peerplays_sidechain_plugin() : peerplays_sidechain_plugin::peerplays_sidechain_plugin() :
my( new detail::peerplays_sidechain_plugin_impl(*this) ) my(new detail::peerplays_sidechain_plugin_impl(*this)) {
{
} }
peerplays_sidechain_plugin::~peerplays_sidechain_plugin() peerplays_sidechain_plugin::~peerplays_sidechain_plugin() {
{
return; return;
} }
std::string peerplays_sidechain_plugin::plugin_name()const std::string peerplays_sidechain_plugin::plugin_name() const {
{
return "peerplays_sidechain"; return "peerplays_sidechain";
} }
void peerplays_sidechain_plugin::plugin_set_program_options( void peerplays_sidechain_plugin::plugin_set_program_options(
boost::program_options::options_description &cli, boost::program_options::options_description &cli,
boost::program_options::options_description& cfg) boost::program_options::options_description &cfg) {
{
my->plugin_set_program_options(cli, cfg); my->plugin_set_program_options(cli, cfg);
} }
void peerplays_sidechain_plugin::plugin_initialize(const boost::program_options::variables_map& options) void peerplays_sidechain_plugin::plugin_initialize(const boost::program_options::variables_map &options) {
{
ilog("peerplays sidechain plugin: plugin_initialize()"); ilog("peerplays sidechain plugin: plugin_initialize()");
my->plugin_initialize(options); my->plugin_initialize(options);
} }
void peerplays_sidechain_plugin::plugin_startup() void peerplays_sidechain_plugin::plugin_startup() {
{
ilog("peerplays sidechain plugin: plugin_startup()"); ilog("peerplays sidechain plugin: plugin_startup()");
my->plugin_startup(); my->plugin_startup();
} }
std::set<chain::son_id_type>& peerplays_sidechain_plugin::get_sons() std::set<chain::son_id_type> &peerplays_sidechain_plugin::get_sons() {
{
return my->get_sons(); return my->get_sons();
} }
@ -613,25 +557,20 @@ son_id_type& peerplays_sidechain_plugin::get_current_son_id() {
return my->get_current_son_id(); return my->get_current_son_id();
} }
son_object peerplays_sidechain_plugin::get_son_object(son_id_type son_id) son_object peerplays_sidechain_plugin::get_son_object(son_id_type son_id) {
{
return my->get_son_object(son_id); return my->get_son_object(son_id);
} }
bool peerplays_sidechain_plugin::is_active_son(son_id_type son_id) bool peerplays_sidechain_plugin::is_active_son(son_id_type son_id) {
{
return my->is_active_son(son_id); return my->is_active_son(son_id);
} }
fc::ecc::private_key peerplays_sidechain_plugin::get_private_key(son_id_type son_id) fc::ecc::private_key peerplays_sidechain_plugin::get_private_key(son_id_type son_id) {
{
return my->get_private_key(son_id); return my->get_private_key(son_id);
} }
fc::ecc::private_key peerplays_sidechain_plugin::get_private_key(chain::public_key_type public_key) fc::ecc::private_key peerplays_sidechain_plugin::get_private_key(chain::public_key_type public_key) {
{
return my->get_private_key(public_key); return my->get_private_key(public_key);
} }
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

9
libraries/plugins/peerplays_sidechain/sidechain_net_handler.cpp
View file

@ -10,8 +10,7 @@ namespace graphene { namespace peerplays_sidechain {
sidechain_net_handler::sidechain_net_handler(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) : sidechain_net_handler::sidechain_net_handler(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
plugin(_plugin), plugin(_plugin),
database(_plugin.database()) database(_plugin.database()) {
{
} }
sidechain_net_handler::~sidechain_net_handler() { sidechain_net_handler::~sidechain_net_handler() {
@ -159,7 +158,6 @@ void sidechain_net_handler::process_deposits() {
std::for_each(idx_range.first, idx_range.second, std::for_each(idx_range.first, idx_range.second,
[&](const son_wallet_deposit_object &swdo) { [&](const son_wallet_deposit_object &swdo) {
ilog("Deposit to process: ${swdo}", ("swdo", swdo)); ilog("Deposit to process: ${swdo}", ("swdo", swdo));
process_deposit(swdo); process_deposit(swdo);
@ -194,7 +192,6 @@ void sidechain_net_handler::process_withdrawals() {
std::for_each(idx_range.first, idx_range.second, std::for_each(idx_range.first, idx_range.second,
[&](const son_wallet_withdraw_object &swwo) { [&](const son_wallet_withdraw_object &swwo) {
ilog("Withdraw to process: ${swwo}", ("swwo", swwo)); ilog("Withdraw to process: ${swwo}", ("swwo", swwo));
process_withdrawal(swwo); process_withdrawal(swwo);
@ -235,6 +232,4 @@ void sidechain_net_handler::process_withdrawal(const son_wallet_withdraw_object&
FC_ASSERT(false, "process_withdrawal not implemented"); FC_ASSERT(false, "process_withdrawal not implemented");
} }
}} // namespace graphene::peerplays_sidechain
} } // graphene::peerplays_sidechain

80
libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp
View file

@ -4,26 +4,30 @@
#include <thread> #include <thread>
#include <boost/algorithm/hex.hpp> #include <boost/algorithm/hex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp> #include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <fc/crypto/base64.hpp> #include <fc/crypto/base64.hpp>
#include <fc/log/logger.hpp> #include <fc/log/logger.hpp>
#include <fc/network/ip.hpp> #include <fc/network/ip.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
#include <graphene/chain/sidechain_address_object.hpp> #include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/son_info.hpp> #include <graphene/chain/son_info.hpp>
#include <graphene/chain/son_wallet_object.hpp> #include <graphene/chain/son_wallet_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
// ============================================================================= // =============================================================================
bitcoin_rpc_client::bitcoin_rpc_client(std::string _ip, uint32_t _rpc, std::string _user, std::string _password, std::string _wallet, std::string _wallet_password) : bitcoin_rpc_client::bitcoin_rpc_client(std::string _ip, uint32_t _rpc, std::string _user, std::string _password, std::string _wallet, std::string _wallet_password) :
ip( _ip ), rpc_port( _rpc ), user( _user ), password( _password ), wallet( _wallet ), wallet_password( _wallet_password ) ip(_ip),
{ rpc_port(_rpc),
user(_user),
password(_password),
wallet(_wallet),
wallet_password(_wallet_password) {
authorization.key = "Authorization"; authorization.key = "Authorization";
authorization.val = "Basic " + fc::base64_encode(user + ":" + password); authorization.val = "Basic " + fc::base64_encode(user + ":" + password);
} }
@ -321,8 +325,7 @@ std::string bitcoin_rpc_client::signrawtransactionwithwallet(const std::string &
return ""; return "";
} }
fc::http::reply bitcoin_rpc_client::send_post_request( std::string body ) fc::http::reply bitcoin_rpc_client::send_post_request(std::string body) {
{
fc::http::connection conn; fc::http::connection conn;
conn.connect_to(fc::ip::endpoint(fc::ip::address(ip), rpc_port)); conn.connect_to(fc::ip::endpoint(fc::ip::address(ip), rpc_port));
@ -337,7 +340,11 @@ fc::http::reply bitcoin_rpc_client::send_post_request( std::string body )
// ============================================================================= // =============================================================================
zmq_listener::zmq_listener( std::string _ip, uint32_t _zmq ): ip( _ip ), zmq_port( _zmq ), ctx( 1 ), socket( ctx, ZMQ_SUB ) { zmq_listener::zmq_listener(std::string _ip, uint32_t _zmq) :
ip(_ip),
zmq_port(_zmq),
ctx(1),
socket(ctx, ZMQ_SUB) {
std::thread(&zmq_listener::handle_zmq, this).detach(); std::thread(&zmq_listener::handle_zmq, this).detach();
} }
@ -395,15 +402,12 @@ sidechain_net_handler_bitcoin::sidechain_net_handler_bitcoin(peerplays_sidechain
wallet_password = options.at("bitcoin-wallet-password").as<std::string>(); wallet_password = options.at("bitcoin-wallet-password").as<std::string>();
} }
if( options.count("bitcoin-private-key") ) if (options.count("bitcoin-private-key")) {
{
const std::vector<std::string> pub_priv_keys = options["bitcoin-private-key"].as<std::vector<std::string>>(); const std::vector<std::string> pub_priv_keys = options["bitcoin-private-key"].as<std::vector<std::string>>();
for (const std::string& itr_key_pair : pub_priv_keys) for (const std::string &itr_key_pair : pub_priv_keys) {
{
auto key_pair = graphene::app::dejsonify<std::pair<std::string, std::string>>(itr_key_pair, 5); auto key_pair = graphene::app::dejsonify<std::pair<std::string, std::string>>(itr_key_pair, 5);
ilog("Bitcoin Public Key: ${public}", ("public", key_pair.first)); ilog("Bitcoin Public Key: ${public}", ("public", key_pair.first));
if(!key_pair.first.length() || !key_pair.second.length()) if (!key_pair.first.length() || !key_pair.second.length()) {
{
FC_THROW("Invalid public private key pair."); FC_THROW("Invalid public private key pair.");
} }
private_keys[key_pair.first] = key_pair.second; private_keys[key_pair.first] = key_pair.second;
@ -520,8 +524,7 @@ std::string sidechain_net_handler_bitcoin::send_transaction( const std::string&
return ""; return "";
} }
std::string sidechain_net_handler_bitcoin::sign_and_send_transaction_with_wallet ( const std::string& tx_json ) std::string sidechain_net_handler_bitcoin::sign_and_send_transaction_with_wallet(const std::string &tx_json) {
{
std::string reply_str = tx_json; std::string reply_str = tx_json;
ilog(reply_str); ilog(reply_str);
@ -553,8 +556,7 @@ std::string sidechain_net_handler_bitcoin::sign_and_send_transaction_with_wallet
return reply_str; return reply_str;
} }
std::string sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& from_address, const std::string& to_address) std::string sidechain_net_handler_bitcoin::transfer_all_btc(const std::string &from_address, const std::string &to_address) {
{
uint64_t fee_rate = bitcoin_client->estimatesmartfee(); uint64_t fee_rate = bitcoin_client->estimatesmartfee();
uint64_t min_fee_rate = 1000; uint64_t min_fee_rate = 1000;
fee_rate = std::max(fee_rate, min_fee_rate); fee_rate = std::max(fee_rate, min_fee_rate);
@ -563,20 +565,15 @@ std::string sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& f
double total_amount = 0.0; double total_amount = 0.0;
std::vector<btc_txout> unspent_utxo = bitcoin_client->listunspent_by_address_and_amount(from_address, 0); std::vector<btc_txout> unspent_utxo = bitcoin_client->listunspent_by_address_and_amount(from_address, 0);
if(unspent_utxo.size() == 0) if (unspent_utxo.size() == 0) {
{
wlog("Failed to find UTXOs to spend for ${pw}", ("pw", from_address)); wlog("Failed to find UTXOs to spend for ${pw}", ("pw", from_address));
return ""; return "";
} } else {
else for (const auto &utx : unspent_utxo) {
{
for(const auto& utx: unspent_utxo)
{
total_amount += utx.amount_; total_amount += utx.amount_;
} }
if(min_amount >= total_amount) if (min_amount >= total_amount) {
{
wlog("Failed not enough BTC to transfer from ${fa}", ("fa", from_address)); wlog("Failed not enough BTC to transfer from ${fa}", ("fa", from_address));
return ""; return "";
} }
@ -589,8 +586,7 @@ std::string sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& f
return sign_and_send_transaction_with_wallet(reply_str); return sign_and_send_transaction_with_wallet(reply_str);
} }
std::string sidechain_net_handler_bitcoin::transfer_deposit_to_primary_wallet (const son_wallet_deposit_object &swdo) std::string sidechain_net_handler_bitcoin::transfer_deposit_to_primary_wallet(const son_wallet_deposit_object &swdo) {
{
const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>(); const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
auto obj = idx.rbegin(); auto obj = idx.rbegin();
if (obj == idx.rend() || obj->addresses.find(sidechain_type::bitcoin) == obj->addresses.end()) { if (obj == idx.rend() || obj->addresses.find(sidechain_type::bitcoin) == obj->addresses.end()) {
@ -633,8 +629,7 @@ std::string sidechain_net_handler_bitcoin::transfer_deposit_to_primary_wallet (c
std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wallet(const son_wallet_withdraw_object &swwo) { std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wallet(const son_wallet_withdraw_object &swwo) {
const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>(); const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
auto obj = idx.rbegin(); auto obj = idx.rbegin();
if (obj == idx.rend() || obj->addresses.find(sidechain_type::bitcoin) == obj->addresses.end()) if (obj == idx.rend() || obj->addresses.find(sidechain_type::bitcoin) == obj->addresses.end()) {
{
return ""; return "";
} }
@ -654,20 +649,15 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
double total_amount = 0.0; double total_amount = 0.0;
std::vector<btc_txout> unspent_utxo = bitcoin_client->listunspent_by_address_and_amount(pw_address, 0); std::vector<btc_txout> unspent_utxo = bitcoin_client->listunspent_by_address_and_amount(pw_address, 0);
if(unspent_utxo.size() == 0) if (unspent_utxo.size() == 0) {
{
wlog("Failed to find UTXOs to spend for ${pw}", ("pw", pw_address)); wlog("Failed to find UTXOs to spend for ${pw}", ("pw", pw_address));
return ""; return "";
} } else {
else for (const auto &utx : unspent_utxo) {
{
for(const auto& utx: unspent_utxo)
{
total_amount += utx.amount_; total_amount += utx.amount_;
} }
if(min_amount > total_amount) if (min_amount > total_amount) {
{
wlog("Failed not enough BTC to spend for ${pw}", ("pw", pw_address)); wlog("Failed not enough BTC to spend for ${pw}", ("pw", pw_address));
return ""; return "";
} }
@ -675,8 +665,7 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
fc::flat_map<std::string, double> outs; fc::flat_map<std::string, double> outs;
outs[swwo.withdraw_address] = swwo.withdraw_amount.value / 100000000.0; outs[swwo.withdraw_address] = swwo.withdraw_amount.value / 100000000.0;
if((total_amount - min_amount) > 0.0) if ((total_amount - min_amount) > 0.0) {
{
outs[pw_address] = total_amount - min_amount; outs[pw_address] = total_amount - min_amount;
} }
@ -697,7 +686,8 @@ void sidechain_net_handler_bitcoin::handle_event( const std::string& event_data
continue; continue;
std::stringstream ss; std::stringstream ss;
ss << "bitcoin" << "-" << v.out.hash_tx << "-" << v.out.n_vout; ss << "bitcoin"
<< "-" << v.out.hash_tx << "-" << v.out.n_vout;
std::string sidechain_uid = ss.str(); std::string sidechain_uid = ss.str();
sidechain_event_data sed; sidechain_event_data sed;
@ -730,7 +720,8 @@ std::vector<info_for_vin> sidechain_net_handler_bitcoin::extract_info_from_block
for (const auto &o : tx.get_child("vout")) { for (const auto &o : tx.get_child("vout")) {
const auto script = o.second.get_child("scriptPubKey"); const auto script = o.second.get_child("scriptPubKey");
if( !script.count("addresses") ) continue; if (!script.count("addresses"))
continue;
for (const auto &addr : script.get_child("addresses")) { // in which cases there can be more addresses? for (const auto &addr : script.get_child("addresses")) { // in which cases there can be more addresses?
const auto address_base58 = addr.second.get_value<std::string>(); const auto address_base58 = addr.second.get_value<std::string>();
@ -751,5 +742,4 @@ std::vector<info_for_vin> sidechain_net_handler_bitcoin::extract_info_from_block
// ============================================================================= // =============================================================================
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

14
libraries/plugins/peerplays_sidechain/sidechain_net_handler_peerplays.cpp
View file

@ -4,25 +4,27 @@
#include <thread> #include <thread>
#include <boost/algorithm/hex.hpp> #include <boost/algorithm/hex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp> #include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <fc/crypto/base64.hpp> #include <fc/crypto/base64.hpp>
#include <fc/log/logger.hpp> #include <fc/log/logger.hpp>
#include <fc/network/ip.hpp> #include <fc/network/ip.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
#include <graphene/chain/sidechain_address_object.hpp> #include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/son_info.hpp> #include <graphene/chain/son_info.hpp>
#include <graphene/chain/son_wallet_object.hpp> #include <graphene/chain/son_wallet_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
namespace graphene { namespace peerplays_sidechain { namespace graphene { namespace peerplays_sidechain {
sidechain_net_handler_peerplays::sidechain_net_handler_peerplays(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) : sidechain_net_handler_peerplays::sidechain_net_handler_peerplays(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
sidechain_net_handler(_plugin, options) { sidechain_net_handler(_plugin, options) {
sidechain = sidechain_type::peerplays; sidechain = sidechain_type::peerplays;
plugin.database().applied_block.connect( [&] (const signed_block& b) { on_applied_block(b); } ); plugin.database().applied_block.connect([&](const signed_block &b) {
on_applied_block(b);
});
} }
sidechain_net_handler_peerplays::~sidechain_net_handler_peerplays() { sidechain_net_handler_peerplays::~sidechain_net_handler_peerplays() {
@ -65,7 +67,8 @@ void sidechain_net_handler_peerplays::on_applied_block(const signed_block& b) {
} }
std::stringstream ss; std::stringstream ss;
ss << "peerplays" << "-" << trx.id().str() << "-" << operation_index; ss << "peerplays"
<< "-" << trx.id().str() << "-" << operation_index;
std::string sidechain_uid = ss.str(); std::string sidechain_uid = ss.str();
sidechain_event_data sed; sidechain_event_data sed;
@ -87,5 +90,4 @@ void sidechain_net_handler_peerplays::on_applied_block(const signed_block& b) {
} }
} }
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain

6
libraries/plugins/peerplays_sidechain/sidechain_net_manager.cpp
View file

@ -9,8 +9,7 @@ namespace graphene { namespace peerplays_sidechain {
sidechain_net_manager::sidechain_net_manager(peerplays_sidechain_plugin &_plugin) : sidechain_net_manager::sidechain_net_manager(peerplays_sidechain_plugin &_plugin) :
plugin(_plugin), plugin(_plugin),
database(_plugin.database()) database(_plugin.database()) {
{
} }
sidechain_net_manager::~sidechain_net_manager() { sidechain_net_manager::~sidechain_net_manager() {
@ -58,5 +57,4 @@ void sidechain_net_manager::process_withdrawals() {
} }
} }
} } // graphene::peerplays_sidechain }} // namespace graphene::peerplays_sidechain