What changed, and why it matters
This commit adds an optional, faster way to set up N-of-N Monero multisig wallets. Normally, all signers must complete a final verification round to prove they are active and have finished setup. The new 'fast non-interactive setup' skips that final round for convenience, but the code and user-facing warnings clearly note the trade-off: you cannot be sure the other signers are alive or finished, so funds sent to the shared address could become permanently inaccessible if any signer failed. The change is explicitly opt-in, gated by warnings, and restricted to N-of-N (e.g., 2-of-2, 3-of-3) setups. It is not a bug fix or a secret backdoor; it is a documented feature with a known risk.
Treat this as a feature addition with a documented operational risk, not as a vulnerability. Reviewers and users should ensure they understand the warning: only use the fast setup when all signers are trusted, available, and capable of completing setup; otherwise funds may be locked. No immediate patch is required, but wallet maintainers may want to confirm that the force_update path cannot be triggered accidentally through the normal RPC/API flow.
Security signals we found
New feature adds a non-default, opt-in fast setup path that intentionally weakens a liveness/verification guarantee
Force-update flag (force_update_use_with_caution) is used internally to bypass the normal post-KEX round
User-facing and API documentation clearly warn that funds may become inaccessible if other signers do not complete setup
No input sanitization changes beyond existing make_multisig/exchange_multisig_keys validation; relies on existing multisig account checks
Functional and unit tests cover valid N-of-N cases, mixed fast/normal setups, and invalid threshold/signer combinations
Evidence from the diff
The merge commit introduces a new multisig setup path, multisig_nofn_fast_noninteractive_setup(), exposed through simplewallet, the wallet API, and the wallet RPC. For N-of-N schemes only, it calls make_multisig() with threshold == num_signers and then force-updates the post-KEX verification round using only the local signer’s post-KEX message (exchange_multisig_keys(…, force_update_use_with_caution=true)). This removes the interactive post-KEX liveness check. The implementation validates that the wallet is not already multisig, that at least two signers exist, that the scheme is N-of-N, and that the resulting status is active-but-not-ready before forcing the final round. UI and API documentation include explicit warnings about the lost liveness guarantee.
Changed components
src/simplewallet/simplewallet.cppsrc/simplewallet/simplewallet.hsrc/wallet/api/wallet.cppsrc/wallet/api/wallet.hsrc/wallet/api/wallet2_api.hsrc/wallet/wallet2.cppsrc/wallet/wallet2.hsrc/wallet/wallet_rpc_server.cppsrc/wallet/wallet_rpc_server_commands_defs.htests/functional_tests/multisig.pytests/unit_tests/multisig.cpputils/python-rpc/framework/wallet.pyInspect captured patch +301 / −15
### src/simplewallet/simplewallet.cpp
@@ -274,7 +274,7 @@ namespace
const char* USAGE_EXPORT_OUTPUTS("export_outputs [all] <filename>");
const char* USAGE_IMPORT_OUTPUTS("import_outputs <filename>");
const char* USAGE_SHOW_TRANSFER("show_transfer <txid>");
- const char* USAGE_MAKE_MULTISIG("make_multisig <threshold> <string1> [<string>...]");
+ const char* USAGE_MAKE_MULTISIG("make_multisig [nofn-fast-noninteractive-setup] <threshold> <string1> [<string>...]");
const char* USAGE_EXCHANGE_MULTISIG_KEYS("exchange_multisig_keys [force-update-use-with-caution] <string> [<string>...]");
const char* USAGE_EXPORT_MULTISIG_INFO("export_multisig_info <filename>");
const char* USAGE_IMPORT_MULTISIG_INFO("import_multisig_info <filename> [<filename>...]");
@@ -1245,11 +1245,22 @@ bool simple_wallet::prepare_multisig_main(const std::vector<std::string> &args,
bool simple_wallet::make_multisig(const std::vector<std::string> &args)
{
CHECK_MULTISIG_ENABLED();
- make_multisig_main(args, false);
+ bool nofn_fast_noninteractive_setup = false;
+
+ auto local_args = args;
+ if (args.size() >= 1 && local_args[0] == "nofn-fast-noninteractive-setup")
+ {
+ nofn_fast_noninteractive_setup = true;
+ local_args.erase(local_args.begin());
+ }
+
+ make_multisig_main(local_args, false, nofn_fast_noninteractive_setup);
return true;
}
-bool simple_wallet::make_multisig_main(const std::vector<std::string> &args, bool called_by_mms)
+bool simple_wallet::make_multisig_main(const std::vector<std::string> &args,
+ bool called_by_mms,
+ const bool nofn_fast_noninteractive_setup /*= false*/)
{
CHECK_MULTISIG_ENABLED();
if (m_wallet->key_on_device())
@@ -1289,6 +1300,27 @@ bool simple_wallet::make_multisig_main(const std::vector<std::string> &args, boo
return false;
}
+ if (nofn_fast_noninteractive_setup)
+ {
+ if (called_by_mms)
+ {
+ fail_msg_writer() << tr("N-of-N fast setup is not supported by the MMS");
+ return false;
+ }
+ const size_t num_signers = args.size() - 1; // threshold | {kex msgs per signer}
+ if (threshold != num_signers)
+ {
+ fail_msg_writer() << tr("N-of-N fast setup requires the threshold to be equal to the number of signers");
+ return false;
+ }
+
+ message_writer(console_color_red, true) << tr("WARNING: N-of-N fast setup skips the post-KEX verification round. "
+ "This means that there is no check to see whether the other signers are alive or have finished setting up their wallets. "
+ "If any other signer can't complete their wallet setup, funds sent to this multisig address will be inaccessible.");
+ if (!command_line::is_yes(input_line(tr("Is this okay?"), true)))
+ return false;
+ }
+
const auto orig_pwd_container = get_and_verify_password();
if(orig_pwd_container == boost::none)
{
@@ -1302,17 +1334,28 @@ 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);
- if (!m_wallet->get_multisig_status().is_ready)
+
+ if (nofn_fast_noninteractive_setup)
+ {
+ const std::string post_kex_msg = m_wallet->multisig_nofn_fast_noninteractive_setup(orig_pwd_container->password(), local_args);
+ success_msg_writer() << tr("Multisig wallet has been created without the post-KEX verification round.");
+ success_msg_writer() << tr("Other participants that are not using the fast setup need this to complete their wallets with exchange_multisig_keys:");
+ success_msg_writer() << post_kex_msg;
+ }
+ else
{
- success_msg_writer() << tr("Another step is needed");
- success_msg_writer() << multisig_extra_info;
- success_msg_writer() << tr("Send this multisig info to all other participants, then use exchange_multisig_keys <info1> [<info2>...] with others' multisig info");
- if (called_by_mms)
+ std::string multisig_extra_info = m_wallet->make_multisig(orig_pwd_container->password(), local_args, threshold);
+ if (!m_wallet->get_multisig_status().is_ready)
{
- get_message_store().process_wallet_created_data(get_multisig_wallet_state(), mms::message_type::additional_key_set, multisig_extra_info);
+ success_msg_writer() << tr("Another step is needed");
+ success_msg_writer() << multisig_extra_info;
+ success_msg_writer() << tr("Send this multisig info to all other participants, then use exchange_multisig_keys <info1> [<info2>...] with others' multisig info");
+ if (called_by_mms)
+ {
+ get_message_store().process_wallet_created_data(get_multisig_wallet_state(), mms::message_type::additional_key_set, multisig_extra_info);
+ }
+ return true;
}
- return true;
}
}
catch (const std::exception &e)
### src/simplewallet/simplewallet.h
@@ -230,7 +230,7 @@ namespace cryptonote
bool prepare_multisig(const std::vector<std::string>& args);
bool prepare_multisig_main(const std::vector<std::string>& args, bool called_by_mms);
bool make_multisig(const std::vector<std::string>& args);
- bool make_multisig_main(const std::vector<std::string>& args, bool called_by_mms);
+ bool make_multisig_main(const std::vector<std::string>& args, bool called_by_mms, const bool nofn_fast_noninteractive_setup = false);
bool exchange_multisig_keys(const std::vector<std::string> &args);
bool exchange_multisig_keys_main(const std::vector<std::string> &args, const bool force_update_use_with_caution, const bool called_by_mms);
bool export_multisig(const std::vector<std::string>& args);
### src/wallet/api/wallet.cpp
@@ -1607,6 +1607,25 @@ string WalletImpl::makeMultisig(const vector<string>& info, const uint32_t thres
return string();
}
+string WalletImpl::makeMultisigNofNFastNoninteractive(const vector<string>& info) {
+ if (checkBackgroundSync("cannot make multisig"))
+ return string();
+ try {
+ clearStatus();
+
+ if (m_wallet->get_multisig_status().multisig_is_active) {
+ throw runtime_error("Wallet is already multisig");
+ }
+
+ return m_wallet->multisig_nofn_fast_noninteractive_setup(epee::wipeable_string(m_password), info);
+ } catch (const exception& e) {
+ LOG_ERROR("Error on making N-of-N multisig wallet (fast setup): " << e.what());
+ setStatusError(string(tr("Failed to make multisig: ")) + e.what());
+ }
+
+ return string();
+}
+
std::string WalletImpl::exchangeMultisigKeys(const std::vector<std::string> &info, const bool force_update_use_with_caution /*= false*/) {
try {
clearStatus();
### src/wallet/api/wallet.h
@@ -156,6 +156,7 @@ class WalletImpl : public Wallet
MultisigState multisig() const override;
std::string getMultisigInfo() const override;
std::string makeMultisig(const std::vector<std::string>& info, uint32_t threshold) override;
+ std::string makeMultisigNofNFastNoninteractive(const std::vector<std::string>& info) override;
std::string exchangeMultisigKeys(const std::vector<std::string> &info, const bool force_update_use_with_caution = false) override;
std::string getMultisigKeyExchangeBooster(const std::vector<std::string> &info, const uint32_t threshold, const uint32_t num_signers) override;
bool exportMultisigImages(std::string& images) override;
### src/wallet/api/wallet2_api.h
@@ -814,6 +814,15 @@ struct Wallet
* @return in case of N / N wallets returns empty string since no more key exchanges needed. For N - 1 / N wallets returns base58 encoded extra multisig info
*/
virtual std::string makeMultisig(const std::vector<std::string>& info, uint32_t threshold) = 0;
+ /**
+ * @brief makeMultisigNofNFastNoninteractive - creates and finalizes an N / N multisig wallet in one step, skipping the
+ * post-KEX verification round
+ * WARNING: the post-KEX round acts as a liveness check on other signers. Without it, there is no guarantee that
+ * other signers are alive or have completed their wallets; if any can't, funds sent to the address are inaccessible.
+ * @param info - vector of multisig infos from all participants (including this wallet) obtained with getMultisigInfo call
+ * @return post-KEX verification message (other participants doing the normal setup need it to finalize their wallets)
+ */
+ virtual std::string makeMultisigNofNFastNoninteractive(const std::vector<std::string>& info) = 0;
/**
* @brief exchange_multisig_keys - provides additional key exchange round for arbitrary multisig schemes (like N-1/N, M/N)
* @param info - base58 encoded key derivations returned by makeMultisig or exchangeMultisigKeys function call
### src/wallet/wallet2.cpp
@@ -6425,6 +6425,34 @@ std::string wallet2::exchange_multisig_keys(const epee::wipeable_string &passwor
return multisig_account.get_next_kex_round_msg();
}
//----------------------------------------------------------------------------------------------------
+std::string wallet2::multisig_nofn_fast_noninteractive_setup(const epee::wipeable_string &password,
+ const std::vector<std::string> &initial_kex_msgs)
+{
+ // N-of-N: the threshold equals the number of signers (initial KEX msgs include the local signer)
+ const std::uint32_t num_signers{static_cast<std::uint32_t>(initial_kex_msgs.size())};
+ CHECK_AND_ASSERT_THROW_MES(!this->get_multisig_status().multisig_is_active,
+ "N-of-N multisig fast setup: the wallet is already multisig.");
+ CHECK_AND_ASSERT_THROW_MES(num_signers >= 2, "N-of-N multisig fast setup: at least two signers are required.");
+ CHECK_AND_ASSERT_THROW_MES(multisig::multisig_kex_rounds_required(num_signers, num_signers) == 1,
+ "N-of-N multisig fast setup: unexpected number of KEX rounds required.");
+
+ // main KEX round (for N-of-N this completes all main KEX rounds and returns the post-KEX verification message)
+ const std::string post_kex_msg{this->make_multisig(password, initial_kex_msgs, num_signers)};
+
+ const multisig::multisig_account_status ms_status{this->get_multisig_status()};
+ CHECK_AND_ASSERT_THROW_MES(ms_status.multisig_is_active && !ms_status.is_ready,
+ "N-of-N multisig fast setup: unexpected multisig status after the main KEX round.");
+
+ // force-update the post-KEX verification round with only the local signer's message
+ // - the post-KEX round is not needed to derive the N-of-N address; skipping it only removes the liveness check on
+ // other signers
+ const std::string final_msg{this->exchange_multisig_keys(password, {post_kex_msg}, true)};
+ CHECK_AND_ASSERT_THROW_MES(this->get_multisig_status().is_ready,
+ "N-of-N multisig fast setup: wallet is not ready after force-updating the post-KEX round.");
+
+ return final_msg;
+}
+//----------------------------------------------------------------------------------------------------
std::string wallet2::get_multisig_first_kex_msg() const
{
// create multisig account
### src/wallet/wallet2.h
@@ -737,6 +737,19 @@ namespace tools
std::string exchange_multisig_keys(const epee::wipeable_string &password,
const std::vector<std::string> &kex_messages,
const bool force_update_use_with_caution = false);
+ /*!
+ * \brief Creates and finalizes an N-of-N multisig wallet in one step, without waiting for the post-KEX verification round
+ * - Calls make_multisig() with threshold = number of signers, then force-updates the post-KEX verification
+ * round using only the local signer's post-KEX message.
+ * - WARNING: This skips the interactive post-KEX round, which acts as a liveness check on other signers. A
+ * completed wallet does NOT prove that other signers are alive or have completed their accounts. If any other
+ * signer can't complete their account, then funds sent to the multisig address will be inaccessible.
+ * \param password - wallet password
+ * \param initial_kex_msgs - first round KEX msgs from all signers (including the local signer)
+ * \return post-KEX verification message (other signers that do the normal setup can use it to finalize their accounts)
+ */
+ std::string multisig_nofn_fast_noninteractive_setup(const epee::wipeable_string &password,
+ const std::vector<std::string> &initial_kex_msgs);
/*!
* \brief Get initial message to start multisig key exchange (before 'make_multisig()' is called)
* \return string to send to other participants
### src/wallet/wallet_rpc_server.cpp
@@ -4631,7 +4631,18 @@ namespace tools
try
{
- res.multisig_info = m_wallet->make_multisig(req.password, req.multisig_info, req.threshold);
+ if (req.nofn_fast_noninteractive_setup)
+ {
+ if (req.threshold != req.multisig_info.size())
+ {
+ er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+ er.message = "N-of-N fast setup requires the threshold to equal the number of signers";
+ return false;
+ }
+ res.multisig_info = m_wallet->multisig_nofn_fast_noninteractive_setup(req.password, req.multisig_info);
+ }
+ else
+ res.multisig_info = m_wallet->make_multisig(req.password, req.multisig_info, req.threshold);
res.address = m_wallet->get_account().get_public_address_str(m_wallet->nettype());
}
catch (const std::exception &e)
### src/wallet/wallet_rpc_server_commands_defs.h
@@ -47,7 +47,7 @@
// advance which version they will stop working with
// Don't go over 32767 for any of these
#define WALLET_RPC_VERSION_MAJOR 1
-#define WALLET_RPC_VERSION_MINOR 38
+#define WALLET_RPC_VERSION_MINOR 39
#define MAKE_WALLET_RPC_VERSION(major,minor) (((major)<<16)|(minor))
#define WALLET_RPC_VERSION MAKE_WALLET_RPC_VERSION(WALLET_RPC_VERSION_MAJOR, WALLET_RPC_VERSION_MINOR)
namespace tools
@@ -2504,11 +2504,13 @@ namespace wallet_rpc
std::vector<std::string> multisig_info;
uint32_t threshold;
std::string password;
+ bool nofn_fast_noninteractive_setup;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(multisig_info)
KV_SERIALIZE(threshold)
KV_SERIALIZE(password)
+ KV_SERIALIZE_OPT(nofn_fast_noninteractive_setup, false)
END_KV_SERIALIZE_MAP()
};
typedef epee::misc_utils::struct_init<request_t> request;
### tests/functional_tests/multisig.py
@@ -61,6 +61,7 @@ def run_test(self):
print('Testing in-depth transferring with many different multisig setups')
self.test_states()
+ self.test_nofn_fast_setup()
self.fund_addrs_with_normal_wallet(PUB_ADDRS)
@@ -343,6 +344,70 @@ def test_states(cls):
except: ok = True
assert ok
+ @classmethod
+ def test_nofn_fast_setup(cls):
+ print('Testing N-of-N multisig fast setup')
+ seeds = [
+ 'velvet lymph giddy number token physics poetry unquoted nibs useful sabotage limits benches lifestyle eden nitrogen anvil fewest avoid batch vials washing fences goat unquoted',
+ 'peeled mixture ionic radar utopia puddle buying illness nuns gadget river spout cavernous bounced paradise drunk looking cottage jump tequila melting went winter adjust spout',
+ 'dilute gutter certain antics pamphlet macro enjoy left slid guarded bogeys upload nineteen bomb jubilee enhanced irritate turnip eggs swung jukebox loudly reduce sedan slid',
+ ]
+ expected_2of2_address = [case[2] for case in TEST_CASES if case[0] == 2 and case[1] == 2][0]
+
+ def prepare_wallets(n):
+ wallets = [None] * n
+ infos = []
+ for i in range(n):
+ wallets[i] = Wallet(idx = i)
+ try: wallets[i].close_wallet()
+ except: pass
+ res = wallets[i].restore_deterministic_wallet(seed = seeds[i])
+ res = wallets[i].prepare_multisig(enable_multisig_experimental = True)
+ assert len(res.multisig_info) > 0
+ infos.append(res.multisig_info)
+ return wallets, infos
+
+ # 2-of-2: wallet 0 uses the fast setup, wallet 1 uses the normal setup
+ wallet2of2, info2of2 = prepare_wallets(2)
+
+ res = wallet2of2[0].make_multisig(info2of2, 2, nofn_fast_noninteractive_setup = True)
+ assert res.address == expected_2of2_address, res.address
+ assert len(res.multisig_info) > 0
+ post_kex_info = [res.multisig_info]
+ res = wallet2of2[0].is_multisig()
+ assert res.multisig
+ assert res.ready
+ assert res.threshold == 2
+ assert res.total == 2
+
+ res = wallet2of2[1].make_multisig(info2of2, 2)
+ post_kex_info.append(res.multisig_info)
+ res = wallet2of2[1].is_multisig()
+ assert res.multisig
+ assert not res.ready
+
+ res = wallet2of2[1].exchange_multisig_keys(post_kex_info)
+ assert res.address == expected_2of2_address, res.address
+ res = wallet2of2[1].is_multisig()
+ assert res.multisig
+ assert res.ready
+
+ # can't fast-setup an already-multisig wallet
+ ok = False
+ try: res = wallet2of2[0].make_multisig(info2of2, 2, nofn_fast_noninteractive_setup = True)
+ except: ok = True
+ assert ok
+
+ # fast setup is only allowed for N-of-N
+ wallet2of3, info2of3 = prepare_wallets(3)
+ for i in range(3):
+ ok = False
+ try: res = wallet2of3[i].make_multisig(info2of3, 2, nofn_fast_noninteractive_setup = True)
+ except: ok = True
+ assert ok
+ res = wallet2of3[i].is_multisig()
+ assert not res.multisig
+
def import_multisig_info(self, signers, expected_outputs):
assert len(signers) >= 2
### tests/unit_tests/multisig.cpp
@@ -280,6 +280,54 @@ static void make_wallets(const unsigned int M, const unsigned int N, const bool
check_results(intermediate_infos, wallets, M);
}
+static void make_wallets_nofn_fast_setup(const unsigned int N, const unsigned int num_fast_setup_wallets)
+{
+ std::vector<tools::wallet2> wallets(N);
+ ASSERT_TRUE(wallets.size() > 1 && wallets.size() <= KEYS_COUNT);
+ ASSERT_TRUE(num_fast_setup_wallets <= wallets.size());
+
+ // initialize wallets, get first round multisig KEX msgs
+ std::vector<std::string> initial_infos(wallets.size());
+
+ for (size_t i = 0; i < wallets.size(); ++i)
+ {
+ make_wallet(i, wallets[i]);
+
+ wallets[i].decrypt_keys("");
+ initial_infos[i] = wallets[i].get_multisig_first_kex_msg();
+ wallets[i].encrypt_keys("");
+ }
+
+ // the first 'num_fast_setup_wallets' wallets use the fast setup, the rest use the normal setup
+ std::vector<std::string> post_kex_infos(wallets.size());
+
+ for (size_t i = 0; i < wallets.size(); ++i)
+ {
+ if (i < num_fast_setup_wallets)
+ {
+ post_kex_infos[i] = wallets[i].multisig_nofn_fast_noninteractive_setup("", initial_infos);
+ EXPECT_TRUE(wallets[i].get_multisig_status().is_ready);
+ }
+ else
+ {
+ post_kex_infos[i] = wallets[i].make_multisig("", initial_infos, N);
+ EXPECT_FALSE(wallets[i].get_multisig_status().is_ready);
+ }
+ }
+
+ // wallets using the normal setup complete the post-KEX round with everyone's post-KEX messages (including the
+ // messages produced by fast-setup wallets)
+ std::vector<std::string> final_infos{post_kex_infos};
+
+ for (size_t i = num_fast_setup_wallets; i < wallets.size(); ++i)
+ {
+ final_infos[i] = wallets[i].exchange_multisig_keys("", post_kex_infos);
+ EXPECT_TRUE(wallets[i].get_multisig_status().is_ready);
+ }
+
+ check_results(final_infos, wallets, N);
+}
+
static void make_wallets_boosting(std::vector<tools::wallet2>& wallets, unsigned int M)
{
ASSERT_TRUE(wallets.size() > 1 && wallets.size() <= KEYS_COUNT);
@@ -408,6 +456,52 @@ TEST(multisig, make_2_3)
make_wallets(2, 3, true);
}
+TEST(multisig, make_nofn_fast_setup)
+{
+ // all wallets use the fast setup
+ make_wallets_nofn_fast_setup(2, 2);
+ make_wallets_nofn_fast_setup(3, 3);
+ make_wallets_nofn_fast_setup(4, 4);
+
+ // some wallets use the fast setup, others use the normal setup
+ make_wallets_nofn_fast_setup(2, 1);
+ make_wallets_nofn_fast_setup(3, 1);
+ make_wallets_nofn_fast_setup(3, 2);
+}
+
+TEST(multisig, make_nofn_fast_setup_invalid)
+{
+ std::vector<tools::wallet2> wallets(3);
+ std::vector<std::string> initial_infos(wallets.size());
+
+ for (size_t i = 0; i < wallets.size(); ++i)
+ {
+ make_wallet(i, wallets[i]);
+
+ wallets[i].decrypt_keys("");
+ initial_infos[i] = wallets[i].get_multisig_first_kex_msg();
+ wallets[i].encrypt_keys("");
+ }
+
+ // only the local signer
+ EXPECT_ANY_THROW(wallets[0].multisig_nofn_fast_noninteractive_setup("", {initial_infos[0]}));
+ EXPECT_FALSE(wallets[0].get_multisig_status().multisig_is_active);
+
+ // local signer missing
+ EXPECT_ANY_THROW(wallets[0].multisig_nofn_fast_noninteractive_setup("", {initial_infos[1], initial_infos[2]}));
+ EXPECT_FALSE(wallets[0].get_multisig_status().multisig_is_active);
+
+ // duplicate signer
+ EXPECT_ANY_THROW(wallets[0].multisig_nofn_fast_noninteractive_setup("", {initial_infos[0], initial_infos[1], initial_infos[1]}));
+ EXPECT_FALSE(wallets[0].get_multisig_status().multisig_is_active);
+
+ // success, then can't set up again
+ EXPECT_NO_THROW(wallets[0].multisig_nofn_fast_noninteractive_setup("", initial_infos));
+ EXPECT_TRUE(wallets[0].get_multisig_status().is_ready);
+ EXPECT_ANY_THROW(wallets[0].multisig_nofn_fast_noninteractive_setup("", initial_infos));
+ EXPECT_TRUE(wallets[0].get_multisig_status().is_ready);
+}
+
TEST(multisig, reload_after_intermediate_exchange)
{
const boost::filesystem::path test_dir = boost::filesystem::temp_directory_path() /
### utils/python-rpc/framework/wallet.py
@@ -545,13 +545,14 @@ def prepare_multisig(self, enable_multisig_experimental = False):
}
return self.rpc.send_json_rpc_request(prepare_multisig)
- def make_multisig(self, multisig_info, threshold, password = ''):
+ def make_multisig(self, multisig_info, threshold, password = '', nofn_fast_noninteractive_setup = False):
make_multisig = {
'method': 'make_multisig',
'params' : {
'multisig_info': multisig_info,
'threshold': threshold,
'password': password,
+ 'nofn_fast_noninteractive_setup': nofn_fast_noninteractive_setup,
},
'jsonrpc': '2.0',
'id': '0'Why this scored 27/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.