Charon/blockchain
1
0
Fork 0
forked from lthn/blockchain
Code Pull requests Activity

Merge branch 'flags' into develop

Browse source
This commit is contained in:
cryptozoidberg 2020-09-01 16:08:23 +02:00
commit 578356b104
No known key found for this signature in database
GPG key ID: 22DEB97A54C6FDEC
13 changed files with 134 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/currency_core/currency_basic.h
View file

@ -508,7 +508,7 @@ namespace currency
END_SERIALIZE()
};
struct etc_tx_uint16_t
struct etc_tx_flags16_t
{
uint16_t v;
BEGIN_SERIALIZE()
@ -518,7 +518,7 @@ namespace currency
typedef boost::mpl::vector21<
tx_service_attachment, tx_comment, tx_payer_old, tx_receiver_old, tx_derivation_hint, std::string, tx_crypto_checksum, etc_tx_time, etc_tx_details_unlock_time, etc_tx_details_expiration_time,
etc_tx_details_flags, crypto::public_key, extra_attachment_info, extra_alias_entry_old, extra_user_data, extra_padding, etc_tx_uint16_t, etc_tx_details_unlock_time2,
etc_tx_details_flags, crypto::public_key, extra_attachment_info, extra_alias_entry_old, extra_user_data, extra_padding, etc_tx_flags16_t, etc_tx_details_unlock_time2,
tx_payer, tx_receiver, extra_alias_entry
> all_payload_types;
@ -749,7 +749,7 @@ SET_VARIANT_TAGS(currency::extra_user_data, 19, "user_data");
SET_VARIANT_TAGS(currency::extra_alias_entry_old, 20, "alias_entry");
SET_VARIANT_TAGS(currency::extra_padding, 21, "extra_padding");
SET_VARIANT_TAGS(crypto::public_key, 22, "pub_key");
SET_VARIANT_TAGS(currency::etc_tx_uint16_t, 23, "etc_tx_uint16");
SET_VARIANT_TAGS(currency::etc_tx_flags16_t, 23, "etc_tx_flags16");
SET_VARIANT_TAGS(uint16_t, 24, "derive_xor");
//txout_v
SET_VARIANT_TAGS(currency::ref_by_id, 25, "ref_by_id");

2
src/currency_core/currency_boost_serialization.h
View file

@ -252,7 +252,7 @@ namespace boost
}
template <class Archive>
inline void serialize(Archive &a, currency::etc_tx_uint16_t&at, const boost::serialization::version_type ver)
inline void serialize(Archive &a, currency::etc_tx_flags16_t&at, const boost::serialization::version_type ver)
{
a & at.v;
}

2
src/currency_core/currency_config.h
View file

@ -221,7 +221,7 @@
#define BC_OFFERS_CURRENCY_MARKET_FILENAME "market.bin"
#define WALLET_FILE_SERIALIZATION_VERSION (CURRENCY_FORMATION_VERSION+67)
#define WALLET_FILE_SERIALIZATION_VERSION (CURRENCY_FORMATION_VERSION+68)
#define CURRENT_MEMPOOL_ARCHIVE_VER (CURRENCY_FORMATION_VERSION+31)

35
src/currency_core/currency_format_utils.cpp
View file

