ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2026-04-29 15:37:53 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
fe0bf736fb7f2fbc6f2125bc0deb197ef21ca2e1
clio/tests/common/util/BinaryTestObject.cpp
Alex Kremer 21066d16e9 chore: Remove copyright from all source files (#2975)
2026-03-24 15:25:32 +00:00

282 lines
9.9 KiB
C++
Raw Blame History

#include "util/BinaryTestObject.hpp"
#include "data/DBHelpers.hpp"
#include "etl/Models.hpp"
#include "etl/impl/Extraction.hpp"
#include "util/StringUtils.hpp"
#include "util/TestObject.hpp"
#include <gtest/gtest.h>
#include <org/xrpl/rpc/v1/ledger.pb.h>
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/proto/org/xrpl/rpc/v1/get_ledger.pb.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol/TxMeta.h>
#include <xrpl/protocol/digest.h>
#include <optional>
#include <string>
#include <utility>
namespace {
constinit auto const kSEQ = 30;
constinit auto const kRAW_HEADER =
"03C3141A01633CD656F91B4EBB5EB89B791BD34DBC8A04BB6F407C5335BC54351E"
"DD733898497E809E04074D14D271E4832D7888754F9230800761563A292FA2315A"
"6DB6FE30CC5909B285080FCD6773CC883F9FE0EE4D439340AC592AADB973ED3CF5"
"3E2232B33EF57CECAC2816E3122816E31A0A00F8377CD95DFA484CFAE282656A58"
"CE5AA29652EFFD80AC59CD91416E4E13DBBE";
} // namespace
namespace util {
std::pair<std::string, std::string>
createTxAndMetaBlobs(std::string metaStr, std::string txnStr)
{
return {hexStringToBinaryString(metaStr), hexStringToBinaryString(txnStr)};
}
std::pair<ripple::STTx, ripple::TxMeta>
createTxAndMeta(std::string hashStr, std::string metaStr, std::string txnStr)
{
ripple::uint256 hash;
EXPECT_TRUE(hash.parseHex(hashStr));
auto const [metaBlob, txnBlob] = createTxAndMetaBlobs(metaStr, txnStr);
ripple::SerialIter it{txnBlob.data(), txnBlob.size()};
return {ripple::STTx{it}, ripple::TxMeta{hash, kSEQ, metaBlob}};
}
etl::model::Transaction
createTransaction(ripple::TxType type, std::string hashStr, std::string metaStr, std::string txnStr)
{
auto const [sttx, meta] = createTxAndMeta(hashStr, metaStr, txnStr);
return {
.raw = "",
.metaRaw = "",
.sttx = sttx,
.meta = meta,
.id = ripple::uint256{"0000000000000000000000000000000000000000000000000000000000000001"},
.key = "0000000000000000000000000000000000000000000000000000000000000001",
.type = type
};
}
etl::model::Object
createObject(etl::model::Object::ModType modType, std::string key)
{
// random object taken from initial ledger load
static constinit auto const kOBJ_PRED =
"B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960A";
static constinit auto const kOBJ_SUCC =
"B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960F";
static constinit auto const kOBJ_BLOB =
"11007222002200002504270918370000000000000C4538000000000000000A554D94799200CC37EFAF45DA7670"
"4ED3CBEDBB4B4FCD"
"56E9CBA5399EB40A7B3BEC629546DD24CDB4C0004C4A5059000000000000000000000000000000000000000000"
"0000000000000000"
"000000000000016680000000000000004C4A505900000000000000000000000000000000368480B7780E3DCF5D"
"062A7BB54129F42F"
"8BB63367D6C38D7EA4C680004C4A505900000000000000000000000000000000C8056BA4E36038A8A0D2C0A869"
"63153E95A84D56";
return {
.key = binaryStringToUint256(hexStringToBinaryString(key)),
.keyRaw = hexStringToBinaryString(key),
.data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{}
: *ripple::strUnHex(kOBJ_BLOB),
.dataRaw = modType == etl::model::Object::ModType::Deleted
? ""
: hexStringToBinaryString(kOBJ_BLOB),
.successor = hexStringToBinaryString(kOBJ_SUCC),
.predecessor = hexStringToBinaryString(kOBJ_PRED),
.type = modType,
};
}
etl::model::Object
createObjectWithBookBase(etl::model::Object::ModType modType, std::string key)
{
// random object taken from initial ledger load
static constinit auto const kOBJ_PRED =
"B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960A";
static constinit auto const kOBJ_SUCC =
"B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960F";
static constinit auto const kOBJ_BLOB =
"11006422000000022505A681E855B4E076DD06D6D583804F9DC94F641337ECB97F71860300EEC17E530A2001D6"
"C9583FFBFAD704E299BE"
"3E544090ECCB12AF45FD03CAEEA852E5048E57F48FD45B505A0008138882D0F98C64A1A0E6D15053589771AD08"
"B8C13D5384FBDAE20000"
"0948011320AC38AE866862CF5A8AF3578C600CEE8BFB894596584B60C0FFA7D22248E33CC3";
return {
.key = binaryStringToUint256(hexStringToBinaryString(key)),
.keyRaw = hexStringToBinaryString(key),
.data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{}
: *ripple::strUnHex(kOBJ_BLOB),
.dataRaw = modType == etl::model::Object::ModType::Deleted
? ""
: hexStringToBinaryString(kOBJ_BLOB),
.successor = hexStringToBinaryString(kOBJ_SUCC),
.predecessor = hexStringToBinaryString(kOBJ_PRED),
.type = modType,
};
}
etl::model::Object
createObjectWithTwoNFTs()
{
std::string const url1 = "abcd1";
std::string const url2 = "abcd2";
ripple::Blob const uri1Blob(url1.begin(), url1.end());
ripple::Blob const uri2Blob(url2.begin(), url2.end());
constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q";
constexpr auto kNFT_ID = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000";
constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
auto const nftPage = createNftTokenPage({{kNFT_ID, url1}, {kNFT_ID2, url2}}, std::nullopt);
auto const serializerNftPage = nftPage.getSerializer();
auto const account = getAccountIdWithString(kACCOUNT);
// key is a token made up from owner's account ID followed by unused (in Clio) value described
// here:
// https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0020-non-fungible-tokens#tokenpage-id-format
constexpr auto kEXTRA_BYTES = "000000000000";
auto const key = std::string(std::begin(account), std::end(account)) + kEXTRA_BYTES;
return {
.key = {},
.keyRaw = key,
.data = {},
.dataRaw = std::string(
static_cast<char const*>(serializerNftPage.getDataPtr()),
serializerNftPage.getDataLength()
),
.successor = "",
.predecessor = "",
.type = etl::model::Object::ModType::Created,
};
}
etl::model::Object
createObjectWithMPT()
{
constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q";
auto const account = getAccountIdWithString(kACCOUNT);
auto const mptID = ripple::makeMptID(2, getAccountIdWithString(kACCOUNT));
auto const mptokenObject = createMpTokenObject(kACCOUNT, mptID);
// key is a token made up from several fields described here:
// https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0033-multi-purpose-tokens#2121-mptoken-ledger-identifier
constexpr auto kSPACE_KEY = 0x007F;
auto const keySha512Half = ripple::sha512Half(kSPACE_KEY, mptID, account);
return {
.key = {},
.keyRaw = std::string(std::begin(keySha512Half), std::end(keySha512Half)),
.data = {},
.dataRaw = std::string(
static_cast<char const*>(mptokenObject.getSerializer().getDataPtr()),
mptokenObject.getSerializer().getDataLength()
),
.successor = "",
.predecessor = "",
.type = etl::model::Object::ModType::Created,
};
}
etl::model::BookSuccessor
createSuccessor()
{
return {
.firstBook = uint256ToString(
ripple::uint256{"A000000000000000000000000000000000000000000000000000000000000000"}
),
.bookBase = uint256ToString(
ripple::uint256{"A000000000000000000000000000000000000000000000000000000000000001"}
),
};
}
etl::impl::PBLedgerResponseType
createDataAndDiff()
{
auto const rawHeaderBlob = hexStringToBinaryString(kRAW_HEADER);
auto res = etl::impl::PBLedgerResponseType();
res.set_ledger_header(rawHeaderBlob);
res.set_objects_included(true);
res.set_object_neighbors_included(true);
{
auto original = org::xrpl::rpc::v1::TransactionAndMetadata();
auto const [metaRaw, txRaw] = createTxAndMetaBlobs();
original.set_transaction_blob(txRaw);
original.set_metadata_blob(metaRaw);
for (int i = 0; i < 10; ++i) {
auto* p = res.mutable_transactions_list()->add_transactions();
*p = original;
}
}
{
auto expected = createObject();
auto original = org::xrpl::rpc::v1::RawLedgerObject();
original.set_data(expected.dataRaw);
original.set_key(expected.keyRaw);
for (auto i = 0; i < 10; ++i) {
auto* p = res.mutable_ledger_objects()->add_objects();
*p = original;
}
}
{
auto expected = createSuccessor();
auto original = org::xrpl::rpc::v1::BookSuccessor();
original.set_first_book(expected.firstBook);
original.set_book_base(expected.bookBase);
res.set_object_neighbors_included(true);
for (auto i = 0; i < 10; ++i) {
auto* p = res.mutable_book_successors()->Add();
*p = original;
}
}
return res;
}
etl::impl::PBLedgerResponseType
createData()
{
auto const rawHeaderBlob = hexStringToBinaryString(kRAW_HEADER);
auto res = etl::impl::PBLedgerResponseType();
res.set_ledger_header(rawHeaderBlob);
res.set_objects_included(false);
res.set_object_neighbors_included(false);
{
auto original = org::xrpl::rpc::v1::TransactionAndMetadata();
auto const [metaRaw, txRaw] = createTxAndMetaBlobs();
original.set_transaction_blob(txRaw);
original.set_metadata_blob(metaRaw);
for (int i = 0; i < 10; ++i) {
auto* p = res.mutable_transactions_list()->add_transactions();
*p = original;
}
}
return res;
}
} // namespace util
Reference in New Issue View Git Blame Copy Permalink