monero-project/monero
monero-project/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-12-22 19:49:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

replace 'multisig()' with 'get_multisig_status()' using multisig_account_status and including '.kex_is_done' member

Browse source
This commit is contained in:
koe 2021-08-11 07:35:43 -05:00
parent c5d10a4ac4
commit 8d94d08816
11 changed files with 197 additions and 154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
src/gen_multisig/gen_multisig.cpp
View file

@ -121,16 +121,15 @@ static bool generate_multisig(uint32_t threshold, uint32_t total, const std::str
}
// exchange keys until the wallets are done
bool ready{false};
wallets[0]->multisig(&ready);
while (!ready)
multisig::multisig_account_status ms_status{wallets[0]->get_multisig_status()};
while (!ms_status.is_ready)
{
for (size_t n = 0; n < total; ++n)
{
kex_msgs_intermediate[n] = wallets[n]->exchange_multisig_keys(pwd_container->password(), kex_msgs_intermediate);
}
wallets[0]->multisig(&ready);
ms_status = wallets[0]->get_multisig_status();
}
std::string address = wallets[0]->get_account().get_public_address_str(wallets[0]->nettype());

13
src/multisig/multisig_account.h
View file

@ -40,6 +40,19 @@
namespace multisig
{
struct multisig_account_status
{
// is the multisig account active/initialized?
bool multisig_is_active{false};
// has the multisig account completed the main key exchange rounds?
bool kex_is_done{false};
// is the multisig account ready to use?
bool is_ready{false};
// multisig is: M-of-N
std::uint32_t threshold{0}; // M
std::uint32_t total{0}; // N
};
/**
* multisig account:
*

137
src/simplewallet/simplewallet.cpp
View file

@ -786,7 +786,6 @@ bool simple_wallet::print_seed(bool encrypted)
{
bool success = false;
epee::wipeable_string seed;
bool ready, multisig;
if (m_wallet->key_on_device())
{
@ -799,10 +798,10 @@ bool simple_wallet::print_seed(bool encrypted)
return true;
}
multisig = m_wallet->multisig(&ready);
if (multisig)
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (ms_status.multisig_is_active)
{
if (!ready)
if (!ms_status.is_ready)
{
fail_msg_writer() << tr("wallet is multisig but not yet finalized");
return true;
@ -811,7 +810,7 @@ bool simple_wallet::print_seed(bool encrypted)
SCOPED_WALLET_UNLOCK();
if (!multisig && !m_wallet->is_deterministic())
if (!ms_status.multisig_is_active && !m_wallet->is_deterministic())
{
fail_msg_writer() << tr("wallet is non-deterministic and has no seed");
return true;
@ -826,7 +825,7 @@ bool simple_wallet::print_seed(bool encrypted)
seed_pass = pwd_container->password();
}
if (multisig)
if (ms_status.multisig_is_active)
success = m_wallet->get_multisig_seed(seed, seed_pass);
else if (m_wallet->is_deterministic())
success = m_wallet->get_seed(seed, seed_pass);
@ -865,7 +864,7 @@ bool simple_wallet::seed_set_language(const std::vector<std::string> &args/* = s
fail_msg_writer() << tr("command not supported by HW wallet");
return true;
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("wallet is multisig and has no seed");
return true;
@ -1011,7 +1010,7 @@ bool simple_wallet::prepare_multisig_main(const std::vector<std::string> &args,
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("This wallet is already multisig");
return false;
@ -1058,7 +1057,7 @@ bool simple_wallet::make_multisig_main(const std::vector<std::string> &args, boo
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("This wallet is already multisig");
return false;
@ -1103,9 +1102,7 @@ bool simple_wallet::make_multisig_main(const std::vector<std::string> &args, boo
auto local_args = args;
local_args.erase(local_args.begin());
std::string multisig_extra_info = m_wallet->make_multisig(orig_pwd_container->password(), local_args, threshold);
bool ready;
m_wallet->multisig(&ready);
if (!ready)
if (!m_wallet->get_multisig_status().is_ready)
{
success_msg_writer() << tr("Another step is needed");
success_msg_writer() << multisig_extra_info;
@ -1123,13 +1120,13 @@ bool simple_wallet::make_multisig_main(const std::vector<std::string> &args, boo
return false;
}
uint32_t total;
if (!m_wallet->multisig(NULL, &threshold, &total))
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("Error creating multisig: new wallet is not multisig");
return false;
}
success_msg_writer() << std::to_string(threshold) << "/" << total << tr(" multisig address: ")
success_msg_writer() << std::to_string(ms_status.threshold) << "/" << ms_status.total << tr(" multisig address: ")
<< m_wallet->get_account().get_public_address_str(m_wallet->nettype());
return true;
@ -1155,18 +1152,18 @@ bool simple_wallet::exchange_multisig_keys_main(const std::vector<std::string> &
const bool force_update_use_with_caution,
const bool called_by_mms) {
CHECK_MULTISIG_ENABLED();
bool ready;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (m_wallet->key_on_device())
{
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if (!m_wallet->multisig(&ready))
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("This wallet is not multisig");
return false;
}
if (ready)
if (ms_status.is_ready)
{
fail_msg_writer() << tr("This wallet is already finalized");
return false;
@ -1182,9 +1179,7 @@ bool simple_wallet::exchange_multisig_keys_main(const std::vector<std::string> &
try
{
std::string multisig_extra_info = m_wallet->exchange_multisig_keys(orig_pwd_container->password(), args, force_update_use_with_caution);
bool ready;
m_wallet->multisig(&ready);
if (!ready)
if (!m_wallet->get_multisig_status().is_ready)
{
message_writer() << tr("Another step is needed");
message_writer() << multisig_extra_info;
@ -1195,9 +1190,8 @@ bool simple_wallet::exchange_multisig_keys_main(const std::vector<std::string> &
}
return true;
} else {
uint32_t threshold, total;
m_wallet->multisig(NULL, &threshold, &total);
success_msg_writer() << tr("Multisig wallet has been successfully created. Current wallet type: ") << threshold << "/" << total;
const multisig::multisig_account_status ms_status_new{m_wallet->get_multisig_status()};
success_msg_writer() << tr("Multisig wallet has been successfully created. Current wallet type: ") << ms_status_new.threshold << "/" << ms_status_new.total;
success_msg_writer() << tr("Multisig address: ") << m_wallet->get_account().get_public_address_str(m_wallet->nettype());
}
}
@ -1220,18 +1214,18 @@ bool simple_wallet::export_multisig(const std::vector<std::string> &args)
bool simple_wallet::export_multisig_main(const std::vector<std::string> &args, bool called_by_mms)
{
CHECK_MULTISIG_ENABLED();
bool ready;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (m_wallet->key_on_device())
{
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if (!m_wallet->multisig(&ready))
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("This wallet is not multisig");
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
fail_msg_writer() << tr("This multisig wallet is not yet finalized");
return false;
@ -1287,24 +1281,24 @@ bool simple_wallet::import_multisig(const std::vector<std::string> &args)
bool simple_wallet::import_multisig_main(const std::vector<std::string> &args, bool called_by_mms)
{
CHECK_MULTISIG_ENABLED();
bool ready;
uint32_t threshold, total;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (m_wallet->key_on_device())
{
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if (!m_wallet->multisig(&ready, &threshold, &total))
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("This wallet is not multisig");
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
fail_msg_writer() << tr("This multisig wallet is not yet finalized");
return false;
}
if (args.size() < threshold - 1)
if (args.size() + 1 < ms_status.threshold)
{
PRINT_USAGE(USAGE_IMPORT_MULTISIG_INFO);
return false;
@ -1384,18 +1378,19 @@ bool simple_wallet::sign_multisig(const std::vector<std::string> &args)
bool simple_wallet::sign_multisig_main(const std::vector<std::string> &args, bool called_by_mms)
{
CHECK_MULTISIG_ENABLED();
bool ready;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};\
if (m_wallet->key_on_device())
{
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if(!m_wallet->multisig(&ready))
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("This is not a multisig wallet");
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
fail_msg_writer() << tr("This multisig wallet is not yet finalized");
return false;
@ -1469,9 +1464,7 @@ bool simple_wallet::sign_multisig_main(const std::vector<std::string> &args, boo
if (txids.empty())
{
uint32_t threshold;
m_wallet->multisig(NULL, &threshold);
uint32_t signers_needed = threshold - signers - 1;
uint32_t signers_needed = ms_status.threshold - signers - 1;
success_msg_writer(true) << tr("Transaction successfully signed to file ") << filename << ", "
<< signers_needed << " more signer(s) needed";
return true;
@ -1501,19 +1494,19 @@ bool simple_wallet::submit_multisig(const std::vector<std::string> &args)
bool simple_wallet::submit_multisig_main(const std::vector<std::string> &args, bool called_by_mms)
{
CHECK_MULTISIG_ENABLED();
bool ready;
uint32_t threshold;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (m_wallet->key_on_device())
{
fail_msg_writer() << tr("command not supported by HW wallet");
return false;
}
if (!m_wallet->multisig(&ready, &threshold))
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("This is not a multisig wallet");
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
fail_msg_writer() << tr("This multisig wallet is not yet finalized");
return false;
@ -1551,10 +1544,10 @@ bool simple_wallet::submit_multisig_main(const std::vector<std::string> &args, b
return false;
}
}
if (txs.m_signers.size() < threshold)
if (txs.m_signers.size() < ms_status.threshold)
{
fail_msg_writer() << (boost::format(tr("Multisig transaction signed by only %u signers, needs %u more signatures"))
% txs.m_signers.size() % (threshold - txs.m_signers.size())).str();
% txs.m_signers.size() % (ms_status.threshold - txs.m_signers.size())).str();
return false;
}
@ -1583,19 +1576,19 @@ bool simple_wallet::submit_multisig_main(const std::vector<std::string> &args, b
bool simple_wallet::export_raw_multisig(const std::vector<std::string> &args)
{
CHECK_MULTISIG_ENABLED();
bool ready;
uint32_t threshold;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (m_wallet->key_on_device())
{
fail_msg_writer() << tr("command not supported by HW wallet");
return true;
}
if (!m_wallet->multisig(&ready, &threshold))
if (!ms_status.multisig_is_active)
{
fail_msg_writer() << tr("This is not a multisig wallet");
return true;
}
if (!ready)
if (!ms_status.is_ready)
{
fail_msg_writer() << tr("This multisig wallet is not yet finalized");
return true;
@ -1621,10 +1614,10 @@ bool simple_wallet::export_raw_multisig(const std::vector<std::string> &args)
fail_msg_writer() << tr("Failed to load multisig transaction from file");
return true;
}
if (txs.m_signers.size() < threshold)
if (txs.m_signers.size() < ms_status.threshold)
{
fail_msg_writer() << (boost::format(tr("Multisig transaction signed by only %u signers, needs %u more signatures"))
% txs.m_signers.size() % (threshold - txs.m_signers.size())).str();
% txs.m_signers.size() % (ms_status.threshold - txs.m_signers.size())).str();
return true;
}
@ -4053,7 +4046,7 @@ void simple_wallet::print_seed(const epee::wipeable_string &seed)
{
success_msg_writer(true) << "\n" << boost::format(tr("NOTE: the following %s can be used to recover access to your wallet. "
"Write them down and store them somewhere safe and secure. Please do not store them in "
"your email or on file storage services outside of your immediate control.\n")) % (m_wallet->multisig() ? tr("string") : tr("25 words"));
"your email or on file storage services outside of your immediate control.\n")) % (m_wallet->get_multisig_status().multisig_is_active ? tr("string") : tr("25 words"));
// don't log
int space_index = 0;
size_t len = seed.size();
@ -5115,14 +5108,14 @@ boost::optional<epee::wipeable_string> simple_wallet::new_wallet(const boost::pr
const epee::wipeable_string &msig_keys = m_wallet->decrypt<epee::wipeable_string>(std::string(multisig_keys.data(), multisig_keys.size()), key, true);
m_wallet->generate(m_wallet_file, std::move(rc.second).password(), msig_keys, create_address_file);
}
bool ready;
uint32_t threshold, total;
if (!m_wallet->multisig(&ready, &threshold, &total) || !ready)
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active || !ms_status.is_ready)
{
fail_msg_writer() << tr("failed to generate new mutlisig wallet");
return {};
}
message_writer(console_color_white, true) << boost::format(tr("Generated new %u/%u multisig wallet: ")) % threshold % total
message_writer(console_color_white, true) << boost::format(tr("Generated new %u/%u multisig wallet: ")) % ms_status.threshold % ms_status.total
<< m_wallet->get_account().get_public_address_str(m_wallet->nettype());
}
catch (const std::exception& e)
@ -5166,12 +5159,11 @@ boost::optional<epee::wipeable_string> simple_wallet::open_wallet(const boost::p
m_wallet->callback(this);
m_wallet->load(m_wallet_file, password);
std::string prefix;
bool ready;
uint32_t threshold, total;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (m_wallet->watch_only())
prefix = tr("Opened watch-only wallet");
else if (m_wallet->multisig(&ready, &threshold, &total))
prefix = (boost::format(tr("Opened %u/%u multisig wallet%s")) % threshold % total % (ready ? "" : " (not yet finalized)")).str();
else if (ms_status.multisig_is_active)
prefix = (boost::format(tr("Opened %u/%u multisig wallet%s")) % ms_status.threshold % ms_status.total % (ms_status.is_ready ? "" : " (not yet finalized)")).str();
else
prefix = tr("Opened wallet");
message_writer(console_color_white, true) <<
@ -5290,7 +5282,7 @@ bool simple_wallet::save(const std::vector<std::string> &args)
//----------------------------------------------------------------------------------------------------
bool simple_wallet::save_watch_only(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
{
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("wallet is multisig and cannot save a watch-only version");
return true;
@ -6906,7 +6898,8 @@ bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::stri
}
// actually commit the transactions
if (m_wallet->multisig() && called_by_mms)
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (ms_status.multisig_is_active && called_by_mms)
{
std::string ciphertext = m_wallet->save_multisig_tx(ptx_vector);
if (!ciphertext.empty())
@ -6915,7 +6908,7 @@ bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::stri
success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to MMS");
}
}
else if (m_wallet->multisig())
else if (ms_status.multisig_is_active)
{
bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
if (!r)
@ -7069,7 +7062,7 @@ bool simple_wallet::sweep_unmixable(const std::vector<std::string> &args_)
}
// actually commit the transactions
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
CHECK_MULTISIG_ENABLED();
bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
@ -7374,7 +7367,7 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
}
// actually commit the transactions
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
CHECK_MULTISIG_ENABLED();
bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
@ -7609,7 +7602,7 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
}
// actually commit the transactions
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
CHECK_MULTISIG_ENABLED();
bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
@ -7957,7 +7950,7 @@ bool simple_wallet::sign_transfer(const std::vector<std::string> &args_)
fail_msg_writer() << tr("command not supported by HW wallet");
return true;
}
if(m_wallet->multisig())
if(m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("This is a multisig wallet, it can only sign with sign_multisig");
return true;
@ -8490,7 +8483,7 @@ bool simple_wallet::get_reserve_proof(const std::vector<std::string> &args)
return true;
}
if (m_wallet->watch_only() || m_wallet->multisig())
if (m_wallet->watch_only() || m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("The reserve proof can be generated only by a full wallet");
return true;
@ -10051,8 +10044,8 @@ bool simple_wallet::status(const std::vector<std::string> &args)
//----------------------------------------------------------------------------------------------------
bool simple_wallet::wallet_info(const std::vector<std::string> &args)
{
bool ready;
uint32_t threshold, total;
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
std::string description = m_wallet->get_description();
if (description.empty())
{
@ -10064,8 +10057,8 @@ bool simple_wallet::wallet_info(const std::vector<std::string> &args)
std::string type;
if (m_wallet->watch_only())
type = tr("Watch only");
else if (m_wallet->multisig(&ready, &threshold, &total))
type = (boost::format(tr("%u/%u multisig%s")) % threshold % total % (ready ? "" : " (not yet finalized)")).str();
else if (ms_status.multisig_is_active)
type = (boost::format(tr("%u/%u multisig%s")) % ms_status.threshold % ms_status.total % (ms_status.is_ready ? "" : " (not yet finalized)")).str();
else
type = tr("Normal");
message_writer() << tr("Type: ") << type;
@ -10092,7 +10085,7 @@ bool simple_wallet::sign(const std::vector<std::string> &args)
fail_msg_writer() << tr("wallet is watch-only and cannot sign");
return true;
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
fail_msg_writer() << tr("This wallet is multisig and cannot sign");
return true;

29
src/wallet/api/wallet.cpp
View file

@ -38,6 +38,7 @@
#include "subaddress_account.h"
#include "common_defines.h"
#include "common/util.h"
#include "multisig/multisig_account.h"
#include "mnemonics/electrum-words.h"
#include "mnemonics/english.h"
@ -84,12 +85,13 @@ namespace {
throw runtime_error("Wallet is not initialized yet");
}
bool ready;
if (!wallet->multisig(&ready)) {
const multisig::multisig_account_status ms_status{wallet->get_multisig_status()};
if (!ms_status.multisig_is_active) {
throw runtime_error("Wallet is not multisig");
}
if (!ready) {
if (!ms_status.is_ready) {
throw runtime_error("Multisig wallet is not finalized yet");
}
}
@ -102,12 +104,13 @@ namespace {
throw runtime_error("Wallet is not initialized yet");
}
bool ready;
if (!wallet->multisig(&ready)) {
const multisig::multisig_account_status ms_status{wallet->get_multisig_status()};
if (!ms_status.multisig_is_active) {
throw runtime_error("Wallet is not multisig");
}
if (ready) {
if (ms_status.is_ready) {
throw runtime_error("Multisig wallet is already finalized");
}
}
@ -1362,7 +1365,13 @@ void WalletImpl::setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex
MultisigState WalletImpl::multisig() const {
MultisigState state;
state.isMultisig = m_wallet->multisig(&state.isReady, &state.threshold, &state.total);
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
state.isMultisig = ms_status.multisig_is_active;
state.kexIsDone = ms_status.kex_is_done;
state.isReady = ms_status.is_ready;
state.threshold = ms_status.threshold;
state.total = ms_status.total;
return state;
}
@ -1383,7 +1392,7 @@ string WalletImpl::makeMultisig(const vector<string>& info, const uint32_t thres
try {
clearStatus();
if (m_wallet->multisig()) {
if (m_wallet->get_multisig_status().multisig_is_active) {
throw runtime_error("Wallet is already multisig");
}
@ -2118,8 +2127,8 @@ std::string WalletImpl::signMultisigParticipant(const std::string &message) cons
{
clearStatus();
bool ready = false;
if (!m_wallet->multisig(&ready) || !ready) {
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active || !ms_status.is_ready) {
m_status = Status_Error;
m_errorString = tr("The wallet must be in multisig ready state");
return {};

3
src/wallet/api/wallet2_api.h
View file

@ -321,9 +321,10 @@ struct SubaddressAccount
};
struct MultisigState {
MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {}
MultisigState() : isMultisig(false), kexIsDone(false), isReady(false), threshold(0), total(0) {}
bool isMultisig;
bool kexIsDone;
bool isReady;
uint32_t threshold;
uint32_t total;

7
src/wallet/message_store.h
View file

@ -245,18 +245,23 @@ namespace mms
crypto::secret_key view_secret_key;
bool multisig;
bool multisig_is_ready;
bool multisig_kex_is_done;
bool has_multisig_partial_key_images;
uint32_t multisig_rounds_passed;
size_t num_transfer_details;
std::string mms_file;
BEGIN_SERIALIZE_OBJECT()
VERSION_FIELD(0)
VERSION_FIELD(1)
FIELD(address)
VARINT_FIELD(nettype)
FIELD(view_secret_key)
FIELD(multisig)
FIELD(multisig_is_ready)
if (version > 0)
FIELD(multisig_kex_is_done)
else
multisig_kex_is_done = multisig_is_ready;
FIELD(has_multisig_partial_key_images)
VARINT_FIELD(multisig_rounds_passed)
VARINT_FIELD(num_transfer_details)

52
src/wallet/wallet2.cpp
View file

@ -1412,14 +1412,14 @@ bool wallet2::get_seed(epee::wipeable_string& electrum_words, const epee::wipeab
//----------------------------------------------------------------------------------------------------
bool wallet2::get_multisig_seed(epee::wipeable_string& seed, const epee::wipeable_string &passphrase, bool raw) const
{
bool ready;
uint32_t threshold, total;
if (!multisig(&ready, &threshold, &total))
const multisig::multisig_account_status ms_status{get_multisig_status()};
if (!ms_status.multisig_is_active)
{
std::cout << "This is not a multisig wallet" << std::endl;
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
std::cout << "This multisig wallet is not yet finalized" << std::endl;
return false;
@ -1434,8 +1434,8 @@ bool wallet2::get_multisig_seed(epee::wipeable_string& seed, const epee::wipeabl
crypto::public_key pkey;
const account_keys &keys = get_account().get_keys();
epee::wipeable_string data;
data.append((const char*)&threshold, sizeof(uint32_t));
data.append((const char*)&total, sizeof(uint32_t));
data.append((const char*)&ms_status.threshold, sizeof(uint32_t));
data.append((const char*)&ms_status.total, sizeof(uint32_t));
skey = keys.m_spend_secret_key;
data.append((const char*)&skey, sizeof(skey));
pkey = keys.m_account_address.m_spend_public_key;
@ -5135,8 +5135,8 @@ std::string wallet2::exchange_multisig_keys(const epee::wipeable_string &passwor
const std::vector<std::string> &kex_messages,
const bool force_update_use_with_caution /*= false*/)
{
bool ready{false};
CHECK_AND_ASSERT_THROW_MES(multisig(&ready), "The wallet is not multisig");
const multisig::multisig_account_status ms_status{get_multisig_status()};
CHECK_AND_ASSERT_THROW_MES(ms_status.multisig_is_active, "The wallet is not multisig");
// decrypt account keys
epee::misc_utils::auto_scope_leave_caller keys_reencryptor;
@ -5263,20 +5263,30 @@ std::string wallet2::get_multisig_first_kex_msg() const
return multisig_account.get_next_kex_round_msg();
}
//----------------------------------------------------------------------------------------------------
bool wallet2::multisig(bool *ready, uint32_t *threshold, uint32_t *total) const
multisig::multisig_account_status wallet2::get_multisig_status() const
{
if (!m_multisig)
return false;
if (threshold)
*threshold = m_multisig_threshold;
if (total)
*total = m_multisig_signers.size();
if (ready)
multisig::multisig_account_status ret;
if (m_multisig)
{
*ready = !(get_account().get_keys().m_account_address.m_spend_public_key == rct::rct2pk(rct::identity())) &&
ret.multisig_is_active = true;
ret.threshold = m_multisig_threshold;
ret.total = m_multisig_signers.size();
ret.kex_is_done = !(get_account().get_keys().m_account_address.m_spend_public_key == rct::rct2pk(rct::identity())) &&
(m_multisig_rounds_passed >= multisig::multisig_kex_rounds_required(m_multisig_signers.size(), m_multisig_threshold));
ret.is_ready = ret.kex_is_done &&
(m_multisig_rounds_passed == multisig::multisig_setup_rounds_required(m_multisig_signers.size(), m_multisig_threshold));
}
return true;
else
{
ret.multisig_is_active = false;
ret.threshold = 0;
ret.total = 0;
ret.kex_is_done = false;
ret.is_ready = false;
}
return ret;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::has_multisig_partial_key_images() const
@ -14332,9 +14342,13 @@ void wallet2::generate_genesis(cryptonote::block& b) const {
//----------------------------------------------------------------------------------------------------
mms::multisig_wallet_state wallet2::get_multisig_wallet_state() const
{
const multisig::multisig_account_status ms_status{get_multisig_status()};
mms::multisig_wallet_state state;
state.nettype = m_nettype;
state.multisig = multisig(&state.multisig_is_ready);
state.multisig = ms_status.multisig_is_active;
state.multisig_is_ready = ms_status.is_ready;
state.multisig_kex_is_done = ms_status.kex_is_done;
state.has_multisig_partial_key_images = has_multisig_partial_key_images();
state.multisig_rounds_passed = m_multisig_rounds_passed;
state.num_transfer_details = m_transfers.size();

3
src/wallet/wallet2.h
View file

@ -57,6 +57,7 @@
#include "common/util.h"
#include "crypto/chacha.h"
#include "crypto/hash.h"
#include "multisig/multisig_account.h"
#include "ringct/rctTypes.h"
#include "ringct/rctOps.h"
#include "checkpoints/checkpoints.h"
@ -1031,7 +1032,7 @@ private:
cryptonote::network_type nettype() const { return m_nettype; }
bool watch_only() const { return m_watch_only; }
bool multisig(bool *ready = NULL, uint32_t *threshold = NULL, uint32_t *total = NULL) const;
multisig::multisig_account_status get_multisig_status() const;
bool has_multisig_partial_key_images() const;
bool has_unknown_key_images() const;
bool get_multisig_seed(epee::wipeable_string& seed, const epee::wipeable_string &passphrase = std::string(), bool raw = true) const;

73
src/wallet/wallet_rpc_server.cpp
View file

@ -65,7 +65,7 @@ using namespace epee;
#define CHECK_MULTISIG_ENABLED() \
do \
{ \
if (m_wallet->multisig() && !m_wallet->is_multisig_enabled()) \
if (m_wallet->get_multisig_status().multisig_is_active && !m_wallet->is_multisig_enabled()) \
{ \
er.code = WALLET_RPC_ERROR_CODE_DISABLED; \
er.message = "This wallet is multisig, and multisig is disabled. Multisig is an experimental feature and may have bugs. Things that could go wrong include: funds sent to a multisig wallet can't be spent at all, can only be spent with the participation of a malicious group member, or can be stolen by a malicious group member. You can enable it by running this once in monero-wallet-cli: set enable-multisig-experimental 1"; \
@ -459,7 +459,7 @@ namespace tools
{
res.balance = req.all_accounts ? m_wallet->balance_all(req.strict) : m_wallet->balance(req.account_index, req.strict);
res.unlocked_balance = req.all_accounts ? m_wallet->unlocked_balance_all(req.strict, &res.blocks_to_unlock, &res.time_to_unlock) : m_wallet->unlocked_balance(req.account_index, req.strict, &res.blocks_to_unlock, &res.time_to_unlock);
res.multisig_import_needed = m_wallet->multisig() && m_wallet->has_multisig_partial_key_images();
res.multisig_import_needed = m_wallet->get_multisig_status().multisig_is_active && m_wallet->has_multisig_partial_key_images();
std::map<uint32_t, std::map<uint32_t, uint64_t>> balance_per_subaddress_per_account;
std::map<uint32_t, std::map<uint32_t, std::pair<uint64_t, std::pair<uint64_t, uint64_t>>>> unlocked_balance_per_subaddress_per_account;
if (req.all_accounts)
@ -1018,7 +1018,7 @@ namespace tools
fill(spent_key_images, key_image_list);
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
multisig_txset = epee::string_tools::buff_to_hex_nodelimer(m_wallet->save_multisig_tx(ptx_vector));
if (multisig_txset.empty())
@ -2060,10 +2060,11 @@ namespace tools
if (req.key_type.compare("mnemonic") == 0)
{
epee::wipeable_string seed;
bool ready;
if (m_wallet->multisig(&ready))
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (ms_status.multisig_is_active)
{
if (!ready)
if (!ms_status.is_ready)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is multisig, but not yet finalized";
@ -3942,7 +3943,14 @@ namespace tools
bool wallet_rpc_server::on_is_multisig(const wallet_rpc::COMMAND_RPC_IS_MULTISIG::request& req, wallet_rpc::COMMAND_RPC_IS_MULTISIG::response& res, epee::json_rpc::error& er, const connection_context *ctx)
{
if (!m_wallet) return not_open(er);
res.multisig = m_wallet->multisig(&res.ready, &res.threshold, &res.total);
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
res.multisig = ms_status.multisig_is_active;
res.kex_is_done = ms_status.kex_is_done;
res.ready = ms_status.is_ready;
res.threshold = ms_status.threshold;
res.total = ms_status.total;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -3955,7 +3963,7 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_ALREADY_MULTISIG;
er.message = "This wallet is already multisig";
@ -3984,7 +3992,7 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
if (m_wallet->multisig())
if (m_wallet->get_multisig_status().multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_ALREADY_MULTISIG;
er.message = "This wallet is already multisig";
@ -4022,14 +4030,15 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
bool ready;
if (!m_wallet->multisig(&ready))
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is not multisig";
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is multisig, but not yet finalized";
@ -4063,15 +4072,15 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
bool ready;
uint32_t threshold, total;
if (!m_wallet->multisig(&ready, &threshold, &total))
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is not multisig";
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is multisig, but not yet finalized";
@ -4079,7 +4088,7 @@ namespace tools
}
CHECK_MULTISIG_ENABLED();
if (req.info.size() < threshold - 1)
if (req.info.size() + 1 < ms_status.threshold)
{
er.code = WALLET_RPC_ERROR_CODE_THRESHOLD_NOT_REACHED;
er.message = "Needs multisig export info from more participants";
@ -4143,9 +4152,9 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
bool ready;
uint32_t threshold, total;
if (!m_wallet->multisig(&ready, &threshold, &total))
multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is not multisig";
@ -4153,7 +4162,7 @@ namespace tools
}
CHECK_MULTISIG_ENABLED();
if (req.multisig_info.size() + 1 < total)
if (req.multisig_info.size() + 1 < ms_status.total)
{
er.code = WALLET_RPC_ERROR_CODE_THRESHOLD_NOT_REACHED;
er.message = "Needs multisig info from more participants";
@ -4163,8 +4172,8 @@ namespace tools
try
{
res.multisig_info = m_wallet->exchange_multisig_keys(req.password, req.multisig_info, req.force_update_use_with_caution);
m_wallet->multisig(&ready);
if (ready)
ms_status = m_wallet->get_multisig_status();
if (ms_status.is_ready)
{
res.address = m_wallet->get_account().get_public_address_str(m_wallet->nettype());
}
@ -4187,15 +4196,15 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
bool ready;
uint32_t threshold, total;
if (!m_wallet->multisig(&ready, &threshold, &total))
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is not multisig";
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is multisig, but not yet finalized";
@ -4257,15 +4266,15 @@ namespace tools
er.message = "Command unavailable in restricted mode.";
return false;
}
bool ready;
uint32_t threshold, total;
if (!m_wallet->multisig(&ready, &threshold, &total))
const multisig::multisig_account_status ms_status{m_wallet->get_multisig_status()};
if (!ms_status.multisig_is_active)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is not multisig";
return false;
}
if (!ready)
if (!ms_status.is_ready)
{
er.code = WALLET_RPC_ERROR_CODE_NOT_MULTISIG;
er.message = "This wallet is multisig, but not yet finalized";
@ -4290,7 +4299,7 @@ namespace tools
return false;
}
if (txs.m_signers.size() < threshold)
if (txs.m_signers.size() < ms_status.threshold)
{
er.code = WALLET_RPC_ERROR_CODE_THRESHOLD_NOT_REACHED;
er.message = "Not enough signers signed this transaction.";

2
src/wallet/wallet_rpc_server_commands_defs.h
View file

@ -2402,12 +2402,14 @@ namespace wallet_rpc
struct response_t
{
bool multisig;
bool kex_is_done;
bool ready;
uint32_t threshold;
uint32_t total;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(multisig)
KV_SERIALIZE(kex_is_done)
KV_SERIALIZE(ready)
KV_SERIALIZE(threshold)
KV_SERIALIZE(total)

25
tests/unit_tests/multisig.cpp
View file

@ -159,12 +159,12 @@ static void check_results(const std::vector<std::string> &intermediate_infos,
for (size_t i = 0; i < wallets.size(); ++i)
{
EXPECT_TRUE(!intermediate_infos[i].empty());
bool ready;
uint32_t threshold, total;
EXPECT_TRUE(wallets[i].multisig(&ready, &threshold, &total));
EXPECT_TRUE(ready);
EXPECT_TRUE(threshold == M);
EXPECT_TRUE(total == wallets.size());
const multisig::multisig_account_status ms_status{wallets[i].get_multisig_status()};
EXPECT_TRUE(ms_status.multisig_is_active);
EXPECT_TRUE(ms_status.kex_is_done);
EXPECT_TRUE(ms_status.is_ready);
EXPECT_TRUE(ms_status.threshold == M);
EXPECT_TRUE(ms_status.total == wallets.size());
wallets[i].decrypt_keys("");
@ -226,10 +226,8 @@ static void make_wallets(const unsigned int M, const unsigned int N, const bool
}
// wallets should not be multisig yet
for (const auto &wallet: wallets)
{
ASSERT_FALSE(wallet.multisig());
}
for (const auto& wallet: wallets)
ASSERT_FALSE(wallet.get_multisig_status().multisig_is_active);
// make wallets multisig, get second round kex messages (if appropriate)
std::vector<std::string> intermediate_infos(wallets.size());
@ -242,16 +240,15 @@ static void make_wallets(const unsigned int M, const unsigned int N, const bool
++rounds_complete;
// perform kex rounds until kex is complete
bool ready;
wallets[0].multisig(&ready);
while (!ready)
multisig::multisig_account_status ms_status{wallets[0].get_multisig_status()};
while (!ms_status.is_ready)
{
if (force_update)
intermediate_infos = exchange_round_force_update(wallets, intermediate_infos, rounds_complete + 1);
else
intermediate_infos = exchange_round(wallets, intermediate_infos);
wallets[0].multisig(&ready);
ms_status = wallets[0].get_multisig_status();
++rounds_complete;
}