@ -710,6 +710,16 @@ namespace currency
crypto::chacha_crypt(m.acc_addr, m_key);
m_was_crypted_entries = true;
}
void operator()(tx_payer_old& pr)
{
crypto::chacha_crypt(pr.acc_addr, m_key);
m_was_crypted_entries = true;
}
void operator()(tx_receiver_old& m)
{
crypto::chacha_crypt(m.acc_addr, m_key);
m_was_crypted_entries = true;
}
void operator()(tx_service_attachment& sa)
{
if (sa.flags&TX_SERVICE_ATTACHMENT_DEFLATE_BODY)
@ -772,7 +782,18 @@ namespace currency
crypto::chacha_crypt(receiver_local.acc_addr, rkey);
rdecrypted_att.push_back(receiver_local);
}
void operator()(const tx_payer_old& pr)
{
tx_payer_old payer_local = pr;
crypto::chacha_crypt(payer_local.acc_addr, rkey);
rdecrypted_att.push_back(payer_local);
}
void operator()(const tx_receiver_old& pr)
{
tx_receiver_old receiver_local = pr;
crypto::chacha_crypt(receiver_local.acc_addr, rkey);
rdecrypted_att.push_back(receiver_local);
}
template<typename attachment_t>
void operator()(const attachment_t& att)
{
@ -1049,6 +1070,11 @@ namespace currency
add_tx_pub_key_to_extra(tx, txkey.pub);
one_time_secret_key = txkey.sec;
//add flags
etc_tx_flags16_t e = AUTO_VAL_INIT(e);
//todo: add some flags here
update_or_add_field_to_extra(tx.extra, e);
//include offers if need
tx.attachment = attachments;
encrypt_attachments(tx, sender_account_keys, crypt_destination_addr, txkey);
@ -2316,18 +2342,15 @@ namespace currency
return true;
}
bool operator()(const etc_tx_uint16_t& dh)
bool operator()(const etc_tx_flags16_t& dh)
{
tv.type = "XOR";
tv.type = "FLAGS16";
tv.short_view = epee::string_tools::pod_to_hex(dh);
tv.datails_view = epee::string_tools::pod_to_hex(dh);
return true;
}
};
//------------------------------------------------------------------
template<class t_container>
bool fill_tx_rpc_payload_items(std::vector<tx_extra_rpc_entry>& target_vector, const t_container& tc)

21
src/currency_core/currency_format_utils.h
View file

@ -433,8 +433,7 @@ namespace currency
ai.m_alias = ard.alias;
return true;
}
//---------------------------------------------------------------
template<class extra_t>
extra_t& get_or_add_field_to_extra(std::vector<extra_v>& extra)
{
@ -446,6 +445,7 @@ namespace currency
extra.push_back(extra_t());
return boost::get<extra_t>(extra.back());
}
//---------------------------------------------------------------
template<class variant_t, class variant_type_t>
void update_or_add_field_to_extra(std::vector<variant_t>& variant_container, const variant_type_t& v)
{
@ -459,7 +459,22 @@ namespace currency
}
variant_container.push_back(v);
}
//---------------------------------------------------------------
template<class variant_type_t, class variant_t>
void remove_field_of_type_from_extra(std::vector<variant_t>& variant_container)
{
for (size_t i = 0; i != variant_container.size();)
{
if (variant_container[i].type() == typeid(variant_type_t))
{
variant_container.erase(variant_container.begin()+i);
}
else
{
i++;
}
}
}
//---------------------------------------------------------------
template<typename t_container>
bool get_payment_id_from_tx(const t_container& att, std::string& payment_id)

4
src/gui/qt-daemon/application/mainwindow.cpp
View file

@ -1651,7 +1651,7 @@ QString MainWindow::open_wallet(const QString& param)
//return que_call2<view::open_wallet_request>("open_wallet", param, [this](const view::open_wallet_request& owd, view::api_response& ar){
PREPARE_ARG_FROM_JSON(view::open_wallet_request, owd);
PREPARE_RESPONSE(view::open_wallet_response, ar);
ar.error_code = m_backend.open_wallet(epee::string_encoding::utf8_to_wstring(owd.path), owd.pass, owd.txs_to_return, ar.response_data);
ar.error_code = m_backend.open_wallet(epee::string_encoding::utf8_to_wstring(owd.path), owd.pass, owd.txs_to_return, ar.response_data, owd.exclude_mining_txs);
return MAKE_RESPONSE(ar);
CATCH_ENTRY_FAIL_API_RESPONCE();
}
@ -1795,7 +1795,7 @@ QString MainWindow::get_recent_transfers(const QString& param)
LOG_API_TIMING();
PREPARE_ARG_FROM_JSON(view::get_recent_transfers_request, a);
PREPARE_RESPONSE(view::transfers_array, ar);
ar.error_code = m_backend.get_recent_transfers(a.wallet_id, a.offset, a.count, ar.response_data);
ar.error_code = m_backend.get_recent_transfers(a.wallet_id, a.offset, a.count, ar.response_data, a.exclude_mining_txs);
return MAKE_RESPONSE(ar);
CATCH_ENTRY_FAIL_API_RESPONCE();
}

5
src/wallet/view_iface.h
View file

