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 committed by gladcow
parent 3c5a985f92
commit e28a19a9d3
5 changed files with 152 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -384,8 +384,7 @@ const int8_t charset_rev[128] = {
-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, 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,8 +421,7 @@ uint32_t polymod(const bytes &values) {
}
/** Expand a HRP for use in checksum computation. */
bytes bech32_expand_hrp(const std::string& hrp)
{
bytes bech32_expand_hrp(const std::string &hrp) {
bytes ret;
ret.reserve(hrp.size() + 90);
ret.resize(hrp.size() * 2 + 1);
@ -450,8 +448,7 @@ bytes bech32_checksum(const std::string &hrp, const bytes &values) {
}
/** Verify a checksum. */
bool bech32_verify_checksum(const std::string& hrp, const bytes& values)
{
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
@ -524,8 +521,7 @@ 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)
{
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);
@ -534,22 +530,19 @@ std::string segwit_addr_encode(const std::string& hrp, uint8_t witver, const byt
}
/** 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)) {
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,8 +759,7 @@ 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)
key_data.push_back(std::make_pair(fc::ecc::public_key::from_base58(p.first), p.second));
@ -775,8 +767,7 @@ std::string get_weighted_multisig_address(const std::vector<std::pair<std::strin
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)
key_data.push_back(std::make_pair(fc::ecc::public_key::from_base58(p.first), p.second));

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

@ -82,8 +82,7 @@ struct btc_in {
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
@ -108,8 +107,7 @@ struct btc_out {
btc_out(const std::string &address, uint64_t amount) :
nValue(amount),
scriptPubKey(lock_script_from_pw_address(address))
{
scriptPubKey(lock_script_from_pw_address(address)) {
}
int64_t nValue;

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();
}
}

72
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>
@ -628,9 +628,7 @@ void sidechain_net_handler_bitcoin::recreate_primary_wallet() {
son_pubkeys_bitcoin.push_back(
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);
@ -686,8 +684,7 @@ static bool has_enough_signatures(const bitcoin_transaction_object &tx_object) {
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,8 +700,7 @@ 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);
op.payer = s_obj.son_account;
@ -726,8 +722,7 @@ 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,
@ -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);
@ -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)
{
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);
}
);
});
bytes from_redeem_script = generate_redeem_script(key_data);
bitcoin_transaction_send_operation op;
@ -866,16 +856,12 @@ 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];
}
}
@ -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)
{
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);
}
);
});
bytes from_redeem_script = generate_redeem_script(key_data);
bitcoin_transaction_send_operation op;
@ -999,16 +981,12 @@ 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];
}
}
@ -1032,13 +1010,13 @@ std::string sidechain_net_handler_bitcoin::transfer_withdrawal_from_primary_wall
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()));
}