mirror of
https://github.com/Retropex/bitcoin.git
synced 2025-08-04 05:54:48 +02:00
378 lines
19 KiB
C++
378 lines
19 KiB
C++
// Copyright (c) 2023 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <bech32.h>
|
|
#include <codex32.h>
|
|
#include <test/util/str.h>
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include <array>
|
|
#include <string>
|
|
|
|
BOOST_AUTO_TEST_SUITE(codex32_tests)
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_misc_invalid)
|
|
{
|
|
// This example uses a "0" threshold with a non-"s" index
|
|
const std::string input1 = "ms10fauxxxxxxxxxxxxxxxxxxxxxxxxxxxx0z26tfn0ulw3p";
|
|
const auto dec1 = codex32::Result{input1};
|
|
BOOST_CHECK_EQUAL(dec1.error(), codex32::INVALID_SHARE_IDX);
|
|
|
|
// This example has a threshold that is not a digit.
|
|
const std::string input2 = "ms1fauxxxxxxxxxxxxxxxxxxxxxxxxxxxxxda3kr3s0s2swg";
|
|
const auto dec2 = codex32::Result{input2};
|
|
BOOST_CHECK_EQUAL(dec2.error(), codex32::INVALID_K);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_vector_1)
|
|
{
|
|
const std::string input = "ms10testsxxxxxxxxxxxxxxxxxxxxxxxxxx4nzvca9cmczlw";
|
|
|
|
const auto dec = codex32::Result{input};
|
|
BOOST_CHECK(dec.IsValid());
|
|
BOOST_CHECK_EQUAL(dec.error(), codex32::OK);
|
|
BOOST_CHECK_EQUAL(dec.GetHrp(), "ms");
|
|
BOOST_CHECK_EQUAL(dec.GetK(), 0);
|
|
BOOST_CHECK_EQUAL(dec.GetIdString(), "test");
|
|
BOOST_CHECK_EQUAL(dec.GetShareIndex(), 's');
|
|
|
|
const auto payload = dec.GetPayload();
|
|
BOOST_CHECK_EQUAL(payload.size(), 16);
|
|
BOOST_CHECK_EQUAL(HexStr(payload), "318c6318c6318c6318c6318c6318c631");
|
|
|
|
// Try re-encoding
|
|
BOOST_CHECK_EQUAL(input, dec.Encode());
|
|
|
|
// Try directly constructing the share
|
|
const auto direct = codex32::Result("ms", 0, "test", 's', payload);
|
|
BOOST_CHECK(direct.IsValid());
|
|
BOOST_CHECK_EQUAL(direct.error(), codex32::OK);
|
|
BOOST_CHECK_EQUAL(direct.GetIdString(), "test");
|
|
BOOST_CHECK_EQUAL(direct.GetShareIndex(), 's');
|
|
|
|
// We cannot check that the codex32 string is exactly the same as the
|
|
// input, since it will not be -- the test vector has nonzero trailing
|
|
// bits while our code will always choose zero trailing bits. But we
|
|
// can at least check that the payloads are identical.
|
|
const auto payload_direct = direct.GetPayload();
|
|
BOOST_CHECK_EQUAL(HexStr(payload), HexStr(payload_direct));
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_vector_2)
|
|
{
|
|
const std::string input_a = "MS12NAMEA320ZYXWVUTSRQPNMLKJHGFEDCAXRPP870HKKQRM";
|
|
const auto dec_a = codex32::Result{input_a};
|
|
BOOST_CHECK(dec_a.IsValid());
|
|
BOOST_CHECK_EQUAL(dec_a.GetHrp(), "ms");
|
|
BOOST_CHECK_EQUAL(dec_a.GetK(), 2);
|
|
BOOST_CHECK_EQUAL(dec_a.GetIdString(), "name");
|
|
BOOST_CHECK_EQUAL(dec_a.GetShareIndex(), 'a');
|
|
BOOST_CHECK(CaseInsensitiveEqual(input_a, dec_a.Encode()));
|
|
|
|
const std::string input_c = "MS12NAMECACDEFGHJKLMNPQRSTUVWXYZ023FTR2GDZMPY6PN";
|
|
const auto dec_c = codex32::Result{input_c};
|
|
BOOST_CHECK(dec_c.IsValid());
|
|
BOOST_CHECK_EQUAL(dec_c.GetHrp(), "ms");
|
|
BOOST_CHECK_EQUAL(dec_c.GetK(), 2);
|
|
BOOST_CHECK_EQUAL(dec_c.GetIdString(), "name");
|
|
BOOST_CHECK_EQUAL(dec_c.GetShareIndex(), 'c');
|
|
BOOST_CHECK(CaseInsensitiveEqual(input_c, dec_c.Encode()));
|
|
|
|
const auto d = codex32::Result{{input_a, input_c}, 'd'};
|
|
BOOST_CHECK(d.IsValid());
|
|
BOOST_CHECK_EQUAL(d.GetHrp(), "ms");
|
|
BOOST_CHECK_EQUAL(d.GetK(), 2);
|
|
BOOST_CHECK_EQUAL(d.GetIdString(), "name");
|
|
BOOST_CHECK_EQUAL(d.GetShareIndex(), 'd');
|
|
BOOST_CHECK(CaseInsensitiveEqual("MS12NAMEDLL4F8JLH4E5VDVULDLFXU2JHDNLSM97XVENRXEG", d.Encode()));
|
|
|
|
const auto err1 = codex32::Result{{}, 's'};
|
|
BOOST_CHECK_EQUAL(err1.error(), codex32::TOO_FEW_SHARES);
|
|
const auto err2 = codex32::Result{{input_c}, 's'};
|
|
BOOST_CHECK_EQUAL(err2.error(), codex32::TOO_FEW_SHARES);
|
|
const auto err3 = codex32::Result{{input_a, input_c}, 'b'};
|
|
BOOST_CHECK_EQUAL(err3.error(), codex32::INVALID_SHARE_IDX);
|
|
|
|
const auto s = codex32::Result{{input_a, input_c}, 's'};
|
|
BOOST_CHECK(s.IsValid());
|
|
BOOST_CHECK_EQUAL(s.GetHrp(), "ms");
|
|
BOOST_CHECK_EQUAL(s.GetK(), 2);
|
|
BOOST_CHECK_EQUAL(s.GetIdString(), "name");
|
|
BOOST_CHECK_EQUAL(s.GetShareIndex(), 's');
|
|
BOOST_CHECK(CaseInsensitiveEqual("MS12NAMES6XQGUZTTXKEQNJSJZV4JV3NZ5K3KWGSPHUH6EVW", s.Encode()));
|
|
|
|
const auto seed = s.GetPayload();
|
|
BOOST_CHECK_EQUAL(seed.size(), 16);
|
|
BOOST_CHECK_EQUAL(HexStr(seed), "d1808e096b35b209ca12132b264662a5");
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_vector_3)
|
|
{
|
|
const auto s = codex32::Result("ms", 3, "Cash", 's', ParseHex("ffeeddccbbaa99887766554433221100"));
|
|
BOOST_CHECK(s.IsValid());
|
|
BOOST_CHECK_EQUAL(s.GetIdString(), "cash");
|
|
BOOST_CHECK_EQUAL(s.GetShareIndex(), 's');
|
|
BOOST_CHECK_EQUAL(s.GetK(), 3);
|
|
BOOST_CHECK_EQUAL(s.Encode(), "ms13cashsllhdmn9m42vcsamx24zrxgs3qqjzqud4m0d6nln");
|
|
|
|
const auto a = codex32::Result{"ms13casha320zyxwvutsrqpnmlkjhgfedca2a8d0zehn8a0t"};
|
|
BOOST_CHECK(a.IsValid());
|
|
BOOST_CHECK_EQUAL(a.GetIdString(), "cash");
|
|
BOOST_CHECK_EQUAL(a.GetShareIndex(), 'a');
|
|
BOOST_CHECK_EQUAL(a.GetK(), 3);
|
|
|
|
const auto c = codex32::Result{"ms13cashcacdefghjklmnpqrstuvwxyz023949xq35my48dr"};
|
|
BOOST_CHECK(c.IsValid());
|
|
BOOST_CHECK_EQUAL(c.GetIdString(), "cash");
|
|
BOOST_CHECK_EQUAL(c.GetShareIndex(), 'c');
|
|
BOOST_CHECK_EQUAL(c.GetK(), 3);
|
|
|
|
const auto err1 = codex32::Result{{}, 'd'};
|
|
BOOST_CHECK_EQUAL(err1.error(), codex32::TOO_FEW_SHARES);
|
|
const auto err2 = codex32::Result{{a, c}, 'd'};
|
|
BOOST_CHECK_EQUAL(err2.error(), codex32::TOO_FEW_SHARES);
|
|
const auto err3 = codex32::Result{{s, a}, 'd'};
|
|
BOOST_CHECK_EQUAL(err3.error(), codex32::TOO_FEW_SHARES);
|
|
const auto err4 = codex32::Result{{s, s, a}, 'd'};
|
|
BOOST_CHECK_EQUAL(err4.error(), codex32::DUPLICATE_SHARE);
|
|
|
|
const auto d = codex32::Result{{s, a, c}, 'd'};
|
|
BOOST_CHECK(d.IsValid());
|
|
BOOST_CHECK_EQUAL(d.GetIdString(), "cash");
|
|
BOOST_CHECK_EQUAL(d.GetShareIndex(), 'd');
|
|
BOOST_CHECK_EQUAL(d.GetK(), 3);
|
|
BOOST_CHECK_EQUAL(d.Encode(), "ms13cashd0wsedstcdcts64cd7wvy4m90lm28w4ffupqs7rm");
|
|
|
|
const auto e = codex32::Result{{a, c, d}, 'e'};
|
|
BOOST_CHECK(e.IsValid());
|
|
BOOST_CHECK_EQUAL(e.GetIdString(), "cash");
|
|
BOOST_CHECK_EQUAL(e.GetShareIndex(), 'e');
|
|
BOOST_CHECK_EQUAL(e.GetK(), 3);
|
|
BOOST_CHECK_EQUAL(e.Encode(), "ms13casheekgpemxzshcrmqhaydlp6yhms3ws7320xyxsar9");
|
|
|
|
const auto f = codex32::Result{{a, s, d}, 'f'};
|
|
BOOST_CHECK(f.IsValid());
|
|
BOOST_CHECK_EQUAL(f.GetIdString(), "cash");
|
|
BOOST_CHECK_EQUAL(f.GetShareIndex(), 'f');
|
|
BOOST_CHECK_EQUAL(f.GetK(), 3);
|
|
BOOST_CHECK_EQUAL(f.Encode(), "ms13cashf8jh6sdrkpyrsp5ut94pj8ktehhw2hfvyrj48704");
|
|
|
|
// Mismatched data
|
|
const auto g1 = codex32::Result{"ms", 2, "cash", 'g', ParseHex("ffeeddccbbaa99887766554433221100")};
|
|
BOOST_CHECK(g1.IsValid());
|
|
const auto err_s1 = codex32::Result{{a, c, g1}, 's'};
|
|
BOOST_CHECK_EQUAL(err_s1.error(), codex32::MISMATCH_K);
|
|
|
|
const auto g2 = codex32::Result{"ms", 3, "leet", 'g', ParseHex("ffeeddccbbaa99887766554433221100")};
|
|
BOOST_CHECK(g2.IsValid());
|
|
const auto err_s2 = codex32::Result{{a, c, g2}, 's'};
|
|
BOOST_CHECK_EQUAL(err_s2.error(), codex32::MISMATCH_ID);
|
|
|
|
const auto g3 = codex32::Result{"ms", 3, "cash", 'g', ParseHex("ffeeddccbbaa99887766554433221100ab")};
|
|
BOOST_CHECK(g3.IsValid());
|
|
const auto err_s3 = codex32::Result{{a, c, g3}, 's'};
|
|
BOOST_CHECK_EQUAL(err_s3.error(), codex32::MISMATCH_LENGTH);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_vector_4)
|
|
{
|
|
const std::string seed = "ffeeddccbbaa99887766554433221100ffeeddccbbaa99887766554433221100";
|
|
const auto s = codex32::Result{"ms", 0, "leet", 's', ParseHex(seed)};
|
|
BOOST_CHECK(s.IsValid());
|
|
BOOST_CHECK_EQUAL(s.GetIdString(), "leet");
|
|
BOOST_CHECK_EQUAL(s.GetShareIndex(), 's');
|
|
BOOST_CHECK_EQUAL(s.GetK(), 0);
|
|
BOOST_CHECK_EQUAL(HexStr(s.GetPayload()), seed);
|
|
BOOST_CHECK_EQUAL(s.Encode(), "ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqqtum9pgv99ycma");
|
|
|
|
std::vector<std::string> alternates = {
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqqtum9pgv99ycma",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqpj82dp34u6lqtd",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqzsrs4pnh7jmpj5",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqrfcpap2w8dqezy",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqy5tdvphn6znrf0",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyq9dsuypw2ragmel",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqx05xupvgp4v6qx",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyq8k0h5p43c2hzsk",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqgum7hplmjtr8ks",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqf9q0lpxzt5clxq",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyq28y48pyqfuu7le",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqt7ly0paesr8x0f",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqvrvg7pqydv5uyz",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqd6hekpea5n0y5j",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyqwcnrwpmlkmt9dt",
|
|
"ms10leetsllhdmn9m42vcsamx24zrxgs3qrl7ahwvhw4fnzrhve25gvezzyq0pgjxpzx0ysaam",
|
|
};
|
|
for (const auto& alt : alternates) {
|
|
const auto s_alt = codex32::Result{alt};
|
|
BOOST_CHECK(s_alt.IsValid());
|
|
BOOST_CHECK_EQUAL(HexStr(s_alt.GetPayload()), seed);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_vector_5)
|
|
{
|
|
const auto s = codex32::Result{"MS100C8VSM32ZXFGUHPCHTLUPZRY9X8GF2TVDW0S3JN54KHCE6MUA7LQPZYGSFJD6AN074RXVCEMLH8WU3TK925ACDEFGHJKLMNPQRSTUVWXY06FHPV80UNDVARHRAK"};
|
|
BOOST_CHECK(s.IsValid());
|
|
BOOST_CHECK_EQUAL(s.error(), codex32::OK);
|
|
BOOST_CHECK_EQUAL(s.GetIdString(), "0c8v");
|
|
BOOST_CHECK_EQUAL(s.GetShareIndex(), 's');
|
|
BOOST_CHECK_EQUAL(s.GetK(), 0);
|
|
BOOST_CHECK_EQUAL(HexStr(s.GetPayload()), "dc5423251cb87175ff8110c8531d0952d8d73e1194e95b5f19d6f9df7c01111104c9baecdfea8cccc677fb9ddc8aec5553b86e528bcadfdcc201c17c638c47e9");
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_errors)
|
|
{
|
|
const std::vector<codex32::Result> errs = {
|
|
codex32::Result("ms", 3, "cash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
// bad hrp
|
|
codex32::Result("bc", 3, "cash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
// bad ID len
|
|
codex32::Result("ms", 3, "cas", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 3, "cashcashcash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 3, "", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
// bad id char
|
|
codex32::Result("ms", 3, "bash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
// bad k
|
|
codex32::Result("ms", 1, "cash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 10, "cash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 100000, "cash", 's', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
// bad share idx
|
|
codex32::Result("ms", 100000, "cash", 'b', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 100000, "cash", 'i', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 100000, "cash", '1', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 100000, "cash", 'o', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
codex32::Result("ms", 100000, "cash", ' ', ParseHex("ffeeddccbbaa99887766554433221100")),
|
|
};
|
|
|
|
BOOST_CHECK_EQUAL(errs[0].error(), codex32::OK);
|
|
BOOST_CHECK_EQUAL(errs[1].error(), codex32::INVALID_HRP);
|
|
BOOST_CHECK_EQUAL(errs[2].error(), codex32::INVALID_ID_LEN);
|
|
BOOST_CHECK_EQUAL(errs[3].error(), codex32::INVALID_ID_LEN);
|
|
BOOST_CHECK_EQUAL(errs[4].error(), codex32::INVALID_ID_LEN);
|
|
BOOST_CHECK_EQUAL(errs[5].error(), codex32::INVALID_ID_CHAR);
|
|
BOOST_CHECK_EQUAL(errs[6].error(), codex32::INVALID_K);
|
|
BOOST_CHECK_EQUAL(errs[7].error(), codex32::INVALID_K);
|
|
BOOST_CHECK_EQUAL(errs[8].error(), codex32::INVALID_K);
|
|
BOOST_CHECK_EQUAL(errs[9].error(), codex32::INVALID_SHARE_IDX);
|
|
BOOST_CHECK_EQUAL(errs[10].error(), codex32::INVALID_SHARE_IDX);
|
|
BOOST_CHECK_EQUAL(errs[11].error(), codex32::INVALID_SHARE_IDX);
|
|
BOOST_CHECK_EQUAL(errs[12].error(), codex32::INVALID_SHARE_IDX);
|
|
BOOST_CHECK_EQUAL(errs[13].error(), codex32::INVALID_SHARE_IDX);
|
|
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_invalid_1)
|
|
{
|
|
std::vector<std::string> bad_checksum = {
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxve740yyge2ghq",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxve740yyge2ghp",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxlk3yepcstwr",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxx6pgnv7jnpcsp",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxx0cpvr7n4geq",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxm5252y7d3lr",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxrd9sukzl05ej",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxc55srw5jrm0",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxgc7rwhtudwc",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxx4gy22afwghvs",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxme084q0vpht7pe0",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxme084q0vpht7pew",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxqyadsp3nywm8a",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxzvg7ar4hgaejk",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcznau0advgxqe",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxch3jrc6j5040j",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx52gxl6ppv40mcv",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx7g4g2nhhle8fk",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx63m45uj8ss4x8",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy4r708q7kg65x",
|
|
};
|
|
for (const auto& bad : bad_checksum) {
|
|
auto res = codex32::Result{bad};
|
|
BOOST_CHECK_EQUAL(res.error(), codex32::BAD_CHECKSUM);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_invalid_2)
|
|
{
|
|
std::vector<std::string> bad_checksum = {
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxurfvwmdcmymdufv",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxcsyppjkd8lz4hx3",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxu6hwvl5p0l9xf3c",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxwqey9rfs6smenxa",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxv70wkzrjr4ntqet",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx3hmlrmpa4zl0v",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxrfggf88znkaup",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxpt7l4aycv9qzj",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxus27z9xtyxyw3",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcwm4re8fs78vn",
|
|
};
|
|
for (const auto& bad : bad_checksum) {
|
|
auto res = codex32::Result{bad};
|
|
BOOST_CHECK(res.error() == codex32::BAD_CHECKSUM || res.error() == codex32::INVALID_LENGTH);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_invalid_3)
|
|
{
|
|
std::vector<std::string> bad_checksum = {
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxw0a4c70rfefn4",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxk4pavy5n46nea",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxx9lrwar5zwng4w",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxr335l5tv88js3",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxvu7q9nz8p7dj68v",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxpq6k542scdxndq3",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkmfw6jm270mz6ej",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxzhddxw99w7xws",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxxx42cux6um92rz",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxxxxarja5kqukdhy9",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxky0ua3ha84qk8",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx9eheesxadh2n2n9",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx9llwmgesfulcj2z",
|
|
"ms12fauxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx02ev7caq6n9fgkf",
|
|
};
|
|
for (const auto& bad : bad_checksum) {
|
|
auto res = codex32::Result{bad};
|
|
BOOST_CHECK_EQUAL(res.error(), codex32::INVALID_LENGTH);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_invalid_hrp)
|
|
{
|
|
std::vector<std::string> bad_checksum = {
|
|
"0fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"ms0fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"m10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"s10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"0fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxhkd4f70m8lgws",
|
|
"10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxhkd4f70m8lgws",
|
|
"m10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxx8t28z74x8hs4l",
|
|
"s10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxh9d0fhnvfyx3x",
|
|
};
|
|
for (const auto& bad : bad_checksum) {
|
|
auto res = codex32::Result{bad};
|
|
BOOST_CHECK(res.error() == codex32::INVALID_HRP || res.error() == codex32::BECH32_DECODE);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(codex32_bip93_invalid_case)
|
|
{
|
|
std::vector<std::string> bad_checksum = {
|
|
"Ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"mS10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"MS10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"ms10FAUXsxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"ms10fauxSxxxxxxxxxxxxxxxxxxxxxxxxxxuqxkk05lyf3x2",
|
|
"ms10fauxsXXXXXXXXXXXXXXXXXXXXXXXXXXuqxkk05lyf3x2",
|
|
"ms10fauxsxxxxxxxxxxxxxxxxxxxxxxxxxxUQXKK05LYF3X2",
|
|
};
|
|
for (const auto& bad : bad_checksum) {
|
|
auto res = codex32::Result{bad};
|
|
BOOST_CHECK_EQUAL(res.error(), codex32::BECH32_DECODE);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|