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

unit_tests: asset_id serializations test: WIP

Browse source
This commit is contained in:
sowle 2024-10-22 18:27:17 +02:00
parent 121067e36d
commit d23fa1911e
No known key found for this signature in database
GPG key ID: C07A24B2D89D49FC
1 changed files with 126 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

264
tests/unit_tests/multiassets_test.cpp
View file

@ -19,123 +19,101 @@
namespace currency
{
struct asset_descriptor_base_v0;
struct asset_descriptor_operation_v0;
}
// branch = develop, HEAD = 0c90262e8a1c4e5e5d052f8db84c60a36691414d
struct currency::asset_descriptor_base_v0
{
uint64_t total_max_supply;
uint64_t current_supply;
uint8_t decimal_point;
std::string ticker;
std::string full_name;
std::string meta_info;
crypto::public_key owner = currency::null_pkey; // consider premultipling by 1/8
bool hidden_supply;
uint8_t version;
BEGIN_VERSIONED_SERIALIZE(0, version)
FIELD(total_max_supply)
FIELD(current_supply)
FIELD(decimal_point)
FIELD(ticker)
FIELD(full_name)
FIELD(meta_info)
FIELD(owner)
FIELD(hidden_supply)
END_SERIALIZE()
BEGIN_BOOST_SERIALIZATION()
BOOST_SERIALIZE(total_max_supply)
BOOST_SERIALIZE(current_supply)
BOOST_SERIALIZE(decimal_point)
BOOST_SERIALIZE(ticker)
BOOST_SERIALIZE(full_name)
BOOST_SERIALIZE(meta_info)
BOOST_SERIALIZE(owner)
BOOST_SERIALIZE(hidden_supply)
BOOST_END_VERSION_UNDER(1)
END_BOOST_SERIALIZATION()
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(total_max_supply) DOC_DSCR("Maximum possible supply for a given asset, cannot be changed after deployment.") DOC_EXMP(1000000000000000000) DOC_END
KV_SERIALIZE(current_supply) DOC_DSCR("Currently emitted supply for the given asset (ignored for REGISTER operation).") DOC_EXMP(500000000000000000) DOC_END
KV_SERIALIZE(decimal_point) DOC_DSCR("Decimal point.") DOC_EXMP(12) DOC_END
KV_SERIALIZE(ticker) DOC_DSCR("Ticker associated with the asset.") DOC_EXMP("ZABC") DOC_END
KV_SERIALIZE(full_name) DOC_DSCR("Full name of the asset.") DOC_EXMP("Zano wrapped ABC") DOC_END
KV_SERIALIZE(meta_info) DOC_DSCR("Any other information associated with the asset in free form.") DOC_EXMP("Stable and private") DOC_END
KV_SERIALIZE_POD_AS_HEX_STRING(owner) DOC_DSCR("Owner's key, used only for EMIT and UPDATE validation, can be changed by transferring asset ownership.") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
KV_SERIALIZE(hidden_supply) DOC_DSCR("This field is reserved for future use and will be documented later.") DOC_END
END_KV_SERIALIZE_MAP()
operator currency::asset_descriptor_base() const
//
// The following structures are taken as-id from branch develop, commit 0c90262e8a1c4e5e5d052f8db84c60a36691414d, for backward compatibility serialization test.
// DO NOT EDIT THEM without a very good reason
//
struct asset_descriptor_base_v0 // EDITED: was asset_descriptor_base originally, changed to asset_descriptor_base_v0
{
currency::asset_descriptor_base asset_descriptor{};
uint64_t total_max_supply = 0;
uint64_t current_supply = 0;
uint8_t decimal_point = 0;
std::string ticker;
std::string full_name;
std::string meta_info;
crypto::public_key owner = currency::null_pkey; // consider premultipling by 1/8
bool hidden_supply = false;
uint8_t version = 0;
asset_descriptor.total_max_supply = total_max_supply;
asset_descriptor.current_supply = current_supply;
asset_descriptor.decimal_point = decimal_point;
asset_descriptor.ticker = ticker;
asset_descriptor.full_name = full_name;
asset_descriptor.meta_info = meta_info;
asset_descriptor.owner = owner;
asset_descriptor.hidden_supply = hidden_supply;
asset_descriptor.version = version;
BEGIN_VERSIONED_SERIALIZE(0, version)
FIELD(total_max_supply)
FIELD(current_supply)
FIELD(decimal_point)
FIELD(ticker)
FIELD(full_name)
FIELD(meta_info)
FIELD(owner)
FIELD(hidden_supply)
END_SERIALIZE()
return asset_descriptor;
}
};
// branch = develop, HEAD = 0c90262e8a1c4e5e5d052f8db84c60a36691414d
struct currency::asset_descriptor_operation_v0
{
uint8_t operation_type = ASSET_DESCRIPTOR_OPERATION_UNDEFINED;
asset_descriptor_base_v0 descriptor;
crypto::public_key amount_commitment; // premultiplied by 1/8
boost::optional<crypto::public_key> opt_asset_id; // target asset_id - for update/emit
uint8_t verion = ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER;
BEGIN_BOOST_SERIALIZATION()
BOOST_SERIALIZE(total_max_supply)
BOOST_SERIALIZE(current_supply)
BOOST_SERIALIZE(decimal_point)
BOOST_SERIALIZE(ticker)
BOOST_SERIALIZE(full_name)
BOOST_SERIALIZE(meta_info)
BOOST_SERIALIZE(owner)
BOOST_SERIALIZE(hidden_supply)
END_BOOST_SERIALIZATION()
BEGIN_VERSIONED_SERIALIZE(ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER, verion)
FIELD(operation_type)
FIELD(descriptor)
FIELD(amount_commitment)
END_VERSION_UNDER(1)
FIELD(opt_asset_id)
END_SERIALIZE()
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(total_max_supply) DOC_DSCR("Maximum possible supply for given asset, can't be changed after deployment") DOC_EXMP(1000000000000000000) DOC_END
KV_SERIALIZE(current_supply) DOC_DSCR("Currently emitted supply for given asset (ignored for REGISTER operation)") DOC_EXMP(500000000000000000) DOC_END
KV_SERIALIZE(decimal_point) DOC_DSCR("Decimal point") DOC_EXMP(12) DOC_END
KV_SERIALIZE(ticker) DOC_DSCR("Ticker associated with asset") DOC_EXMP("ZUSD") DOC_END
KV_SERIALIZE(full_name) DOC_DSCR("Full name of the asset") DOC_EXMP("Zano wrapped USD") DOC_END
KV_SERIALIZE(meta_info) DOC_DSCR("Any other information assetiaded with asset in a free form") DOC_EXMP("Stable and private") DOC_END
KV_SERIALIZE_POD_AS_HEX_STRING(owner) DOC_DSCR("Owner's key, used only for EMIT and UPDATE validation, could be changed by transferring asset ownership") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
KV_SERIALIZE(hidden_supply) DOC_DSCR("This one reserved for future use, will be documented later") DOC_END
END_KV_SERIALIZE_MAP()
};
BEGIN_BOOST_SERIALIZATION()
BOOST_SERIALIZE(operation_type)
BOOST_SERIALIZE(descriptor)
BOOST_SERIALIZE(amount_commitment)
BOOST_END_VERSION_UNDER(1)
BOOST_SERIALIZE(opt_asset_id)
END_BOOST_SERIALIZATION()
#define ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER_V0 1
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(operation_type) DOC_DSCR("Asset operation type identifier") DOC_EXMP(1) DOC_END
KV_SERIALIZE(descriptor) DOC_DSCR("Asset descriptor") DOC_EXMP_AUTO() DOC_END
KV_SERIALIZE_POD_AS_HEX_STRING(amount_commitment) DOC_DSCR("Amount commitment") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
KV_SERIALIZE_POD_AS_HEX_STRING(opt_asset_id) DOC_DSCR("ID of an asset.") DOC_EXMP("cc4e69455e63f4a581257382191de6856c2156630b3fba0db4bdd73ffcfb36b6") DOC_END
END_KV_SERIALIZE_MAP()
operator currency::asset_descriptor_operation() const
struct asset_descriptor_operation_v0 // EDITED: was asset_descriptor_operation originally, changed to asset_descriptor_operation_v0
{
currency::asset_descriptor_operation operation_descriptor{};
uint8_t operation_type = ASSET_DESCRIPTOR_OPERATION_UNDEFINED;
asset_descriptor_base_v0 descriptor; // EDITED: was asset_descriptor_base originally, changed to asset_descriptor_base_v0
crypto::public_key amount_commitment; // premultiplied by 1/8
boost::optional<crypto::public_key> opt_asset_id; // target asset_id - for update/emit
uint8_t verion = ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER_V0; // EDITED: was ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER originally, changed to ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER_V0
operation_descriptor.operation_type = operation_type;
operation_descriptor.descriptor = descriptor;
operation_descriptor.amount_commitment = amount_commitment;
operation_descriptor.opt_asset_id = opt_asset_id;
operation_descriptor.verion = verion;
BEGIN_VERSIONED_SERIALIZE(ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER_V0, verion) // EDITED: was ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER originally, changed to ASSET_DESCRIPTOR_OPERATION_STRUCTURE_VER_V0
FIELD(operation_type)
FIELD(descriptor)
FIELD(amount_commitment)
END_VERSION_UNDER(1)
FIELD(opt_asset_id)
END_SERIALIZE()
return operation_descriptor;
}
};
BEGIN_BOOST_SERIALIZATION()
BOOST_SERIALIZE(operation_type)
BOOST_SERIALIZE(descriptor)
BOOST_SERIALIZE(amount_commitment)
BOOST_END_VERSION_UNDER(1)
BOOST_SERIALIZE(opt_asset_id)
END_BOOST_SERIALIZATION()
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(operation_type) DOC_DSCR("Asset operation type identifier") DOC_EXMP(1) DOC_END
KV_SERIALIZE(descriptor) DOC_DSCR("Asset descriptor") DOC_EXMP_AUTO() DOC_END
KV_SERIALIZE_POD_AS_HEX_STRING(amount_commitment) DOC_DSCR("Amount commitment") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
KV_SERIALIZE_POD_AS_HEX_STRING(opt_asset_id) DOC_DSCR("ID of an asset.") DOC_EXMP("cc4e69455e63f4a581257382191de6856c2156630b3fba0db4bdd73ffcfb36b6") DOC_END
END_KV_SERIALIZE_MAP()
};
//
// End: Code insertion from commit 0c90262e8a1c4e5e5d052f8db84c60a36691414d
//
} // namespace currency
BOOST_CLASS_VERSION(currency::asset_descriptor_base_v0, 0);
BOOST_CLASS_VERSION(currency::asset_descriptor_operation_v0, 1);
BOOST_CLASS_VERSION(currency::asset_descriptor_base_v0, 0);
template<typename asset_descriptor>
static asset_descriptor get_adb(const crypto::public_key& owner = currency::null_pkey)
@ -180,8 +158,8 @@ static asset_operation_descriptor get_ado(const asset_base_descriptor& base_desc
asset_operation_descriptor descriptor{};
descriptor.operation_type = operation;
descriptor.descriptor = base_descriptor;
descriptor.amount_commitment = currency::null_pkey;
descriptor.opt_descriptor = base_descriptor;
descriptor.opt_amount_commitment = currency::null_pkey;
if (asset_id.has_value())
{
@ -471,12 +449,15 @@ TEST(multiassets, native_serialization_get_or_calculate_asset_id_undefined)
crypto::public_key calculated_asset_id{};
const std::optional ado{deserialize<currency::asset_descriptor_operation>(serialization_method::native, serialized_ado)};
ASSERT_TRUE(ado.has_value());
ASSERT_EQ(ado.value().verion, 1);
ASSERT_EQ(ado.value().descriptor.version, 0);
ASSERT_EQ(ado.value().operation_type, ASSET_DESCRIPTOR_OPERATION_UNDEFINED);
ASSERT_TRUE(ado.has_value() && ado->opt_descriptor.has_value());
ASSERT_EQ(ado->version, 1);
ASSERT_EQ(ado->opt_descriptor->version, 0);
ASSERT_EQ(ado->operation_type, ASSET_DESCRIPTOR_OPERATION_UNDEFINED);
success = currency::get_or_calculate_asset_id(ado.value(), &calculated_point_asset_id, &calculated_asset_id);
ASSERT_FALSE(success);
std::string reserialized_ado = t_serializable_object_to_blob(ado.value());
ASSERT_EQ(serialized_ado, reserialized_ado);
}
TEST(multiassets, native_serialization_get_or_calculate_asset_id_register)
@ -490,22 +471,23 @@ TEST(multiassets, native_serialization_get_or_calculate_asset_id_register)
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'};
crypto::point_t expected_point_asset_id{};
crypto::public_key expected_asset_id{};
crypto::point_t calculated_point_asset_id{};
crypto::public_key calculated_asset_id{};
const std::optional ado{deserialize<currency::asset_descriptor_operation>(serialization_method::native, serialized_ado)};
ASSERT_TRUE(ado.has_value());
ASSERT_EQ(ado.value().verion, 1);
ASSERT_EQ(ado.value().descriptor.version, 0);
ASSERT_EQ(ado.value().operation_type, ASSET_DESCRIPTOR_OPERATION_REGISTER);
ASSERT_TRUE(ado.has_value() && ado->opt_descriptor.has_value());
ASSERT_EQ(ado->version, 1);
ASSERT_EQ(ado->opt_descriptor->version, 0);
ASSERT_EQ(ado->operation_type, ASSET_DESCRIPTOR_OPERATION_REGISTER);
success = currency::get_or_calculate_asset_id(ado.value(), &calculated_point_asset_id, &calculated_asset_id);
ASSERT_TRUE(success);
success = expected_point_asset_id.from_string("6f46324faae448b9e3b96dac94da17be6ab7eaaba398de86d8743042c98bace0");
ASSERT_TRUE(success);
ASSERT_EQ(calculated_point_asset_id, expected_point_asset_id);
expected_asset_id = expected_point_asset_id.to_public_key();
ASSERT_EQ(calculated_asset_id, expected_asset_id);
ASSERT_EQ(calculated_asset_id, expected_point_asset_id.to_public_key());
std::string reserialized_ado = t_serializable_object_to_blob(ado.value());
ASSERT_EQ(serialized_ado, reserialized_ado);
}
TEST(multiassets, native_serialization_get_or_calculate_asset_id_emit)
@ -519,22 +501,23 @@ TEST(multiassets, native_serialization_get_or_calculate_asset_id_emit)
'\xfc', '\x1c', '^', '\xdc', 'r', '\x80', 'G', 'C', '}', 'f', '~'};
crypto::point_t expected_point_asset_id{};
crypto::public_key expected_asset_id{};
crypto::point_t calculated_point_asset_id{};
crypto::public_key calculated_asset_id{};
const std::optional ado{deserialize<currency::asset_descriptor_operation>(serialization_method::native, serialized_ado)};
ASSERT_TRUE(ado.has_value());
ASSERT_EQ(ado.value().verion, 1);
ASSERT_EQ(ado.value().descriptor.version, 0);
ASSERT_EQ(ado.value().operation_type, ASSET_DESCRIPTOR_OPERATION_EMIT);
ASSERT_TRUE(ado.has_value() && ado->opt_descriptor.has_value());
ASSERT_EQ(ado->version, 1);
ASSERT_EQ(ado->opt_descriptor->version, 0);
ASSERT_EQ(ado->operation_type, ASSET_DESCRIPTOR_OPERATION_EMIT);
success = currency::get_or_calculate_asset_id(ado.value(), &calculated_point_asset_id, &calculated_asset_id);
ASSERT_TRUE(success);
success = expected_point_asset_id.from_string("49a3d6652aaa0b3b77292c534e91ff80de9120aeb6fc1c5edc728047437d667e");
ASSERT_TRUE(success);
ASSERT_EQ(calculated_point_asset_id, expected_point_asset_id);
expected_asset_id = expected_point_asset_id.to_public_key();
ASSERT_EQ(calculated_asset_id, expected_asset_id);
ASSERT_EQ(calculated_asset_id, expected_point_asset_id.to_public_key());
std::string reserialized_ado = t_serializable_object_to_blob(ado.value());
ASSERT_EQ(serialized_ado, reserialized_ado);
}
TEST(multiassets, native_serialization_get_or_calculate_asset_id_update)
@ -548,22 +531,23 @@ TEST(multiassets, native_serialization_get_or_calculate_asset_id_update)
'^', '\x1b', '\xed', 'N', '\xa9', '\xb5', '\xf5', '\x92', '\xfa', '\xdf', '\x90', '\xed', 'k'};
crypto::point_t expected_point_asset_id{};
crypto::public_key expected_asset_id{};
crypto::point_t calculated_point_asset_id{};
crypto::public_key calculated_asset_id{};
const std::optional ado{deserialize<currency::asset_descriptor_operation>(serialization_method::native, serialized_ado)};
ASSERT_TRUE(ado.has_value());
ASSERT_EQ(ado.value().verion, 1);
ASSERT_EQ(ado.value().descriptor.version, 0);
ASSERT_EQ(ado.value().operation_type, ASSET_DESCRIPTOR_OPERATION_UPDATE);
ASSERT_TRUE(ado.has_value() && ado->opt_descriptor.has_value());
ASSERT_EQ(ado->version, 1);
ASSERT_EQ(ado->opt_descriptor->version, 0);
ASSERT_EQ(ado->operation_type, ASSET_DESCRIPTOR_OPERATION_UPDATE);
success = currency::get_or_calculate_asset_id(ado.value(), &calculated_point_asset_id, &calculated_asset_id);
ASSERT_TRUE(success);
success = expected_point_asset_id.from_string("c371f60dd8333298c6aa746b71e1e20527b1ff5e1bed4ea9b5f592fadf90ed6b");
ASSERT_TRUE(success);
ASSERT_EQ(calculated_point_asset_id, expected_point_asset_id);
expected_asset_id = expected_point_asset_id.to_public_key();
ASSERT_EQ(calculated_asset_id, expected_asset_id);
ASSERT_EQ(calculated_asset_id, expected_point_asset_id.to_public_key());
std::string reserialized_ado = t_serializable_object_to_blob(ado.value());
ASSERT_EQ(serialized_ado, reserialized_ado);
}
TEST(multiassets, native_serialization_get_or_calculate_asset_id_public_burn)
@ -577,24 +561,27 @@ TEST(multiassets, native_serialization_get_or_calculate_asset_id_public_burn)
'\xd3', '\xed', 'V', '\xa3', '\x8c', '\xd9', '\xdd', '\xc5', '\xdb', 'W', 'g', '?', '\x8f'};
crypto::point_t expected_point_asset_id{};
crypto::public_key expected_asset_id{};
crypto::point_t calculated_point_asset_id{};
crypto::public_key calculated_asset_id{};
const std::optional ado{deserialize<currency::asset_descriptor_operation>(serialization_method::native, serialized_ado)};
ASSERT_TRUE(ado.has_value());
ASSERT_EQ(ado.value().verion, 1);
ASSERT_EQ(ado.value().descriptor.version, 0);
ASSERT_EQ(ado.value().operation_type, ASSET_DESCRIPTOR_OPERATION_PUBLIC_BURN);
ASSERT_TRUE(ado.has_value() && ado->opt_descriptor.has_value());
ASSERT_EQ(ado->version, 1);
ASSERT_EQ(ado->opt_descriptor->version, 0);
ASSERT_EQ(ado->operation_type, ASSET_DESCRIPTOR_OPERATION_PUBLIC_BURN);
success = currency::get_or_calculate_asset_id(ado.value(), &calculated_point_asset_id, &calculated_asset_id);
ASSERT_TRUE(success);
success = expected_point_asset_id.from_string("54f3f72c72e5b014ad2b2b9001acef954fe82dd3ed56a38cd9ddc5db57673f8f");
ASSERT_TRUE(success);
ASSERT_EQ(calculated_point_asset_id, expected_point_asset_id);
expected_asset_id = expected_point_asset_id.to_public_key();
ASSERT_EQ(calculated_asset_id, expected_asset_id);
ASSERT_EQ(calculated_asset_id, expected_point_asset_id.to_public_key());
std::string reserialized_ado = t_serializable_object_to_blob(ado.value());
ASSERT_EQ(serialized_ado, reserialized_ado);
}
#if 0
TEST(multiassets, boost_serialization_get_or_calculate_asset_id_undefined)
{
bool success{};
@ -944,3 +931,4 @@ TEST(multiassets, key_value_serialization_get_or_calculate_asset_id_public_burn)
expected_asset_id = expected_point_asset_id.to_public_key();
ASSERT_EQ(calculated_asset_id, expected_asset_id);
}
#endif