Move signal connection after handlers are created

- Better exposure of sidechain private keys in sidechain handlers
- Support non default Bitcoin wallets

libraries/plugins/peerplays_sidechain/bitcoin_utils.cpp

@@ -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 {
@@ -35,11 +35,13 @@ static const unsigned char OP_GREATERTHAN = 0xa0;
 static const unsigned char OP_HASH160 = 0xa9;
 static const unsigned char OP_CHECKSIG = 0xac;
 
-class WriteBytesStream{
+class WriteBytesStream {
 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);
    }
 
@@ -48,149 +50,128 @@ public:
       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);
-      {
+      } else if (val <= std::numeric_limits<unsigned short>::max()) {
-          writedata8(val);
+         writedata8(253);
-      }
+         writedata16(val);
-      else if (val <= std::numeric_limits<unsigned short>::max())
+      } else if (val <= std::numeric_limits<unsigned int>::max()) {
-      {
+         writedata8(254);
-          writedata8(253);
+         writedata32(val);
-          writedata16(val);
+      } else {
-      }
+         writedata8(255);
-      else if (val <= std::numeric_limits<unsigned int>::max())
+         writedata64(val);
-      {
-          writedata8(254);
-          writedata32(val);
-      }
-      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_;
+   bytes &storage_;
 };
 
-class ReadBytesStream{
+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_; }
+   size_t current_pos() const {
-   void set_pos(size_t pos)
+      return pos_;
-   {
+   }
-      if(pos > end_)
+   void set_pos(size_t pos) {
+      if (pos > end_)
          FC_THROW("Invalid position in BTC tx buffer");
       pos_ = pos;
    }
 
-   inline bool read( unsigned char* d, size_t s ) {
+   inline bool read(unsigned char *d, size_t s) {
-     if( end_ - pos_ >= s ) {
+      if (end_ - pos_ >= s) {
-       memcpy( d, &storage_[pos_], s );
+         memcpy(d, &storage_[pos_], s);
-       pos_ += s;
+         pos_ += s;
-       return true;
+         return true;
-     }
+      }
-     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;
+      }
-     }
+      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;
-       {
+      } else if (size == 253) {
-           ret = size;
+         ret = readdata16();
-       }
+         if (ret < 253)
-       else if (size == 253)
+            FC_THROW("non-canonical ReadCompactSize()");
-       {
+      } else if (size == 254) {
-           ret = readdata16();
+         ret = readdata32();
-           if (ret < 253)
+         if (ret < 0x10000u)
-               FC_THROW("non-canonical ReadCompactSize()");
+            FC_THROW("non-canonical ReadCompactSize()");
-       }
+      } else {
-       else if (size == 254)
+         ret = readdata64();
-       {
+         if (ret < 0x100000000ULL)
-           ret = readdata32();
+            FC_THROW("non-canonical ReadCompactSize()");
-           if (ret < 0x10000u)
+      }
-               FC_THROW("non-canonical ReadCompactSize()");
+      if (ret > (uint64_t)0x02000000)
-       }
+         FC_THROW("ReadCompactSize(): size too large");
-       else
+      return ret;
-       {
-           ret = readdata64();
-           if (ret < 0x100000000ULL)
-               FC_THROW("non-canonical ReadCompactSize()");
-       }
-       if (ret > (uint64_t)0x02000000)
-           FC_THROW("ReadCompactSize(): size too large");
-       return ret;
    }
 
-   void readdata(bytes& data)
+   void readdata(bytes &data) {
-   {
       size_t s = read_compact_int();
       data.clear();
       data.resize(s);
@@ -198,38 +179,34 @@ public:
    }
 
 private:
-   const bytes& storage_;
+   const bytes &storage_;
    size_t pos_;
    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.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());
+   str.read((unsigned char *)hash.data(), hash.data_size());
    n = str.readdata32();
    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,53 +214,46 @@ 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;
       str.put(flags);
    }
    str.write_compact_int(vin.size());
-   for(const auto& in: vin)
+   for (const auto &in : vin)
       in.to_bytes(stream);
    str.write_compact_int(vout.size());
-   for(const auto& out: vout)
+   for (const auto &out : vout)
       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());
-         for(const auto& stack_item: in.scriptWitness)
+         for (const auto &stack_item : in.scriptWitness)
             str.writedata(stack_item);
       }
    }
    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();
    unsigned char flags = 0;
    vin.clear();
@@ -293,43 +263,42 @@ size_t btc_tx::fill_from_bytes(const bytes& data, size_t pos)
    size_t vin_size = ds.read_compact_int();
    vin.resize(vin_size);
    pos = ds.current_pos();
-   for(auto& in: vin)
+   for (auto &in : vin)
       pos = in.fill_from_bytes(data, pos);
    ds.set_pos(pos);
    if (vin_size == 0) {
-       /* We read a dummy or an empty vin. */
+      /* We read a dummy or an empty vin. */
-       ds.get(flags);
+      ds.get(flags);
-       if (flags != 0) {
+      if (flags != 0) {
-          size_t vin_size = ds.read_compact_int();
+         size_t vin_size = ds.read_compact_int();
-          vin.resize(vin_size);
+         vin.resize(vin_size);
-          pos = ds.current_pos();
+         pos = ds.current_pos();
-          for(auto& in: vin)
+         for (auto &in : vin)
-             pos = in.fill_from_bytes(data, pos);
+            pos = in.fill_from_bytes(data, pos);
-          ds.set_pos(pos);
+         ds.set_pos(pos);
-          size_t vout_size = ds.read_compact_int();
+         size_t vout_size = ds.read_compact_int();
-          vout.resize(vout_size);
+         vout.resize(vout_size);
-          pos = ds.current_pos();
+         pos = ds.current_pos();
-          for(auto& out: vout)
+         for (auto &out : vout)
-             pos = out.fill_from_bytes(data, pos);
+            pos = out.fill_from_bytes(data, pos);
-          ds.set_pos(pos);
+         ds.set_pos(pos);
-          hasWitness = true;
+         hasWitness = true;
-       }
+      }
    } else {
-       /* We read a non-empty vin. Assume a normal vout follows. */
+      /* We read a non-empty vin. Assume a normal vout follows. */
       size_t vout_size = ds.read_compact_int();
       vout.resize(vout_size);
       pos = ds.current_pos();
-      for(auto& out: vout)
+      for (auto &out : vout)
          pos = out.fill_from_bytes(data, pos);
       ds.set_pos(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)
+         for (auto &stack_item : in.scriptWitness)
             ds.readdata(stack_item);
       }
    }
@@ -337,61 +306,56 @@ 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)
+   if (data == 0)
       str.put(OP_0);
-   else if(data == 1)
+   else if (data == 1)
       str.put(OP_1);
-   else if(data == 2)
+   else if (data == 2)
       str.put(OP_2);
-   else if(data == 3)
+   else if (data == 3)
       str.put(OP_3);
-   else if(data == 4)
+   else if (data == 4)
       str.put(OP_4);
-   else if(data == 5)
+   else if (data == 5)
       str.put(OP_5);
-   else if(data == 6)
+   else if (data == 6)
       str.put(OP_6);
-   else if(data == 7)
+   else if (data == 7)
       str.put(OP_7);
-   else if(data == 8)
+   else if (data == 8)
       str.put(OP_8);
-   else if(data == 9)
+   else if (data == 9)
       str.put(OP_9);
-   else if(data == 10)
+   else if (data == 10)
       str.put(OP_10);
-   else if(data == 11)
+   else if (data == 11)
       str.put(OP_11);
-   else if(data == 12)
+   else if (data == 12)
       str.put(OP_12);
-   else if(data == 13)
+   else if (data == 13)
       str.put(OP_13);
-   else if(data == 14)
+   else if (data == 14)
       str.put(OP_14);
-   else if(data == 15)
+   else if (data == 15)
       str.put(OP_15);
-   else if(data == 16)
+   else if (data == 16)
       str.put(OP_16);
    else
       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();
@@ -409,110 +373,110 @@ bytes generate_redeem_script(std::vector<std::pair<fc::ecc::public_key, int> > k
 }
 
 /** The Bech32 character set for encoding. */
-const char* charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+const char *charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
 
 /** Concatenate two byte arrays. */
-bytes cat(bytes x, const bytes& y) {
+bytes cat(bytes x, const bytes &y) {
-    x.insert(x.end(), y.begin(), y.end());
+   x.insert(x.end(), y.begin(), y.end());
-    return x;
+   return x;
 }
 
 /** Expand a HRP for use in checksum computation. */
-bytes expand_hrp(const std::string& hrp) {
+bytes expand_hrp(const std::string &hrp) {
-    bytes ret;
+   bytes ret;
-    ret.resize(hrp.size() * 2 + 1);
+   ret.resize(hrp.size() * 2 + 1);
-    for (size_t i = 0; i < hrp.size(); ++i) {
+   for (size_t i = 0; i < hrp.size(); ++i) {
-        unsigned char c = hrp[i];
+      unsigned char c = hrp[i];
-        ret[i] = c >> 5;
+      ret[i] = c >> 5;
-        ret[i + hrp.size() + 1] = c & 0x1f;
+      ret[i + hrp.size() + 1] = c & 0x1f;
-    }
+   }
-    ret[hrp.size()] = 0;
+   ret[hrp.size()] = 0;
-    return ret;
+   return ret;
 }
 
 /** Find the polynomial with value coefficients mod the generator as 30-bit. */
-uint32_t polymod(const bytes& values) {
+uint32_t polymod(const bytes &values) {
-    uint32_t chk = 1;
+   uint32_t chk = 1;
-    for (size_t i = 0; i < values.size(); ++i) {
+   for (size_t i = 0; i < values.size(); ++i) {
-        uint8_t top = chk >> 25;
+      uint8_t top = chk >> 25;
-        chk = (chk & 0x1ffffff) << 5 ^ values[i] ^
+      chk = (chk & 0x1ffffff) << 5 ^ values[i] ^
             (-((top >> 0) & 1) & 0x3b6a57b2UL) ^
             (-((top >> 1) & 1) & 0x26508e6dUL) ^
             (-((top >> 2) & 1) & 0x1ea119faUL) ^
             (-((top >> 3) & 1) & 0x3d4233ddUL) ^
             (-((top >> 4) & 1) & 0x2a1462b3UL);
-    }
+   }
-    return chk;
+   return chk;
 }
 
 /** Create a checksum. */
-bytes bech32_checksum(const std::string& hrp, const bytes& values) {
+bytes bech32_checksum(const std::string &hrp, const bytes &values) {
-    bytes enc = cat(expand_hrp(hrp), values);
+   bytes enc = cat(expand_hrp(hrp), values);
-    enc.resize(enc.size() + 6);
+   enc.resize(enc.size() + 6);
-    uint32_t mod = polymod(enc) ^ 1;
+   uint32_t mod = polymod(enc) ^ 1;
-    bytes ret;
+   bytes ret;
-    ret.resize(6);
+   ret.resize(6);
-    for (size_t i = 0; i < 6; ++i) {
+   for (size_t i = 0; i < 6; ++i) {
-        ret[i] = (mod >> (5 * (5 - i))) & 31;
+      ret[i] = (mod >> (5 * (5 - i))) & 31;
-    }
+   }
-    return ret;
+   return ret;
 }
 
 /** Encode a Bech32 string. */
-std::string bech32(const std::string& hrp, const bytes& values) {
+std::string bech32(const std::string &hrp, const bytes &values) {
-    bytes checksum = bech32_checksum(hrp, values);
+   bytes checksum = bech32_checksum(hrp, values);
-    bytes combined = cat(values, checksum);
+   bytes combined = cat(values, checksum);
-    std::string ret = hrp + '1';
+   std::string ret = hrp + '1';
-    ret.reserve(ret.size() + combined.size());
+   ret.reserve(ret.size() + combined.size());
-    for (size_t i = 0; i < combined.size(); ++i) {
+   for (size_t i = 0; i < combined.size(); ++i) {
-        ret += charset[combined[i]];
+      ret += charset[combined[i]];
-    }
+   }
-    return ret;
+   return ret;
 }
 
 /** Convert from one power-of-2 number base to another. */
-template<int frombits, int tobits, bool pad>
+template <int frombits, int tobits, bool pad>
-bool convertbits(bytes& out, const bytes& in) {
+bool convertbits(bytes &out, const bytes &in) {
-    int acc = 0;
+   int acc = 0;
-    int bits = 0;
+   int bits = 0;
-    const int maxv = (1 << tobits) - 1;
+   const int maxv = (1 << tobits) - 1;
-    const int max_acc = (1 << (frombits + tobits - 1)) - 1;
+   const int max_acc = (1 << (frombits + tobits - 1)) - 1;
-    for (size_t i = 0; i < in.size(); ++i) {
+   for (size_t i = 0; i < in.size(); ++i) {
-        int value = in[i];
+      int value = in[i];
-        acc = ((acc << frombits) | value) & max_acc;
+      acc = ((acc << frombits) | value) & max_acc;
-        bits += frombits;
+      bits += frombits;
-        while (bits >= tobits) {
+      while (bits >= tobits) {
-            bits -= tobits;
+         bits -= tobits;
-            out.push_back((acc >> bits) & maxv);
+         out.push_back((acc >> bits) & maxv);
-        }
+      }
-    }
+   }
-    if (pad) {
+   if (pad) {
-        if (bits) out.push_back((acc << (tobits - bits)) & maxv);
+      if (bits)
-    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
+         out.push_back((acc << (tobits - bits)) & maxv);
-        return false;
+   } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
-    }
+      return false;
-    return true;
+   }
+   return true;
 }
 
 /** Encode a SegWit address. */
-std::string segwit_addr_encode(const std::string& hrp, uint8_t witver, const bytes& witprog) {
+std::string segwit_addr_encode(const std::string &hrp, uint8_t witver, const bytes &witprog) {
-    bytes enc;
+   bytes enc;
-    enc.push_back(witver);
+   enc.push_back(witver);
-    convertbits<8, 5, true>(enc, witprog);
+   convertbits<8, 5, true>(enc, witprog);
-    std::string ret = bech32(hrp, enc);
+   std::string ret = bech32(hrp, enc);
-    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
-   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());
    switch (network) {
-   case(mainnet):
+   case (mainnet):
       return segwit_addr_encode("bc", 0, wp);
-   case(testnet):
+   case (testnet):
-   case(regtest):
+   case (regtest):
       return segwit_addr_encode("tb", 0, wp);
    default:
       FC_THROW("Unknown bitcoin network type");
@@ -520,77 +484,68 @@ 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());
+   fc::sha256 h = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.size());
    bytes shash(h.data(), h.data() + h.data_size());
    add_data_to_script(result, shash);
    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());
+      hasher.write(reinterpret_cast<const char *>(&data[0]), data.size());
    }
    fc::sha256 res = fc::sha256::hash(hasher.result());
    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));
-      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());
+      hasher.write(reinterpret_cast<const char *>(&data[0]), data.size());
    }
    fc::sha256 res = fc::sha256::hash(hasher.result());
    return bytes(res.data(), res.data() + res.data_size());
 }
 
