2#include <test/jtx/mpt.h>
4#include <test/jtx/Account.h>
5#include <test/jtx/Env.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/credentials.h>
8#include <test/jtx/owners.h>
9#include <test/jtx/pay.h>
10#include <test/jtx/ter.h>
11#include <test/jtx/trust.h>
13#include <xrpl/basics/Slice.h>
14#include <xrpl/basics/StringUtilities.h>
15#include <xrpl/basics/base_uint.h>
16#include <xrpl/basics/contract.h>
17#include <xrpl/basics/strHex.h>
18#include <xrpl/beast/unit_test/suite.h>
19#include <xrpl/json/json_value.h>
20#include <xrpl/ledger/helpers/MPTokenHelpers.h>
21#include <xrpl/protocol/AccountID.h>
22#include <xrpl/protocol/Asset.h>
23#include <xrpl/protocol/ConfidentialTransfer.h>
24#include <xrpl/protocol/Indexes.h>
25#include <xrpl/protocol/LedgerFormats.h>
26#include <xrpl/protocol/Protocol.h>
27#include <xrpl/protocol/Rate.h>
28#include <xrpl/protocol/SField.h>
29#include <xrpl/protocol/TER.h>
30#include <xrpl/protocol/TxFlags.h>
31#include <xrpl/protocol/UintTypes.h>
32#include <xrpl/protocol/jss.h>
33#include <xrpl/tx/transactors/token/MPTokenIssuanceSet.h>
35#include <utility/mpt_utility.h>
37#include <mpt_protocol.h>
39#include <secp256k1_mpt.h>
48#include <source_location>
59constexpr std::uint64_t kElGamalDecryptRangeLow = 0;
60constexpr std::uint64_t kElGamalDecryptRangeHigh = 3000;
75 std::optional<T>
const& opt,
82 std::string(what) +
" must be present (called from " +
83 std::string(loc.function_name()) +
")");
94mpt_pedersen_proof_params
97 mpt_pedersen_proof_params res{};
99 res.pedersen_commitment, params.pedersenCommitment.data(), kMPT_PEDERSEN_COMMIT_SIZE);
100 res.amount = params.amt;
101 std::memcpy(res.ciphertext, params.encryptedAmt.data(), kMPT_ELGAMAL_TOTAL_SIZE);
102 std::memcpy(res.blinding_factor, params.blindingFactor.data(), kMPT_BLINDING_FACTOR_SIZE);
114setAccountField(json::Value& jv, std::optional<Account>
const& account)
116 Account const& act = requireValue(account,
"account");
117 jv[sfAccount] = act.human();
129setDestinationField(json::Value& jv, std::optional<Account>
const& dest)
131 Account const& act = requireValue(dest,
"dest");
132 jv[sfDestination] = act.human();
145setProofOrDummy(json::Value& jv, std::optional<Buffer>
const& proof, std::size_t dummyLen)
158[[nodiscard]] std::optional<Buffer>
160 std::unordered_map<
AccountID, std::vector<Buffer>>
const& keys,
162 std::optional<std::uint32_t> epoch)
164 auto const it = keys.find(account);
165 if (it == keys.end() || it->second.empty())
169 return it->second.back();
171 if (*epoch >= it->second.size())
174 return it->second[*
epoch];
183checkSiteReason(std::source_location
const& checkLoc)
185 return std::string(
"check ") + std::filesystem::path{checkLoc.
file_name()}.filename().string() +
220 for (
auto const& h : holders)
222 if (accounts.
find(h.human()) != accounts.
cend())
224 accounts.
emplace(h.human(), h);
238 env_.fund(arg.xrp, issuer_);
239 for (auto const& it : holders_)
240 env_.fund(arg.xrpHolders, it.second);
243 env_.fund(arg.xrp, *arg.auditor);
249 env_.require(Owners(issuer_, 0));
250 for (auto const& it : holders_)
252 if (issuer_.id() == it.second.id())
253 Throw<std::runtime_error>(
"Issuer can't be holder");
254 env_.require(Owners(it.second, 0));
303 .auditor = arg.auditor,
327 jv[sfAccount] = arg.
issuer->human();
340 jv[sfTransactionType] = jss::MPTokenIssuanceCreate;
371 auto const authAndPay = [&](
auto const& accts,
auto const&& getAcct) {
372 for (
auto const& it : accts)
374 authorize({.account = getAcct(it)}, loc);
377 if (arg.
pay && arg.
pay->first.empty())
378 pay(
issuer_, getAcct(it), arg.
pay->second, std::nullopt, std::nullopt, loc);
382 for (
auto const& p : arg.
pay->first)
383 pay(
issuer_, p, arg.
pay->second, std::nullopt, std::nullopt, loc);
390 authAndPay(
holders_, [](
auto const& it) {
return it.second; });
394 authAndPay(*arg.
authorize, [](
auto const& it) { return it; });
399 if (arg.
pay->first.empty())
401 authAndPay(
holders_, [](
auto const& it) {
return it.second; });
405 authAndPay(arg.
pay->first, [](
auto const& it) { return it; });
417 jv[sfAccount] = arg.
issuer->human();
419 jv[sfTransactionType] = jss::MPTokenIssuanceDestroy;
449 jv[sfAccount] = arg.
account->human();
452 jv[sfHolder] = arg.
holder->human();
453 jv[sfTransactionType] = jss::MPTokenAuthorize;
497 [&](
SLEP const& sle) {
531 for (
auto const&
holder : holders)
543 jv[sfAccount] = arg.
account->human();
548 [&jv]<
typename T>(T
const&
holder) {
551 jv[sfHolder] =
holder.human();
562 jv[sfDelegate] = arg.
delegate->human();
575 jv[sfTransactionType] = jss::MPTokenIssuanceSet;
605 if (*arg.
flags & tfMPTLock)
607 flags |= lsfMPTLocked;
609 else if (*arg.
flags & tfMPTUnlock)
611 flags &= ~lsfMPTLocked;
616 if ((*arg.
flags & f.setFlag) != 0u)
618 flags |= f.ledgerFlag;
626 require(std::nullopt, arg.
holder.has_value());
628 require(*account,
false);
641 "MPTTester::set: issuer's pubkey is not set");
644 return strHex((*sle)[sfIssuerEncryptionKey]) ==
strHex(*issuerPubKey);
665 "MPTTester::set: auditor's pubkey is not set");
668 return strHex((*sle)[sfAuditorEncryptionKey]) ==
strHex(*auditorPubKey);
686 if (
auto const sle =
env_.le(key))
695 if (sle->isFieldPresent(sfDomainID))
696 return expected == sle->getFieldH256(sfDomainID);
705 [&](
SLEP const& sle) {
return expectedAmount == (*sle)[sfMPTAmount]; },
holder);
712 [&](
SLEP const& sle) {
return expectedAmount == (*sle)[sfOutstandingAmount]; });
719 return expectedAmount == (*sle)[~sfConfidentialOutstandingAmount].value_or(0);
733 if (sle->isFieldPresent(sfMPTokenMetadata))
734 return strHex(sle->getFieldVL(sfMPTokenMetadata)) ==
strHex(metadata);
743 [&](
SLEP const& sle) ->
bool {
return sle->isFieldPresent(sfMPTokenMetadata); });
750 if (sle->isFieldPresent(sfTransferFee))
751 return sle->getFieldU16(sfTransferFee) == transferFee;
759 return forObject([&](
SLEP const& sle) ->
bool {
return sle->isFieldPresent(sfTransferFee); });
767 return sle->getFieldU32(sfImmutableFlags) == expectedFlags;
777 return (*sle)[~sfIssuerKeyEpoch] == issuerKeyEpoch &&
778 (*sle)[~sfAuditorKeyEpoch] == auditorKeyEpoch;
789 [&](
SLEP const& sle) ->
bool {
790 return (*sle)[~sfIssuerKeyMirrorEpoch] == issuerKeyMirrorEpoch &&
791 (*sle)[~sfAuditorKeyMirrorEpoch] == auditorKeyMirrorEpoch;
801 [&](
SLEP const& sle) ->
bool {
802 epoch = (*sle)[~field];
817 return !sle->isFieldPresent(field);
820 return expected && sle->isFieldPresent(field) &&
825 return matches(sle, sfIssuerEncryptionKey, issuerKeyOwner) &&
826 matches(sle, sfAuditorEncryptionKey, auditorKeyOwner);
837 [&](
SLEP const& sle) ->
bool {
838 auto const encryptionKey = (*sle)[~field];
840 return !encryptionKey;
841 return encryptionKey &&
Slice(*encryptionKey) ==
Slice(*expected);
948operator
Asset()
const
963 return sle->getFieldU64(sfOutstandingAmount);
968 return sle->getFieldU64(sfMPTAmount);
980 return (*sle)[~sfConfidentialOutstandingAmount].value_or(0);
990 UInt256 const& contextHash)
const
998 if (!sleHolder || !sleIssuance)
1001 auto const ciphertextBlob = sleHolder->getFieldVL(sfIssuerEncryptedBalance);
1003 return std::nullopt;
1005 auto const pubKeyBlob = sleIssuance->getFieldVL(sfIssuerEncryptionKey);
1007 return std::nullopt;
1011 if (mpt_get_clawback_proof(
1016 ciphertextBlob.data(),
1019 return std::nullopt;
1030 return std::nullopt;
1034 return std::nullopt;
1038 if (mpt_get_convert_proof(
1039 requireValue(pubKey,
"pubKey").data(),
1040 requireValue(privKey,
"privKey").data(),
1043 return std::nullopt;
1053 Slice const& blindingFactor,
1058 auto const pedersenBalanceParams = makePedersenParams(balanceParams);
1061 return std::nullopt;
1063 auto const senderPrivKey =
getPrivKey(sender);
1065 return std::nullopt;
1067 auto const senderPubKey =
getPubKey(sender);
1069 return std::nullopt;
1072 return std::nullopt;
1076 for (
size_t i = 0; i < recipients.
size(); ++i)
1078 auto const& r = recipients[i];
1082 return std::nullopt;
1092 if (mpt_get_confidential_send_proof(
1093 senderPrivKey->data(),
1094 senderPubKey->data(),
1096 participants.
data(),
1098 blindingFactor.
data(),
1101 &pedersenBalanceParams,
1104 return std::nullopt;
1129 if (mpt_get_pedersen_commitment(amount, pedersenBlindingFactor.
data(), buf.
data()) != 0)
1146 if (!sleMptoken || !sleMptoken->isFieldPresent(sfConfidentialBalanceSpending))
1147 return std::nullopt;
1152 if (!holderPubKey || !holderPrivKey)
1153 return std::nullopt;
1155 auto const pedersenParams = makePedersenParams(pcParams);
1156 Buffer proof(kExpectedProofLength);
1158 if (mpt_get_convert_back_proof(
1159 holderPrivKey->data(),
1160 holderPubKey->data(),
1165 return std::nullopt;
1180 SField const* field =
nullptr;
1184 field = &sfConfidentialBalanceInbox;
1187 field = &sfConfidentialBalanceSpending;
1190 field = &sfIssuerEncryptedBalance;
1193 field = &sfAuditorEncryptedBalance;
1197 if (field ==
nullptr || !sle->isFieldPresent(*field))
1200 auto const blob = sle->getFieldVL(*field);
1201 return Buffer(blob.data(), blob.size());
1209 [&](
SLEP const& sle) {
1210 flags = sle->getFlags();
1223 jv[sfMPTokenIssuanceID] =
to_string(*
id);
1242 return env_.seq(requireValue(account,
"account"));
1257template <
typename T>
1265 Buffer const blindingFactor =
1267 jv[sfBlindingFactor.jsonName] =
strHex(blindingFactor);
1270 Buffer const holderCiphertext = arg.holderEncryptedAmt
1271 ? *arg.holderEncryptedAmt
1274 jv[sfHolderEncryptedAmount.jsonName] =
strHex(holderCiphertext);
1277 Buffer const issuerCiphertext = arg.issuerEncryptedAmt
1278 ? *arg.issuerEncryptedAmt
1281 jv[sfIssuerEncryptedAmount.jsonName] =
strHex(issuerCiphertext);
1285 if (arg.auditorEncryptedAmt)
1287 auditorCiphertext = *arg.auditorEncryptedAmt;
1289 else if (
auditor_.has_value() && arg.fillAuditorEncryptedAmt.value_or(
false))
1296 if (auditorCiphertext)
1297 jv[sfAuditorEncryptedAmount.jsonName] =
strHex(*auditorCiphertext);
1306 auto const amt = requireValue(arg.
amt,
"amt");
1315 if (!prevInboxBalance || !prevSpendingBalance || !prevIssuerBalance)
1320 bool const hasAuditorAmt =
1327 if (!prevAuditorBalance)
1340 return prevOutstanding && postOutstanding && *prevOutstanding == *postOutstanding;
1345 return prevConfidentialOutstanding + amt == postConfidentialOutstanding;
1367 if (!postInboxBalance || !postIssuerBalance || !postSpendingBalance)
1374 if (!postAuditorBalance)
1385 [&] ->
bool {
return *prevAuditorBalance + amt == *postAuditorBalance; }, loc));
1389 RequireAny([&] ->
bool {
return *postSpendingBalance == *prevSpendingBalance; }, loc));
1393 [&] ->
bool {
return *prevIssuerBalance + amt == *postIssuerBalance; }, loc));
1397 RequireAny([&] ->
bool {
return *prevInboxBalance + amt == *postInboxBalance; }, loc));
1402 [&] ->
bool {
return *postInboxBalance + *postSpendingBalance == *postIssuerBalance; },
1410 [&](
SLEP const& sle) ->
bool {
1413 auto const holderPubKey =
getPubKey(account);
1417 "MPTTester::convert: holder's pubkey is "
1421 return strHex((*sle)[sfHolderEncryptionKey]) ==
1439 jv[jss::TransactionType] = jss::ConfidentialMPTConvert;
1442 auto const amt = requireValue(arg.
amt,
"amt");
1451 jv[sfZKProof.jsonName] = *arg.
proof;
1468 Account const& dest = requireValue(arg.
dest,
"dest");
1469 auto const amt = requireValue(arg.
amt,
"amt");
1479 if (!prevSenderInbox || !prevSenderSpending || !prevSenderIssuer)
1486 if (!prevSenderAuditor)
1494 if (!prevDestInbox || !prevDestSpending || !prevDestIssuer)
1501 if (!prevDestAuditor)
1505 auto const senderPubAmt =
getBalance(account);
1520 if (!postSenderInbox || !postSenderSpending || !postSenderIssuer)
1528 if (!postDestInbox || !postDestSpending || !postDestIssuer)
1537 RequireAny([&] ->
bool {
return prevOA && postOA && *prevOA == *postOA; }, loc));
1538 env_.require(
RequireAny([&] ->
bool {
return prevCOA == postCOA; }, loc));
1543 return *prevSenderSpending >= amt &&
1544 *postSenderSpending == *prevSenderSpending - amt;
1547 env_.require(
RequireAny([&] ->
bool {
return postSenderInbox == prevSenderInbox; }, loc));
1550 return *prevSenderIssuer >= amt && *postSenderIssuer == *prevSenderIssuer - amt;
1556 RequireAny([&] ->
bool {
return *postDestInbox == *prevDestInbox + amt; }, loc));
1558 RequireAny([&] ->
bool {
return *postDestSpending == *prevDestSpending; }, loc));
1560 RequireAny([&] ->
bool {
return *postDestIssuer == *prevDestIssuer + amt; }, loc));
1564 [&] ->
bool {
return *postSenderInbox + *postSenderSpending == *postSenderIssuer; },
1567 [&] ->
bool {
return *postDestInbox + *postDestSpending == *postDestIssuer; }, loc));
1571 [&] ->
bool {
return getMPTokenVersion(account) == prevSenderVersion + 1; }, loc));
1579 if (!postSenderAuditor || !postDestAuditor)
1584 return *postSenderAuditor == *postSenderIssuer &&
1585 *postDestAuditor == *postDestIssuer;
1592 return *prevSenderAuditor >= amt &&
1593 *postSenderAuditor == *prevSenderAuditor - amt;
1599 [&] ->
bool {
return *postDestAuditor == *prevDestAuditor + amt; }, loc));
1611 jv[jss::TransactionType] = jss::ConfidentialMPTSend;
1614 Account const& dest = setDestinationField(jv, arg.
dest);
1615 auto const amt = requireValue(arg.
amt,
"amt");
1619 Buffer const blindingFactor =
1624 auto const destAmt =
1639 jv[sfSenderEncryptedAmount] =
strHex(senderAmt);
1640 jv[sfDestinationEncryptedAmount] =
strHex(destAmt);
1641 jv[sfIssuerEncryptedAmount] =
strHex(issuerAmt);
1643 jv[sfAuditorEncryptedAmount] =
strHex(*auditorAmt);
1657 prevSenderSpending = chain->spending;
1658 prevEncryptedSenderSpending = chain->encSpending;
1659 version = chain->version;
1664 if (!ledgerSpending)
1666 prevSenderSpending = *ledgerSpending;
1673 Buffer amountCommitment, balanceCommitment;
1683 jv[sfAmountCommitment] =
strHex(amountCommitment);
1695 jv[sfBalanceCommitment] =
strHex(balanceCommitment);
1699 jv[sfZKProof.jsonName] = *arg.
proof;
1703 auto const ctxHash =
1708 auto const senderPubKey =
getPubKey(account);
1709 auto const destPubKey =
getPubKey(dest);
1715 .publicKey =
Slice(*senderPubKey),
1716 .encryptedAmount = senderAmt,
1722 .publicKey =
Slice(*destPubKey),
1723 .encryptedAmount = destAmt,
1729 .publicKey =
Slice(*issuerPubKey),
1730 .encryptedAmount = issuerAmt,
1743 .publicKey =
Slice(*auditorPubKey),
1744 .encryptedAmount = *auditorAmt,
1752 if (prevEncryptedSenderSpending && prevSenderSpending > 0)
1761 .pedersenCommitment = amountCommitment,
1763 .encryptedAmt = senderAmt,
1764 .blindingFactor = blindingFactor,
1767 .pedersenCommitment = balanceCommitment,
1768 .amt = prevSenderSpending,
1769 .encryptedAmt = *prevEncryptedSenderSpending,
1770 .blindingFactor = balanceBlindingFactor,
1783 auto const hexStr = jv[sfSenderEncryptedAmount.jsonName].
asString();
1784 auto const bytes =
strUnHex(hexStr);
1787 return Buffer(bytes->data(), bytes->size());
1797 if (!prevSpending || !prevEncSpending)
1802 *prevSpending,
Slice(*prevEncSpending), prevVersion, sendAmt,
Slice(senderEncAmt));
1805 return std::move(*chain);
1811 Slice const& currentEncSpending,
1814 Slice const& senderEncAmt)
1816 if (sendAmt > currentSpending)
1817 return std::nullopt;
1820 if (!newEncSpending)
1821 return std::nullopt;
1824 .spending = currentSpending - sendAmt,
1825 .encSpending = std::move(*newEncSpending),
1826 .version = currentVersion + 1,
1835 jv[sfAccount] = account.human();
1838 jv[sfHolder] =
holder.human();
1840 jv[jss::TransactionType] = jss::ConfidentialMPTClawback;
1843 auto const amt = requireValue(arg.
amt,
"amt");
1848 jv[sfZKProof] = *arg.
proof;
1853 auto const contextHash =
1882 RequireAny([&] ->
bool {
return prevCOA >= amt && postCOA == prevCOA - amt; }, loc));
1884 [&] ->
bool {
return prevOA && postOA && *prevOA >= amt && *postOA == *prevOA - amt; },
1900 env_.require(
RequireAny([&] ->
bool {
return postVersion == prevVersion + 1; }, loc));
1908 secp256k1_pubkey pubKey;
1909 if (secp256k1_elgamal_generate_keypair(
secp256k1Context(), privKey, &pubKey) == 0)
1915 if (secp256k1_ec_pubkey_serialize(
1916 secp256k1Context(), compressedPubKey, &outLen, &pubKey, SECP256K1_EC_COMPRESSED) != 1 ||
1922 auto& pubKeyEpochs =
pubKeys_[account.id()];
1932 return keyAtEpoch(
pubKeys_, account.id(), epoch);
1938 return keyAtEpoch(
privKeys_, account.id(), epoch);
1945 if (
auto const pubKey =
getPubKey(account))
1963 return std::nullopt;
1967 return std::nullopt;
1969 auto const privKey =
getPrivKey(account, epoch);
1971 return std::nullopt;
1973 uint64_t decryptedAmt = 0;
1974 if (secp256k1_elgamal_decrypt(
1980 kElGamalDecryptRangeLow,
1981 kElGamalDecryptRangeHigh) == 0)
1983 return std::nullopt;
1986 return decryptedAmt;
2013 return std::nullopt;
2025 setAccountField(jv, arg.
account);
2027 jv[sfTransactionType] = jss::ConfidentialMPTMergeInbox;
2037 auto const holderPubAmt =
getBalance(account);
2047 if (!prevInboxBalance || !prevSpendingBalance || !prevIssuerBalance)
2062 if (!postInboxBalance || !postSpendingBalance || !postIssuerBalance ||
2063 !prevIssuerEncrypted || !postInboxEncrypted || !postIssuerEncrypted)
2068 RequireAny([&] ->
bool {
return prevOA && postOA && *prevOA == *postOA; }, loc));
2069 env_.require(
RequireAny([&] ->
bool {
return prevCOA == postCOA; }, loc));
2073 return *postSpendingBalance == *prevInboxBalance + *prevSpendingBalance &&
2074 *postInboxBalance == 0;
2079 RequireAny([&] ->
bool {
return *prevIssuerBalance == *postIssuerBalance; }, loc));
2081 auto const holderPubKey =
getPubKey(account);
2086 requireValue(holderPubKey,
"holderPubKey"), account.id(),
issuanceID());
2091 RequireAny([&] ->
bool {
return *postInboxEncrypted == *expectedInbox; }, loc));
2093 RequireAny([&] ->
bool {
return *postIssuerEncrypted == *prevIssuerEncrypted; }, loc));
2096 return postAuditorEncrypted.has_value() == prevAuditorEncrypted.has_value() &&
2097 (!postAuditorEncrypted || *postAuditorEncrypted == *prevAuditorEncrypted);
2100 env_.require(
RequireAny([&] ->
bool {
return postVersion == prevVersion + 1; }, loc));
2103 [&] ->
bool {
return *postSpendingBalance + *postInboxBalance == *postIssuerBalance; },
2112 return std::nullopt;
2117 return std::nullopt;
2119 return (*sle)[sfOutstandingAmount];
2135 return (*sle)[~sfConfidentialBalanceVersion].value_or(0);
2144 auto const amt = requireValue(arg.
amt,
"amt");
2150 if (!prevInboxBalance || !prevSpendingBalance || !prevIssuerBalance)
2160 if (!prevAuditorBalance)
2175 return prevOutstanding && postOutstanding && *prevOutstanding == *postOutstanding;
2180 return prevConfidentialOutstanding - amt == postConfidentialOutstanding;
2188 if (!postInboxBalance || !postIssuerBalance || !postSpendingBalance)
2195 if (!postAuditorBalance)
2200 [&] ->
bool {
return *prevAuditorBalance - amt == *postAuditorBalance; }, loc));
2205 RequireAny([&] ->
bool {
return *postInboxBalance == *prevInboxBalance; }, loc));
2209 [&] ->
bool {
return *prevIssuerBalance - amt == *postIssuerBalance; }, loc));
2213 [&] ->
bool {
return *prevSpendingBalance - amt == *postSpendingBalance; }, loc));
2216 env_.require(
RequireAny([&] ->
bool {
return postVersion == prevVersion + 1; }, loc));
2221 [&] ->
bool {
return *postInboxBalance + *postSpendingBalance == *postIssuerBalance; },
2232 jv[jss::TransactionType] = jss::ConfidentialMPTConvertBack;
2235 auto const amt = requireValue(arg.
amt,
"amt");
2241 if (!prevSpendingBalance)
2244 Buffer pedersenCommitment;
2255 jv[sfBalanceCommitment] =
strHex(pedersenCommitment);
2265 auto const contextHash =
2269 if (prevEncSpending)
2276 .pedersenCommitment = pedersenCommitment,
2277 .amt = *prevSpendingBalance,
2278 .encryptedAmt = *prevEncSpending,
2279 .blindingFactor = pcBlindingFactor,
2293 jv[jss::TransactionType] = jss::ConfidentialMPTMirrorUpdate;
2295 setAccountField(jv, arg.
account);
2299 jv[sfHolder] = arg.
holder->human();
2322 jv[jss::TransactionType] = jss::ConfidentialMPTHolderKeyUpdate;
2324 setAccountField(jv, arg.
account);
bool expect(Condition const &shouldBeTrue)
Evaluate a test condition.
std::string asString() const
Returns the unquoted string value.
Like std::vector<char> but better.
std::size_t size() const noexcept
Returns the number of bytes in the buffer.
std::uint8_t const * data() const noexcept
Return a pointer to beginning of the storage.
constexpr value_type value() const
Returns the underlying value.
static constexpr std::array< FlagMapping, 7 > flagMapping
An immutable linear range of bytes.
std::uint8_t const * data() const noexcept
Return a pointer to beginning of the storage.
std::size_t size() const noexcept
Returns the number of bytes in the storage.
Immutable cryptographic account descriptor.
AccountID id() const
Returns the Account ID.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
beast::unit_test::Suite & test
std::unordered_map< AccountID, std::vector< Buffer > > pubKeys_
static constexpr auto holderEncryptedInbox
void mirrorUpdate(MPTMirrorUpdate const &arg=MPTMirrorUpdate{}, std::source_location const &loc=std::source_location::current())
std::optional< std::uint32_t > getMirrorEpoch(Account const &holder, SF_UINT32 const &field) const
std::unordered_map< std::string, Account > const holders_
Buffer encryptAmount(Account const &account, uint64_t const amt, Buffer const &blindingFactor) const
bool forObject(std::function< bool(SLEP const &sle)> const &cb, std::optional< Account > const &holder=std::nullopt) const
void mergeInbox(MPTMergeInbox const &arg=MPTMergeInbox{}, std::source_location const &loc=std::source_location::current())
bool checkMPTokenAmount(Account const &holder, std::int64_t expectedAmount) const
std::optional< MPTID > id_
json::Value convertJV(MPTConvert const &arg, std::uint32_t seq)
Build a confidential convert JV without submitting it.
static Buffer getPedersenCommitment(std::uint64_t const amount, Buffer const &pedersenBlindingFactor)
static json::Value destroyJV(MPTDestroy const &arg=MPTDestroy{})
void setIssuanceIdField(json::Value &jv, std::optional< MPTID > const &id) const
Sets sfMPTokenIssuanceID on jv, falling back to id_ if arg's id is not set.
std::optional< Buffer > getEncryptedBalance(Account const &account, EncryptedBalanceType option=holderEncryptedInbox) const
void convertBack(MPTConvertBack const &arg=MPTConvertBack{}, std::source_location const &loc=std::source_location::current())
std::optional< uint64_t > getDecryptedBalance(Account const &account, EncryptedBalanceType balanceType) const
bool checkMirrorEpochs(Account const &holder, std::optional< std::uint32_t > issuerKeyMirrorEpoch, std::optional< std::uint32_t > auditorKeyMirrorEpoch) const
Account const & holder(std::string const &h) const
static json::Value authorizeJV(MPTAuthorize const &arg=MPTAuthorize{})
bool isTransferFeePresent() const
std::optional< Buffer > getClawbackProof(Account const &holder, std::uint64_t amount, Buffer const &privateKey, UInt256 const &txHash) const
bool checkMetadata(std::string const &metadata) const
std::uint32_t generateKeyPair(Account const &account)
bool checkFlags(uint32_t const expectedFlags, std::optional< Account > const &holder=std::nullopt) const
bool isMetadataPresent() const
MPT operator[](std::string const &name) const
void holderKeyUpdate(MPTHolderKeyUpdate const &arg=MPTHolderKeyUpdate{}, std::source_location const &loc=std::source_location::current())
std::optional< Buffer > getSchnorrProof(Account const &account, UInt256 const &ctxHash) const
static constexpr auto issuerEncryptedBalance
bool checkDomainID(std::optional< UInt256 > expected) const
std::uint32_t getMPTokenVersion(Account const account) const
bool checkIssuerMirrorEncryptionKey(std::optional< Buffer > const &expected, Account const &holder) const
Account const & issuer() const
std::optional< std::int64_t > getIssuanceOutstandingBalance() const
static json::Value createJV(MPTCreate const &arg=MPTCreate{})
MPTTester(Env &env, Account issuer, MPTInit const &constr={}, std::source_location const &loc=std::source_location::current())
json::Value sendJV(MPTConfidentialSend const &arg, std::uint32_t seq, std::optional< ConfidentialSendChainState > chain=std::nullopt)
Build a confidential send JV.
ConfidentialSendChainState chainAfterSend(Account const &sender, std::uint64_t sendAmt, json::Value const &jv) const
Compute the projected sender state after a confidential send in a batch.
static json::Value setJV(MPTSet const &set={})
MPTID const & issuanceID() const
static constexpr auto holderEncryptedSpending
std::optional< uint64_t > decryptAmount(Account const &account, Buffer const &amt, std::optional< std::uint32_t > epoch=std::nullopt) const
void send(MPTConfidentialSend const &arg=MPTConfidentialSend{}, std::source_location const &loc=std::source_location::current())
bool checkEncryptionKeys(std::optional< Account > const &issuerKeyOwner, std::optional< Account > const &auditorKeyOwner) const
bool checkImmutableFlags(std::uint32_t expectedFlags) const
std::int64_t getBalance(Account const &account) const
TER submit(A const &arg, WithSourceLocation< json::Value > jv)
void fillConversionCiphertexts(T const &arg, json::Value &jv, Account const &account, std::uint64_t const amount) const
std::optional< Buffer > getConfidentialSendProof(Account const &sender, std::uint64_t const amount, std::vector< ConfidentialRecipient > const &recipients, Slice const &blindingFactor, UInt256 const &contextHash, PedersenProofParams const &amountParams, PedersenProofParams const &balanceParams) const
std::optional< Buffer > getPubKey(Account const &account, std::optional< std::uint32_t > epoch=std::nullopt) const
std::optional< Account > const auditor_
json::Value mergeInboxJV(MPTMergeInbox const &arg=MPTMergeInbox{}) const
void authorizeHolders(Holders const &holders, std::source_location const &loc=std::source_location::current())
static constexpr auto auditorEncryptedBalance
void pay(Account const &src, Account const &dest, std::int64_t amount, std::optional< TER > err=std::nullopt, std::optional< std::vector< std::string > > credentials=std::nullopt, std::source_location const &loc=std::source_location::current())
std::unordered_map< AccountID, std::vector< Buffer > > privKeys_
void claw(Account const &issuer, Account const &holder, std::int64_t amount, std::optional< TER > err=std::nullopt, std::source_location const &loc=std::source_location::current())
void confidentialClaw(MPTConfidentialClawback const &arg=MPTConfidentialClawback{}, std::source_location const &loc=std::source_location::current())
PrettyAmount mpt(std::int64_t amount) const
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
void set(MPTSet const &set={}, std::source_location const &loc=std::source_location::current())
std::int64_t getIssuanceConfidentialBalance() const
std::uint32_t ticketOrSeq(std::optional< std::uint32_t > const &ticketSeq, std::optional< Account > const &account) const
bool checkTransferFee(std::uint16_t transferFee) const
bool checkInitialIssuerKey(std::optional< Buffer > const &expected) const
bool checkIssuanceConfidentialBalance(std::int64_t expectedAmount) const
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
bool checkEncryptionKey(std::optional< Buffer > const &expected, SF_VL const &field, std::optional< Account > const &holder=std::nullopt) const
PrettyAmount operator()(std::int64_t amount) const
std::uint32_t getFlags(std::optional< Account > const &holder) const
bool checkKeyEpochs(std::optional< std::uint32_t > issuerKeyEpoch, std::optional< std::uint32_t > auditorKeyEpoch) const
static std::unordered_map< std::string, Account > makeHolders(std::vector< Account > const &holders)
bool checkMPTokenOutstandingAmount(std::int64_t expectedAmount) const
void convert(MPTConvert const &arg=MPTConvert{}, std::source_location const &loc=std::source_location::current())
std::optional< Buffer > getPrivKey(Account const &account, std::optional< std::uint32_t > epoch=std::nullopt) const
void destroy(MPTDestroy const &arg=MPTDestroy{}, std::source_location const &loc=std::source_location::current())
std::optional< Buffer > getConvertBackProof(Account const &holder, std::uint64_t const amount, UInt256 const &contextHash, PedersenProofParams const &pcParams) const
json::Value convertBackJV(MPTConvertBack const &arg, std::uint32_t seq)
Build a confidential convertBack JV without submitting it.
Converts to MPT Issue or STAmount.
Test helper that checks MPT issuance or holder balances.
std::source_location testLoc_
MPTTester const & tester_
std::int64_t const amount_
void operator()(Env &env) const
std::source_location checkLoc_
Test helper that checks MPT flag settings after creation.
std::source_location checkLoc_
void operator()(Env &env) const
std::optional< Account > holder_
std::source_location testLoc_
Match the number of items in the account's owner directory.
Test helper that accepts any condition supplied by a callback.
std::function< bool()> cb_
std::source_location testLoc_
void operator()(Env &env) const
std::source_location checkLoc_
Set the expected result code for a JTx The test will fail if the code doesn't match.
@ Array
array value (ordered list)
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount, NetClock::duration const &settleDelay, PublicKey const &pk, std::optional< NetClock::time_point > const &cancelAfter, std::optional< std::uint32_t > const &dstTag)
json::Value claw(Account const &account, STAmount const &amount, std::optional< Account > const &mptHolder)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
std::vector< STAmount > fund(jtx::Env &env, jtx::Account const &gw, std::vector< jtx::Account > const &accounts, std::vector< STAmount > const &amts, Fund how)
static MPTCreate makeMPTCreate(MPTInitDef const &arg)
Buffer gMakeZeroBuffer(std::size_t size)
Create a zero-initialized buffer for malformed cryptography test inputs.
std::vector< Account > Holders
std::optional< ConfidentialSendChainState > computeNextSendChainState(std::uint64_t currentSpending, Slice const ¤tEncSpending, std::uint32_t currentVersion, std::uint64_t sendAmt, Slice const &senderEncAmt)
Use this when building a second (or later) confidential send from the same account in the same batch.
static Buffer parseSenderEncAmt(json::Value const &jv)
constexpr std::size_t kEcPubKeyLength
Length of EC public key (compressed).
constexpr std::uint8_t kEcCompressedPrefixEvenY
Compressed EC point prefix for even y-coordinate.
constexpr std::size_t kEcBlindingFactorLength
Length of the EC blinding factor in bytes.
std::optional< Buffer > encryptCanonicalZeroAmount(Slice const &pubKeySlice, AccountID const &account, MPTID const &mptId)
Generates the canonical zero encryption for a specific MPToken.
UInt256 getConvertContextHash(AccountID const &account, UInt192 const &issuanceID, std::uint32_t sequence)
Generates the context hash for ConfidentialMPTConvert transactions.
std::string strHex(FwdIt begin, FwdIt end)
UInt256 getSendContextHash(AccountID const &account, UInt192 const &issuanceID, std::uint32_t sequence, AccountID const &destination, std::uint32_t version)
Generates the context hash for ConfidentialMPTSend transactions.
UInt256 getConvertBackContextHash(AccountID const &account, UInt192 const &issuanceID, std::uint32_t sequence, std::uint32_t version)
Generates the context hash for ConfidentialMPTConvertBack transactions.
constexpr std::size_t kEcClawbackProofLength
Length of the ZKProof for ConfidentialMPTClawback.
std::optional< Buffer > encryptAmount(uint64_t const amt, Slice const &pubKeySlice, Slice const &blindingFactor)
Encrypts an amount using ElGamal encryption.
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
constexpr std::size_t kEcSchnorrProofLength
Length of Schnorr ZKProof for public key registration (compact form) in bytes.
std::optional< EcPair > makeEcPair(Slice const &buffer)
Parses an ElGamal ciphertext into two secp256k1 public key components.
bool matches(char const *string, char const *regex)
Return true if the string loosely matches the regex.
constexpr std::size_t kEcGamalEncryptedTotalLength
EC ElGamal ciphertext length: two compressed EC points concatenated.
TypedField< STInteger< std::uint32_t > > SF_UINT32
std::string to_string(BaseUInt< Bits, Tag > const &a)
constexpr std::size_t kEcConvertBackProofLength
128 bytes compact sigma proof + 688 bytes single bulletproof.
constexpr std::size_t kEcPedersenCommitmentLength
Length of Pedersen Commitment (compressed).
std::optional< Buffer > homomorphicSubtract(Slice const &a, Slice const &b)
Homomorphically subtracts two ElGamal ciphertexts.
std::optional< Blob > strUnHex(std::size_t strSize, Iterator begin, Iterator end)
Rate transferRate(ReadView const &view, AccountID const &issuer)
Returns IOU issuer transfer fee as Rate.
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
TypedField< STBlob > SF_VL
secp256k1_context const * secp256k1Context()
constexpr std::size_t kEcEqualityProofLength
Length of compact equality proof.
UInt256 getClawbackContextHash(AccountID const &account, UInt192 const &issuanceID, std::uint32_t sequence, AccountID const &holder)
Generates the context hash for ConfidentialMPTClawback transactions.
Buffer generateBlindingFactor()
Generates a cryptographically secure blinding factor (size=xrpl::kEcBlindingFactorLength).
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
constexpr std::size_t kEcSendProofLength
192 bytes compact sigma proof + 754 bytes double bulletproof.
bool isTesSuccess(TER x) noexcept
STAmount multiply(STAmount const &amount, Number const &frac, Number::RoundingMode rm)
constexpr std::size_t kEcPrivKeyLength
Length of EC private key in bytes.
XRPL_NO_SANITIZE_ADDRESS void Throw(Args &&... args)
When building multiple confidential sends from the same account inside a single batch transaction,...
Arguments for building an MPTokenAuthorize test transaction.
std::optional< Account > holder
std::optional< Account > account
std::optional< MPTID > id
std::optional< std::uint32_t > flags
Arguments for building a ConfidentialMPTClawback test transaction.
std::optional< std::uint32_t > ticketSeq
std::optional< std::string > proof
std::optional< std::uint64_t > amt
std::optional< MPTID > id
std::optional< Account > account
std::optional< Account > holder
Arguments for building a ConfidentialMPTSend test transaction.
std::optional< std::vector< std::string > > credentials
std::optional< Buffer > balanceCommitment
std::optional< MPTID > id
std::optional< std::uint32_t > ticketSeq
std::optional< std::uint64_t > amt
std::optional< bool > fillAuditorEncryptedAmt
std::optional< Account > account
std::optional< Buffer > auditorEncryptedAmt
std::optional< Account > dest
std::optional< Buffer > blindingFactor
std::optional< Buffer > amountCommitment
std::optional< std::string > proof
std::optional< Buffer > senderEncryptedAmt
std::optional< Buffer > destEncryptedAmt
std::optional< Buffer > issuerEncryptedAmt
Arguments for building a ConfidentialMPTConvertBack test transaction.
std::optional< Buffer > auditorEncryptedAmt
std::optional< MPTID > id
std::optional< std::uint64_t > amt
std::optional< Account > account
std::optional< std::uint32_t > ticketSeq
std::optional< Buffer > proof
std::optional< Buffer > pedersenCommitment
Arguments for building a ConfidentialMPTConvert test transaction.
std::optional< bool > fillAuditorEncryptedAmt
std::optional< MPTID > id
std::optional< std::uint64_t > amt
std::optional< Buffer > auditorEncryptedAmt
std::optional< bool > fillSchnorrProof
std::optional< Buffer > holderPubKey
std::optional< Account > account
std::optional< std::string > proof
std::optional< std::uint32_t > ticketSeq
Arguments for building an MPTokenIssuanceCreate test transaction.
std::optional< std::uint8_t > assetScale
std::optional< std::uint32_t > immutableFlags
std::optional< std::string > metadata
std::optional< std::uint32_t > flags
std::optional< std::uint64_t > maxAmt
std::optional< UInt256 > domainID
std::optional< Account > issuer
std::optional< std::pair< std::vector< Account >, std::uint64_t > > pay
std::optional< std::uint16_t > transferFee
std::optional< std::vector< Account > > authorize
Arguments for building an MPTokenIssuanceDestroy test transaction.
std::optional< Account > issuer
std::optional< MPTID > id
Arguments for building a ConfidentialMPTHolderKeyUpdate test transaction.
std::optional< Account > account
std::optional< Buffer > inboxCiphertext
std::optional< Buffer > proof
std::optional< MPTID > id
std::optional< Buffer > spendingCiphertext
std::optional< Buffer > holderPubKey
Full constructor arguments for MPTTester initialization.
std::uint16_t transferFee
std::optional< std::uint64_t > maxAmt
std::optional< std::uint32_t > immutableFlags
std::optional< std::uint64_t > pay
Arguments for initializing funded MPT test accounts and issuance.
std::optional< Account > auditor
Arguments for building a ConfidentialMPTMergeInbox test transaction.
std::optional< MPTID > id
std::optional< Account > account
Arguments for building a ConfidentialMPTMirrorUpdate test transaction.
std::optional< Buffer > auditorEncryptedAmount
std::optional< Account > holder
std::optional< Account > account
std::optional< Buffer > zkProof
std::optional< MPTID > id
std::optional< Buffer > issuerEncryptedAmount
Arguments for building an MPTokenIssuanceSet test transaction.
std::optional< Account > account
std::optional< Buffer > auditorPubKey
std::optional< MPTID > id
std::optional< std::uint32_t > immutableFlags
std::optional< std::uint16_t > transferFee
std::optional< std::uint32_t > flags
std::optional< std::variant< Account, AccountID > > holder
std::optional< std::string > metadata
std::optional< Buffer > issuerPubKey
std::optional< UInt256 > domainID
std::optional< Account > delegate
Stores the parameters that are exclusively used to generate a Pedersen linkage proof.
Buffer const pedersenCommitment
The Pedersen commitment used by the proof.
Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports XRP conver...
Wrapper that captures std::source_location when implicitly constructed.