aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/core_tests/chaingen.h43
-rw-r--r--tests/core_tests/chaingen_main.cpp10
-rw-r--r--tests/core_tests/multisig.cpp152
-rw-r--r--tests/core_tests/multisig.h60
-rw-r--r--tests/unit_tests/multisig.cpp179
5 files changed, 298 insertions, 146 deletions
diff --git a/tests/core_tests/chaingen.h b/tests/core_tests/chaingen.h
index 34b205ae5..6b9277a30 100644
--- a/tests/core_tests/chaingen.h
+++ b/tests/core_tests/chaingen.h
@@ -544,6 +544,7 @@ inline bool do_replay_file(const std::string& filename)
}
return do_replay_events<t_test_class>(events);
}
+
//--------------------------------------------------------------------------
#define GENERATE_ACCOUNT(account) \
cryptonote::account_base account; \
@@ -556,47 +557,7 @@ inline bool do_replay_file(const std::string& filename)
{ \
for (size_t msidx = 0; msidx < total; ++msidx) \
account[msidx].generate(); \
- std::unordered_set<crypto::public_key> all_multisig_keys; \
- std::vector<std::vector<crypto::secret_key>> view_keys(total); \
- std::vector<std::vector<crypto::public_key>> spend_keys(total); \
- for (size_t msidx = 0; msidx < total; ++msidx) \
- { \
- for (size_t msidx_inner = 0; msidx_inner < total; ++msidx_inner) \
- { \
- if (msidx_inner != msidx) \
- { \
- crypto::secret_key vkh = cryptonote::get_multisig_blinded_secret_key(account[msidx_inner].get_keys().m_view_secret_key); \
- view_keys[msidx].push_back(vkh); \
- crypto::secret_key skh = cryptonote::get_multisig_blinded_secret_key(account[msidx_inner].get_keys().m_spend_secret_key); \
- crypto::public_key pskh; \
- crypto::secret_key_to_public_key(skh, pskh); \
- spend_keys[msidx].push_back(pskh); \
- } \
- } \
- } \
- for (size_t msidx = 0; msidx < total; ++msidx) \
- { \
- std::vector<crypto::secret_key> multisig_keys; \
- crypto::secret_key spend_skey; \
- crypto::public_key spend_pkey; \
- if (threshold == total) \
- cryptonote::generate_multisig_N_N(account[msidx].get_keys(), spend_keys[msidx], multisig_keys, (rct::key&)spend_skey, (rct::key&)spend_pkey); \
- else \
- cryptonote::generate_multisig_N1_N(account[msidx].get_keys(), spend_keys[msidx], multisig_keys, (rct::key&)spend_skey, (rct::key&)spend_pkey); \
- crypto::secret_key view_skey = cryptonote::generate_multisig_view_secret_key(account[msidx].get_keys().m_view_secret_key, view_keys[msidx]); \
- account[msidx].make_multisig(view_skey, spend_skey, spend_pkey, multisig_keys); \
- for (const auto &k: multisig_keys) \
- all_multisig_keys.insert(rct::rct2pk(rct::scalarmultBase(rct::sk2rct(k)))); \
- } \
- if (threshold < total) \
- { \
- std::vector<crypto::public_key> spend_public_keys; \
- for (const auto &k: all_multisig_keys) \
- spend_public_keys.push_back(k); \
- crypto::public_key spend_pkey = cryptonote::generate_multisig_N1_N_spend_public_key(spend_public_keys); \
- for (size_t msidx = 0; msidx < total; ++msidx) \
- account[msidx].finalize_multisig(spend_pkey); \
- } \
+ make_multisig_accounts(account, threshold); \
} while(0)
#define MAKE_ACCOUNT(VEC_EVENTS, account) \
diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp
index abc412318..84254cfdb 100644
--- a/tests/core_tests/chaingen_main.cpp
+++ b/tests/core_tests/chaingen_main.cpp
@@ -223,6 +223,16 @@ int main(int argc, char* argv[])
GENERATE_AND_PLAY(gen_multisig_tx_invalid_33_1__no_threshold);
GENERATE_AND_PLAY(gen_multisig_tx_invalid_33_1_2_no_threshold);
GENERATE_AND_PLAY(gen_multisig_tx_invalid_33_1_3_no_threshold);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_24_1_2);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_24_1_2_many_inputs);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_25_1_2);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_25_1_2_many_inputs);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_48_1_234);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_48_1_234_many_inputs);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_24_1_no_signers);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_25_1_no_signers);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_48_1_no_signers);
+ GENERATE_AND_PLAY(gen_multisig_tx_valid_48_1_23_no_threshold);
GENERATE_AND_PLAY(gen_bp_tx_valid_1);
GENERATE_AND_PLAY(gen_bp_tx_invalid_1_1);
diff --git a/tests/core_tests/multisig.cpp b/tests/core_tests/multisig.cpp
index 46cc0ff35..fe5feb942 100644
--- a/tests/core_tests/multisig.cpp
+++ b/tests/core_tests/multisig.cpp
@@ -41,6 +41,87 @@ using namespace cryptonote;
//#define NO_MULTISIG
+void make_multisig_accounts(std::vector<cryptonote::account_base>& account, uint32_t threshold)
+{
+ std::vector<crypto::secret_key> all_view_keys;
+ std::vector<std::vector<crypto::public_key>> derivations(account.size());
+ //storage for all set of multisig derivations and spend public key (in first round)
+ std::unordered_set<crypto::public_key> exchanging_keys;
+
+ for (size_t msidx = 0; msidx < account.size(); ++msidx)
+ {
+ crypto::secret_key vkh = cryptonote::get_multisig_blinded_secret_key(account[msidx].get_keys().m_view_secret_key);
+ all_view_keys.push_back(vkh);
+
+ crypto::secret_key skh = cryptonote::get_multisig_blinded_secret_key(account[msidx].get_keys().m_spend_secret_key);
+ crypto::public_key pskh;
+ crypto::secret_key_to_public_key(skh, pskh);
+
+ derivations[msidx].push_back(pskh);
+ exchanging_keys.insert(pskh);
+ }
+
+ uint32_t roundsTotal = 1;
+ if (threshold < account.size())
+ roundsTotal = account.size() - threshold;
+
+ //secret multisig keys of every account
+ std::vector<std::vector<crypto::secret_key>> multisig_keys(account.size());
+ std::vector<crypto::secret_key> spend_skey(account.size());
+ std::vector<crypto::public_key> spend_pkey(account.size());
+ for (uint32_t round = 0; round < roundsTotal; ++round)
+ {
+ std::unordered_set<crypto::public_key> roundKeys;
+ for (size_t msidx = 0; msidx < account.size(); ++msidx)
+ {
+ // subtracting one's keys from set of all unique keys is the same as key exchange
+ auto myKeys = exchanging_keys;
+ for (const auto& d: derivations[msidx])
+ myKeys.erase(d);
+
+ if (threshold == account.size())
+ {
+ cryptonote::generate_multisig_N_N(account[msidx].get_keys(), std::vector<crypto::public_key>(myKeys.begin(), myKeys.end()), multisig_keys[msidx], (rct::key&)spend_skey[msidx], (rct::key&)spend_pkey[msidx]);
+ }
+ else
+ {
+ derivations[msidx] = cryptonote::generate_multisig_derivations(account[msidx].get_keys(), std::vector<crypto::public_key>(myKeys.begin(), myKeys.end()));
+ roundKeys.insert(derivations[msidx].begin(), derivations[msidx].end());
+ }
+ }
+
+ exchanging_keys = roundKeys;
+ roundKeys.clear();
+ }
+
+ std::unordered_set<crypto::public_key> all_multisig_keys;
+ for (size_t msidx = 0; msidx < account.size(); ++msidx)
+ {
+ std::unordered_set<crypto::secret_key> view_keys(all_view_keys.begin(), all_view_keys.end());
+ view_keys.erase(all_view_keys[msidx]);
+
+ crypto::secret_key view_skey = cryptonote::generate_multisig_view_secret_key(account[msidx].get_keys().m_view_secret_key, std::vector<secret_key>(view_keys.begin(), view_keys.end()));
+ if (threshold < account.size())
+ {
+ multisig_keys[msidx] = cryptonote::calculate_multisig_keys(derivations[msidx]);
+ spend_skey[msidx] = cryptonote::calculate_multisig_signer_key(multisig_keys[msidx]);
+ }
+ account[msidx].make_multisig(view_skey, spend_skey[msidx], spend_pkey[msidx], multisig_keys[msidx]);
+ for (const auto &k: multisig_keys[msidx]) {
+ all_multisig_keys.insert(rct::rct2pk(rct::scalarmultBase(rct::sk2rct(k))));
+ }
+ }
+
+ if (threshold < account.size())
+ {
+ std::vector<crypto::public_key> public_keys(std::vector<crypto::public_key>(all_multisig_keys.begin(), all_multisig_keys.end()));
+ crypto::public_key spend_pkey = cryptonote::generate_multisig_M_N_spend_public_key(public_keys);
+
+ for (size_t msidx = 0; msidx < account.size(); ++msidx)
+ account[msidx].finalize_multisig(spend_pkey);
+ }
+}
+
//----------------------------------------------------------------------------------------------------------------------
// Tests
@@ -55,7 +136,6 @@ bool gen_multisig_tx_validation_base::generate_with(std::vector<test_event_entry
CHECK_AND_ASSERT_MES(total >= 2, false, "Bad scheme");
CHECK_AND_ASSERT_MES(threshold <= total, false, "Bad scheme");
- CHECK_AND_ASSERT_MES(threshold >= total - 1, false, "Unsupported scheme");
#ifdef NO_MULTISIG
CHECK_AND_ASSERT_MES(total <= 5, false, "Unsupported scheme");
#endif
@@ -480,6 +560,48 @@ bool gen_multisig_tx_valid_89_3_1245789::generate(std::vector<test_event_entry>&
return generate_with(events, 2, mixin, amount_paid, true, 8, 9, 3, {1, 2, 4, 5, 7, 8, 9}, NULL, NULL);
}
+bool gen_multisig_tx_valid_24_1_2::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, true, 2, 4, 1, {2}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_24_1_2_many_inputs::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 4, mixin, amount_paid, true, 2, 4, 1, {2}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_25_1_2::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, true, 2, 5, 1, {2}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_25_1_2_many_inputs::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 4, mixin, amount_paid, true, 2, 5, 1, {2}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_48_1_234::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, true, 4, 8, 1, {2, 3, 4}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_48_1_234_many_inputs::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 4, mixin, amount_paid, true, 4, 8, 1, {2, 3, 4}, NULL, NULL);
+}
+
bool gen_multisig_tx_invalid_22_1__no_threshold::generate(std::vector<test_event_entry>& events) const
{
const size_t mixin = 4;
@@ -521,3 +643,31 @@ bool gen_multisig_tx_invalid_45_5_23_no_threshold::generate(std::vector<test_eve
const uint64_t amount_paid = 10000;
return generate_with(events, 2, mixin, amount_paid, false, 4, 5, 5, {2, 3}, NULL, NULL);
}
+
+bool gen_multisig_tx_valid_24_1_no_signers::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, false, 2, 4, 1, {}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_25_1_no_signers::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, false, 2, 5, 1, {}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_48_1_no_signers::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, false, 4, 8, 1, {}, NULL, NULL);
+}
+
+bool gen_multisig_tx_valid_48_1_23_no_threshold::generate(std::vector<test_event_entry>& events) const
+{
+ const size_t mixin = 4;
+ const uint64_t amount_paid = 10000;
+ return generate_with(events, 2, mixin, amount_paid, false, 4, 8, 1, {2, 3}, NULL, NULL);
+}
diff --git a/tests/core_tests/multisig.h b/tests/core_tests/multisig.h
index f0157a6d1..9e4cb3a23 100644
--- a/tests/core_tests/multisig.h
+++ b/tests/core_tests/multisig.h
@@ -161,6 +161,42 @@ struct gen_multisig_tx_valid_89_3_1245789: public gen_multisig_tx_validation_bas
};
template<> struct get_test_options<gen_multisig_tx_valid_89_3_1245789>: public get_test_options<gen_multisig_tx_validation_base> {};
+struct gen_multisig_tx_valid_24_1_2: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_24_1_2>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_24_1_2_many_inputs: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_24_1_2_many_inputs>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_25_1_2: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_25_1_2>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_25_1_2_many_inputs: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_25_1_2_many_inputs>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_48_1_234: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_48_1_234>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_48_1_234_many_inputs: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_48_1_234_many_inputs>: public get_test_options<gen_multisig_tx_validation_base> {};
+
// invalid
struct gen_multisig_tx_invalid_22_1__no_threshold: public gen_multisig_tx_validation_base
{
@@ -197,3 +233,27 @@ struct gen_multisig_tx_invalid_45_5_23_no_threshold: public gen_multisig_tx_vali
bool generate(std::vector<test_event_entry>& events) const;
};
template<> struct get_test_options<gen_multisig_tx_invalid_45_5_23_no_threshold>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_24_1_no_signers: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_24_1_no_signers>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_25_1_no_signers: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_25_1_no_signers>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_48_1_no_signers: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_48_1_no_signers>: public get_test_options<gen_multisig_tx_validation_base> {};
+
+struct gen_multisig_tx_valid_48_1_23_no_threshold: public gen_multisig_tx_validation_base
+{
+ bool generate(std::vector<test_event_entry>& events) const;
+};
+template<> struct get_test_options<gen_multisig_tx_valid_48_1_23_no_threshold>: public get_test_options<gen_multisig_tx_validation_base> {};
diff --git a/tests/unit_tests/multisig.cpp b/tests/unit_tests/multisig.cpp
index 83924c7af..7268f2690 100644
--- a/tests/unit_tests/multisig.cpp
+++ b/tests/unit_tests/multisig.cpp
@@ -49,9 +49,19 @@ static const struct
{
"9t6Hn946u3eah5cuncH1hB5hGzsTUoevtf4SY7MHN5NgJZh2SFWsyVt3vUhuHyRKyrCQvr71Lfc1AevG3BXE11PQFoXDtD8",
"bbd3175ef9fd9f5eefdc43035f882f74ad14c4cf1799d8b6f9001bc197175d02"
+ },
+ {
+ "9zmAWoNyNPbgnYSm3nJNpAKHm6fCcs3MR94gBWxp9MCDUiMUhyYFfyQETUDLPF7DP6ZsmNo6LRxwPP9VmhHNxKrER9oGigT",
+ "f2efae45bef1917a7430cda8fcffc4ee010e3178761aa41d4628e23b1fe2d501"
+ },
+ {
+ "9ue8NJMg3WzKxTtmjeXzWYF5KmU6dC7LHEt9wvYdPn2qMmoFUa8hJJHhSHvJ46UEwpDyy5jSboNMRaDBKwU54NT42YcNUp5",
+ "a4cef54ed3fd61cd78a2ceb82ecf85a903ad2db9a86fb77ff56c35c56016280a"
}
};
+static const size_t KEYS_COUNT = 5;
+
static void make_wallet(unsigned int idx, tools::wallet2 &wallet)
{
ASSERT_TRUE(idx < sizeof(test_addresses) / sizeof(test_addresses[0]));
@@ -76,126 +86,87 @@ static void make_wallet(unsigned int idx, tools::wallet2 &wallet)
}
}
-static void make_M_2_wallet(tools::wallet2 &wallet0, tools::wallet2 &wallet1, unsigned int M)
+static std::vector<std::string> exchange_round(std::vector<tools::wallet2>& wallets, const std::vector<std::string>& mis)
{
- ASSERT_TRUE(M <= 2);
-
- make_wallet(0, wallet0);
- make_wallet(1, wallet1);
-
- std::vector<crypto::secret_key> sk0(1), sk1(1);
- std::vector<crypto::public_key> pk0(1), pk1(1);
-
- wallet0.decrypt_keys("");
- std::string mi0 = wallet0.get_multisig_info();
- wallet0.encrypt_keys("");
- wallet1.decrypt_keys("");
- std::string mi1 = wallet1.get_multisig_info();
- wallet1.encrypt_keys("");
-
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi1, sk0[0], pk0[0]));
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi0, sk1[0], pk1[0]));
-
- ASSERT_FALSE(wallet0.multisig() || wallet1.multisig());
- wallet0.make_multisig("", sk0, pk0, M);
- wallet1.make_multisig("", sk1, pk1, M);
-
- ASSERT_TRUE(wallet0.get_account().get_public_address_str(cryptonote::TESTNET) == wallet1.get_account().get_public_address_str(cryptonote::TESTNET));
-
- bool ready;
- uint32_t threshold, total;
- ASSERT_TRUE(wallet0.multisig(&ready, &threshold, &total));
- ASSERT_TRUE(ready);
- ASSERT_TRUE(threshold == M);
- ASSERT_TRUE(total == 2);
- ASSERT_TRUE(wallet1.multisig(&ready, &threshold, &total));
- ASSERT_TRUE(ready);
- ASSERT_TRUE(threshold == M);
- ASSERT_TRUE(total == 2);
+ std::vector<std::string> new_infos;
+ for (size_t i = 0; i < wallets.size(); ++i) {
+ new_infos.push_back(wallets[i].exchange_multisig_keys("", mis));
+ }
+
+ return new_infos;
}
-static void make_M_3_wallet(tools::wallet2 &wallet0, tools::wallet2 &wallet1, tools::wallet2 &wallet2, unsigned int M)
+static void make_wallets(std::vector<tools::wallet2>& wallets, unsigned int M)
{
- ASSERT_TRUE(M <= 3);
-
- make_wallet(0, wallet0);
- make_wallet(1, wallet1);
- make_wallet(2, wallet2);
-
- std::vector<crypto::secret_key> sk0(2), sk1(2), sk2(2);
- std::vector<crypto::public_key> pk0(2), pk1(2), pk2(2);
-
- wallet0.decrypt_keys("");
- std::string mi0 = wallet0.get_multisig_info();
- wallet0.encrypt_keys("");
- wallet1.decrypt_keys("");
- std::string mi1 = wallet1.get_multisig_info();
- wallet1.encrypt_keys("");
- wallet2.decrypt_keys("");
- std::string mi2 = wallet2.get_multisig_info();
- wallet2.encrypt_keys("");
-
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi1, sk0[0], pk0[0]));
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi2, sk0[1], pk0[1]));
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi0, sk1[0], pk1[0]));
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi2, sk1[1], pk1[1]));
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi0, sk2[0], pk2[0]));
- ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi1, sk2[1], pk2[1]));
-
- ASSERT_FALSE(wallet0.multisig() || wallet1.multisig() || wallet2.multisig());
- std::string mxi0 = wallet0.make_multisig("", sk0, pk0, M);
- std::string mxi1 = wallet1.make_multisig("", sk1, pk1, M);
- std::string mxi2 = wallet2.make_multisig("", sk2, pk2, M);
-
- const size_t nset = !mxi0.empty() + !mxi1.empty() + !mxi2.empty();
- ASSERT_TRUE((M < 3 && nset == 3) || (M == 3 && nset == 0));
-
- if (nset > 0)
- {
- std::unordered_set<crypto::public_key> pkeys;
- std::vector<crypto::public_key> signers(3, crypto::null_pkey);
- ASSERT_TRUE(tools::wallet2::verify_extra_multisig_info(mxi0, pkeys, signers[0]));
- ASSERT_TRUE(tools::wallet2::verify_extra_multisig_info(mxi1, pkeys, signers[1]));
- ASSERT_TRUE(tools::wallet2::verify_extra_multisig_info(mxi2, pkeys, signers[2]));
- ASSERT_TRUE(pkeys.size() == 3);
- ASSERT_TRUE(wallet0.finalize_multisig("", pkeys, signers));
- ASSERT_TRUE(wallet1.finalize_multisig("", pkeys, signers));
- ASSERT_TRUE(wallet2.finalize_multisig("", pkeys, signers));
+ ASSERT_TRUE(wallets.size() > 1 && wallets.size() <= KEYS_COUNT);
+ ASSERT_TRUE(M <= wallets.size());
+
+ std::vector<std::string> mis(wallets.size());
+
+ for (size_t i = 0; i < wallets.size(); ++i) {
+ make_wallet(i, wallets[i]);
+
+ wallets[i].decrypt_keys("");
+ mis[i] = wallets[i].get_multisig_info();
+ wallets[i].encrypt_keys("");
+ }
+
+ for (auto& wallet: wallets) {
+ ASSERT_FALSE(wallet.multisig() || wallet.multisig() || wallet.multisig());
+ }
+
+ std::vector<std::string> mxis;
+ for (size_t i = 0; i < wallets.size(); ++i) {
+ // it's ok to put all of multisig keys in this function. it throws in case of error
+ mxis.push_back(wallets[i].make_multisig("", mis, M));
}
- ASSERT_TRUE(wallet0.get_account().get_public_address_str(cryptonote::TESTNET) == wallet1.get_account().get_public_address_str(cryptonote::TESTNET));
- ASSERT_TRUE(wallet0.get_account().get_public_address_str(cryptonote::TESTNET) == wallet2.get_account().get_public_address_str(cryptonote::TESTNET));
-
- bool ready;
- uint32_t threshold, total;
- ASSERT_TRUE(wallet0.multisig(&ready, &threshold, &total));
- ASSERT_TRUE(ready);
- ASSERT_TRUE(threshold == M);
- ASSERT_TRUE(total == 3);
- ASSERT_TRUE(wallet1.multisig(&ready, &threshold, &total));
- ASSERT_TRUE(ready);
- ASSERT_TRUE(threshold == M);
- ASSERT_TRUE(total == 3);
- ASSERT_TRUE(wallet2.multisig(&ready, &threshold, &total));
- ASSERT_TRUE(ready);
- ASSERT_TRUE(threshold == M);
- ASSERT_TRUE(total == 3);
+ while (!mxis[0].empty()) {
+ mxis = exchange_round(wallets, mxis);
+ }
+
+ for (size_t i = 0; i < wallets.size(); ++i) {
+ ASSERT_TRUE(mxis[i].empty());
+ bool ready;
+ uint32_t threshold, total;
+ ASSERT_TRUE(wallets[i].multisig(&ready, &threshold, &total));
+ ASSERT_TRUE(ready);
+ ASSERT_TRUE(threshold == M);
+ ASSERT_TRUE(total == wallets.size());
+
+ if (i != 0) {
+ // "equals" is transitive relation so we need only to compare first wallet's address to each others' addresses. no need to compare 0's address with itself.
+ ASSERT_TRUE(wallets[0].get_account().get_public_address_str(cryptonote::TESTNET) == wallets[i].get_account().get_public_address_str(cryptonote::TESTNET));
+ }
+ }
}
TEST(multisig, make_2_2)
{
- tools::wallet2 wallet0, wallet1;
- make_M_2_wallet(wallet0, wallet1, 2);
+ std::vector<tools::wallet2> wallets(2);
+ make_wallets(wallets, 2);
}
TEST(multisig, make_3_3)
{
- tools::wallet2 wallet0, wallet1, wallet2;
- make_M_3_wallet(wallet0, wallet1, wallet2, 3);
+ std::vector<tools::wallet2> wallets(3);
+ make_wallets(wallets, 3);
}
TEST(multisig, make_2_3)
{
- tools::wallet2 wallet0, wallet1, wallet2;
- make_M_3_wallet(wallet0, wallet1, wallet2, 2);
+ std::vector<tools::wallet2> wallets(3);
+ make_wallets(wallets, 2);
+}
+
+TEST(multisig, make_2_4)
+{
+ std::vector<tools::wallet2> wallets(4);
+ make_wallets(wallets, 2);
+}
+
+TEST(multisig, make_2_5)
+{
+ std::vector<tools::wallet2> wallets(5);
+ make_wallets(wallets, 2);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 01:02:51 +0000