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/elliptic.hpp>
#include <fc/crypto/ripemd160.hpp>
#include <fc/crypto/sha256.hpp>
#include <fc/io/raw.hpp>
#include <graphene/peerplays_sidechain/bitcoin_utils.hpp>
#include <secp256k1.h>
namespace graphene { namespace peerplays_sidechain {
@ -37,7 +37,9 @@ static const unsigned char OP_CHECKSIG = 0xac;
class WriteBytesStream {
public:
WriteBytesStream(bytes& buffer) : storage_(buffer) {}
WriteBytesStream(bytes &buffer) :
storage_(buffer) {
}
void write(const unsigned char *d, size_t s) {
storage_.insert(storage_.end(), d, d + s);
@ -48,68 +50,61 @@ public:
return true;
}
void writedata8(uint8_t obj)
{
void writedata8(uint8_t obj) {
write((unsigned char *)&obj, 1);
}
void writedata16(uint16_t obj)
{
void writedata16(uint16_t obj) {
obj = htole16(obj);
write((unsigned char *)&obj, 2);
}
void writedata32(uint32_t obj)
{
void writedata32(uint32_t obj) {
obj = htole32(obj);
write((unsigned char *)&obj, 4);
}
void writedata64(uint64_t obj)
{
void writedata64(uint64_t obj) {
obj = htole64(obj);
write((unsigned char *)&obj, 8);
}
void write_compact_int(uint64_t val)
{
if (val < 253)
{
void write_compact_int(uint64_t val) {
if (val < 253) {
writedata8(val);
}
else if (val <= std::numeric_limits<unsigned short>::max())
{
} else if (val <= std::numeric_limits<unsigned short>::max()) {
writedata8(253);
writedata16(val);
}
else if (val <= std::numeric_limits<unsigned int>::max())
{
} else if (val <= std::numeric_limits<unsigned int>::max()) {
writedata8(254);
writedata32(val);
}
else
{
} else {
writedata8(255);
writedata64(val);
}
}
void writedata(const bytes& data)
{
void writedata(const bytes &data) {
write_compact_int(data.size());
write(&data[0], data.size());
}
private:
bytes &storage_;
};
class ReadBytesStream {
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_; }
void set_pos(size_t pos)
{
size_t current_pos() const {
return pos_;
}
void set_pos(size_t pos) {
if (pos > end_)
FC_THROW("Invalid position in BTC tx buffer");
pos_ = pos;
@ -124,8 +119,7 @@ public:
FC_THROW("invalid bitcoin tx buffer");
}
inline bool get( unsigned char& c )
{
inline bool get(unsigned char &c) {
if (pos_ < end_) {
c = storage_[pos_++];
return true;
@ -133,53 +127,41 @@ public:
FC_THROW("invalid bitcoin tx buffer");
}
uint8_t readdata8()
{
uint8_t readdata8() {
uint8_t obj;
read((unsigned char *)&obj, 1);
return obj;
}
uint16_t readdata16()
{
uint16_t readdata16() {
uint16_t obj;
read((unsigned char *)&obj, 2);
return le16toh(obj);
}
uint32_t readdata32()
{
uint32_t readdata32() {
uint32_t obj;
read((unsigned char *)&obj, 4);
return le32toh(obj);
}
uint64_t readdata64()
{
uint64_t readdata64() {
uint64_t obj;
read((unsigned char *)&obj, 8);
return le64toh(obj);
}
uint64_t read_compact_int()
{
uint64_t read_compact_int() {
uint8_t size = readdata8();
uint64_t ret = 0;
if (size < 253)
{
if (size < 253) {
ret = size;
}
else if (size == 253)
{
} else if (size == 253) {
ret = readdata16();
if (ret < 253)
FC_THROW("non-canonical ReadCompactSize()");
}
else if (size == 254)
{
} else if (size == 254) {
ret = readdata32();
if (ret < 0x10000u)
FC_THROW("non-canonical ReadCompactSize()");
}
else
{
} else {
ret = readdata64();
if (ret < 0x100000000ULL)
FC_THROW("non-canonical ReadCompactSize()");
@ -189,8 +171,7 @@ public:
return ret;
}
void readdata(bytes& data)
{
void readdata(bytes &data) {
size_t s = read_compact_int();
data.clear();
data.resize(s);
@ -203,16 +184,14 @@ private:
size_t end_;
};
void btc_outpoint::to_bytes(bytes& stream) const
{
void btc_outpoint::to_bytes(bytes &stream) const {
WriteBytesStream str(stream);
// TODO: write size?
str.write((unsigned char *)hash.data(), hash.data_size());
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);
// TODO: read 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();
}
void btc_in::to_bytes(bytes& stream) const
{
void btc_in::to_bytes(bytes &stream) const {
prevout.to_bytes(stream);
WriteBytesStream str(stream);
str.writedata(scriptSig);
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);
ReadBytesStream str(data, pos);
str.readdata(scriptSig);
@ -237,27 +214,23 @@ size_t btc_in::fill_from_bytes(const bytes& data, size_t pos)
return str.current_pos();
}
void btc_out::to_bytes(bytes& stream) const
{
void btc_out::to_bytes(bytes &stream) const {
WriteBytesStream str(stream);
str.writedata64(nValue);
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);
nValue = str.readdata64();
str.readdata(scriptPubKey);
return str.current_pos();
}
void btc_tx::to_bytes(bytes& stream) const
{
void btc_tx::to_bytes(bytes &stream) const {
WriteBytesStream str(stream);
str.writedata32(nVersion);
if(hasWitness)
{
if (hasWitness) {
// write dummy inputs and flag
str.write_compact_int(0);
unsigned char flags = 1;
@ -269,10 +242,8 @@ void btc_tx::to_bytes(bytes& stream) const
str.write_compact_int(vout.size());
for (const auto &out : vout)
out.to_bytes(stream);
if(hasWitness)
{
for(const auto& in: vin)
{
if (hasWitness) {
for (const auto &in : vin) {
str.write_compact_int(in.scriptWitness.size());
for (const auto &stack_item : in.scriptWitness)
str.writedata(stack_item);
@ -281,8 +252,7 @@ void btc_tx::to_bytes(bytes& stream) const
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);
nVersion = ds.readdata32();
unsigned char flags = 0;
@ -325,8 +295,7 @@ size_t btc_tx::fill_from_bytes(const bytes& data, size_t pos)
}
if (hasWitness) {
/* The witness flag is present, and we support witnesses. */
for (auto& in: vin)
{
for (auto &in : vin) {
unsigned int size = ds.read_compact_int();
in.scriptWitness.resize(size);
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();
}
void add_data_to_script(bytes& script, const bytes& data)
{
void add_data_to_script(bytes &script, const bytes &data) {
WriteBytesStream str(script);
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);
if (data == 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});
}
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;
bytes result;
add_number_to_script(result, 0);
for(auto& p: key_data)
{
for (auto &p : key_data) {
total_weight += p.second;
result.push_back(OP_SWAP);
auto raw_data = p.first.serialize();
@ -487,7 +451,8 @@ bool convertbits(bytes& out, const bytes& in) {
}
}
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)) {
return false;
}
@ -503,8 +468,7 @@ std::string segwit_addr_encode(const std::string& hrp, uint8_t witver, const byt
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
fc::sha256 sh = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.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");
}
bytes lock_script_for_redeem_script(const bytes &script)
{
bytes lock_script_for_redeem_script(const bytes &script) {
bytes result;
result.push_back(OP_0);
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;
}
bytes hash_prevouts(const btc_tx& unsigned_tx)
{
bytes hash_prevouts(const btc_tx &unsigned_tx) {
fc::sha256::encoder hasher;
for(const auto& in: unsigned_tx.vin)
{
for (const auto &in : unsigned_tx.vin) {
bytes data;
in.prevout.to_bytes(data);
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());
}
bytes hash_sequence(const btc_tx& unsigned_tx)
{
bytes hash_sequence(const btc_tx &unsigned_tx) {
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));
}
fc::sha256 res = fc::sha256::hash(hasher.result());
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;
for(const auto& out: unsigned_tx.vout)
{
for (const auto &out : unsigned_tx.vout) {
bytes data;
out.to_bytes(data);
hasher.write(reinterpret_cast<const char *>(&data[0]), data.size());
@ -572,8 +529,7 @@ const secp256k1_context_t* btc_get_context() {
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;
int size = result.size();
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<uint64_t> in_amounts,
const bytes &redeem_script,
const fc::ecc::private_key& priv_key)
{
const fc::ecc::private_key &priv_key) {
btc_tx 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);
// calc digest for every input according to BIP143
// implement SIGHASH_ALL scheme
for(const auto& in: tx.vin)
{
for (const auto &in : tx.vin) {
fc::sha256::encoder hasher;
hasher.write(reinterpret_cast<const char *>(&tx.nVersion), sizeof(tx.nVersion));
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;
}
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;
tx.fill_from_bytes(unsigned_tx);
bytes dummy_data;
for(auto key: priv_keys)
{
if(key)
{
for (auto key : priv_keys) {
if (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");
// 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++)
tx.vin[i].scriptWitness.insert(tx.vin[i].scriptWitness.begin(), signatures[i]);
}
else
{
} else {
for (unsigned int i = 0; i < tx.vin.size(); i++)
tx.vin[i].scriptWitness.push_back(dummy_data);
}
}
for(auto& in: tx.vin)
{
for (auto &in : tx.vin) {
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,
const bytes &redeem_script,
unsigned int key_count)
{
unsigned int key_count) {
btc_tx tx;
tx.fill_from_bytes(unsigned_tx);
bytes dummy_data;
for(auto& in: tx.vin)
{
for (auto &in : tx.vin) {
for (unsigned i = 0; i < key_count; i++)
in.scriptWitness.push_back(dummy_data);
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,
std::vector<uint64_t> in_amounts,
const fc::ecc::private_key &priv_key,
unsigned int key_idx)
{
unsigned int key_idx) {
btc_tx tx;
tx.fill_from_bytes(partially_signed_tx);
FC_ASSERT(tx.vin.size() > 0);
@ -710,13 +655,11 @@ bytes partially_sign_pw_transfer_transaction(const bytes& partially_signed_tx,
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;
tx.fill_from_bytes(unsigned_tx);
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];
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
@ -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]);
}
for(auto& in: tx.vin)
{
for (auto &in : tx.vin) {
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;
}
}}
}} // namespace graphene::peerplays_sidechain

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

@ -1,6 +1,6 @@
#pragma once
#include <graphene/peerplays_sidechain/defs.hpp>
#include <fc/optional.hpp>
#include <graphene/peerplays_sidechain/defs.hpp>
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);
bytes lock_script_for_redeem_script(const bytes &script);
std::vector<bytes> signatures_for_raw_transaction(const bytes &unsigned_tx,
std::vector<uint64_t> in_amounts,
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 bytes &redeem_script);
struct btc_outpoint
{
struct btc_outpoint {
fc::uint256 hash;
uint32_t n;
@ -74,8 +72,7 @@ struct btc_outpoint
size_t fill_from_bytes(const bytes &data, size_t pos = 0);
};
struct btc_in
{
struct btc_in {
btc_outpoint prevout;
bytes scriptSig;
uint32_t nSequence;
@ -85,8 +82,7 @@ struct btc_in
size_t fill_from_bytes(const bytes &data, size_t pos = 0);
};
struct btc_out
{
struct btc_out {
int64_t nValue;
bytes scriptPubKey;
@ -94,8 +90,7 @@ struct btc_out
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_out> vout;
int32_t nVersion;
@ -106,5 +101,4 @@ struct btc_tx
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 <vector>
#include <fc/crypto/sha256.hpp>
#include <fc/safe.hpp>
#include <fc/time.hpp>
#include <fc/crypto/sha256.hpp>
#include <graphene/chain/protocol/asset.hpp>
#include <graphene/chain/protocol/types.hpp>
@ -22,14 +22,11 @@ enum class sidechain_type {
using bytes = std::vector<unsigned char>;
struct prev_out
{
bool operator!=( const prev_out& obj ) const
{
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;
@ -40,8 +37,7 @@ struct prev_out
uint64_t amount;
};
struct info_for_vin
{
struct info_for_vin {
info_for_vin() = default;
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;
};
} } // graphene::peerplays_sidechain
}} // namespace graphene::peerplays_sidechain
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 {
using namespace chain;
namespace detail
{
namespace detail {
class peerplays_sidechain_plugin_impl;
}
class peerplays_sidechain_plugin : public graphene::app::plugin
{
class peerplays_sidechain_plugin : public graphene::app::plugin {
public:
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);
};
} } //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;
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 <zmq.hpp>
#include <fc/signals.hpp>
#include <fc/network/http/connection.hpp>
#include <fc/signals.hpp>
#include <graphene/chain/son_wallet_deposit_object.hpp>
#include <graphene/chain/son_wallet_withdraw_object.hpp>
namespace graphene { namespace peerplays_sidechain {
class btc_txout
{
class btc_txout {
public:
std::string txid_;
unsigned int out_num_;
@ -37,7 +36,6 @@ public:
std::string signrawtransactionwithwallet(const std::string &tx_hash);
private:
fc::http::reply send_post_request(std::string body);
std::string ip;
@ -55,9 +53,12 @@ private:
class zmq_listener {
public:
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;
private:
void handle_zmq();
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);
};
} } // 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);
private:
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 sign_transaction(const std::string &transaction);
std::string send_transaction(const std::string &transaction);
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 process_deposits();
void process_withdrawals();
private:
peerplays_sidechain_plugin &plugin;
graphene::chain::database &database;
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 <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/range/algorithm_ext/insert.hpp>
#include <fc/log/logger.hpp>
#include <fc/smart_ref_impl.hpp>
#include <graphene/chain/proposal_object.hpp>
#include <graphene/chain/protocol/transfer.hpp>
#include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/son_wallet_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/utilities/key_conversion.hpp>
@ -19,11 +19,9 @@ namespace bpo = boost::program_options;
namespace graphene { namespace peerplays_sidechain {
namespace detail
{
namespace detail {
class peerplays_sidechain_plugin_impl
{
class peerplays_sidechain_plugin_impl {
public:
peerplays_sidechain_plugin_impl(peerplays_sidechain_plugin &_plugin);
virtual ~peerplays_sidechain_plugin_impl();
@ -68,7 +66,6 @@ class peerplays_sidechain_plugin_impl
fc::future<void> _son_processing_task;
void on_applied_block(const signed_block &b);
};
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_peerplays(false),
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 {
if (_heartbeat_task.valid())
_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(
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")));
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));
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());
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()
("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))),
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());
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()("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)");
cli.add_options()
("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()
("bitcoin-node-rpc-port", bpo::value<uint32_t>()->default_value(22222), "RPC port of Bitcoin node");
cli.add_options()
("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user");
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")),
cli.add_options()("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()("bitcoin-node-rpc-port", bpo::value<uint32_t>()->default_value(22222), "RPC port of Bitcoin node");
cli.add_options()("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user");
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)");
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");
if (config_ready_son) {
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");
#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>>();
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);
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);
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
// 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);
}
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));
}
}
@ -181,7 +155,9 @@ void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_opt
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));
@ -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) {
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;
}
@ -252,8 +226,7 @@ son_id_type& peerplays_sidechain_plugin_impl::get_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>();
auto son_obj = idx.find(son_id);
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;
}
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>();
auto son_obj = idx.find(son_id);
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());
}
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);
}
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);
if (private_key_itr != private_keys.end()) {
return private_key_itr->second;
@ -296,19 +266,19 @@ fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(chain::pub
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();
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));
_heartbeat_task = fc::schedule([this]{heartbeat_loop();},
_heartbeat_task = fc::schedule([this] {
heartbeat_loop();
},
next_wakeup, "SON Heartbeat Production");
}
void peerplays_sidechain_plugin_impl::heartbeat_loop()
{
void peerplays_sidechain_plugin_impl::heartbeat_loop() {
schedule_heartbeat_loop();
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();
int64_t time_to_next_son_processing = 500000;
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");
}
void peerplays_sidechain_plugin_impl::son_processing()
{
void peerplays_sidechain_plugin_impl::son_processing() {
if (plugin.database().get_global_properties().active_sons.size() <= 0) {
return;
}
@ -373,15 +343,12 @@ void peerplays_sidechain_plugin_impl::son_processing()
process_deposits();
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));
chain::proposal_update_operation puo;
puo.fee_paying_account = get_son_object(son_id).son_account;
@ -413,38 +380,32 @@ void peerplays_sidechain_plugin_impl::approve_proposals()
continue;
}
if(proposal.proposed_transaction.operations.size() == 1
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_report_down_operation>::value) {
if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_report_down_operation>::value) {
approve_proposal(son_id, proposal.id);
continue;
}
if(proposal.proposed_transaction.operations.size() == 1
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_update_operation>::value) {
if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_update_operation>::value) {
approve_proposal(son_id, proposal.id);
continue;
}
if(proposal.proposed_transaction.operations.size() == 1
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_create_operation>::value) {
if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_create_operation>::value) {
approve_proposal(son_id, proposal.id);
continue;
}
if(proposal.proposed_transaction.operations.size() == 1
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_process_operation>::value) {
if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_deposit_process_operation>::value) {
approve_proposal(son_id, proposal.id);
continue;
}
if(proposal.proposed_transaction.operations.size() == 1
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_create_operation>::value) {
if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_create_operation>::value) {
approve_proposal(son_id, proposal.id);
continue;
}
if(proposal.proposed_transaction.operations.size() == 1
&& proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_process_operation>::value) {
if (proposal.proposed_transaction.operations.size() == 1 && proposal.proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_withdraw_process_operation>::value) {
approve_proposal(son_id, proposal.id);
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();
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();
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
// proposal is already raised.
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
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
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
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);
@ -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) {
chain::database &d = plugin.database();
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();
}
void peerplays_sidechain_plugin_impl::process_deposits()
{
void peerplays_sidechain_plugin_impl::process_deposits() {
net_manager->process_deposits();
}
void peerplays_sidechain_plugin_impl::process_withdrawals()
{
void peerplays_sidechain_plugin_impl::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();
}
} // end namespace detail
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;
}
std::string peerplays_sidechain_plugin::plugin_name()const
{
std::string peerplays_sidechain_plugin::plugin_name() const {
return "peerplays_sidechain";
}
void peerplays_sidechain_plugin::plugin_set_program_options(
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);
}
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()");
my->plugin_initialize(options);
}
void peerplays_sidechain_plugin::plugin_startup()
{
void peerplays_sidechain_plugin::plugin_startup() {
ilog("peerplays sidechain plugin: 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();
}
@ -613,25 +557,20 @@ son_id_type& peerplays_sidechain_plugin::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);
}
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);
}
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);
}
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);
}
} } // 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) :
plugin(_plugin),
database(_plugin.database())
{
database(_plugin.database()) {
}
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,
[&](const son_wallet_deposit_object &swdo) {
ilog("Deposit to process: ${swdo}", ("swdo", swdo));
process_deposit(swdo);
@ -194,7 +192,6 @@ void sidechain_net_handler::process_withdrawals() {
std::for_each(idx_range.first, idx_range.second,
[&](const son_wallet_withdraw_object &swwo) {
ilog("Withdraw to process: ${swwo}", ("swwo", 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");
}
} } // graphene::peerplays_sidechain
}} // namespace graphene::peerplays_sidechain

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

@ -4,26 +4,30 @@
#include <thread>
#include <boost/algorithm/hex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <fc/crypto/base64.hpp>
#include <fc/log/logger.hpp>
#include <fc/network/ip.hpp>
#include <graphene/chain/account_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
#include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/son_info.hpp>
#include <graphene/chain/son_wallet_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
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) :
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.val = "Basic " + fc::base64_encode(user + ":" + password);
}
@ -321,8 +325,7 @@ std::string bitcoin_rpc_client::signrawtransactionwithwallet(const std::string &
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;
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();
}
@ -395,15 +402,12 @@ sidechain_net_handler_bitcoin::sidechain_net_handler_bitcoin(peerplays_sidechain
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>>();
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);
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.");
}
private_keys[key_pair.first] = key_pair.second;
@ -520,8 +524,7 @@ std::string sidechain_net_handler_bitcoin::send_transaction( const std::string&
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;
ilog(reply_str);
@ -553,8 +556,7 @@ std::string sidechain_net_handler_bitcoin::sign_and_send_transaction_with_wallet
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 min_fee_rate = 1000;
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;
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));
return "";
}
else
{
for(const auto& utx: unspent_utxo)
{
} else {
for (const auto &utx : unspent_utxo) {
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));
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);
}
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>();
auto obj = idx.rbegin();
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) {
const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
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 "";
}
@ -654,20 +649,15 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
double total_amount = 0.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));
return "";
}
else
{
for(const auto& utx: unspent_utxo)
{
} else {
for (const auto &utx : unspent_utxo) {
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));
return "";
}
@ -675,8 +665,7 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
fc::flat_map<std::string, double> outs;
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;
}
@ -697,7 +686,8 @@ void sidechain_net_handler_bitcoin::handle_event( const std::string& event_data
continue;
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();
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")) {
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?
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 <boost/algorithm/hex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <fc/crypto/base64.hpp>
#include <fc/log/logger.hpp>
#include <fc/network/ip.hpp>
#include <graphene/chain/account_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
#include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/son_info.hpp>
#include <graphene/chain/son_wallet_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
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(_plugin, options) {
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() {
@ -65,7 +67,8 @@ void sidechain_net_handler_peerplays::on_applied_block(const signed_block& b) {
}
std::stringstream ss;
ss << "peerplays" << "-" << trx.id().str() << "-" << operation_index;
ss << "peerplays"
<< "-" << trx.id().str() << "-" << operation_index;
std::string sidechain_uid = ss.str();
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) :
plugin(_plugin),
database(_plugin.database())
{
database(_plugin.database()) {
}
sidechain_net_manager::~sidechain_net_manager() {
@ -58,5 +57,4 @@ void sidechain_net_manager::process_withdrawals() {
}
}
} } // graphene::peerplays_sidechain
}} // namespace graphene::peerplays_sidechain