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

Code formatting

Browse source
This commit is contained in:
Srdjan Obucina 2020-03-14 02:18:03 +01:00
parent b1fbd26bcf
commit 2b6c700644
5 changed files with 152 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -377,15 +377,14 @@ const char *charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
/** The Bech32 character set for decoding. */
const int8_t charset_rev[128] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1,
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1,
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1
};
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1,
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1,
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1};
/** Concatenate two byte arrays. */
bytes cat(bytes x, const bytes &y) {
@ -422,18 +421,17 @@ uint32_t polymod(const bytes &values) {
}
/** Expand a HRP for use in checksum computation. */
bytes bech32_expand_hrp(const std::string& hrp)
{
bytes ret;
ret.reserve(hrp.size() + 90);
ret.resize(hrp.size() * 2 + 1);
for (size_t i = 0; i < hrp.size(); ++i) {
unsigned char c = hrp[i];
ret[i] = c >> 5;
ret[i + hrp.size() + 1] = c & 0x1f;
}
ret[hrp.size()] = 0;
return ret;
bytes bech32_expand_hrp(const std::string &hrp) {
bytes ret;
ret.reserve(hrp.size() + 90);
ret.resize(hrp.size() * 2 + 1);
for (size_t i = 0; i < hrp.size(); ++i) {
unsigned char c = hrp[i];
ret[i] = c >> 5;
ret[i + hrp.size() + 1] = c & 0x1f;
}
ret[hrp.size()] = 0;
return ret;
}
/** Create a checksum. */
@ -450,17 +448,16 @@ bytes bech32_checksum(const std::string &hrp, const bytes &values) {
}
/** Verify a checksum. */
bool bech32_verify_checksum(const std::string& hrp, const bytes& values)
{
// PolyMod computes what value to xor into the final values to make the checksum 0. However,
// if we required that the checksum was 0, it would be the case that appending a 0 to a valid
// list of values would result in a new valid list. For that reason, Bech32 requires the
// resulting checksum to be 1 instead.
return polymod(cat(bech32_expand_hrp(hrp), values)) == 1;
bool bech32_verify_checksum(const std::string &hrp, const bytes &values) {
// PolyMod computes what value to xor into the final values to make the checksum 0. However,
// if we required that the checksum was 0, it would be the case that appending a 0 to a valid
// list of values would result in a new valid list. For that reason, Bech32 requires the
// resulting checksum to be 1 instead.
return polymod(cat(bech32_expand_hrp(hrp), values)) == 1;
}
/** Encode a Bech32 string. */
std::string bech32_encode(const std::string& hrp, const bytes& values) {
std::string bech32_encode(const std::string &hrp, const bytes &values) {
bytes checksum = bech32_checksum(hrp, values);
bytes combined = cat(values, checksum);
std::string ret = hrp + '1';
@ -472,10 +469,10 @@ std::string bech32_encode(const std::string& hrp, const bytes& values) {
}
/** Decode a Bech32 string. */
bytes bech32_decode(const std::string& str) {
bytes bech32_decode(const std::string &str) {
if (str.size() > 90)
FC_THROW("Invalid bech32 string ${a}", ("a", str));
for (unsigned char c: str) {
for (unsigned char c : str) {
if (c < 33 || c > 126)
FC_THROW("Invalid bech32 string ${a}", ("a", str));
if (c >= 'A' && c <= 'Z')
@ -524,32 +521,28 @@ bool convertbits(bytes &out, const bytes &in) {
}
/** Encode a SegWit address. */
std::string segwit_addr_encode(const std::string& hrp, uint8_t witver, const bytes& witprog)
{
bytes enc;
enc.push_back(witver);
convertbits<8, 5, true>(enc, witprog);
std::string ret = bech32_encode(hrp, enc);
return ret;
std::string segwit_addr_encode(const std::string &hrp, uint8_t witver, const bytes &witprog) {
bytes enc;
enc.push_back(witver);
convertbits<8, 5, true>(enc, witprog);
std::string ret = bech32_encode(hrp, enc);
return ret;
}
/** Decode a SegWit address. */
bytes segwit_addr_decode(const std::string& addr)
{
bytes segwit_addr_decode(const std::string &addr) {
bytes dec = bech32_decode(addr);
if (dec.size() < 1)
FC_THROW("Invalid bech32 address ${a}", ("a", addr));
bytes conv;
if (!convertbits<5, 8, false>(conv, bytes(dec.begin() + 1, dec.end())) ||
conv.size() < 2 || conv.size() > 40 || dec[0] > 16 || (dec[0] == 0 &&
conv.size() != 20 && conv.size() != 32)) {
FC_THROW("Invalid bech32 address ${a}", ("a", addr));
}
return conv;
if (dec.size() < 1)
FC_THROW("Invalid bech32 address ${a}", ("a", addr));
bytes conv;
if (!convertbits<5, 8, false>(conv, bytes(dec.begin() + 1, dec.end())) ||
conv.size() < 2 || conv.size() > 40 || dec[0] > 16 || (dec[0] == 0 && conv.size() != 20 && conv.size() != 32)) {
FC_THROW("Invalid bech32 address ${a}", ("a", addr));
}
return conv;
}
std::string p2wsh_address_from_redeem_script(const bytes& script, bitcoin_network network)
{
std::string p2wsh_address_from_redeem_script(const bytes &script, bitcoin_network network) {
// calc script hash
fc::sha256 sh = fc::sha256::hash(reinterpret_cast<const char *>(&script[0]), script.size());
bytes wp(sh.data(), sh.data() + sh.data_size());
@ -766,19 +759,17 @@ bytes add_signatures_to_unsigned_tx(const bytes &unsigned_tx, const std::vector<
return ret;
}
std::string get_weighted_multisig_address(const std::vector<std::pair<std::string, uint64_t> > &public_keys)
{
std::string get_weighted_multisig_address(const std::vector<std::pair<std::string, uint64_t>> &public_keys) {
std::vector<std::pair<fc::ecc::public_key, uint64_t>> key_data;
for(auto p: public_keys)
for (auto p : public_keys)
key_data.push_back(std::make_pair(fc::ecc::public_key::from_base58(p.first), p.second));
bytes redeem_script = generate_redeem_script(key_data);
return p2wsh_address_from_redeem_script(redeem_script);
}
bytes get_weighted_multisig_redeem_script(std::vector<std::pair<std::string, uint64_t> > public_keys)
{
bytes get_weighted_multisig_redeem_script(std::vector<std::pair<std::string, uint64_t>> public_keys) {
std::vector<std::pair<fc::ecc::public_key, uint64_t>> key_data;
for(auto p: public_keys)
for (auto p : public_keys)
key_data.push_back(std::make_pair(fc::ecc::public_key::from_base58(p.first), p.second));
return generate_redeem_script(key_data);
}

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

@ -15,8 +15,8 @@ std::string p2wsh_address_from_redeem_script(const bytes &script, bitcoin_networ
bytes lock_script_for_redeem_script(const bytes &script);
bytes lock_script_from_pw_address(const std::string &address);
std::string get_weighted_multisig_address(const std::vector<std::pair<std::string, uint64_t>>& public_keys);
bytes get_weighted_multisig_redeem_script(std::vector<std::pair<std::string, uint64_t> > public_keys);
std::string get_weighted_multisig_address(const std::vector<std::pair<std::string, uint64_t>> &public_keys);
bytes get_weighted_multisig_redeem_script(std::vector<std::pair<std::string, uint64_t>> public_keys);
std::vector<bytes> signatures_for_raw_transaction(const bytes &unsigned_tx,
std::vector<uint64_t> in_amounts,
@ -78,12 +78,11 @@ struct btc_outpoint {
struct btc_in {
btc_in() = default;
btc_in(const btc_in&) = default;
btc_in(btc_in&&) = default;
btc_in& operator=(const btc_in&) = default;
btc_in(const btc_in &) = default;
btc_in(btc_in &&) = default;
btc_in &operator=(const btc_in &) = default;
btc_in(const std::string& txid, uint32_t out, uint32_t sequence = 0xffffffff)
{
btc_in(const std::string &txid, uint32_t out, uint32_t sequence = 0xffffffff) {
prevout.n = out;
prevout.hash = fc::uint256(txid);
// reverse hash due to the different from_hex algo in bitcoin
@ -102,14 +101,13 @@ struct btc_in {
struct btc_out {
btc_out() = default;
btc_out(const btc_out&) = default;
btc_out(btc_out&&) = default;
btc_out& operator=(const btc_out&) = default;
btc_out(const btc_out &) = default;
btc_out(btc_out &&) = default;
btc_out &operator=(const btc_out &) = default;
btc_out(const std::string& address, uint64_t amount) :
nValue(amount),
scriptPubKey(lock_script_from_pw_address(address))
{
btc_out(const std::string &address, uint64_t amount) :
nValue(amount),
scriptPubKey(lock_script_from_pw_address(address)) {
}
int64_t nValue;

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

@ -106,8 +106,8 @@ private:
std::string sign_transaction(const std::string &transaction) override;
std::string send_transaction(const std::string &transaction) override;
std::string sign_and_send_transaction_with_wallet(const std::string &tx_json);
std::string create_weighted_multisignature_wallet( const std::vector<std::pair<std::string, uint64_t>>& public_keys );
void transfer_all_btc(const std::string& from_address, const vector<son_info>& from_sons, const std::string& to_address);
std::string create_weighted_multisignature_wallet(const std::vector<std::pair<std::string, uint64_t>> &public_keys);
void transfer_all_btc(const std::string &from_address, const vector<son_info> &from_sons, 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 publish_btc_tx(const bitcoin_transaction_object &tx_object);

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

@ -13,8 +13,8 @@
#include <graphene/chain/sidechain_transaction_object.hpp>
#include <graphene/chain/son_wallet_object.hpp>
#include <graphene/chain/son_wallet_withdraw_object.hpp>
#include <graphene/peerplays_sidechain/sidechain_net_manager.hpp>
#include <graphene/peerplays_sidechain/bitcoin_utils.hpp>
#include <graphene/peerplays_sidechain/sidechain_net_manager.hpp>
#include <graphene/utilities/key_conversion.hpp>
namespace bpo = boost::program_options;
@ -352,7 +352,6 @@ void peerplays_sidechain_plugin_impl::son_processing() {
process_withdrawals();
complete_signing();
}
}

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

@ -1,5 +1,5 @@
#include <graphene/peerplays_sidechain/sidechain_net_handler_bitcoin.hpp>
#include <graphene/peerplays_sidechain/bitcoin_utils.hpp>
#include <graphene/peerplays_sidechain/sidechain_net_handler_bitcoin.hpp>
#include <algorithm>
#include <thread>
@ -14,8 +14,8 @@
#include <fc/network/ip.hpp>
#include <graphene/chain/account_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
#include <graphene/chain/proposal_object.hpp>
#include <graphene/chain/protocol/son_wallet.hpp>
#include <graphene/chain/sidechain_address_object.hpp>
#include <graphene/chain/sidechain_transaction_object.hpp>
#include <graphene/chain/son_info.hpp>
@ -553,7 +553,7 @@ void zmq_listener::handle_zmq() {
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()));
event_received(block_hash);
} catch (zmq::error_t& e) {
} catch (zmq::error_t &e) {
}
}
}
@ -624,13 +624,11 @@ void sidechain_net_handler_bitcoin::recreate_primary_wallet() {
auto active_sons = gpo.active_sons;
vector<pair<string, uint64_t>> son_pubkeys_bitcoin;
for ( const son_info& si : active_sons ) {
for (const son_info &si : active_sons) {
son_pubkeys_bitcoin.push_back(
make_pair(
make_pair(
si.sidechain_public_keys.at(sidechain_type::bitcoin),
si.total_votes
)
);
si.total_votes));
}
string address = create_weighted_multisignature_wallet(son_pubkeys_bitcoin);
@ -645,17 +643,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 ) );
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.proposed_ops.emplace_back(op_wrapper(op));
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);
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){
ilog("sidechain_net_handler: sending proposal for son wallet update operation failed with exception ${e}",("e", e.what()));
} catch (fc::exception e) {
ilog("sidechain_net_handler: sending proposal for son wallet update operation failed with exception ${e}", ("e", e.what()));
return;
}
@ -681,13 +679,12 @@ void sidechain_net_handler_bitcoin::process_withdrawal(const son_wallet_withdraw
static bool has_enough_signatures(const bitcoin_transaction_object &tx_object) {
// TODO: Verify with weights calculation
bool has_empty = false;
for(auto s: tx_object.signatures)
for (auto s : tx_object.signatures)
has_empty |= s.second.empty();
return !has_empty;
}
void sidechain_net_handler_bitcoin::process_signing()
{
void sidechain_net_handler_bitcoin::process_signing() {
const auto &idx = plugin.database().get_index_type<proposal_index>().indices().get<by_id>();
vector<proposal_id_type> proposals;
for (const auto &proposal : idx) {
@ -703,10 +700,9 @@ void sidechain_net_handler_bitcoin::process_signing()
auto it = tx_object.signatures.find(son_id);
if (it == tx_object.signatures.end())
continue;
if (it->second.empty())
{
if (it->second.empty()) {
bitcoin_transaction_sign_operation op;
son_object s_obj= plugin.get_son_object(son_id);
son_object s_obj = plugin.get_son_object(son_id);
op.payer = s_obj.son_account;
op.proposal_id = proposal.id;
fc::ecc::private_key k = plugin.get_private_key(son_id);
@ -715,10 +711,10 @@ void sidechain_net_handler_bitcoin::process_signing()
signed_transaction trx = plugin.database().create_signed_transaction(k, op);
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));
} catch(fc::exception e){
ilog("sidechain_net_handler: bitcoin transaction signing failed with exception ${e}",("e", e.what()));
} catch (fc::exception e) {
ilog("sidechain_net_handler: bitcoin transaction signing failed with exception ${e}", ("e", e.what()));
return;
}
}
@ -726,37 +722,36 @@ void sidechain_net_handler_bitcoin::process_signing()
}
}
void sidechain_net_handler_bitcoin::complete_signing()
{
void sidechain_net_handler_bitcoin::complete_signing() {
const auto &idx = plugin.database().get_index_type<bitcoin_transaction_index>().indices().get<by_processed>();
const auto &idx_range = idx.equal_range(false);
std::for_each(idx_range.first, idx_range.second,
[&](const bitcoin_transaction_object &tx_object) {
// check if all signatures collected
if (has_enough_signatures(tx_object)) {
publish_btc_tx(tx_object);
bitcoin_send_transaction_process_operation op;
op.payer = GRAPHENE_SON_ACCOUNT;
op.bitcoin_transaction_id = tx_object.id;
// check if all signatures collected
if (has_enough_signatures(tx_object)) {
publish_btc_tx(tx_object);
bitcoin_send_transaction_process_operation op;
op.payer = GRAPHENE_SON_ACCOUNT;
op.bitcoin_transaction_id = tx_object.id;
const chain::global_property_object& gpo = database.get_global_properties();
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 ) );
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 );
const chain::global_property_object &gpo = database.get_global_properties();
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));
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);
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())
plugin.app().p2p_node()->broadcast(net::trx_message(trx));
} catch(fc::exception e){
ilog("sidechain_net_handler_bitcoin: sending proposal for bitcoin send operation failed with exception ${e}",("e", e.what()));
return;
}
}
});
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())
plugin.app().p2p_node()->broadcast(net::trx_message(trx));
} catch (fc::exception e) {
ilog("sidechain_net_handler_bitcoin: sending proposal for bitcoin send operation failed with exception ${e}", ("e", e.what()));
return;
}
}
});
}
std::string sidechain_net_handler_bitcoin::create_multisignature_wallet(const std::vector<std::string> public_keys) {
@ -781,8 +776,7 @@ std::string sidechain_net_handler_bitcoin::send_transaction(const std::string &t
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) {
if (!wallet_password.empty()) {
bitcoin_client->walletpassphrase(wallet_password, 60);
}
@ -810,8 +804,7 @@ std::string sidechain_net_handler_bitcoin::sign_and_send_transaction_with_wallet
return reply_str;
}
void sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& from_address, const vector<son_info>& from_sons, const std::string& to_address)
{
void sidechain_net_handler_bitcoin::transfer_all_btc(const std::string &from_address, const vector<son_info> &from_sons, 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);
@ -820,16 +813,16 @@ void sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& from_add
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) {
wlog("Failed to find UTXOs to spend for ${pw}",("pw", from_address));
if (unspent_utxo.size() == 0) {
wlog("Failed to find UTXOs to spend for ${pw}", ("pw", from_address));
return;
} else {
for(const auto& utx: unspent_utxo) {
for (const auto &utx : unspent_utxo) {
total_amount += utx.amount_;
}
if(min_amount >= total_amount) {
wlog("Failed not enough BTC to transfer from ${fa}",("fa", from_address));
if (min_amount >= total_amount) {
wlog("Failed not enough BTC to transfer from ${fa}", ("fa", from_address));
return;
}
}
@ -839,24 +832,21 @@ void sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& from_add
tx.nVersion = 2;
tx.nLockTime = 0;
std::vector<uint64_t> amounts;
for(const auto& utx: unspent_utxo)
{
for (const auto &utx : unspent_utxo) {
tx.vin.push_back(btc_in(utx.txid_, utx.out_num_));
amounts.push_back(uint64_t(utx.amount_ * 100000000.0));
}
tx.vout.push_back(btc_out(to_address, uint64_t((total_amount - min_amount) * 100000000.0)));
std::vector<std::pair<fc::ecc::public_key, uint64_t> > key_data;
for(auto si: from_sons)
{
std::vector<std::pair<fc::ecc::public_key, uint64_t>> key_data;
for (auto si : from_sons) {
fc::ecc::public_key pk = si.signing_key;
key_data.push_back(std::make_pair(pk, si.total_votes));
}
std::sort(key_data.begin(), key_data.end(),
[](std::pair<fc::ecc::public_key, uint64_t> p1, std::pair<fc::ecc::public_key, uint64_t> p2){
return (p1.second > p2.second);
}
);
[](std::pair<fc::ecc::public_key, uint64_t> p1, std::pair<fc::ecc::public_key, uint64_t> p2) {
return (p1.second > p2.second);
});
bytes from_redeem_script = generate_redeem_script(key_data);
bitcoin_transaction_send_operation op;
@ -866,34 +856,30 @@ void sidechain_net_handler_bitcoin::transfer_all_btc(const std::string& from_add
tx.to_bytes(op.unsigned_tx);
// add signatures
std::set<son_id_type> plugin_sons = plugin.get_sons();
for(auto si: from_sons)
{
if (plugin_sons.find(si.son_id) != plugin_sons.end())
{
for (auto si : from_sons) {
if (plugin_sons.find(si.son_id) != plugin_sons.end()) {
fc::ecc::private_key k = plugin.get_private_key(si.son_id);
std::vector<bytes> signatures = signatures_for_raw_transaction(op.unsigned_tx, amounts, from_redeem_script, k);
op.signatures[si.son_id] = signatures;
}
else
{
} else {
op.signatures[si.son_id];
}
}
const chain::global_property_object& gpo = database.get_global_properties();
const chain::global_property_object &gpo = database.get_global_properties();
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 ) );
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.proposed_ops.emplace_back(op_wrapper(op));
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);
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){
ilog("sidechain_net_handler: sending proposal for son wallet update operation failed with exception ${e}",("e", e.what()));
} catch (fc::exception e) {
ilog("sidechain_net_handler: sending proposal for son wallet update operation failed with exception ${e}", ("e", e.what()));
return;
}
}
@ -926,7 +912,7 @@ std::string sidechain_net_handler_bitcoin::transfer_deposit_to_primary_wallet(co
bytes unsigned_tx;
tx.to_bytes(unsigned_tx);
std::string reply_str = fc::to_hex((char*)&unsigned_tx[0], unsigned_tx.size());
std::string reply_str = fc::to_hex((char *)&unsigned_tx[0], unsigned_tx.size());
return sign_and_send_transaction_with_wallet(reply_str);
}
@ -966,30 +952,26 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
tx.nLockTime = 0;
tx.hasWitness = true;
std::vector<uint64_t> amounts;
for(const auto& utxo: unspent_utxo)
{
for (const auto &utxo : unspent_utxo) {
tx.vin.push_back(btc_in(utxo.txid_, utxo.amount_));
amounts.push_back(uint64_t(utxo.amount_ * 100000000.0));
}
tx.vout.push_back(btc_out(swwo.withdraw_address, swwo.withdraw_amount.value));
if((total_amount - min_amount) > 0.0)
{
if ((total_amount - min_amount) > 0.0) {
tx.vout.push_back(btc_out(pw_address, (total_amount - min_amount) * 100000000.0));
}
auto from_sons = obj->sons;
std::vector<std::pair<fc::ecc::public_key, uint64_t> > key_data;
for(auto si: from_sons)
{
std::vector<std::pair<fc::ecc::public_key, uint64_t>> key_data;
for (auto si : from_sons) {
fc::ecc::public_key pk = si.signing_key;
key_data.push_back(std::make_pair(pk, si.total_votes));
}
std::sort(key_data.begin(), key_data.end(),
[](std::pair<fc::ecc::public_key, uint64_t> p1, std::pair<fc::ecc::public_key, uint64_t> p2){
return (p1.second > p2.second);
}
);
[](std::pair<fc::ecc::public_key, uint64_t> p1, std::pair<fc::ecc::public_key, uint64_t> p2) {
return (p1.second > p2.second);
});
bytes from_redeem_script = generate_redeem_script(key_data);
bitcoin_transaction_send_operation op;
@ -999,48 +981,44 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
tx.to_bytes(op.unsigned_tx);
// add signatures
std::set<son_id_type> plugin_sons = plugin.get_sons();
for(auto si: from_sons)
{
if (plugin_sons.find(si.son_id) != plugin_sons.end())
{
for (auto si : from_sons) {
if (plugin_sons.find(si.son_id) != plugin_sons.end()) {
fc::ecc::private_key k = plugin.get_private_key(si.son_id);
std::vector<bytes> signatures = signatures_for_raw_transaction(op.unsigned_tx, amounts, from_redeem_script, k);
op.signatures[si.son_id] = signatures;
}
else
{
} else {
op.signatures[si.son_id];
}
}
const chain::global_property_object& gpo = database.get_global_properties();
const chain::global_property_object &gpo = database.get_global_properties();
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 ) );
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.proposed_ops.emplace_back(op_wrapper(op));
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);
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){
ilog("sidechain_net_handler: sending proposal for son wallet update operation failed with exception ${e}",("e", e.what()));
} catch (fc::exception e) {
ilog("sidechain_net_handler: sending proposal for son wallet update operation failed with exception ${e}", ("e", e.what()));
return "";
}
return "";
}
void sidechain_net_handler_bitcoin::publish_btc_tx(const bitcoin_transaction_object &tx_object)
{
void sidechain_net_handler_bitcoin::publish_btc_tx(const bitcoin_transaction_object &tx_object) {
std::vector<std::vector<bytes>> signatures;
signatures.resize(tx_object.signatures.size());
std::transform(tx_object.signatures.begin(), tx_object.signatures.end(),
signatures.begin(), [](const std::pair<son_id_type, std::vector<bytes>>& p) { return p.second; }
);
signatures.begin(), [](const std::pair<son_id_type, std::vector<bytes>> &p) {
return p.second;
});
bytes signed_tx = add_signatures_to_unsigned_tx(tx_object.unsigned_tx, signatures, tx_object.redeem_script);
bitcoin_client->sendrawtransaction(fc::to_hex((const char*)&signed_tx[0], signed_tx.size()));
bitcoin_client->sendrawtransaction(fc::to_hex((const char *)&signed_tx[0], signed_tx.size()));
}
void sidechain_net_handler_bitcoin::handle_event(const std::string &event_data) {