-const secp256k1_context_t* btc_get_context() {
+const secp256k1_context_t *btc_get_context() {
-    static secp256k1_context_t* ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN );
+   static secp256k1_context_t *ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
-    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;
    int size = result.size();
-   FC_ASSERT( secp256k1_ecdsa_sign( btc_get_context(),
+   FC_ASSERT(secp256k1_ecdsa_sign(btc_get_context(),
-                                    (unsigned char*) digest.data(),
+                                  (unsigned char *)digest.data(),
-                                    (unsigned char*) result.begin(),
+                                  (unsigned char *)result.begin(),
-                                    &size,
+                                  &size,
-                                    (unsigned char*) priv_key.get_secret().data(),
+                                  (unsigned char *)priv_key.get_secret().data(),
-                                    secp256k1_nonce_function_rfc6979,
+                                  secp256k1_nonce_function_rfc6979,
-                                    nullptr));
+                                  nullptr));
    return bytes(result.begin(), result.begin() + size);
 }
 
-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;
    tx.fill_from_bytes(unsigned_tx);
 
@@ -604,27 +559,26 @@ 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 *>(&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());
-      hasher.write(reinterpret_cast<const char*>(&hashSequence[0]), hashSequence.size());
+      hasher.write(reinterpret_cast<const char *>(&hashSequence[0]), hashSequence.size());
       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());
       bytes serializedScript;
       WriteBytesStream stream(serializedScript);
       stream.writedata(redeem_script);
-      hasher.write(reinterpret_cast<const char*>(&serializedScript[0]), serializedScript.size());
+      hasher.write(reinterpret_cast<const char *>(&serializedScript[0]), serializedScript.size());
       uint64_t amount = *cur_amount++;
-      hasher.write(reinterpret_cast<const char*>(&amount), sizeof(amount));
+      hasher.write(reinterpret_cast<const char *>(&amount), sizeof(amount));
-      hasher.write(reinterpret_cast<const char*>(&in.nSequence), sizeof(in.nSequence));
+      hasher.write(reinterpret_cast<const char *>(&in.nSequence), sizeof(in.nSequence));
-      hasher.write(reinterpret_cast<const char*>(&hashOutputs[0]), hashOutputs.size());
+      hasher.write(reinterpret_cast<const char *>(&hashOutputs[0]), hashOutputs.size());
-      hasher.write(reinterpret_cast<const char*>(&tx.nLockTime), sizeof(tx.nLockTime));
+      hasher.write(reinterpret_cast<const char *>(&tx.nLockTime), sizeof(tx.nLockTime));
       // add sigtype SIGHASH_ALL
       uint32_t sigtype = 1;
-      hasher.write(reinterpret_cast<const char*>(&sigtype), sizeof(sigtype));
+      hasher.write(reinterpret_cast<const char *>(&sigtype), sizeof(sigtype));
 
       fc::sha256 digest = fc::sha256::hash(hasher.result());
       //std::vector<char> res = priv_key.sign(digest);
@@ -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)
+   for (auto key : priv_keys) {
-   {
+      if (key) {
-      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++)
+         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++)
-      {
-         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);
    }
 
@@ -669,17 +617,15 @@ bytes sign_pw_transfer_transaction(const bytes &unsigned_tx, std::vector<uint64_
    return ret;
 }
 
-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;
    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++)
-      for(unsigned i = 0; i < key_count; i++)
          in.scriptWitness.push_back(dummy_data);
       in.scriptWitness.push_back(redeem_script);
    }
@@ -690,11 +636,10 @@ bytes add_dummy_signatures_for_pw_transfer(const bytes& unsigned_tx,
    return ret;
 }
 
-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;
    tx.fill_from_bytes(partially_signed_tx);
    FC_ASSERT(tx.vin.size() > 0);
@@ -703,29 +648,26 @@ bytes partially_sign_pw_transfer_transaction(const bytes& partially_signed_tx,
    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
    unsigned witness_idx = tx.vin[0].scriptWitness.size() - 2 - key_idx;
-   for(unsigned int i = 0; i < tx.vin.size(); i++)
+   for (unsigned int i = 0; i < tx.vin.size(); i++)
       tx.vin[i].scriptWitness[witness_idx] = signatures[i];
    bytes ret;
    tx.to_bytes(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;
    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];
-         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
+      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]);
    }
 
-   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

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin_utils.hpp

@@ -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 {
 
@@ -10,24 +10,23 @@ enum bitcoin_network {
    regtest
 };
 
-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);
-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,
+                                                  const fc::ecc::private_key &priv_key);
-                                                 const fc::ecc::private_key& priv_key);
 
 /*
  * unsigned_tx - tx,  all inputs of which are spends of the PW P2SH address
  * returns signed transaction
  */
-bytes sign_pw_transfer_transaction(const bytes& unsigned_tx,
+bytes sign_pw_transfer_transaction(const bytes &unsigned_tx,
                                    std::vector<uint64_t> in_amounts,
-                                   const bytes& redeem_script,
+                                   const bytes &redeem_script,
-                                   const std::vector<fc::optional<fc::ecc::private_key>>& priv_keys);
+                                   const std::vector<fc::optional<fc::ecc::private_key>> &priv_keys);
 
 ///
 ////// \brief Adds dummy signatures instead of real signatures
@@ -35,8 +34,8 @@ bytes sign_pw_transfer_transaction(const bytes& unsigned_tx,
 ////// \param redeem_script
 ////// \param key_count
 ////// \return can be used as partially signed tx
-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);
 
 ///
@@ -47,10 +46,10 @@ bytes add_dummy_signatures_for_pw_transfer(const bytes& unsigned_tx,
 /// \param key_idx
 /// \return
 ///
-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);
 
 ///
 /// \brief Creates ready to publish bitcoin transaction from unsigned tx and
@@ -61,50 +60,45 @@ bytes partially_sign_pw_transfer_transaction(const bytes& partially_signed_tx,
 /// \param redeem_script
 /// \return
 ///
-bytes add_signatures_to_unsigned_tx(const bytes& unsigned_tx,
+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;
    uint32_t n;
 
-   void to_bytes(bytes& stream) const;
+   void to_bytes(bytes &stream) const;
-   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;
    bytes scriptSig;
    uint32_t nSequence;
    std::vector<bytes> scriptWitness;
 
-   void to_bytes(bytes& stream) const;
+   void to_bytes(bytes &stream) const;
-   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;
    bytes scriptPubKey;
 
-   void to_bytes(bytes& stream) const;
+   void to_bytes(bytes &stream) const;
-   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_out> vout;
    int32_t nVersion;
    uint32_t nLockTime;
    bool hasWitness;
 
-   void to_bytes(bytes& stream) const;
+   void to_bytes(bytes &stream) const;
-   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
-

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/defs.hpp

@@ -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
+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->amount != obj.amount )
+          this->amount != obj.amount) {
-      {
          return true;
       }
       return false;
@@ -40,16 +37,15 @@ 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 );
+   info_for_vin(const prev_out &_out, const std::string &_address, bytes _script = bytes(), bool _resend = false);
 
-   bool operator!=( const info_for_vin& obj ) const;
+   bool operator!=(const info_for_vin &obj) const;
 
    struct comparer {
-      bool operator() ( const info_for_vin& lhs, const info_for_vin& rhs ) const;
+      bool operator()(const info_for_vin &lhs, const info_for_vin &rhs) const;
    };
 
    static uint64_t count_id_info_for_vin;
@@ -66,19 +62,19 @@ struct info_for_vin
 };
 
 struct sidechain_event_data {
-    fc::time_point_sec timestamp;
+   fc::time_point_sec timestamp;
-    sidechain_type sidechain;
+   sidechain_type sidechain;
-    std::string sidechain_uid;
+   std::string sidechain_uid;
-    std::string sidechain_transaction_id;
+   std::string sidechain_transaction_id;
-    std::string sidechain_from;
+   std::string sidechain_from;
-    std::string sidechain_to;
+   std::string sidechain_to;
-    std::string sidechain_currency;
+   std::string sidechain_currency;
-    fc::safe<int64_t> sidechain_amount;
+   fc::safe<int64_t> sidechain_amount;
-    chain::account_id_type peerplays_from;
+   chain::account_id_type peerplays_from;
-    chain::account_id_type peerplays_to;
+   chain::account_id_type peerplays_to;
-    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))

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/peerplays_sidechain_plugin.hpp