@ -371,11 +371,13 @@ public:
std::vector<tools::wallet_public::wallet_transfer_info> unconfirmed;
std::vector<tools::wallet_public::wallet_transfer_info> history;
uint64_t total_history_items;
uint64_t last_item_index;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(unconfirmed)
KV_SERIALIZE(history)
KV_SERIALIZE(total_history_items)
KV_SERIALIZE(last_item_index)
END_KV_SERIALIZE_MAP()
};
@ -385,11 +387,13 @@ public:
std::string pass;
std::string path;
uint64_t txs_to_return;
bool exclude_mining_txs;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(pass)
KV_SERIALIZE(path)
KV_SERIALIZE(txs_to_return)
KV_SERIALIZE(exclude_mining_txs)
END_KV_SERIALIZE_MAP()
};
@ -398,6 +402,7 @@ public:
uint64_t wallet_id;
uint64_t offset;
uint64_t count;
bool exclude_mining_txs;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(wallet_id)

64
src/wallet/wallet2.cpp
View file

@ -1184,6 +1184,15 @@ void wallet2::prepare_wti(wallet_public::wallet_transfer_info& wti, uint64_t hei
decrypt_payload_items(decrypt_attachment_as_income, tx, m_account.get_keys(), decrypted_att);
if ((is_watch_only() && !wti.is_income)|| (height > 638000 && !have_type_in_variant_container<etc_tx_flags16_t>(decrypted_att)))
{
remove_field_of_type_from_extra<tx_receiver_old>(decrypted_att);
remove_field_of_type_from_extra<tx_payer_old>(decrypted_att);
}
if (is_watch_only() && !wti.is_income)
{
remove_field_of_type_from_extra<tx_comment>(decrypted_att);
}
prepare_wti_decrypted_attachments(wti, decrypted_att);
process_contract_info(wti, decrypted_att);
}
@ -2890,17 +2899,27 @@ uint64_t wallet2::get_transfer_entries_count()
return m_transfers.size();
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_recent_transfers_history(std::vector<wallet_public::wallet_transfer_info>& trs, size_t offset, size_t count, uint64_t& total)
void wallet2::get_recent_transfers_history(std::vector<wallet_public::wallet_transfer_info>& trs, size_t offset, size_t count, uint64_t& total, uint64_t& last_item_index, bool exclude_mining_txs)
{
if (offset >= m_transfer_history.size())
if (!count || offset >= m_transfer_history.size())
return;
auto start = m_transfer_history.rbegin() + offset;
auto stop = m_transfer_history.size() - offset >= count ? start + count : m_transfer_history.rend();
if (!count)
stop = m_transfer_history.rend();
trs.insert(trs.end(), start, stop);
for (auto it = m_transfer_history.rbegin() + offset; it != m_transfer_history.rend(); it++)
{
if (exclude_mining_txs)
{
if(it->is_mining)
continue;
}
trs.push_back(*it);
last_item_index = it - m_transfer_history.rbegin();
if (trs.size() >= count)
{
break;
}
}
total = m_transfer_history.size();
}
//----------------------------------------------------------------------------------------------------
@ -3223,10 +3242,16 @@ bool wallet2::build_minted_block(const currency::COMMAND_RPC_SCAN_POS::request&
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_unconfirmed_transfers(std::vector<wallet_public::wallet_transfer_info>& trs)
void wallet2::get_unconfirmed_transfers(std::vector<wallet_public::wallet_transfer_info>& trs, bool exclude_mining_txs)
{
for (auto& u : m_unconfirmed_txs)
{
if (exclude_mining_txs && u.second.is_mining)
{
continue;
}
trs.push_back(u.second);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_core_runtime_config(const currency::core_runtime_config& pc)
@ -4163,8 +4188,8 @@ bool wallet2::extract_offers_from_transfer_entry(size_t i, std::unordered_map<cr
auto it = offers_local.find(h);
if (it == offers_local.end())
{
WLT_LOG_L3("Unable to find original tx record " << h << " in cancel offer " << h);
break;
WLT_LOG_L3("Unable to find original tx record " << h << " in cancel offer " << h);
break;
}
offers_local.erase(it);
@ -4220,7 +4245,7 @@ uint64_t wallet2::select_indices_for_transfer(std::vector<uint64_t>& selected_in
WLT_LOG_GREEN("Selecting indices for transfer of " << print_money_brief(needed_money) << " with " << fake_outputs_count << " fake outs, found_free_amounts.size()=" << found_free_amounts.size() << "...", LOG_LEVEL_0);
uint64_t found_money = 0;
std::string selected_amounts_str;
while(found_money < needed_money && found_free_amounts.size())
while (found_money < needed_money && found_free_amounts.size())
{
auto it = found_free_amounts.lower_bound(needed_money - found_money);
if (!(it != found_free_amounts.end() && it->second.size()))
@ -4253,6 +4278,23 @@ bool wallet2::is_transfer_ready_to_go(const transfer_details& td, uint64_t fake_
return false;
}
//----------------------------------------------------------------------------------------------------
void wallet2::wipeout_extra_if_needed(std::vector<wallet_public::wallet_transfer_info>& transfer_history)
{
WLT_LOG_L0("Processing [wipeout_extra_if_needed]...");
for (auto it = transfer_history.begin(); it != transfer_history.end(); )
{
if (it->height > 638000)
{
it->remote_addresses.clear();
if (is_watch_only() && !it->is_income)
{
it->comment.clear();
}
}
}
WLT_LOG_L0("Processing [wipeout_extra_if_needed] DONE");
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_transfer_able_to_go(const transfer_details& td, uint64_t fake_outputs_count)
{
if (!td.is_spendable())

10
src/wallet/wallet2.h
View file

@ -482,10 +482,10 @@ namespace tools
currency::account_base& get_account() { return m_account; }
const currency::account_base& get_account() const { return m_account; }
void get_recent_transfers_history(std::vector<wallet_public::wallet_transfer_info>& trs, size_t offset, size_t count, uint64_t& total);
void get_recent_transfers_history(std::vector<wallet_public::wallet_transfer_info>& trs, size_t offset, size_t count, uint64_t& total, uint64_t& last_item_index, bool exclude_mining_txs = false);
uint64_t get_recent_transfers_total_count();
uint64_t get_transfer_entries_count();
void get_unconfirmed_transfers(std::vector<wallet_public::wallet_transfer_info>& trs);
void get_unconfirmed_transfers(std::vector<wallet_public::wallet_transfer_info>& trs, bool exclude_mining_txs = false);
void init(const std::string& daemon_address = "http://localhost:8080");
bool deinit();
@ -730,8 +730,14 @@ namespace tools
a & m_tx_keys;
a & m_last_pow_block_h;
//after processing
if (ver < 152)
{
wipeout_extra_if_needed(m_transfer_history);
}
}
void wipeout_extra_if_needed(std::vector<wallet_public::wallet_transfer_info>& transfer_history);
bool is_transfer_ready_to_go(const transfer_details& td, uint64_t fake_outputs_count);
bool is_transfer_able_to_go(const transfer_details& td, uint64_t fake_outputs_count);
uint64_t select_indices_for_transfer(std::vector<uint64_t>& ind, free_amounts_cache_type& found_free_amounts, uint64_t needed_money, uint64_t fake_outputs_count);

4
src/wallet/wallet_public_structs_defs.h
View file

@ -275,11 +275,13 @@ namespace wallet_public
of GET_RECENT_TXS_AND_INFO with offsets)
*/
bool update_provision_info;
bool exclude_mining_txs;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(offset)
KV_SERIALIZE(count)
KV_SERIALIZE(update_provision_info)
KV_SERIALIZE(exclude_mining_txs)
END_KV_SERIALIZE_MAP()
};
@ -288,11 +290,13 @@ namespace wallet_public
wallet_provision_info pi;
std::vector<wallet_transfer_info> transfers;
uint64_t total_transfers;
uint64_t last_item_index;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(pi)
KV_SERIALIZE(transfers)
KV_SERIALIZE(total_transfers)
KV_SERIALIZE(last_item_index)
END_KV_SERIALIZE_MAP()
};
};

4
src/wallet/wallet_rpc_server.cpp
View file

@ -223,9 +223,9 @@ namespace tools
}
if (req.offset == 0)
m_wallet.get_unconfirmed_transfers(res.transfers);
m_wallet.get_unconfirmed_transfers(res.transfers, req.exclude_mining_txs);
m_wallet.get_recent_transfers_history(res.transfers, req.offset, req.count, res.total_transfers);
m_wallet.get_recent_transfers_history(res.transfers, req.offset, req.count, res.total_transfers, res.last_item_index, req.exclude_mining_txs);
return true;
}

12
src/wallet/wallets_manager.cpp
View file

@ -815,7 +815,7 @@ std::string wallets_manager::get_my_offers(const bc_services::core_offers_filter
#endif
}
std::string wallets_manager::open_wallet(const std::wstring& path, const std::string& password, uint64_t txs_to_return, view::open_wallet_response& owr)
std::string wallets_manager::open_wallet(const std::wstring& path, const std::string& password, uint64_t txs_to_return, view::open_wallet_response& owr, bool exclude_mining_txs)
{
// check if that file already opened
SHARED_CRITICAL_REGION_BEGIN(m_wallets_lock);
@ -854,9 +854,9 @@ std::string wallets_manager::open_wallet(const std::wstring& path, const std::st
if (w->is_watch_only() && !w->is_auditable())
return API_RETURN_CODE_WALLET_WATCH_ONLY_NOT_SUPPORTED;
w->get_recent_transfers_history(owr.recent_history.history, 0, txs_to_return, owr.recent_history.total_history_items);
w->get_recent_transfers_history(owr.recent_history.history, 0, txs_to_return, owr.recent_history.total_history_items, owr.recent_history.last_item_index, exclude_mining_txs);
//w->get_unconfirmed_transfers(owr.recent_history.unconfirmed);
w->get_unconfirmed_transfers(owr.recent_history.history);
w->get_unconfirmed_transfers(owr.recent_history.history, exclude_mining_txs);
owr.wallet_local_bc_size = w->get_blockchain_current_size();
//workaround for missed fee
owr.seed = w->get_account().get_seed_phrase();
@ -912,7 +912,7 @@ bool wallets_manager::get_opened_wallets(std::list<view::open_wallet_response>&
return true;
}
std::string wallets_manager::get_recent_transfers(size_t wallet_id, uint64_t offset, uint64_t count, view::transfers_array& tr_hist)
std::string wallets_manager::get_recent_transfers(size_t wallet_id, uint64_t offset, uint64_t count, view::transfers_array& tr_hist, bool exclude_mining_txs)
{
GET_WALLET_BY_ID(wallet_id, w);
auto wallet_locked = w.try_lock();
@ -921,8 +921,8 @@ std::string wallets_manager::get_recent_transfers(size_t wallet_id, uint64_t off
return API_RETURN_CODE_CORE_BUSY;
}
w->get()->get_unconfirmed_transfers(tr_hist.unconfirmed);
w->get()->get_recent_transfers_history(tr_hist.history, offset, count, tr_hist.total_history_items);
w->get()->get_unconfirmed_transfers(tr_hist.unconfirmed, exclude_mining_txs);
w->get()->get_recent_transfers_history(tr_hist.history, offset, count, tr_hist.total_history_items, tr_hist.last_item_index, exclude_mining_txs);
auto fix_tx = [](tools::wallet_public::wallet_transfer_info& wti) -> void {
wti.show_sender = currency::is_showing_sender_addres(wti.tx);

4
src/wallet/wallets_manager.h
View file

@ -97,13 +97,13 @@ public:
bool quick_clear_wallets_no_save();
bool send_stop_signal();
bool get_opened_wallets(std::list<view::open_wallet_response>& result);
std::string open_wallet(const std::wstring& path, const std::string& password, uint64_t txs_to_return, view::open_wallet_response& owr);
std::string open_wallet(const std::wstring& path, const std::string& password, uint64_t txs_to_return, view::open_wallet_response& owr, bool exclude_mining_txs = false);
std::string generate_wallet(const std::wstring& path, const std::string& password, view::open_wallet_response& owr);
std::string restore_wallet(const std::wstring& path, const std::string& password, const std::string& restore_key, view::open_wallet_response& owr);
std::string invoke(uint64_t wallet_id, std::string params);
std::string get_wallet_status(uint64_t wallet_id);
std::string run_wallet(uint64_t wallet_id);
std::string get_recent_transfers(size_t wallet_id, uint64_t offset, uint64_t count, view::transfers_array& tr_hist);
std::string get_recent_transfers(size_t wallet_id, uint64_t offset, uint64_t count, view::transfers_array& tr_hist, bool exclude_mining_txs = false);
std::string get_wallet_info(size_t wallet_id, view::wallet_info& wi);
std::string get_contracts(size_t wallet_id, std::vector<tools::wallet_public::escrow_contract_details>& contracts);
std::string create_proposal(const view::create_proposal_param_gui& cpp);