@@ -7,34 +7,30 @@
 namespace graphene { namespace peerplays_sidechain {
 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();
 
-      std::string plugin_name()const override;
+   std::string plugin_name() const override;
-      virtual void plugin_set_program_options(
+   virtual void plugin_set_program_options(
-         boost::program_options::options_description& cli,
+         boost::program_options::options_description &cli,
-         boost::program_options::options_description& cfg) override;
+         boost::program_options::options_description &cfg) override;
-      virtual void plugin_initialize(const boost::program_options::variables_map& options) override;
+   virtual void plugin_initialize(const boost::program_options::variables_map &options) override;
-      virtual void plugin_startup() override;
+   virtual void plugin_startup() override;
 
-      std::unique_ptr<detail::peerplays_sidechain_plugin_impl> my;
+   std::unique_ptr<detail::peerplays_sidechain_plugin_impl> my;
 
-      std::set<chain::son_id_type>& get_sons();
+   std::set<chain::son_id_type> &get_sons();
-      son_id_type& get_current_son_id();
+   son_id_type &get_current_son_id();
-      son_object get_son_object(son_id_type son_id);
+   son_object get_son_object(son_id_type son_id);
-      bool is_active_son(son_id_type son_id);
+   bool is_active_son(son_id_type son_id);
-      std::map<chain::public_key_type, fc::ecc::private_key>& get_private_keys();
+   fc::ecc::private_key get_private_key(son_id_type son_id);
-      fc::ecc::private_key get_private_key(son_id_type son_id);
+   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
-

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler.hpp

@@ -12,34 +12,35 @@ namespace graphene { namespace peerplays_sidechain {
 
 class sidechain_net_handler {
 public:
-    sidechain_net_handler(peerplays_sidechain_plugin& _plugin, const boost::program_options::variables_map& options);
+   sidechain_net_handler(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options);
-    virtual ~sidechain_net_handler();
+   virtual ~sidechain_net_handler();
 
-    graphene::peerplays_sidechain::sidechain_type get_sidechain();
+   graphene::peerplays_sidechain::sidechain_type get_sidechain();
-    std::vector<std::string> get_sidechain_deposit_addresses();
+   std::vector<std::string> get_sidechain_deposit_addresses();
-    std::vector<std::string> get_sidechain_withdraw_addresses();
+   std::vector<std::string> get_sidechain_withdraw_addresses();
+   std::string get_private_key(std::string public_key);
 
-    void sidechain_event_data_received(const sidechain_event_data& sed);
+   void sidechain_event_data_received(const sidechain_event_data &sed);
+   void process_deposits();
+   void process_withdrawals();
 
-    virtual void recreate_primary_wallet() = 0;
+   virtual void recreate_primary_wallet() = 0;
-    virtual void process_deposits() = 0;
+   virtual void process_deposit(const son_wallet_deposit_object &swdo) = 0;
-    virtual void process_deposit(const son_wallet_deposit_object& swdo) = 0;
+   virtual void process_withdrawal(const son_wallet_withdraw_object &swwo) = 0;
-    virtual void process_withdrawals() = 0;
-    virtual void process_withdrawal(const son_wallet_withdraw_object& swwo) = 0;
 
 protected:
-    peerplays_sidechain_plugin& plugin;
+   peerplays_sidechain_plugin &plugin;
-    graphene::chain::database& database;
+   graphene::chain::database &database;
-    graphene::peerplays_sidechain::sidechain_type sidechain;
+   graphene::peerplays_sidechain::sidechain_type sidechain;
 
-    virtual std::string create_multisignature_wallet( const std::vector<std::string> public_keys ) = 0;
+   std::map<std::string, std::string> private_keys;
-    virtual std::string transfer( const std::string& from, const std::string& to, const uint64_t amount ) = 0;
+
-    virtual std::string sign_transaction( const std::string& transaction ) = 0;
+   virtual std::string create_multisignature_wallet(const std::vector<std::string> public_keys) = 0;
-    virtual std::string send_transaction( const std::string& transaction ) = 0;
+   virtual std::string transfer(const std::string &from, const std::string &to, const uint64_t amount) = 0;
+   virtual std::string sign_transaction(const std::string &transaction) = 0;
+   virtual std::string send_transaction(const std::string &transaction) = 0;
 
 private:
-
 };
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_bitcoin.hpp

@@ -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_;
@@ -22,28 +21,35 @@ public:
 
 class bitcoin_rpc_client {
 public:
-   bitcoin_rpc_client( std::string _ip, uint32_t _rpc, std::string _user, std::string _password) ;
+   bitcoin_rpc_client(std::string _ip, uint32_t _rpc, std::string _user, std::string _password, std::string _wallet, std::string _wallet_password);
    bool connection_is_not_defined() const;
 
-   std::string addmultisigaddress( const std::vector<std::string> public_keys );
+   std::string addmultisigaddress(const std::vector<std::string> public_keys);
-   std::string createrawtransaction(const std::vector<btc_txout>& ins, const fc::flat_map<std::string, double> outs);
+   std::string createrawtransaction(const std::vector<btc_txout> &ins, const fc::flat_map<std::string, double> outs);
+   std::string createwallet(const std::string &wallet_name);
+   std::string encryptwallet(const std::string &passphrase);
    uint64_t estimatesmartfee();
-   std::string getblock( const std::string& block_hash, int32_t verbosity = 2 );
+   std::string getblock(const std::string &block_hash, int32_t verbosity = 2);
-   void importaddress( const std::string& address_or_script);
+   void importaddress(const std::string &address_or_script);
    std::vector<btc_txout> listunspent();
-   std::vector<btc_txout> listunspent_by_address_and_amount(const std::string& address, double transfer_amount);
+   std::vector<btc_txout> listunspent_by_address_and_amount(const std::string &address, double transfer_amount);
-   void sendrawtransaction( const std::string& tx_hex );
+   std::string loadwallet(const std::string &filename);
-   std::string signrawtransactionwithkey(const std::string& tx_hash, const std::string& private_key);
+   void sendrawtransaction(const std::string &tx_hex);
-   std::string signrawtransactionwithwallet(const std::string& tx_hash);
+   std::string signrawtransactionwithkey(const std::string &tx_hash, const std::string &private_key);
+   std::string signrawtransactionwithwallet(const std::string &tx_hash);
+   std::string unloadwallet(const std::string &filename);
+   std::string walletlock();
+   bool walletpassphrase(const std::string &passphrase, uint32_t timeout = 60);
 
 private:
-
+   fc::http::reply send_post_request(std::string body, bool show_log = false);
-   fc::http::reply send_post_request( std::string body );
 
    std::string ip;
    uint32_t rpc_port;
    std::string user;
    std::string password;
+   std::string wallet;
+   std::string wallet_password;
 
    fc::http::header authorization;
 };
@@ -52,10 +58,13 @@ private:
 
 class zmq_listener {
 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:
    void handle_zmq();
    std::vector<zmq::message_t> receive_multipart();
@@ -71,24 +80,12 @@ private:
 
 class sidechain_net_handler_bitcoin : public sidechain_net_handler {
 public:
-   sidechain_net_handler_bitcoin(peerplays_sidechain_plugin& _plugin, const boost::program_options::variables_map& options);
+   sidechain_net_handler_bitcoin(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options);
    virtual ~sidechain_net_handler_bitcoin();
 
    void recreate_primary_wallet();
-   void process_deposits();
+   void process_deposit(const son_wallet_deposit_object &swdo);
-   void process_deposit(const son_wallet_deposit_object& swdo);
+   void process_withdrawal(const son_wallet_withdraw_object &swwo);
-   void process_withdrawals();
-   void process_withdrawal(const son_wallet_withdraw_object& swwo);
-
-   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 );
-   std::string sign_and_send_transaction_with_wallet ( const std::string& tx_json );
-   std::string transfer_all_btc(const std::string& from_address, const std::string& to_address);
-   std::string transfer_deposit_to_primary_wallet (const son_wallet_deposit_object &swdo);
-   std::string transfer_withdrawal_from_primary_wallet(const son_wallet_withdraw_object &swwo);
-
 
 private:
    std::string ip;
@@ -96,14 +93,23 @@ private:
    uint32_t rpc_port;
    std::string rpc_user;
    std::string rpc_password;
-   std::map<std::string, std::string> _private_keys;
+   std::string wallet;
+   std::string wallet_password;
 
-   std::unique_ptr<zmq_listener> listener;
    std::unique_ptr<bitcoin_rpc_client> bitcoin_client;
+   std::unique_ptr<zmq_listener> listener;
 
-   void handle_event( const std::string& event_data);
+   std::string create_multisignature_wallet(const std::vector<std::string> public_keys);
-   std::vector<info_for_vin> extract_info_from_block( const std::string& _block );
+   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);
+   std::string sign_and_send_transaction_with_wallet(const std::string &tx_json);
+   std::string transfer_all_btc(const std::string &from_address, const std::string &to_address);
+   std::string transfer_deposit_to_primary_wallet(const son_wallet_deposit_object &swdo);
+   std::string transfer_withdrawal_from_primary_wallet(const son_wallet_withdraw_object &swwo);
+
+   void handle_event(const std::string &event_data);
+   std::vector<info_for_vin> extract_info_from_block(const std::string &_block);
 };
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_peerplays.hpp

@@ -10,25 +10,20 @@ namespace graphene { namespace peerplays_sidechain {
 
 class sidechain_net_handler_peerplays : public sidechain_net_handler {
 public:
-    sidechain_net_handler_peerplays(peerplays_sidechain_plugin& _plugin, const boost::program_options::variables_map& options);
+   sidechain_net_handler_peerplays(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options);
-    virtual ~sidechain_net_handler_peerplays();
+   virtual ~sidechain_net_handler_peerplays();
 
-    void recreate_primary_wallet();
+   void recreate_primary_wallet();
-    void process_deposits();
+   void process_deposit(const son_wallet_deposit_object &swdo);
-    void process_deposit(const son_wallet_deposit_object& swdo);
+   void process_withdrawal(const son_wallet_withdraw_object &swwo);
-    void process_withdrawals();
-    void process_withdrawal(const son_wallet_withdraw_object& swwo);
-
-    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 );
 
 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);
+   void on_applied_block(const signed_block &b);
-
 };
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_manager.hpp

@@ -12,19 +12,18 @@ namespace graphene { namespace peerplays_sidechain {
 
 class sidechain_net_manager {
 public:
-   sidechain_net_manager(peerplays_sidechain_plugin& _plugin);
+   sidechain_net_manager(peerplays_sidechain_plugin &_plugin);
    virtual ~sidechain_net_manager();
 
-   bool create_handler(peerplays_sidechain::sidechain_type sidechain, const boost::program_options::variables_map& options);
+   bool create_handler(peerplays_sidechain::sidechain_type sidechain, const boost::program_options::variables_map &options);
    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;
 
+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
-

libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp

@@ -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,287 +19,270 @@ 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:
-   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();
 
-      void plugin_set_program_options(
+   void 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);
-      void plugin_initialize(const boost::program_options::variables_map& options);
+   void plugin_initialize(const boost::program_options::variables_map &opt);
-      void plugin_startup();
+   void plugin_startup();
 
-      std::set<chain::son_id_type>& get_sons();
+   std::set<chain::son_id_type> &get_sons();
-      son_id_type& get_current_son_id();
+   son_id_type &get_current_son_id();
-      son_object get_son_object(son_id_type son_id);
+   son_object get_son_object(son_id_type son_id);
-      bool is_active_son(son_id_type son_id);
+   bool is_active_son(son_id_type son_id);
-      std::map<chain::public_key_type, fc::ecc::private_key>& get_private_keys();
+   fc::ecc::private_key get_private_key(son_id_type son_id);
-      fc::ecc::private_key get_private_key(son_id_type son_id);
+   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);
 
-      void schedule_heartbeat_loop();
+   void schedule_heartbeat_loop();
-      void heartbeat_loop();
+   void heartbeat_loop();
-      void create_son_down_proposals();
+   void schedule_son_processing();
-      void create_son_deregister_proposals();
+   void son_processing();
-      void recreate_primary_wallet();
+   void approve_proposals();
-      void process_deposits();
+   void create_son_down_proposals();
-      void process_withdrawals();
+   void create_son_deregister_proposals();
+   void recreate_primary_wallet();
+   void process_deposits();
+   void process_withdrawals();
 
-   private:
+private:
-      peerplays_sidechain_plugin& plugin;
+   peerplays_sidechain_plugin &plugin;
 
-      bool config_ready_son;
+   boost::program_options::variables_map options;
-      bool config_ready_bitcoin;
-      bool config_ready_peerplays;
 
-      son_id_type current_son_id;
+   bool config_ready_son;
+   bool config_ready_bitcoin;
+   bool config_ready_peerplays;
 
-      std::unique_ptr<peerplays_sidechain::sidechain_net_manager> net_manager;
+   son_id_type current_son_id;
-      std::map<chain::public_key_type, fc::ecc::private_key> _private_keys;
-      std::set<chain::son_id_type> _sons;
-      fc::future<void> _heartbeat_task;
 
-      void on_applied_block( const signed_block& b );
+   std::unique_ptr<peerplays_sidechain::sidechain_net_manager> net_manager;
-      void on_new_objects(const vector<object_id_type>& new_object_ids);
+   std::set<chain::son_id_type> sons;
+   std::map<chain::public_key_type, fc::ecc::private_key> private_keys;
+   fc::future<void> _heartbeat_task;
+   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) :
+peerplays_sidechain_plugin_impl::peerplays_sidechain_plugin_impl(peerplays_sidechain_plugin &_plugin) :
       plugin(_plugin),
       config_ready_son(false),
       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() )
+      if (_heartbeat_task.valid())
          _heartbeat_task.cancel_and_wait(__FUNCTION__);
-   } catch(fc::canceled_exception&) {
+   } catch (fc::canceled_exception &) {
       //Expected exception. Move along.
-   } catch(fc::exception& e) {
+   } catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+   }
+
+   try {
+      if (_son_processing_task.valid())
+         _son_processing_task.cancel_and_wait(__FUNCTION__);
+   } catch (fc::canceled_exception &) {
+      //Expected exception. Move along.
+   } catch (fc::exception &e) {
       edump((e.to_detail_string()));
    }
 }
 
 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")));
    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()
+   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());
-         ("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))),
-         ("peerplays-private-key", bpo::value<vector<string>>()->composing()->multitoken()->
+                     "Tuple of [PublicKey, WIF private key] (may specify multiple times)");
-               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()("bitcoin-node-ip", bpo::value<string>()->default_value("99.79.189.95"), "IP address of Bitcoin node");
-               "Tuple of [PublicKey, WIF private key] (may specify multiple times)")
+   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");
-         ("bitcoin-node-ip", bpo::value<string>()->default_value("99.79.189.95"), "IP address of Bitcoin node")
+   cli.add_options()("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user");
-         ("bitcoin-node-zmq-port", bpo::value<uint32_t>()->default_value(11111), "ZMQ port of Bitcoin node")
+   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");
-         ("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user")
+   cli.add_options()("bitcoin-wallet-password", bpo::value<string>(), "Bitcoin wallet password");
-         ("bitcoin-node-rpc-password", bpo::value<string>()->default_value("1"), "Bitcoin RPC password")
+   cli.add_options()("bitcoin-private-key", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR(std::make_pair("02d0f137e717fb3aab7aff99904001d49a0a636c5e1342f8927a4ba2eaee8e9772", "cVN31uC9sTEr392DLVUEjrtMgLA8Yb3fpYmTRj7bomTm6nn2ANPr")),
-         ("bitcoin-address", bpo::value<string>()->default_value("2N911a7smwDzUGARg8s7Q1ViizFCw6gWcbR"), "Bitcoin address")
+                     "Tuple of [Bitcoin public key, Bitcoin private key] (may specify multiple times)");
-         ("bitcoin-public-key", bpo::value<string>()->default_value("02d0f137e717fb3aab7aff99904001d49a0a636c5e1342f8927a4ba2eaee8e9772"), "Bitcoin public key")
-         ("bitcoin-private-key", bpo::value<string>()->default_value("cVN31uC9sTEr392DLVUEjrtMgLA8Yb3fpYmTRj7bomTm6nn2ANPr"), "Bitcoin private key")
-         ("bitcoin-private-keys", bpo::value<vector<string>>()->composing()->multitoken()->
-               DEFAULT_VALUE_VECTOR(std::make_pair("02d0f137e717fb3aab7aff99904001d49a0a636c5e1342f8927a4ba2eaee8e9772", "cVN31uC9sTEr392DLVUEjrtMgLA8Yb3fpYmTRj7bomTm6nn2ANPr")),
-               "Tuple of [Bitcoin PublicKey, 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 &opt) {
-{
+   options = opt;
-   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) {
-      LOAD_VALUE_SET(options, "son-id", _sons, chain::son_id_type)
+      LOAD_VALUE_SET(options, "son-id", sons, chain::son_id_type)
       if (options.count("son-ids"))
-         boost::insert(_sons, fc::json::from_string(options.at("son-ids").as<string>()).as<vector<chain::son_id_type>>( 5 ));
+         boost::insert(sons, fc::json::from_string(options.at("son-ids").as<string>()).as<vector<chain::son_id_type>>(5));
-      config_ready_son = config_ready_son && !_sons.empty();
+      config_ready_son = config_ready_son && !sons.empty();
 
 #ifndef SUPPORT_MULTIPLE_SONS
-      FC_ASSERT( _sons.size() == 1, "Multiple SONs not supported" );
+      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);
-            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));
                }
             }
-            _private_keys[key_id_to_wif_pair.first] = *private_key;
+            private_keys[key_id_to_wif_pair.first] = *private_key;
          }
+         config_ready_son = config_ready_son && !private_keys.empty();
       }
-   } else {
+   }
+   if (!config_ready_son) {
       wlog("Haven't set up SON parameters");
       throw;
    }
 
-   plugin.database().applied_block.connect( [&] (const signed_block& b) { on_applied_block(b); } );
+   config_ready_bitcoin = options.count("bitcoin-node-ip") &&
-   plugin.database().new_objects.connect( [&] (const vector<object_id_type>& ids, const flat_set<account_id_type>& impacted_accounts) { on_new_objects(ids); } );
+                          options.count("bitcoin-node-zmq-port") && options.count("bitcoin-node-rpc-port") &&
-
+                          options.count("bitcoin-node-rpc-user") && options.count("bitcoin-node-rpc-password") &&
-   net_manager = std::unique_ptr<sidechain_net_manager>(new sidechain_net_manager(plugin));
+                          /*options.count( "bitcoin-wallet" ) && options.count( "bitcoin-wallet-password" ) &&*/
-
+                          options.count("bitcoin-private-key");
-   config_ready_bitcoin = options.count( "bitcoin-node-ip" ) &&
+   if (!config_ready_bitcoin) {
-           options.count( "bitcoin-node-zmq-port" ) && options.count( "bitcoin-node-rpc-port" ) &&
-           options.count( "bitcoin-node-rpc-user" ) && options.count( "bitcoin-node-rpc-password" ) &&
-           options.count( "bitcoin-address" ) && options.count( "bitcoin-public-key" ) && options.count( "bitcoin-private-key" );
-   if (config_ready_bitcoin) {
-      net_manager->create_handler(sidechain_type::bitcoin, options);
-      ilog("Bitcoin sidechain handler created");
-   } else {
       wlog("Haven't set up Bitcoin sidechain parameters");
    }
 
    //config_ready_ethereum = options.count( "ethereum-node-ip" ) &&
    //        options.count( "ethereum-address" ) && options.count( "ethereum-public-key" ) && options.count( "ethereum-private-key" );
-   //if (config_ready_ethereum) {
+   //if (!config_ready_ethereum) {
-   //   net_manager->create_handler(sidechain_type::ethereum, options);
-   //   ilog("Ethereum sidechain handler created");
-   //} else {
    //   wlog("Haven't set up Ethereum sidechain parameters");
    //}
 
    config_ready_peerplays = true;
-   if (config_ready_peerplays) {
+   if (!config_ready_peerplays) {
-      net_manager->create_handler(sidechain_type::peerplays, options);
-      ilog("Peerplays sidechain handler created");
-   } else {
       wlog("Haven't set up Peerplays sidechain parameters");
    }
 
-   if (!(config_ready_bitcoin /*&& config_ready_ethereum*/)) {
+   if (!(config_ready_bitcoin /*&& config_ready_ethereum*/ && config_ready_peerplays)) {
       wlog("Haven't set up any sidechain parameters");
       throw;
    }
 }
 
-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()));
+      ilog("Starting ${n} SON instances", ("n", sons.size()));
 
       schedule_heartbeat_loop();
    } else {
       elog("No sons configured! Please add SON IDs and private keys to configuration.");
    }
 
+   net_manager = std::unique_ptr<sidechain_net_manager>(new sidechain_net_manager(plugin));
+
    if (config_ready_bitcoin) {
+      net_manager->create_handler(sidechain_type::bitcoin, options);
       ilog("Bitcoin sidechain handler running");
    }
 
    //if (config_ready_ethereum) {
+   //   net_manager->create_handler(sidechain_type::ethereum, options);
    //   ilog("Ethereum sidechain handler running");
    //}
 
    if (config_ready_peerplays) {
+      net_manager->create_handler(sidechain_type::peerplays, options);
       ilog("Peerplays sidechain handler running");
    }
+
+   plugin.database().applied_block.connect([&](const signed_block &b) {
+      on_applied_block(b);
+   });
 }
 
-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;
 }
 
-son_id_type& peerplays_sidechain_plugin_impl::get_current_son_id() {
+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>();
-   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())
       return {};
    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())
       return false;
 
-   const chain::global_property_object& gpo = plugin.database().get_global_properties();
+   const chain::global_property_object &gpo = plugin.database().get_global_properties();
    vector<son_id_type> active_son_ids;
    active_son_ids.reserve(gpo.active_sons.size());
    std::transform(gpo.active_sons.begin(), gpo.active_sons.end(),
                   std::inserter(active_son_ids, active_son_ids.end()),
-                  [](const son_info& swi) {
+                  [](const son_info &swi) {
-      return swi.son_id;
+                     return swi.son_id;
-   });
+                  });
 
    auto it = std::find(active_son_ids.begin(), active_son_ids.end(), son_id);
 
    return (it != active_son_ids.end());
 }
 
-std::map<chain::public_key_type, fc::ecc::private_key>& peerplays_sidechain_plugin_impl::get_private_keys()
+fc::ecc::private_key peerplays_sidechain_plugin_impl::get_private_key(son_id_type son_id) {
-{
-   return _private_keys;
-}
-
-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);
-   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 {};
 }
 
-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 ) );
+   fc::time_point next_wakeup(now + fc::seconds(time_to_next_heartbeat));
 
-   _heartbeat_task = fc::schedule([this]{heartbeat_loop();},
+   _heartbeat_task = fc::schedule([this] {
-                                         next_wakeup, "SON Heartbeat Production");
+      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();
+   chain::database &d = plugin.database();
 
-   for (son_id_type son_id : _sons) {
+   for (son_id_type son_id : sons) {
       if (is_active_son(son_id) || get_son_object(son_id).status == chain::son_status::in_maintenance) {
 
          ilog("peerplays_sidechain_plugin:  sending heartbeat for SON ${son}", ("son", son_id));
@@ -308,14 +291,14 @@ void peerplays_sidechain_plugin_impl::heartbeat_loop()
          op.son_id = son_id;
          op.ts = fc::time_point::now() + fc::seconds(0);
          chain::signed_transaction trx = d.create_signed_transaction(plugin.get_private_key(son_id), op);
-         fc::future<bool> fut = fc::async( [&](){
+         fc::future<bool> fut = fc::async([&]() {
             try {
                d.push_transaction(trx, database::validation_steps::skip_block_size_check);
-               if(plugin.app().p2p_node())
+               if (plugin.app().p2p_node())
                   plugin.app().p2p_node()->broadcast(net::trx_message(trx));
                return true;
-            } catch(fc::exception e){
+            } catch (fc::exception e) {
-               ilog("peerplays_sidechain_plugin_impl:  sending heartbeat failed with exception ${e}",("e", e.what()));
+               ilog("peerplays_sidechain_plugin_impl:  sending heartbeat failed with exception ${e}", ("e", e.what()));
                return false;
             }
          });
@@ -324,131 +307,32 @@ void peerplays_sidechain_plugin_impl::heartbeat_loop()
    }
 }
 
-void peerplays_sidechain_plugin_impl::create_son_deregister_proposals()
+void peerplays_sidechain_plugin_impl::schedule_son_processing() {
-{
+   fc::time_point now = fc::time_point::now();
-   chain::database& d = plugin.database();
+   int64_t time_to_next_son_processing = 500000;
-   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)
+   fc::time_point next_wakeup(now + fc::microseconds(time_to_next_son_processing));
-   {
+
-      // We shouldn't raise proposals for the SONs for which a de-reg
+   _son_processing_task = fc::schedule([this] {
-      // proposal is already raised.
+      son_processing();
-      std::set<son_id_type> sons_being_dereg = d.get_sons_being_deregistered();
+   },
-      for( auto& son : sons_to_be_dereg)
+                                       next_wakeup, "SON Processing");
-      {
-         // New SON to be deregistered
-         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())
-            {
-               // 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);
-               fc::future<bool> fut = fc::async( [&](){
-                  try {
-                     d.push_transaction(trx, database::validation_steps::skip_block_size_check);
-                     if(plugin.app().p2p_node())
-                        plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-                     return true;
-                  } catch(fc::exception e){
-                     ilog("peerplays_sidechain_plugin_impl:  sending son dereg proposal failed with exception ${e}",("e", e.what()));
-                     return false;
-                  }
-               });
-               fut.wait(fc::seconds(10));
-            }
-         }
-      }
-   }
 }
 
-void peerplays_sidechain_plugin_impl::create_son_down_proposals()
+void peerplays_sidechain_plugin_impl::son_processing() {
-{
+   if (plugin.database().get_global_properties().active_sons.size() <= 0) {
-   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();
-
-      chain::son_report_down_operation son_down_op;
-      son_down_op.payer = GRAPHENE_SON_ACCOUNT;
-      son_down_op.son_id = son_id;
-      son_down_op.down_ts = last_active_ts;
-
-      proposal_create_operation proposal_op;
-      proposal_op.fee_paying_account = get_son_object(plugin.get_current_son_id()).son_account;
-      proposal_op.proposed_ops.push_back( op_wrapper( son_down_op ) );
-      uint32_t lifetime = ( gpo.parameters.block_interval * gpo.active_witnesses.size() ) * 3;
-      proposal_op.expiration_time = time_point_sec( d.head_block_time().sec_since_epoch() + lifetime );
-      return proposal_op;
-   };
-
-   chain::database& d = plugin.database();
-   const chain::global_property_object& gpo = d.get_global_properties();
-   const chain::dynamic_global_property_object& dgpo = d.get_dynamic_global_properties();
-   const auto& idx = d.get_index_type<chain::son_index>().indices().get<by_id>();
-   std::set<son_id_type> sons_being_reported_down = d.get_sons_being_reported_down();
-   chain::son_id_type my_son_id = get_current_son_id();
-   for(auto son_inf: gpo.active_sons) {
-      if(my_son_id == son_inf.son_id || (sons_being_reported_down.find(son_inf.son_id) != sons_being_reported_down.end())){
-         continue;
-      }
-      auto son_obj = idx.find( son_inf.son_id );
-      auto stats = son_obj->statistics(d);
-      fc::time_point_sec last_maintenance_time = dgpo.next_maintenance_time - gpo.parameters.maintenance_interval;
-      fc::time_point_sec last_active_ts = ((stats.last_active_timestamp > last_maintenance_time) ? stats.last_active_timestamp : last_maintenance_time);
-      int64_t down_threshold = gpo.parameters.son_down_time();
-      if(((son_obj->status == chain::son_status::active) || (son_obj->status == chain::son_status::request_maintenance)) &&
-          ((fc::time_point::now() - last_active_ts) > fc::seconds(down_threshold)))  {
-         ilog("peerplays_sidechain_plugin:  sending son down proposal for ${t} from ${s}",("t",std::string(object_id_type(son_obj->id)))("s",std::string(object_id_type(my_son_id))));
-         chain::proposal_create_operation op = create_son_down_proposal(son_inf.son_id, last_active_ts);
-         chain::signed_transaction trx = d.create_signed_transaction(plugin.get_private_key(get_son_object(my_son_id).signing_key), op);
-         fc::future<bool> fut = fc::async( [&](){
-            try {
-               d.push_transaction(trx, database::validation_steps::skip_block_size_check);
-               if(plugin.app().p2p_node())
-                  plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-               return true;
-            } catch(fc::exception e){
-               ilog("peerplays_sidechain_plugin_impl:  sending son down proposal failed with exception ${e}",("e", e.what()));
-               return false;
-            }
-         });
-         fut.wait(fc::seconds(10));
-      }
-   }
-}
-
-void peerplays_sidechain_plugin_impl::recreate_primary_wallet()
-{
-   net_manager->recreate_primary_wallet();
-}
-
-void peerplays_sidechain_plugin_impl::process_deposits()
-{
-   net_manager->process_deposits();
-}
-
-void peerplays_sidechain_plugin_impl::process_withdrawals()
-{
-   net_manager->process_withdrawals();
-}
-
-void peerplays_sidechain_plugin_impl::on_applied_block( const signed_block& b )
-{
-   chain::database& d = plugin.database();
-   const chain::global_property_object& gpo = d.get_global_properties();
-   bool latest_block = ((fc::time_point::now() - b.timestamp) < fc::microseconds(gpo.parameters.block_interval * 1000000));
-   if(gpo.active_sons.size() <= 0 || !latest_block) {
       return;
    }
 
-   chain::son_id_type next_son_id = d.get_scheduled_son(1);
+   chain::son_id_type next_son_id = plugin.database().get_scheduled_son(1);
-   ilog("peerplays_sidechain_plugin_impl:  Scheduled SON ${son}",("son", next_son_id));
+   ilog("peerplays_sidechain_plugin_impl:  Scheduled SON ${son}", ("son", next_son_id));
 
-   // check if we control scheduled SON
+   // Tasks that are executed by all active SONs, no matter if scheduled
-   if( _sons.find( next_son_id ) != _sons.end() ) {
+   // E.g. sending approvals and signing
+   approve_proposals();
+
+   // Tasks that are executed by scheduled and active SON
+   if (sons.find(next_son_id) != sons.end()) {
 
       current_son_id = next_son_id;
 
@@ -461,166 +345,251 @@ void peerplays_sidechain_plugin_impl::on_applied_block( const signed_block& b )
       process_deposits();
 
       process_withdrawals();
-
    }
 }
 
-void peerplays_sidechain_plugin_impl::on_new_objects(const vector<object_id_type>& new_object_ids)
+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;
       puo.fee_paying_account = get_son_object(son_id).son_account;
       puo.proposal = proposal_id;
-      puo.active_approvals_to_add = { get_son_object(son_id).son_account };
+      puo.active_approvals_to_add = {get_son_object(son_id).son_account};
       chain::signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(son_id), puo);
-      fc::future<bool> fut = fc::async( [&](){
+      fc::future<bool> fut = fc::async([&]() {
          try {
             plugin.database().push_transaction(trx, database::validation_steps::skip_block_size_check);
-            if(plugin.app().p2p_node())
+            if (plugin.app().p2p_node())
                plugin.app().p2p_node()->broadcast(net::trx_message(trx));
             return true;
-         } catch(fc::exception e){
+         } catch (fc::exception e) {
-            ilog("peerplays_sidechain_plugin_impl:  sending approval failed with exception ${e}",("e", e.what()));
+            ilog("peerplays_sidechain_plugin_impl:  sending approval failed with exception ${e}", ("e", e.what()));
             return false;
          }
       });
       fut.wait(fc::seconds(10));
    };
 
-   for(auto object_id: new_object_ids) {
+   const auto &idx = plugin.database().get_index_type<proposal_index>().indices().get<by_id>();
-      if( object_id.is<chain::proposal_object>() ) {
+   vector<proposal_id_type> proposals;
+   for (const auto &proposal : idx) {
+      proposals.push_back(proposal.id);
+   }
 
-         for (son_id_type son_id : _sons) {
+   for (const auto proposal_id : proposals) {
-            if (!is_active_son(son_id)) {
+      for (son_id_type son_id : sons) {
-               continue;
+         if (!is_active_son(son_id)) {
+            continue;
+         }
+
+         const object *obj = plugin.database().find_object(proposal_id);
+         const chain::proposal_object *proposal_ptr = dynamic_cast<const chain::proposal_object *>(obj);
+         if (proposal_ptr == nullptr) {
+            continue;
+         }
+         const proposal_object proposal = *proposal_ptr;
+
+         if (proposal.available_active_approvals.find(get_son_object(son_id).son_account) != proposal.available_active_approvals.end()) {
+            continue;
+         }
+
+         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_delete_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) {
+            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) {
+            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) {
+            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) {
+            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) {
+            approve_proposal(son_id, proposal.id);
+            continue;
+         }
+      }
+   }
+}
+
+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();
+
+      chain::son_report_down_operation son_down_op;
+      son_down_op.payer = GRAPHENE_SON_ACCOUNT;
+      son_down_op.son_id = son_id;
+      son_down_op.down_ts = last_active_ts;
+
+      proposal_create_operation proposal_op;
+      proposal_op.fee_paying_account = get_son_object(plugin.get_current_son_id()).son_account;
+      proposal_op.proposed_ops.push_back(op_wrapper(son_down_op));
+      uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+      proposal_op.expiration_time = time_point_sec(d.head_block_time().sec_since_epoch() + lifetime);
+      return proposal_op;
+   };
+
+   chain::database &d = plugin.database();
+   const chain::global_property_object &gpo = d.get_global_properties();
+   const chain::dynamic_global_property_object &dgpo = d.get_dynamic_global_properties();
+   const auto &idx = d.get_index_type<chain::son_index>().indices().get<by_id>();
+   std::set<son_id_type> sons_being_reported_down = d.get_sons_being_reported_down();
+   chain::son_id_type my_son_id = get_current_son_id();
+   for (auto son_inf : gpo.active_sons) {
+      if (my_son_id == son_inf.son_id || (sons_being_reported_down.find(son_inf.son_id) != sons_being_reported_down.end())) {
+         continue;
+      }
+      auto son_obj = idx.find(son_inf.son_id);
+      auto stats = son_obj->statistics(d);
+      fc::time_point_sec last_maintenance_time = dgpo.next_maintenance_time - gpo.parameters.maintenance_interval;
+      fc::time_point_sec last_active_ts = ((stats.last_active_timestamp > last_maintenance_time) ? stats.last_active_timestamp : last_maintenance_time);
+      int64_t down_threshold = gpo.parameters.son_down_time();
+      if (((son_obj->status == chain::son_status::active) || (son_obj->status == chain::son_status::request_maintenance)) &&
+          ((fc::time_point::now() - last_active_ts) > fc::seconds(down_threshold))) {
+         ilog("peerplays_sidechain_plugin:  sending son down proposal for ${t} from ${s}", ("t", std::string(object_id_type(son_obj->id)))("s", std::string(object_id_type(my_son_id))));
+         chain::proposal_create_operation op = create_son_down_proposal(son_inf.son_id, last_active_ts);
+         chain::signed_transaction trx = d.create_signed_transaction(plugin.get_private_key(get_son_object(my_son_id).signing_key), op);
+         fc::future<bool> fut = fc::async([&]() {
+            try {
+               d.push_transaction(trx, database::validation_steps::skip_block_size_check);
+               if (plugin.app().p2p_node())
+                  plugin.app().p2p_node()->broadcast(net::trx_message(trx));
+               return true;
+            } catch (fc::exception e) {
+               ilog("peerplays_sidechain_plugin_impl:  sending son down proposal failed with exception ${e}", ("e", e.what()));
+               return false;
             }
+         });
+         fut.wait(fc::seconds(10));
+      }
+   }
+}
 
-            const object* obj = plugin.database().find_object(object_id);
+void peerplays_sidechain_plugin_impl::create_son_deregister_proposals() {
-            const chain::proposal_object* proposal = dynamic_cast<const chain::proposal_object*>(obj);
+   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(proposal == nullptr || (proposal->available_active_approvals.find(get_son_object(son_id).son_account) != proposal->available_active_approvals.end())) {
+   if (sons_to_be_dereg.size() > 0) {
-               continue;
+      // 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();
-            if(proposal->proposed_transaction.operations.size() == 1
+      for (auto &son : sons_to_be_dereg) {
-            && proposal->proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_report_down_operation>::value) {
+         // New SON to be deregistered
-               approve_proposal( son_id, proposal->id );
+         if (sons_being_dereg.find(son) == sons_being_dereg.end() && my_son_id != son) {
-               continue;
+            // 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(proposal->proposed_transaction.operations.size() == 1
+               // Signing and pushing into the txs to be included in the block
-            && proposal->proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_delete_operation>::value) {
+               ilog("peerplays_sidechain_plugin:  sending son deregister proposal for ${p} from ${s}", ("p", son)("s", my_son_id));
-               approve_proposal( son_id, proposal->id );
+               chain::signed_transaction trx = d.create_signed_transaction(plugin.get_private_key(get_son_object(my_son_id).signing_key), *op);
-               continue;
+               fc::future<bool> fut = fc::async([&]() {
-            }
+                  try {
-
+                     d.push_transaction(trx, database::validation_steps::skip_block_size_check);
-            if(proposal->proposed_transaction.operations.size() == 1
+                     if (plugin.app().p2p_node())
-            && proposal->proposed_transaction.operations[0].which() == chain::operation::tag<chain::son_wallet_update_operation>::value) {
+                        plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-               approve_proposal( son_id, proposal->id );
+                     return true;
-               continue;
+                  } catch (fc::exception e) {
-            }
+                     ilog("peerplays_sidechain_plugin_impl:  sending son dereg proposal failed with exception ${e}", ("e", e.what()));
-
+                     return false;
-            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 );
+               fut.wait(fc::seconds(10));
-               continue;
-            }
-
-            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) {
-               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) {
-               approve_proposal( son_id, proposal->id );
-               continue;
             }
          }
       }
    }
 }
 
+void peerplays_sidechain_plugin_impl::recreate_primary_wallet() {
+   net_manager->recreate_primary_wallet();
+}
+
+void peerplays_sidechain_plugin_impl::process_deposits() {
+   net_manager->process_deposits();
+}
+
+void peerplays_sidechain_plugin_impl::process_withdrawals() {
+   net_manager->process_withdrawals();
+}
+
+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 &cli,
-   boost::program_options::options_description& cfg)
+      boost::program_options::options_description &cfg) {
-{
+   my->plugin_set_program_options(cli, cfg);
-   ilog("peerplays sidechain plugin:  plugin_set_program_options()");
-    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();
-    return my->get_sons();
 }
 
-son_id_type& peerplays_sidechain_plugin::get_current_son_id() {
+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);
 }
 
-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);
 }
 
-std::map<chain::public_key_type, fc::ecc::private_key>& peerplays_sidechain_plugin::get_private_keys()
+fc::ecc::private_key peerplays_sidechain_plugin::get_private_key(son_id_type son_id) {
-{
-   return my->get_private_keys();
-}
-
-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);
-    return my->get_private_key(public_key);
 }
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/sidechain_net_handler.cpp

@@ -8,10 +8,9 @@
 
 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() {
@@ -24,44 +23,52 @@ graphene::peerplays_sidechain::sidechain_type sidechain_net_handler::get_sidecha
 std::vector<std::string> sidechain_net_handler::get_sidechain_deposit_addresses() {
    std::vector<std::string> result;
 
-   const auto& sidechain_addresses_idx = database.get_index_type<sidechain_address_index>();
+   const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>();
-   const auto& sidechain_addresses_by_sidechain_idx = sidechain_addresses_idx.indices().get<by_sidechain>();
+   const auto &sidechain_addresses_by_sidechain_idx = sidechain_addresses_idx.indices().get<by_sidechain>();
-   const auto& sidechain_addresses_by_sidechain_range = sidechain_addresses_by_sidechain_idx.equal_range(sidechain);
+   const auto &sidechain_addresses_by_sidechain_range = sidechain_addresses_by_sidechain_idx.equal_range(sidechain);
    std::for_each(sidechain_addresses_by_sidechain_range.first, sidechain_addresses_by_sidechain_range.second,
-         [&result] (const sidechain_address_object& sao) {
+                 [&result](const sidechain_address_object &sao) {
-      result.push_back(sao.deposit_address);
+                    result.push_back(sao.deposit_address);
-   });
+                 });
    return result;
 }
 
 std::vector<std::string> sidechain_net_handler::get_sidechain_withdraw_addresses() {
    std::vector<std::string> result;
 
-   const auto& sidechain_addresses_idx = database.get_index_type<sidechain_address_index>();
+   const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>();
-   const auto& sidechain_addresses_by_sidechain_idx = sidechain_addresses_idx.indices().get<by_sidechain>();
+   const auto &sidechain_addresses_by_sidechain_idx = sidechain_addresses_idx.indices().get<by_sidechain>();
-   const auto& sidechain_addresses_by_sidechain_range = sidechain_addresses_by_sidechain_idx.equal_range(sidechain);
+   const auto &sidechain_addresses_by_sidechain_range = sidechain_addresses_by_sidechain_idx.equal_range(sidechain);
    std::for_each(sidechain_addresses_by_sidechain_range.first, sidechain_addresses_by_sidechain_range.second,
-         [&result] (const sidechain_address_object& sao) {
+                 [&result](const sidechain_address_object &sao) {
-      result.push_back(sao.withdraw_address);
+                    result.push_back(sao.withdraw_address);
-   });
+                 });
    return result;
 }
 
-void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_data& sed) {
+std::string sidechain_net_handler::get_private_key(std::string public_key) {
-   ilog( "sidechain_event_data:" );
+   auto private_key_itr = private_keys.find(public_key);
-   ilog( "  timestamp:                ${timestamp}", ( "timestamp", sed.timestamp ) );
+   if (private_key_itr != private_keys.end()) {
-   ilog( "  sidechain:                ${sidechain}", ( "sidechain", sed.sidechain ) );
+      return private_key_itr->second;
-   ilog( "  sidechain_uid:            ${uid}", ( "uid", sed.sidechain_uid ) );
+   }
-   ilog( "  sidechain_transaction_id: ${transaction_id}", ( "transaction_id", sed.sidechain_transaction_id ) );
+   return std::string();
-   ilog( "  sidechain_from:           ${from}", ( "from", sed.sidechain_from ) );
+}
-   ilog( "  sidechain_to:             ${to}", ( "to", sed.sidechain_to ) );
-   ilog( "  sidechain_currency:       ${currency}", ( "currency", sed.sidechain_currency ) );
-   ilog( "  sidechain_amount:         ${amount}", ( "amount", sed.sidechain_amount ) );
-   ilog( "  peerplays_from:           ${peerplays_from}", ( "peerplays_from", sed.peerplays_from ) );
-   ilog( "  peerplays_to:             ${peerplays_to}", ( "peerplays_to", sed.peerplays_to ) );
-   ilog( "  peerplays_asset:          ${peerplays_asset}", ( "peerplays_asset", sed.peerplays_asset ) );
 
-   const chain::global_property_object& gpo = database.get_global_properties();
+void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_data &sed) {
+   ilog("sidechain_event_data:");
+   ilog("  timestamp:                ${timestamp}", ("timestamp", sed.timestamp));
+   ilog("  sidechain:                ${sidechain}", ("sidechain", sed.sidechain));
+   ilog("  sidechain_uid:            ${uid}", ("uid", sed.sidechain_uid));
+   ilog("  sidechain_transaction_id: ${transaction_id}", ("transaction_id", sed.sidechain_transaction_id));
+   ilog("  sidechain_from:           ${from}", ("from", sed.sidechain_from));
+   ilog("  sidechain_to:             ${to}", ("to", sed.sidechain_to));
+   ilog("  sidechain_currency:       ${currency}", ("currency", sed.sidechain_currency));
+   ilog("  sidechain_amount:         ${amount}", ("amount", sed.sidechain_amount));
+   ilog("  peerplays_from:           ${peerplays_from}", ("peerplays_from", sed.peerplays_from));
+   ilog("  peerplays_to:             ${peerplays_to}", ("peerplays_to", sed.peerplays_to));
+   ilog("  peerplays_asset:          ${peerplays_asset}", ("peerplays_asset", sed.peerplays_asset));
+
+   const chain::global_property_object &gpo = database.get_global_properties();
 
    // Deposit request
    if ((sed.peerplays_to == GRAPHENE_SON_ACCOUNT) && (sed.sidechain_currency.compare("1.3.0") != 0)) {
@@ -83,18 +90,17 @@ void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_
          if (plugin.is_active_son(son_id)) {
             proposal_create_operation proposal_op;
             proposal_op.fee_paying_account = plugin.get_son_object(son_id).son_account;
-            proposal_op.proposed_ops.emplace_back( op_wrapper( op ) );
+            proposal_op.proposed_ops.emplace_back(op_wrapper(op));
-            uint32_t lifetime = ( gpo.parameters.block_interval * gpo.active_witnesses.size() ) * 3;
+            uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
-            proposal_op.expiration_time = time_point_sec( database.head_block_time().sec_since_epoch() + lifetime );
+            proposal_op.expiration_time = time_point_sec(database.head_block_time().sec_since_epoch() + lifetime);
 
-            //ilog("sidechain_net_handler:  sending proposal for son wallet deposit create operation by ${son}", ("son", son_id));
             signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(son_id), proposal_op);
             try {
                database.push_transaction(trx, database::validation_steps::skip_block_size_check);
-               if(plugin.app().p2p_node())
+               if (plugin.app().p2p_node())
                   plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-            } catch(fc::exception e){
+            } catch (fc::exception e) {
-               ilog("sidechain_net_handler:  sending proposal for son wallet deposit create operation by ${son} failed with exception ${e}", ("son", son_id) ("e", e.what()));
+               ilog("sidechain_net_handler:  sending proposal for son wallet deposit create operation by ${son} failed with exception ${e}", ("son", son_id)("e", e.what()));
             }
          }
       }
@@ -104,9 +110,9 @@ void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_
    // Withdrawal request
    if ((sed.peerplays_to == GRAPHENE_SON_ACCOUNT) && (sed.sidechain_currency.compare("1.3.0") == 0)) {
       // BTC Payout only (for now)
-      const auto& sidechain_addresses_idx = database.get_index_type<sidechain_address_index>().indices().get<by_account_and_sidechain>();
+      const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>().indices().get<by_account_and_sidechain>();
-      const auto& addr_itr = sidechain_addresses_idx.find(std::make_tuple(sed.peerplays_from, sidechain_type::bitcoin));
+      const auto &addr_itr = sidechain_addresses_idx.find(std::make_tuple(sed.peerplays_from, sidechain_type::bitcoin));
-      if ( addr_itr == sidechain_addresses_idx.end() )
+      if (addr_itr == sidechain_addresses_idx.end())
          return;
 
       son_wallet_withdraw_create_operation op;
@@ -117,27 +123,26 @@ void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_
       op.peerplays_transaction_id = sed.sidechain_transaction_id;
       op.peerplays_from = sed.peerplays_from;
       op.peerplays_asset = sed.peerplays_asset;
-      op.withdraw_sidechain = sidechain_type::bitcoin; // BTC payout only (for now)
+      op.withdraw_sidechain = sidechain_type::bitcoin;        // BTC payout only (for now)
-      op.withdraw_address = addr_itr->withdraw_address; // BTC payout only (for now)
+      op.withdraw_address = addr_itr->withdraw_address;       // BTC payout only (for now)
-      op.withdraw_currency = "BTC"; // BTC payout only (for now)
+      op.withdraw_currency = "BTC";                           // BTC payout only (for now)
       op.withdraw_amount = sed.peerplays_asset.amount * 1000; // BTC payout only (for now)
 
       for (son_id_type son_id : plugin.get_sons()) {
          if (plugin.is_active_son(son_id)) {
             proposal_create_operation proposal_op;
             proposal_op.fee_paying_account = plugin.get_son_object(son_id).son_account;
-            proposal_op.proposed_ops.emplace_back( op_wrapper( op ) );
+            proposal_op.proposed_ops.emplace_back(op_wrapper(op));
-            uint32_t lifetime = ( gpo.parameters.block_interval * gpo.active_witnesses.size() ) * 3;
+            uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
-            proposal_op.expiration_time = time_point_sec( database.head_block_time().sec_since_epoch() + lifetime );
+            proposal_op.expiration_time = time_point_sec(database.head_block_time().sec_since_epoch() + lifetime);
 
-            //ilog("sidechain_net_handler:  sending proposal for son wallet withdraw create operation by ${son}", ("son", son_id));
             signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(son_id), proposal_op);
             try {
                database.push_transaction(trx, database::validation_steps::skip_block_size_check);
-               if(plugin.app().p2p_node())
+               if (plugin.app().p2p_node())
                   plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-            } catch(fc::exception e){
+            } catch (fc::exception e) {
-               ilog("sidechain_net_handler:  sending proposal for son wallet withdraw create operation by ${son} failed with exception ${e}", ("son", son_id) ("e", e.what()));
+               ilog("sidechain_net_handler:  sending proposal for son wallet withdraw create operation by ${son} failed with exception ${e}", ("son", son_id)("e", e.what()));
             }
          }
       }
@@ -147,79 +152,84 @@ void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_
    FC_ASSERT(false, "Invalid sidechain event");
 }
 
+void sidechain_net_handler::process_deposits() {
+   const auto &idx = plugin.database().get_index_type<son_wallet_deposit_index>().indices().get<by_sidechain_and_processed>();
+   const auto &idx_range = idx.equal_range(std::make_tuple(sidechain, false));
+
+   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);
+
+                    const chain::global_property_object &gpo = plugin.database().get_global_properties();
+
+                    son_wallet_deposit_process_operation p_op;
+                    p_op.payer = GRAPHENE_SON_ACCOUNT;
+                    p_op.son_wallet_deposit_id = swdo.id;
+
+                    proposal_create_operation proposal_op;
+                    proposal_op.fee_paying_account = plugin.get_son_object(plugin.get_current_son_id()).son_account;
+                    proposal_op.proposed_ops.emplace_back(op_wrapper(p_op));
+                    uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+                    proposal_op.expiration_time = time_point_sec(plugin.database().head_block_time().sec_since_epoch() + lifetime);
+
+                    signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id()), proposal_op);
+                    trx.validate();
+                    try {
+                       plugin.database().push_transaction(trx, database::validation_steps::skip_block_size_check);
+                       if (plugin.app().p2p_node())
+                          plugin.app().p2p_node()->broadcast(net::trx_message(trx));
+                    } catch (fc::exception e) {
+                       ilog("sidechain_net_handler:  sending proposal for transfer operation failed with exception ${e}", ("e", e.what()));
+                    }
+                 });
+}
+
+void sidechain_net_handler::process_withdrawals() {
+   const auto &idx = plugin.database().get_index_type<son_wallet_withdraw_index>().indices().get<by_withdraw_sidechain_and_processed>();
+   const auto &idx_range = idx.equal_range(std::make_tuple(sidechain, false));
+
+   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);
+
+                    const chain::global_property_object &gpo = plugin.database().get_global_properties();
+
+                    son_wallet_withdraw_process_operation p_op;
+                    p_op.payer = GRAPHENE_SON_ACCOUNT;
+                    p_op.son_wallet_withdraw_id = swwo.id;
+
+                    proposal_create_operation proposal_op;
+                    proposal_op.fee_paying_account = plugin.get_son_object(plugin.get_current_son_id()).son_account;
+                    proposal_op.proposed_ops.emplace_back(op_wrapper(p_op));
+                    uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+                    proposal_op.expiration_time = time_point_sec(plugin.database().head_block_time().sec_since_epoch() + lifetime);
+
+                    signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id()), proposal_op);
+                    trx.validate();
+                    try {
+                       plugin.database().push_transaction(trx, database::validation_steps::skip_block_size_check);
+                       if (plugin.app().p2p_node())
+                          plugin.app().p2p_node()->broadcast(net::trx_message(trx));
+                    } catch (fc::exception e) {
+                       ilog("sidechain_net_handler:  sending proposal for transfer operation failed with exception ${e}", ("e", e.what()));
+                    }
+                 });
+}
+
 void sidechain_net_handler::recreate_primary_wallet() {
    FC_ASSERT(false, "recreate_primary_wallet not implemented");
 }
 
-void sidechain_net_handler::process_deposits() {
+void sidechain_net_handler::process_deposit(const son_wallet_deposit_object &swdo) {
-   const auto& idx = plugin.database().get_index_type<son_wallet_deposit_index>().indices().get<by_sidechain_and_processed>();
+   FC_ASSERT(false, "process_deposit not implemented");
-   const auto& idx_range = idx.equal_range(std::make_tuple(sidechain, false));
-
-   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);
-
-      const chain::global_property_object& gpo = plugin.database().get_global_properties();
-
-      son_wallet_deposit_process_operation p_op;
-      p_op.payer = GRAPHENE_SON_ACCOUNT;
-      p_op.son_wallet_deposit_id = swdo.id;
-
-      proposal_create_operation proposal_op;
-      proposal_op.fee_paying_account = plugin.get_son_object(plugin.get_current_son_id()).son_account;
-      proposal_op.proposed_ops.emplace_back( op_wrapper( p_op ) );
-      uint32_t lifetime = ( gpo.parameters.block_interval * gpo.active_witnesses.size() ) * 3;
-      proposal_op.expiration_time = time_point_sec( plugin.database().head_block_time().sec_since_epoch() + lifetime );
-
-      signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id()), proposal_op);
-      trx.validate();
-      try {
-         plugin.database().push_transaction(trx, database::validation_steps::skip_block_size_check);
-         if(plugin.app().p2p_node())
-            plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-      } catch(fc::exception e){
-         ilog("sidechain_net_handler:  sending proposal for transfer operation failed with exception ${e}",("e", e.what()));
-      }
-   });
 }
 
-void sidechain_net_handler::process_withdrawals() {
+void sidechain_net_handler::process_withdrawal(const son_wallet_withdraw_object &swwo) {
-   const auto& idx = plugin.database().get_index_type<son_wallet_withdraw_index>().indices().get<by_withdraw_sidechain_and_processed>();
+   FC_ASSERT(false, "process_withdrawal not implemented");
-   const auto& idx_range = idx.equal_range(std::make_tuple(sidechain, false));
-
-   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);
-
-      const chain::global_property_object& gpo = plugin.database().get_global_properties();
-
-      son_wallet_withdraw_process_operation p_op;
-      p_op.payer = GRAPHENE_SON_ACCOUNT;
-      p_op.son_wallet_withdraw_id = swwo.id;
-
-      proposal_create_operation proposal_op;
-      proposal_op.fee_paying_account = plugin.get_son_object(plugin.get_current_son_id()).son_account;
-      proposal_op.proposed_ops.emplace_back( op_wrapper( p_op ) );
-      uint32_t lifetime = ( gpo.parameters.block_interval * gpo.active_witnesses.size() ) * 3;
-      proposal_op.expiration_time = time_point_sec( plugin.database().head_block_time().sec_since_epoch() + lifetime );
-
-      signed_transaction trx = plugin.database().create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id()), proposal_op);
-      trx.validate();
-      try {
-         plugin.database().push_transaction(trx, database::validation_steps::skip_block_size_check);
-         if(plugin.app().p2p_node())
-            plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-      } catch(fc::exception e){
-         ilog("sidechain_net_handler:  sending proposal for transfer operation failed with exception ${e}",("e", e.what()));
-      }
-   });
 }
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp

@@ -4,28 +4,32 @@
 #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 ):
+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 )
+      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 );
+   authorization.val = "Basic " + fc::base64_encode(user + ":" + password);
 }
 
 bool bitcoin_rpc_client::connection_is_not_defined() const {
@@ -62,7 +66,7 @@ std::string bitcoin_rpc_client::addmultisigaddress(const std::vector<std::string
    }
 
    if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("BTC multisig address creation failed! Reply: ${msg}", ("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
    return "";
 }
@@ -88,8 +92,6 @@ std::string bitcoin_rpc_client::createrawtransaction(const std::vector<btc_txout
    }
    body += std::string("]] }");
 
-   ilog(body);
-
    const auto reply = send_post_request(body);
 
    if (reply.body.empty()) {
@@ -105,11 +107,67 @@ std::string bitcoin_rpc_client::createrawtransaction(const std::vector<btc_txout
       if (json.count("result"))
          return ss.str();
    } else if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("Failed to create raw transaction: [${body}]! Reply: ${msg}", ("body", body)("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
    return std::string();
 }
 
+std::string bitcoin_rpc_client::createwallet(const std::string &wallet_name) {
+   std::string body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"createwallet\", \"method\": "
+                                  "\"createwallet\", \"params\": [\"" +
+                                  wallet_name + "\"] }");
+
+   const auto reply = send_post_request(body);
+
+   if (reply.body.empty()) {
+      wlog("Bitcoin RPC call ${function} failed", ("function", __FUNCTION__));
+      return std::string();
+   }
+
+   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+   boost::property_tree::ptree json;
+   boost::property_tree::read_json(ss, json);
+
+   if (reply.status == 200) {
+      std::stringstream ss;
+      boost::property_tree::json_parser::write_json(ss, json.get_child("result"));
+      return ss.str();
+   }
+
+   if (json.count("error") && !json.get_child("error").empty()) {
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
+   }
+   return "";
+}
+
+std::string bitcoin_rpc_client::encryptwallet(const std::string &passphrase) {
+   std::string body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"encryptwallet\", \"method\": "
+                                  "\"encryptwallet\", \"params\": [\"" +
+                                  passphrase + "\"] }");
+
+   const auto reply = send_post_request(body);
+
+   if (reply.body.empty()) {
+      wlog("Bitcoin RPC call ${function} failed", ("function", __FUNCTION__));
+      return std::string();
+   }
+
+   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+   boost::property_tree::ptree json;
+   boost::property_tree::read_json(ss, json);
+
+   if (reply.status == 200) {
+      std::stringstream ss;
+      boost::property_tree::json_parser::write_json(ss, json.get_child("result"));
+      return ss.str();
+   }
+
+   if (json.count("error") && !json.get_child("error").empty()) {
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
+   }
+   return "";
+}
+
 uint64_t bitcoin_rpc_client::estimatesmartfee() {
    static const auto confirmation_target_blocks = 6;
 
@@ -160,7 +218,7 @@ std::string bitcoin_rpc_client::getblock(const std::string &block_hash, int32_t
    }
 
    if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("Bitcoin RPC call ${function} failed with reply '${msg}'", ("function", __FUNCTION__)("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
    return "";
 }
@@ -185,7 +243,7 @@ void bitcoin_rpc_client::importaddress(const std::string &address_or_script) {
       idump((address_or_script)(ss.str()));
       return;
    } else if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("Failed to import address [${addr}]! Reply: ${msg}", ("addr", address_or_script)("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
 }
 
@@ -217,7 +275,7 @@ std::vector<btc_txout> bitcoin_rpc_client::listunspent() {
          }
       }
    } else if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("Failed to list unspent txo! Reply: ${msg}", ("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
    return result;
 }
@@ -254,18 +312,44 @@ std::vector<btc_txout> bitcoin_rpc_client::listunspent_by_address_and_amount(con
          }
       }
    } else if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("Failed to list unspent txo! Reply: ${msg}", ("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
    return result;
 }
 
+std::string bitcoin_rpc_client::loadwallet(const std::string &filename) {
+   std::string body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"loadwallet\", \"method\": "
+                                  "\"loadwallet\", \"params\": [\"" +
+                                  filename + "\"] }");
+
+   const auto reply = send_post_request(body);
+
+   if (reply.body.empty()) {
+      wlog("Bitcoin RPC call ${function} failed", ("function", __FUNCTION__));
+      return std::string();
+   }
+
+   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+   boost::property_tree::ptree json;
+   boost::property_tree::read_json(ss, json);
+
+   if (reply.status == 200) {
+      std::stringstream ss;
+      boost::property_tree::json_parser::write_json(ss, json.get_child("result"));
+      return ss.str();
+   }
+
+   if (json.count("error") && !json.get_child("error").empty()) {
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
+   }
+   return "";
+}
+
 void bitcoin_rpc_client::sendrawtransaction(const std::string &tx_hex) {
    const auto body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"sendrawtransaction\", "
                                  "\"method\": \"sendrawtransaction\", \"params\": [") +
                      std::string("\"") + tx_hex + std::string("\"") + std::string("] }");
 
-   ilog(body);
-
    const auto reply = send_post_request(body);
 
    if (reply.body.empty()) {
@@ -284,7 +368,7 @@ void bitcoin_rpc_client::sendrawtransaction(const std::string &tx_hex) {
       if (error_code == -27) // transaction already in block chain
          return;
 
-      wlog("BTC tx is not sent! Reply: ${msg}", ("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
 }
 
@@ -298,8 +382,6 @@ std::string bitcoin_rpc_client::signrawtransactionwithwallet(const std::string &
    std::string params = "\"" + tx_hash + "\"";
    body = body + params + std::string("]}");
 
-   ilog(body);
-
    const auto reply = send_post_request(body);
 
    if (reply.body.empty()) {
@@ -316,64 +398,161 @@ std::string bitcoin_rpc_client::signrawtransactionwithwallet(const std::string &
    }
 
    if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("BTC sign_raw_transaction_with_wallet failed! Reply: ${msg}", ("msg", ss.str()));
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
    }
    return "";
 }
 
-fc::http::reply bitcoin_rpc_client::send_post_request( std::string body )
+std::string bitcoin_rpc_client::unloadwallet(const std::string &filename) {
-{
+   std::string body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"unloadwallet\", \"method\": "
+                                  "\"unloadwallet\", \"params\": [\"" +
+                                  filename + "\"] }");
+
+   const auto reply = send_post_request(body);
+
+   if (reply.body.empty()) {
+      wlog("Bitcoin RPC call ${function} failed", ("function", __FUNCTION__));
+      return std::string();
+   }
+
+   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+   boost::property_tree::ptree json;
+   boost::property_tree::read_json(ss, json);
+
+   if (reply.status == 200) {
+      std::stringstream ss;
+      boost::property_tree::json_parser::write_json(ss, json.get_child("result"));
+      return ss.str();
+   }
+
+   if (json.count("error") && !json.get_child("error").empty()) {
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
+   }
+   return "";
+}
+
+std::string bitcoin_rpc_client::walletlock() {
+   std::string body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"walletlock\", \"method\": "
+                                  "\"walletlock\", \"params\": [] }");
+
+   const auto reply = send_post_request(body);
+
+   if (reply.body.empty()) {
+      wlog("Bitcoin RPC call ${function} failed", ("function", __FUNCTION__));
+      return std::string();
+   }
+
+   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+   boost::property_tree::ptree json;
+   boost::property_tree::read_json(ss, json);
+
+   if (reply.status == 200) {
+      std::stringstream ss;
+      boost::property_tree::json_parser::write_json(ss, json.get_child("result"));
+      return ss.str();
+   }
+
+   if (json.count("error") && !json.get_child("error").empty()) {
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
+   }
+   return "";
+}
+
+bool bitcoin_rpc_client::walletpassphrase(const std::string &passphrase, uint32_t timeout) {
+   std::string body = std::string("{\"jsonrpc\": \"1.0\", \"id\":\"walletpassphrase\", \"method\": "
+                                  "\"walletpassphrase\", \"params\": [\"" +
+                                  passphrase + "\", " + std::to_string(timeout) + "] }");
+
+   const auto reply = send_post_request(body);
+
+   if (reply.body.empty()) {
+      wlog("Bitcoin RPC call ${function} failed", ("function", __FUNCTION__));
+      return false;
+   }
+
+   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+   boost::property_tree::ptree json;
+   boost::property_tree::read_json(ss, json);
+
+   if (reply.status == 200) {
+      return true;
+   }
+
+   if (json.count("error") && !json.get_child("error").empty()) {
+      wlog("Bitcoin RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body)("msg", ss.str()));
+   }
+   return false;
+}
+
+fc::http::reply bitcoin_rpc_client::send_post_request(std::string body, bool show_log) {
    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));
 
-   const auto url = "http://" + ip + ":" + std::to_string( rpc_port );
+   std::string url = "http://" + ip + ":" + std::to_string(rpc_port);
 
-   return conn.request( "POST", url, body, fc::http::headers{authorization} );
+   if (wallet.length() > 0) {
+      url = url + "/wallet/" + wallet;
+   }
+
+   fc::http::reply reply = conn.request("POST", url, body, fc::http::headers{authorization});
+
+   if (show_log) {
+      ilog("Request URL: ${url}", ("url", url));
+      ilog("Request:     ${body}", ("body", body));
+      std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+      ilog("Response:    ${ss}", ("ss", ss.str()));
+   }
+
+   return reply;
 }
 
 // =============================================================================
 
-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) :
-   std::thread( &zmq_listener::handle_zmq, this ).detach();
+      ip(_ip),
+      zmq_port(_zmq),
+      ctx(1),
+      socket(ctx, ZMQ_SUB) {
+   std::thread(&zmq_listener::handle_zmq, this).detach();
 }
 
 std::vector<zmq::message_t> zmq_listener::receive_multipart() {
    std::vector<zmq::message_t> msgs;
 
    int32_t more;
-   size_t more_size = sizeof( more );
+   size_t more_size = sizeof(more);
-   while ( true ) {
+   while (true) {
       zmq::message_t msg;
-      socket.recv( &msg, 0 );
+      socket.recv(&msg, 0);
-      socket.getsockopt( ZMQ_RCVMORE, &more, &more_size );
+      socket.getsockopt(ZMQ_RCVMORE, &more, &more_size);
 
-      if ( !more )
+      if (!more)
          break;
-      msgs.push_back( std::move(msg) );
+      msgs.push_back(std::move(msg));
    }
 
    return msgs;
 }
 
 void zmq_listener::handle_zmq() {
-   socket.setsockopt( ZMQ_SUBSCRIBE, "hashblock", 9 );
+   socket.setsockopt(ZMQ_SUBSCRIBE, "hashblock", 9);
    //socket.setsockopt( ZMQ_SUBSCRIBE, "hashtx", 6 );
    //socket.setsockopt( ZMQ_SUBSCRIBE, "rawblock", 8 );
    //socket.setsockopt( ZMQ_SUBSCRIBE, "rawtx", 5 );
-   socket.connect( "tcp://" + ip + ":" + std::to_string( zmq_port ) );
+   socket.connect("tcp://" + ip + ":" + std::to_string(zmq_port));
 
-   while ( true ) {
+   while (true) {
       auto msg = receive_multipart();
-      const auto header = std::string( static_cast<char*>( msg[0].data() ), msg[0].size() );
+      const auto header = std::string(static_cast<char *>(msg[0].data()), msg[0].size());
-      const auto block_hash = boost::algorithm::hex( std::string( static_cast<char*>( msg[1].data() ), msg[1].size() ) );
+      const auto block_hash = boost::algorithm::hex(std::string(static_cast<char *>(msg[1].data()), msg[1].size()));
 
-      event_received( block_hash );
+      event_received(block_hash);
    }
 }
 
 // =============================================================================
 
-sidechain_net_handler_bitcoin::sidechain_net_handler_bitcoin(peerplays_sidechain_plugin& _plugin, const boost::program_options::variables_map& options) :
+sidechain_net_handler_bitcoin::sidechain_net_handler_bitcoin(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
       sidechain_net_handler(_plugin, options) {
    sidechain = sidechain_type::bitcoin;
 
@@ -382,64 +561,70 @@ sidechain_net_handler_bitcoin::sidechain_net_handler_bitcoin(peerplays_sidechain
    rpc_port = options.at("bitcoin-node-rpc-port").as<uint32_t>();
    rpc_user = options.at("bitcoin-node-rpc-user").as<std::string>();
    rpc_password = options.at("bitcoin-node-rpc-password").as<std::string>();
+   wallet = "";
+   if (options.count("bitcoin-wallet")) {
+      wallet = options.at("bitcoin-wallet").as<std::string>();
+   }
+   wallet_password = "";
+   if (options.count("bitcoin-wallet-password")) {
+      wallet_password = options.at("bitcoin-wallet-password").as<std::string>();
+   }
 
-   if( options.count("bitcoin-private-keys") )
+   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-keys"].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));
-         auto key_pair = graphene::app::dejsonify<std::pair<std::string, std::string> >(itr_key_pair, 5);
+         if (!key_pair.first.length() || !key_pair.second.length()) {
-         ilog("Public Key: ${public}", ("public", key_pair.first));
-         if(!key_pair.first.length() || !key_pair.second.length())
-         {
             FC_THROW("Invalid public private key pair.");
          }
-         _private_keys[key_pair.first] = key_pair.second;
+         private_keys[key_pair.first] = key_pair.second;
       }
    }
 
    fc::http::connection conn;
    try {
-      conn.connect_to( fc::ip::endpoint( fc::ip::address( ip ), rpc_port ) );
+      conn.connect_to(fc::ip::endpoint(fc::ip::address(ip), rpc_port));
-   } catch ( fc::exception e ) {
+   } catch (fc::exception e) {
-      elog( "No BTC node running at ${ip} or wrong rpc port: ${port}", ("ip", ip) ("port", rpc_port) );
+      elog("No BTC node running at ${ip} or wrong rpc port: ${port}", ("ip", ip)("port", rpc_port));
-      FC_ASSERT( false );
+      FC_ASSERT(false);
    }
 
-   listener = std::unique_ptr<zmq_listener>( new zmq_listener( ip, zmq_port ) );
+   bitcoin_client = std::unique_ptr<bitcoin_rpc_client>(new bitcoin_rpc_client(ip, rpc_port, rpc_user, rpc_password, wallet, wallet_password));
-   bitcoin_client = std::unique_ptr<bitcoin_rpc_client>( new bitcoin_rpc_client( ip, rpc_port, rpc_user, rpc_password ) );
+   if (!wallet.empty()) {
+      bitcoin_client->loadwallet(wallet);
+   }
 
-   listener->event_received.connect([this]( const std::string& event_data ) {
+   listener = std::unique_ptr<zmq_listener>(new zmq_listener(ip, zmq_port));
-      std::thread( &sidechain_net_handler_bitcoin::handle_event, this, event_data ).detach();
+   listener->event_received.connect([this](const std::string &event_data) {
-   } );
+      std::thread(&sidechain_net_handler_bitcoin::handle_event, this, event_data).detach();
+   });
 }
 
 sidechain_net_handler_bitcoin::~sidechain_net_handler_bitcoin() {
 }
 
 void sidechain_net_handler_bitcoin::recreate_primary_wallet() {
-   const auto& swi = database.get_index_type<son_wallet_index>().indices().get<by_id>();
+   const auto &swi = database.get_index_type<son_wallet_index>().indices().get<by_id>();
    const auto &active_sw = swi.rbegin();
    if (active_sw != swi.rend()) {
 
       if ((active_sw->addresses.find(sidechain_type::bitcoin) == active_sw->addresses.end()) ||
           (active_sw->addresses.at(sidechain_type::bitcoin).empty())) {
 
-         const chain::global_property_object& gpo = database.get_global_properties();
+         const chain::global_property_object &gpo = database.get_global_properties();
 
          auto active_sons = gpo.active_sons;
          vector<string> son_pubkeys_bitcoin;
-         for ( const son_info& si : active_sons ) {
+         for (const son_info &si : active_sons) {
             son_pubkeys_bitcoin.push_back(si.sidechain_public_keys.at(sidechain_type::bitcoin));
          }
          string reply_str = create_multisignature_wallet(son_pubkeys_bitcoin);
 
-         ilog(reply_str);
-
          std::stringstream active_pw_ss(reply_str);
          boost::property_tree::ptree active_pw_pt;
-         boost::property_tree::read_json( active_pw_ss, active_pw_pt );
+         boost::property_tree::read_json(active_pw_ss, active_pw_pt);
-         if( active_pw_pt.count( "error" ) && active_pw_pt.get_child( "error" ).empty() ) {
+         if (active_pw_pt.count("error") && active_pw_pt.get_child("error").empty()) {
 
             std::stringstream res;
             boost::property_tree::json_parser::write_json(res, active_pw_pt.get_child("result"));
@@ -452,17 +637,17 @@ void sidechain_net_handler_bitcoin::recreate_primary_wallet() {
 
             proposal_create_operation proposal_op;
             proposal_op.fee_paying_account = plugin.get_son_object(plugin.get_current_son_id()).son_account;
-            proposal_op.proposed_ops.emplace_back( op_wrapper( op ) );
+            proposal_op.proposed_ops.emplace_back(op_wrapper(op));
-            uint32_t lifetime = ( gpo.parameters.block_interval * gpo.active_witnesses.size() ) * 3;
+            uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
-            proposal_op.expiration_time = time_point_sec( database.head_block_time().sec_since_epoch() + lifetime );
+            proposal_op.expiration_time = time_point_sec(database.head_block_time().sec_since_epoch() + lifetime);
 
             signed_transaction trx = database.create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id()), proposal_op);
             try {
                database.push_transaction(trx, database::validation_steps::skip_block_size_check);
-               if(plugin.app().p2p_node())
+               if (plugin.app().p2p_node())
                   plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-            } catch(fc::exception e){
+            } catch (fc::exception e) {
-               ilog("sidechain_net_handler:  sending proposal for son wallet update operation failed with exception ${e}",("e", e.what()));
+               ilog("sidechain_net_handler:  sending proposal for son wallet update operation failed with exception ${e}", ("e", e.what()));
                return;
             }
 
@@ -470,7 +655,7 @@ void sidechain_net_handler_bitcoin::recreate_primary_wallet() {
             if (prev_sw != swi.rend()) {
                std::stringstream prev_sw_ss(prev_sw->addresses.at(sidechain_type::bitcoin));
                boost::property_tree::ptree prev_sw_pt;
-               boost::property_tree::read_json( prev_sw_ss, prev_sw_pt );
+               boost::property_tree::read_json(prev_sw_ss, prev_sw_pt);
 
                std::string active_pw_address = active_pw_pt.get_child("result").get<std::string>("address");
                std::string prev_pw_address = prev_sw_pt.get<std::string>("address");
@@ -482,63 +667,57 @@ void sidechain_net_handler_bitcoin::recreate_primary_wallet() {
    }
 }
 
-void sidechain_net_handler_bitcoin::process_deposits() {
-   sidechain_net_handler::process_deposits();
-}
-
 void sidechain_net_handler_bitcoin::process_deposit(const son_wallet_deposit_object &swdo) {
-   ilog(__FUNCTION__);
    transfer_deposit_to_primary_wallet(swdo);
 }
 
-void sidechain_net_handler_bitcoin::process_withdrawals() {
-   sidechain_net_handler::process_withdrawals();
-}
-
 void sidechain_net_handler_bitcoin::process_withdrawal(const son_wallet_withdraw_object &swwo) {
-   ilog(__FUNCTION__);
    transfer_withdrawal_from_primary_wallet(swwo);
 }
 
-std::string sidechain_net_handler_bitcoin::create_multisignature_wallet( const std::vector<std::string> public_keys ) {
+std::string sidechain_net_handler_bitcoin::create_multisignature_wallet(const std::vector<std::string> public_keys) {
    return bitcoin_client->addmultisigaddress(public_keys);
 }
 
-std::string sidechain_net_handler_bitcoin::transfer( const std::string& from, const std::string& to, const uint64_t amount ) {
+std::string sidechain_net_handler_bitcoin::transfer(const std::string &from, const std::string &to, const uint64_t amount) {
    return "";
 }
 
-std::string sidechain_net_handler_bitcoin::sign_transaction( const std::string& transaction ) {
+std::string sidechain_net_handler_bitcoin::sign_transaction(const std::string &transaction) {
    return "";
 }
 
-std::string sidechain_net_handler_bitcoin::send_transaction( const std::string& transaction ) {
+std::string sidechain_net_handler_bitcoin::send_transaction(const std::string &transaction) {
    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);
-
    std::stringstream ss_utx(reply_str);
    boost::property_tree::ptree pt;
-   boost::property_tree::read_json( ss_utx, pt );
+   boost::property_tree::read_json(ss_utx, pt);
 
-   if( !(pt.count( "error" ) && pt.get_child( "error" ).empty()) || !pt.count("result") ) {
+   if (!(pt.count("error") && pt.get_child("error").empty()) || !pt.count("result")) {
       return "";
    }
 
+   if (!wallet_password.empty()) {
+      bitcoin_client->walletpassphrase(wallet_password, 60);
+   }
+
    std::string unsigned_tx_hex = pt.get<std::string>("result");
 
    reply_str = bitcoin_client->signrawtransactionwithwallet(unsigned_tx_hex);
-   ilog(reply_str);
    std::stringstream ss_stx(reply_str);
    boost::property_tree::ptree stx_json;
-   boost::property_tree::read_json( ss_stx, stx_json );
+   boost::property_tree::read_json(ss_stx, stx_json);
 
-   if( !(stx_json.count( "error" ) && stx_json.get_child( "error" ).empty()) || !stx_json.count("result") || !stx_json.get_child("result").count("hex") ) {
+   //if (!wallet_password.empty()) {
+   //   bitcoin_client->walletlock();
+   //}
+
+   if (!(stx_json.count("error") && stx_json.get_child("error").empty()) || !stx_json.count("result") || !stx_json.get_child("result").count("hex")) {
       return "";
    }
 
@@ -549,31 +728,25 @@ 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);
 
-   double min_amount = ((double)fee_rate/100000000.0); // Account only for relay fee for now
+   double min_amount = ((double)fee_rate / 100000000.0); // Account only for relay fee for now
    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));
-      wlog("Failed to find UTXOs to spend for ${pw}",("pw", from_address));
       return "";
-   }
+   } else {
-   else
+      for (const auto &utx : unspent_utxo) {
-   {
-      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));
-         wlog("Failed not enough BTC to transfer from ${fa}",("fa", from_address));
          return "";
       }
    }
@@ -585,9 +758,8 @@ 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>();
-   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()) {
       return "";
@@ -597,19 +769,19 @@ std::string sidechain_net_handler_bitcoin::transfer_deposit_to_primary_wallet (c
 
    std::stringstream ss(pw_address_json);
    boost::property_tree::ptree json;
-   boost::property_tree::read_json( ss, json );
+   boost::property_tree::read_json(ss, json);
 
    std::string pw_address = json.get<std::string>("address");
 
    std::string txid = swdo.sidechain_transaction_id;
    std::string suid = swdo.sidechain_uid;
-   std::string nvout = suid.substr(suid.find_last_of("-")+1);
+   std::string nvout = suid.substr(suid.find_last_of("-") + 1);
    uint64_t deposit_amount = swdo.sidechain_amount.value;
    uint64_t fee_rate = bitcoin_client->estimatesmartfee();
    uint64_t min_fee_rate = 1000;
    fee_rate = std::max(fee_rate, min_fee_rate);
    deposit_amount -= fee_rate; // Deduct minimum relay fee
-   double transfer_amount = (double)deposit_amount/100000000.0;
+   double transfer_amount = (double)deposit_amount / 100000000.0;
 
    std::vector<btc_txout> ins;
    fc::flat_map<std::string, double> outs;
@@ -627,10 +799,9 @@ 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>();
+   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 "";
    }
 
@@ -638,7 +809,7 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
 
    std::stringstream ss(pw_address_json);
    boost::property_tree::ptree json;
-   boost::property_tree::read_json( ss, json );
+   boost::property_tree::read_json(ss, json);
 
    std::string pw_address = json.get<std::string>("address");
 
@@ -650,29 +821,23 @@ 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));
-      wlog("Failed to find UTXOs to spend for ${pw}",("pw", pw_address));
       return "";
-   }
+   } else {
-   else
+      for (const auto &utx : unspent_utxo) {
-   {
-      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));
-         wlog("Failed not enough BTC to spend for ${pw}",("pw", pw_address));
          return "";
       }
    }
 
    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;
    }
 
@@ -680,20 +845,21 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
    return sign_and_send_transaction_with_wallet(reply_str);
 }
 
-void sidechain_net_handler_bitcoin::handle_event( const std::string& event_data ) {
+void sidechain_net_handler_bitcoin::handle_event(const std::string &event_data) {
    std::string block = bitcoin_client->getblock(event_data);
-   if( block != "" ) {
+   if (block != "") {
-      const auto& vins = extract_info_from_block( block );
+      const auto &vins = extract_info_from_block(block);
 
-      const auto& sidechain_addresses_idx = database.get_index_type<sidechain_address_index>().indices().get<by_sidechain_and_deposit_address>();
+      const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>().indices().get<by_sidechain_and_deposit_address>();
 
-      for( const auto& v : vins ) {
+      for (const auto &v : vins) {
-         const auto& addr_itr = sidechain_addresses_idx.find(std::make_tuple(sidechain, v.address));
+         const auto &addr_itr = sidechain_addresses_idx.find(std::make_tuple(sidechain, v.address));
-         if ( addr_itr == sidechain_addresses_idx.end() )
+         if (addr_itr == sidechain_addresses_idx.end())
             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;
@@ -713,31 +879,32 @@ void sidechain_net_handler_bitcoin::handle_event( const std::string& event_data
    }
 }
 
-std::vector<info_for_vin> sidechain_net_handler_bitcoin::extract_info_from_block( const std::string& _block ) {
+std::vector<info_for_vin> sidechain_net_handler_bitcoin::extract_info_from_block(const std::string &_block) {
-   std::stringstream ss( _block );
+   std::stringstream ss(_block);
    boost::property_tree::ptree block;
-   boost::property_tree::read_json( ss, block );
+   boost::property_tree::read_json(ss, block);
 
    std::vector<info_for_vin> result;
 
-   for (const auto& tx_child : block.get_child("tx")) {
+   for (const auto &tx_child : block.get_child("tx")) {
-      const auto& tx = tx_child.second;
+      const auto &tx = tx_child.second;
 
-      for ( const auto& o : tx.get_child("vout") ) {
+      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?
+         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>();
             info_for_vin vin;
             vin.out.hash_tx = tx.get_child("txid").get_value<std::string>();
-            string amount = o.second.get_child( "value" ).get_value<std::string>();
+            string amount = o.second.get_child("value").get_value<std::string>();
             amount.erase(std::remove(amount.begin(), amount.end(), '.'), amount.end());
             vin.out.amount = std::stoll(amount);
-            vin.out.n_vout = o.second.get_child( "n" ).get_value<uint32_t>();
+            vin.out.n_vout = o.second.get_child("n").get_value<uint32_t>();
             vin.address = address_base58;
-            result.push_back( vin );
+            result.push_back(vin);
          }
       }
    }
@@ -747,5 +914,4 @@ std::vector<info_for_vin> sidechain_net_handler_bitcoin::extract_info_from_block
 
 // =============================================================================
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/sidechain_net_handler_peerplays.cpp

@@ -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_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() {
@@ -31,69 +33,61 @@ sidechain_net_handler_peerplays::~sidechain_net_handler_peerplays() {
 void sidechain_net_handler_peerplays::recreate_primary_wallet() {
 }
 
-void sidechain_net_handler_peerplays::process_deposits() {
+void sidechain_net_handler_peerplays::process_deposit(const son_wallet_deposit_object &swdo) {
-   sidechain_net_handler::process_deposits();
 }
 
-void sidechain_net_handler_peerplays::process_deposit(const son_wallet_deposit_object& swdo) {
+void sidechain_net_handler_peerplays::process_withdrawal(const son_wallet_withdraw_object &swwo) {
 }
 
-void sidechain_net_handler_peerplays::process_withdrawals() {
+std::string sidechain_net_handler_peerplays::create_multisignature_wallet(const std::vector<std::string> public_keys) {
-   sidechain_net_handler::process_withdrawals();
-}
-
-void sidechain_net_handler_peerplays::process_withdrawal(const son_wallet_withdraw_object& swwo) {
-}
-
-std::string sidechain_net_handler_peerplays::create_multisignature_wallet( const std::vector<std::string> public_keys ) {
    return "";
 }
 
-std::string sidechain_net_handler_peerplays::transfer( const std::string& from, const std::string& to, const uint64_t amount ) {
+std::string sidechain_net_handler_peerplays::transfer(const std::string &from, const std::string &to, const uint64_t amount) {
    return "";
 }
 
-std::string sidechain_net_handler_peerplays::sign_transaction( const std::string& transaction ) {
+std::string sidechain_net_handler_peerplays::sign_transaction(const std::string &transaction) {
    return "";
 }
 
-std::string sidechain_net_handler_peerplays::send_transaction( const std::string& transaction ) {
+std::string sidechain_net_handler_peerplays::send_transaction(const std::string &transaction) {
    return "";
 }
 
-void sidechain_net_handler_peerplays::on_applied_block(const signed_block& b) {
+void sidechain_net_handler_peerplays::on_applied_block(const signed_block &b) {
-    for (const auto& trx: b.transactions) {
+   for (const auto &trx : b.transactions) {
-        size_t operation_index = -1;
+      size_t operation_index = -1;
-        for (auto op: trx.operations) {
+      for (auto op : trx.operations) {
-            operation_index = operation_index + 1;
+         operation_index = operation_index + 1;
-            if (op.which() == operation::tag<transfer_operation>::value){
+         if (op.which() == operation::tag<transfer_operation>::value) {
-                transfer_operation transfer_op = op.get<transfer_operation>();
+            transfer_operation transfer_op = op.get<transfer_operation>();
-                if (transfer_op.to != GRAPHENE_SON_ACCOUNT) {
+            if (transfer_op.to != GRAPHENE_SON_ACCOUNT) {
-                    continue;
+               continue;
-                }
-
-                std::stringstream ss;
-                ss << "peerplays" << "-" << trx.id().str() << "-" << operation_index;
-                std::string sidechain_uid = ss.str();
-
-                sidechain_event_data sed;
-                sed.timestamp = plugin.database().head_block_time();
-                sed.sidechain = sidechain_type::peerplays;
-                sed.sidechain_uid = sidechain_uid;
-                sed.sidechain_transaction_id = trx.id().str();
-                sed.sidechain_from = fc::to_string(transfer_op.from.space_id) + "." + fc::to_string(transfer_op.from.type_id) + "." + fc::to_string((uint64_t)transfer_op.from.instance);
-                sed.sidechain_to = fc::to_string(transfer_op.to.space_id) + "." + fc::to_string(transfer_op.to.type_id) + "." + fc::to_string((uint64_t)transfer_op.to.instance);
-                sed.sidechain_currency = fc::to_string(transfer_op.amount.asset_id.space_id) + "." + fc::to_string(transfer_op.amount.asset_id.type_id) + "." + fc::to_string((uint64_t)transfer_op.amount.asset_id.instance); //transfer_op.amount.asset_id(plugin.database()).symbol;
-                sed.sidechain_amount = transfer_op.amount.amount;
-                sed.peerplays_from = transfer_op.from;
-                sed.peerplays_to = transfer_op.to;
-                // We should calculate exchange rate between CORE/TEST and other Peerplays asset
-                sed.peerplays_asset = asset(transfer_op.amount.amount / transfer_op.amount.asset_id(plugin.database()).options.core_exchange_rate.quote.amount);
-                sidechain_event_data_received(sed);
             }
-        }
+
-    }
+            std::stringstream ss;
+            ss << "peerplays"
+               << "-" << trx.id().str() << "-" << operation_index;
+            std::string sidechain_uid = ss.str();
+
+            sidechain_event_data sed;
+            sed.timestamp = plugin.database().head_block_time();
+            sed.sidechain = sidechain_type::peerplays;
+            sed.sidechain_uid = sidechain_uid;
+            sed.sidechain_transaction_id = trx.id().str();
+            sed.sidechain_from = fc::to_string(transfer_op.from.space_id) + "." + fc::to_string(transfer_op.from.type_id) + "." + fc::to_string((uint64_t)transfer_op.from.instance);
+            sed.sidechain_to = fc::to_string(transfer_op.to.space_id) + "." + fc::to_string(transfer_op.to.type_id) + "." + fc::to_string((uint64_t)transfer_op.to.instance);
+            sed.sidechain_currency = fc::to_string(transfer_op.amount.asset_id.space_id) + "." + fc::to_string(transfer_op.amount.asset_id.type_id) + "." + fc::to_string((uint64_t)transfer_op.amount.asset_id.instance); //transfer_op.amount.asset_id(plugin.database()).symbol;
+            sed.sidechain_amount = transfer_op.amount.amount;
+            sed.peerplays_from = transfer_op.from;
+            sed.peerplays_to = transfer_op.to;
+            // We should calculate exchange rate between CORE/TEST and other Peerplays asset
+            sed.peerplays_asset = asset(transfer_op.amount.amount / transfer_op.amount.asset_id(plugin.database()).options.core_exchange_rate.quote.amount);
+            sidechain_event_data_received(sed);
+         }
+      }
+   }
 }
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-

libraries/plugins/peerplays_sidechain/sidechain_net_manager.cpp

@@ -7,56 +7,54 @@
 
 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() {
 }
 
-bool sidechain_net_manager::create_handler(peerplays_sidechain::sidechain_type sidechain, const boost::program_options::variables_map& options) {
+bool sidechain_net_manager::create_handler(peerplays_sidechain::sidechain_type sidechain, const boost::program_options::variables_map &options) {
 
    bool ret_val = false;
 
    switch (sidechain) {
-      case sidechain_type::bitcoin: {
+   case sidechain_type::bitcoin: {
-         std::unique_ptr<sidechain_net_handler> h = std::unique_ptr<sidechain_net_handler>(new sidechain_net_handler_bitcoin(plugin, options));
+      std::unique_ptr<sidechain_net_handler> h = std::unique_ptr<sidechain_net_handler>(new sidechain_net_handler_bitcoin(plugin, options));
-         net_handlers.push_back(std::move(h));
+      net_handlers.push_back(std::move(h));
-         ret_val = true;
+      ret_val = true;
-         break;
+      break;
-      }
+   }
-      case sidechain_type::peerplays: {
+   case sidechain_type::peerplays: {
-         std::unique_ptr<sidechain_net_handler> h = std::unique_ptr<sidechain_net_handler>(new sidechain_net_handler_peerplays(plugin, options));
+      std::unique_ptr<sidechain_net_handler> h = std::unique_ptr<sidechain_net_handler>(new sidechain_net_handler_peerplays(plugin, options));
-         net_handlers.push_back(std::move(h));
+      net_handlers.push_back(std::move(h));
-         ret_val = true;
+      ret_val = true;
-         break;
+      break;
-      }
+   }
-      default:
+   default:
-         assert(false);
+      assert(false);
    }
 
    return ret_val;
 }
 
 void sidechain_net_manager::recreate_primary_wallet() {
-   for ( size_t i = 0; i < net_handlers.size(); i++ ) {
+   for (size_t i = 0; i < net_handlers.size(); i++) {
       net_handlers.at(i)->recreate_primary_wallet();
    }
 }
 
 void sidechain_net_manager::process_deposits() {
-   for ( size_t i = 0; i < net_handlers.size(); i++ ) {
+   for (size_t i = 0; i < net_handlers.size(); i++) {
       net_handlers.at(i)->process_deposits();
    }
 }
 
 void sidechain_net_manager::process_withdrawals() {
-   for ( size_t i = 0; i < net_handlers.size(); i++ ) {
+   for (size_t i = 0; i < net_handlers.size(); i++) {
       net_handlers.at(i)->process_withdrawals();
    }
 }
 
-} } // graphene::peerplays_sidechain
+}} // namespace graphene::peerplays_sidechain
-