1#include <test/jtx/Env.h>
2#include <test/jtx/TestHelpers.h>
3#include <test/jtx/WSClient.h>
4#include <test/jtx/amount.h>
5#include <test/jtx/batch.h>
6#include <test/jtx/domain.h>
7#include <test/jtx/envconfig.h>
8#include <test/jtx/escrow.h>
9#include <test/jtx/fee.h>
10#include <test/jtx/mpt.h>
11#include <test/jtx/offer.h>
12#include <test/jtx/owners.h>
13#include <test/jtx/paths.h>
14#include <test/jtx/pay.h>
15#include <test/jtx/permissioned_dex.h>
16#include <test/jtx/sendmax.h>
17#include <test/jtx/seq.h>
18#include <test/jtx/sig.h>
19#include <test/jtx/tags.h>
20#include <test/jtx/token.h>
21#include <test/jtx/txflags.h>
23#include <xrpld/app/main/LoadManager.h>
24#include <xrpld/core/Config.h>
26#include <xrpl/basics/UnorderedContainers.h>
27#include <xrpl/basics/base_uint.h>
28#include <xrpl/basics/strHex.h>
29#include <xrpl/beast/unit_test/suite.h>
30#include <xrpl/config/Constants.h>
31#include <xrpl/core/NetworkIDService.h>
32#include <xrpl/json/json_value.h>
33#include <xrpl/json/to_string.h>
34#include <xrpl/protocol/AccountID.h>
35#include <xrpl/protocol/ErrorCodes.h>
36#include <xrpl/protocol/Feature.h>
37#include <xrpl/protocol/Fees.h>
38#include <xrpl/protocol/Indexes.h>
39#include <xrpl/protocol/KeyType.h>
40#include <xrpl/protocol/PublicKey.h>
41#include <xrpl/protocol/SField.h>
42#include <xrpl/protocol/STValidation.h>
43#include <xrpl/protocol/SecretKey.h>
44#include <xrpl/protocol/Seed.h>
45#include <xrpl/protocol/SeqProxy.h>
46#include <xrpl/protocol/TxFlags.h>
47#include <xrpl/protocol/UintTypes.h>
48#include <xrpl/protocol/XRPAmount.h>
49#include <xrpl/protocol/jss.h>
50#include <xrpl/protocol/tokens.h>
51#include <xrpl/server/LoadFeeTrack.h>
52#include <xrpl/server/NetworkOPs.h>
76 using namespace std::chrono_literals;
85 stream[jss::streams].append(
"server");
86 auto jv = wsc->invoke(
"subscribe", stream);
87 if (wsc->version() == 2)
90 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
92 BEAST_EXPECT(jv[jss::status] ==
"success");
104 for (
int i = 0; i < 5; ++i)
110 wsc->findMsg(5s, [&](
auto const& jv) { return jv[jss::type] ==
"serverStatus"; }));
115 auto jv = wsc->invoke(
"unsubscribe", stream);
116 if (wsc->version() == 2)
119 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
121 BEAST_EXPECT(jv[jss::status] ==
"success");
127 for (
int i = 0; i < 5; ++i)
132 auto jvo = wsc->getMsg(10ms);
133 BEAST_EXPECTS(!jvo,
"getMsg: " +
to_string(jvo.value()));
140 using namespace std::chrono_literals;
149 stream[jss::streams].append(
"ledger");
150 auto jv = wsc->invoke(
"subscribe", stream);
151 if (wsc->version() == 2)
154 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
156 BEAST_EXPECT(jv[jss::result][jss::ledger_index] == 2);
166 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
167 return jv[jss::ledger_index] == 3 &&
168 jv[jss::network_id] == env.app().getNetworkIDService().getNetworkID();
177 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
178 return jv[jss::ledger_index] == 4 &&
179 jv[jss::network_id] == env.app().getNetworkIDService().getNetworkID();
184 auto jv = wsc->invoke(
"unsubscribe", stream);
185 if (wsc->version() == 2)
188 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
190 BEAST_EXPECT(jv[jss::status] ==
"success");
196 using namespace std::chrono_literals;
199 auto baseFee = env.
current()->fees().base.drops();
206 stream[jss::streams].append(
"transactions");
207 auto jv = wsc->invoke(
"subscribe", stream);
208 if (wsc->version() == 2)
211 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
213 BEAST_EXPECT(jv[jss::status] ==
"success");
221 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
222 return jv[jss::meta][
"AffectedNodes"][1u][
"CreatedNode"][
"NewFields"]
223 [jss::Account] == Account(
"alice").human() &&
224 jv[jss::transaction][jss::TransactionType] == jss::Payment &&
225 jv[jss::transaction][jss::DeliverMax] ==
226 std::to_string(10000000000 + baseFee) &&
227 jv[jss::transaction][jss::Fee] == std::to_string(baseFee) &&
228 jv[jss::transaction][jss::Sequence] == 1;
232 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
233 return jv[jss::meta][
"AffectedNodes"][0u][
"ModifiedNode"][
"FinalFields"]
234 [jss::Account] == Account(
"alice").human();
241 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
242 return jv[jss::meta][
"AffectedNodes"][1u][
"CreatedNode"][
"NewFields"]
244 == Account(
"bob").human() &&
245 jv[jss::transaction][jss::TransactionType]
247 jv[jss::transaction][jss::DeliverMax]
248 == std::to_string(10000000000 + baseFee) &&
249 jv[jss::transaction][jss::Fee]
250 == std::to_string(baseFee) &&
251 jv[jss::transaction][jss::Sequence]
256 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
257 return jv[jss::meta][
"AffectedNodes"][0u][
"ModifiedNode"][
"FinalFields"]
258 [jss::Account] == Account(
"bob").human();
264 auto jv = wsc->invoke(
"unsubscribe", stream);
265 if (wsc->version() == 2)
268 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
270 BEAST_EXPECT(jv[jss::status] ==
"success");
277 stream[jss::accounts].append(
Account(
"alice").human());
278 auto jv = wsc->invoke(
"subscribe", stream);
279 if (wsc->version() == 2)
282 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
284 BEAST_EXPECT(jv[jss::status] ==
"success");
291 BEAST_EXPECT(!wsc->getMsg(10ms));
298 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
299 return jv[jss::meta][
"AffectedNodes"][1u][
"ModifiedNode"][
"FinalFields"]
300 [jss::Account] == Account(
"alice").human();
303 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
304 return jv[jss::meta][
"AffectedNodes"][1u][
"CreatedNode"][
"NewFields"][
"LowLimit"]
305 [jss::issuer] == Account(
"alice").human();
310 auto jv = wsc->invoke(
"unsubscribe", stream);
311 if (wsc->version() == 2)
314 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
316 BEAST_EXPECT(jv[jss::status] ==
"success");
322 testcase(
"transactions API version 2");
324 using namespace std::chrono_literals;
327 cfg->fees.referenceFee = 10;
336 stream[jss::api_version] = 2;
338 stream[jss::streams].append(
"transactions");
339 auto jv = wsc->invoke(
"subscribe", stream);
340 if (wsc->version() == 2)
343 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
345 BEAST_EXPECT(jv[jss::status] ==
"success");
349 env.fund(
XRP(10000),
"alice");
350 BEAST_EXPECT(env.syncClose());
353 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
354 return jv[jss::meta][
"AffectedNodes"][1u][
"CreatedNode"][
"NewFields"]
356 == Account(
"alice").human() &&
357 jv[jss::close_time_iso]
358 ==
"2000-01-01T00:00:10Z" &&
359 jv[jss::validated] == true &&
360 jv[jss::ledger_hash] ==
361 "5CC95BD8BA54A009A4F5BA437867BBFCF18F5A9CFB7F68FE7816258D164C1516" &&
362 !jv[jss::inLedger] &&
363 jv[jss::ledger_index] == 3 &&
364 jv[jss::tx_json][jss::TransactionType]
366 jv[jss::tx_json][jss::DeliverMax]
368 !jv[jss::tx_json].isMember(jss::Amount) &&
369 jv[jss::tx_json][jss::Fee]
371 jv[jss::tx_json][jss::Sequence]
376 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
377 return jv[jss::meta][
"AffectedNodes"][0u][
"ModifiedNode"][
"FinalFields"]
378 [jss::Account] == Account(
"alice").human();
384 auto jv = wsc->invoke(
"unsubscribe", stream);
385 if (wsc->version() == 2)
388 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
390 BEAST_EXPECT(jv[jss::status] ==
"success");
405 stream[jss::streams].append(
"manifests");
406 auto jv = wsc->invoke(
"subscribe", stream);
407 if (wsc->version() == 2)
410 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
412 BEAST_EXPECT(jv[jss::status] ==
"success");
416 auto jv = wsc->invoke(
"unsubscribe", stream);
417 if (wsc->version() == 2)
420 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
422 BEAST_EXPECT(jv[jss::status] ==
"success");
446 auto const parsedseed =
448 if (BEAST_EXPECT(parsedseed); not parsedseed.has_value())
462 stream[jss::streams].append(
"validations");
463 auto jv = wsc->invoke(
"subscribe", stream);
464 if (wsc->version() == 2)
467 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
469 BEAST_EXPECT(jv[jss::status] ==
"success");
474 auto const validValidationFields = [&env, &valPublicKey](
json::Value const& jv) {
475 if (jv[jss::type] !=
"validationReceived")
478 if (jv[jss::validation_public_key].asString() != valPublicKey)
490 if (jv[jss::full] !=
true)
493 if (jv.isMember(jss::load_fee))
496 if (!jv.isMember(jss::signature))
499 if (!jv.isMember(jss::signing_time))
502 if (!jv.isMember(jss::cookie))
505 if (!jv.isMember(jss::validated_hash))
509 if (!jv.isMember(jss::network_id) || jv[jss::network_id] != netID)
524 if (env.
closed()->rules().enabled(featureSmartEscrow))
529 if (jv.isMember(jss::bytecode_size_limit) !=
isFlagLedger)
537 if (jv.isMember(jss::gas_limit))
540 if (jv.isMember(jss::bytecode_size_limit))
543 if (jv.isMember(jss::gas_price))
551 while (env.
closed()->header().seq < 300)
554 using namespace std::chrono_literals;
555 BEAST_EXPECT(wsc->findMsg(5s, validValidationFields));
560 auto jv = wsc->invoke(
"unsubscribe", stream);
561 if (wsc->version() == 2)
564 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
566 BEAST_EXPECT(jv[jss::status] ==
"success");
577 jv[jss::url] =
"http://localhost/events";
578 jv[jss::url_username] =
"admin";
579 jv[jss::url_password] =
"password";
581 jv[jss::streams][0u] =
"validations";
582 auto jr = env.
rpc(
"json",
"subscribe",
to_string(jv))[jss::result];
583 BEAST_EXPECT(jr[jss::status] ==
"success");
585 jv[jss::streams][0u] =
"ledger";
586 jr = env.
rpc(
"json",
"subscribe",
to_string(jv))[jss::result];
587 BEAST_EXPECT(jr[jss::status] ==
"success");
590 jr = env.
rpc(
"json",
"unsubscribe",
to_string(jv))[jss::result];
591 BEAST_EXPECT(jr[jss::status] ==
"success");
593 jv[jss::streams][0u] =
"validations";
594 jr = env.
rpc(
"json",
"unsubscribe",
to_string(jv))[jss::result];
595 BEAST_EXPECT(jr[jss::status] ==
"success");
602 auto const method = subscribe ?
"subscribe" :
"unsubscribe";
603 testcase <<
"Error cases for " << method;
609 auto const jr = env.
rpc(
"json", method,
"{}")[jss::result];
610 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
612 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
617 jv[jss::url] =
"not-a-url";
618 jv[jss::username] =
"admin";
619 jv[jss::password] =
"password";
620 auto const jr = env.
rpc(
"json", method,
to_string(jv))[jss::result];
623 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
625 BEAST_EXPECT(jr[jss::error_message] ==
"Failed to parse url.");
633 jv[jss::url] =
"ftp://scheme.not.supported.tld";
634 auto const jr = env.
rpc(
"json", method,
to_string(jv))[jss::result];
637 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
639 BEAST_EXPECT(jr[jss::error_message] ==
"Only http and https is supported.");
646 jv[jss::url] =
"no-url";
647 auto const jr = envNonadmin.
rpc(
"json", method,
to_string(jv))[jss::result];
648 BEAST_EXPECT(jr[jss::error] ==
"noPermission");
650 BEAST_EXPECT(jr[jss::error_message] ==
"You don't have permission for this command.");
663 for (
auto const& f : {jss::accounts_proposed, jss::accounts})
665 for (
auto const& nonArray : nonArrays)
669 auto const jr = wsc->invoke(method, jv)[jss::result];
670 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
672 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
678 auto const jr = wsc->invoke(method, jv)[jss::result];
679 BEAST_EXPECT(jr[jss::error] ==
"actMalformed");
681 BEAST_EXPECT(jr[jss::error_message] ==
"Account malformed.");
685 for (
auto const& nonArray : nonArrays)
688 jv[jss::mpt_issuances] = nonArray;
689 auto jr = wsc->invoke(method, jv)[jss::result];
690 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
692 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
698 jv[jss::mpt_issuances][0u] = 1;
699 auto jr = wsc->invoke(method, jv)[jss::result];
700 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
702 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
708 jv[jss::mpt_issuances][0u] =
"not-an-mpt-issuance-id";
709 auto jr = wsc->invoke(method, jv)[jss::result];
710 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
712 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
718 jv[jss::mpt_issuances][0u] =
"0123456789ABCDEF";
719 auto jr = wsc->invoke(method, jv)[jss::result];
720 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
722 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
725 for (
auto const& nonArray : nonArrays)
728 jv[jss::books] = nonArray;
729 auto const jr = wsc->invoke(method, jv)[jss::result];
730 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
732 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
738 jv[jss::books][0u] = 1;
739 auto const jr = wsc->invoke(method, jv)[jss::result];
740 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
742 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
751 auto const jr = wsc->invoke(method, jv)[jss::result];
753 BEAST_EXPECT(jr[jss::error] ==
"srcCurMalformed");
755 BEAST_EXPECT(jr[jss::error_message] ==
"Source currency is malformed.");
764 jv[jss::books][0u][jss::taker_pays][jss::currency] =
"ZZZZ";
765 auto const jr = wsc->invoke(method, jv)[jss::result];
766 BEAST_EXPECT(jr[jss::error] ==
"srcCurMalformed");
768 BEAST_EXPECT(jr[jss::error_message] ==
"Source currency is malformed.");
777 jv[jss::books][0u][jss::taker_pays][jss::currency] =
"USD";
778 jv[jss::books][0u][jss::taker_pays][jss::issuer] = 1;
779 auto const jr = wsc->invoke(method, jv)[jss::result];
780 BEAST_EXPECT(jr[jss::error] ==
"srcIsrMalformed");
782 BEAST_EXPECT(jr[jss::error_message] ==
"Source issuer is malformed.");
791 jv[jss::books][0u][jss::taker_pays][jss::currency] =
"USD";
792 jv[jss::books][0u][jss::taker_pays][jss::issuer] =
Account{
"gateway"}.
human() +
"DEAD";
793 auto const jr = wsc->invoke(method, jv)[jss::result];
794 BEAST_EXPECT(jr[jss::error] ==
"srcIsrMalformed");
796 BEAST_EXPECT(jr[jss::error_message] ==
"Source issuer is malformed.");
803 jv[jss::books][0u][jss::taker_pays] =
806 auto const jr = wsc->invoke(method, jv)[jss::result];
808 BEAST_EXPECT(jr[jss::error] ==
"dstAmtMalformed");
811 jr[jss::error_message] ==
"Destination amount/currency/issuer is malformed.");
818 jv[jss::books][0u][jss::taker_pays] =
820 jv[jss::books][0u][jss::taker_gets][jss::currency] =
"ZZZZ";
821 auto const jr = wsc->invoke(method, jv)[jss::result];
824 BEAST_EXPECT(jr[jss::error] ==
"dstAmtMalformed");
827 jr[jss::error_message] ==
"Destination amount/currency/issuer is malformed.");
834 jv[jss::books][0u][jss::taker_pays] =
836 jv[jss::books][0u][jss::taker_gets][jss::currency] =
"USD";
837 jv[jss::books][0u][jss::taker_gets][jss::issuer] = 1;
838 auto const jr = wsc->invoke(method, jv)[jss::result];
839 BEAST_EXPECT(jr[jss::error] ==
"dstIsrMalformed");
841 BEAST_EXPECT(jr[jss::error_message] ==
"Destination issuer is malformed.");
848 jv[jss::books][0u][jss::taker_pays] =
850 jv[jss::books][0u][jss::taker_gets][jss::currency] =
"USD";
851 jv[jss::books][0u][jss::taker_gets][jss::issuer] =
Account{
"gateway"}.
human() +
"DEAD";
852 auto const jr = wsc->invoke(method, jv)[jss::result];
853 BEAST_EXPECT(jr[jss::error] ==
"dstIsrMalformed");
855 BEAST_EXPECT(jr[jss::error_message] ==
"Destination issuer is malformed.");
862 jv[jss::books][0u][jss::taker_pays] =
864 jv[jss::books][0u][jss::taker_gets] =
866 auto const jr = wsc->invoke(method, jv)[jss::result];
867 BEAST_EXPECT(jr[jss::error] ==
"badMarket");
869 BEAST_EXPECT(jr[jss::error_message] ==
"No such market.");
872 for (
auto const& nonArray : nonArrays)
875 jv[jss::streams] = nonArray;
876 auto const jr = wsc->invoke(method, jv)[jss::result];
877 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
879 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
885 jv[jss::streams][0u] = 1;
886 auto const jr = wsc->invoke(method, jv)[jss::result];
887 BEAST_EXPECT(jr[jss::error] ==
"malformedStream");
889 BEAST_EXPECT(jr[jss::error_message] ==
"Stream malformed.");
895 jv[jss::streams][0u] =
"not_a_stream";
896 auto const jr = wsc->invoke(method, jv)[jss::result];
897 BEAST_EXPECT(jr[jss::error] ==
"malformedStream");
899 BEAST_EXPECT(jr[jss::error_message] ==
"Stream malformed.");
909 jv[jss::books][0u][jss::taker_pays] =
911 jv[jss::books][0u][jss::taker_gets][jss::currency] =
"XRP";
912 jv[jss::books][0u][jss::taker] = 1;
913 auto const jr = wsc->invoke(method, jv)[jss::result];
914 BEAST_EXPECTS(jr[jss::error] ==
"actMalformed", jr.toStyledString());
916 BEAST_EXPECT(jr[jss::error_message] ==
"Account malformed.");
924 jv[jss::books][0u][jss::taker_pays] =
926 jv[jss::books][0u][jss::taker_gets][jss::currency] =
"XRP";
927 jv[jss::books][0u][jss::taker] =
"not_an_account";
928 auto const jr = wsc->invoke(method, jv)[jss::result];
929 BEAST_EXPECTS(jr[jss::error] ==
"actMalformed", jr.toStyledString());
931 BEAST_EXPECT(jr[jss::error_message] ==
"Account malformed.");
939 jv[jss::books][0u][jss::taker_pays] =
941 jv[jss::books][0u][jss::taker_gets][jss::currency] =
"XRP";
942 jv[jss::books][0u][jss::taker] =
Account{
"alice"}.
human() +
"DEAD";
943 auto const jr = wsc->invoke(method, jv)[jss::result];
944 BEAST_EXPECTS(jr[jss::error] ==
"actMalformed", jr.toStyledString());
946 BEAST_EXPECT(jr[jss::error_message] ==
"Account malformed.");
956 using namespace std::chrono_literals;
969 auto const goodSubRPC = [](
json::Value const& subReply) ->
bool {
970 return subReply.isMember(jss::result) && subReply[jss::result].isMember(jss::status) &&
971 subReply[jss::result][jss::status] == jss::success;
979 auto const getTxHash = [](
WSClient& wsc,
984 bool firstFlag =
false;
986 for (
int i = 0; i < numReplies; ++i)
989 auto reply = wsc.
getMsg(timeout);
993 if (r.isMember(jss::account_history_tx_index))
994 idx = r[jss::account_history_tx_index].asInt();
995 if (r.isMember(jss::account_history_tx_first))
997 bool const boundary = r.isMember(jss::account_history_boundary);
998 int const ledgerIdx = r[jss::ledger_index].asInt();
999 if (r.isMember(jss::transaction) && r[jss::transaction].isMember(jss::hash))
1001 auto t{r[jss::transaction]};
1002 v.emplace_back(idx, t[jss::hash].asString(), boundary, ledgerIdx);
1006 return {
false, firstFlag};
1009 return {
true, firstFlag};
1016 auto sendPayments = [
this](
1025 for (
int i = 0; i < newTxns; ++i)
1027 auto& from = (i % 2 == 0) ? a : b;
1028 auto& to = (i % 2 == 0) ? b : a;
1034 for (
int i = 0; i < ledgersToClose; ++i)
1044 auto const hashCompare = [](IdxHashVec
const& accountVec,
1045 IdxHashVec
const& txHistoryVec,
1046 bool sizeCompare) ->
bool {
1047 if (accountVec.empty() || txHistoryVec.empty())
1049 if (sizeCompare && accountVec.size() != txHistoryVec.size())
1053 for (
auto const& tx : txHistoryVec)
1055 txHistoryMap.
emplace(std::get<1>(tx), std::get<0>(tx));
1059 if (i >= accountVec.size())
1061 auto const it = txHistoryMap.
find(std::get<1>(accountVec[i]));
1062 if (it == txHistoryMap.
end())
1067 auto firstHistoryIndex = getHistoryIndex(0);
1068 if (!firstHistoryIndex)
1070 for (
std::size_t i = 1; i < accountVec.size(); ++i)
1072 if (
auto idx = getHistoryIndex(i); !idx || *idx != *firstHistoryIndex + i)
1108 auto const checkBoundary = [](IdxHashVec
const& vec,
bool ) {
1109 size_t const numTx = vec.size();
1110 for (
size_t i = 0; i < numTx; ++i)
1112 auto [idx, hash, boundary, ledger] = vec[i];
1113 if ((i + 1 == numTx || ledger != std::get<3>(vec[i + 1])) != boundary)
1132 request[jss::account_history_tx_stream][jss::account] = alice.
human();
1133 auto jv = wscTxHistory->invoke(
"subscribe", request);
1134 if (!BEAST_EXPECT(goodSubRPC(jv)))
1137 jv = wscTxHistory->invoke(
"subscribe", request);
1138 BEAST_EXPECT(!goodSubRPC(jv));
1143 request[jss::account_history_tx_stream][jss::stop_history_tx_only] =
true;
1144 jv = wscTxHistory->invoke(
"unsubscribe", request);
1145 if (!BEAST_EXPECT(goodSubRPC(jv)))
1148 sendPayments(env, env.
master, alice, 1, 1, 123456);
1151 auto r = getTxHash(*wscTxHistory, vec, 1);
1152 if (!BEAST_EXPECT(r.first && r.second))
1158 request[jss::account_history_tx_stream][jss::stop_history_tx_only] =
false;
1159 jv = wscTxHistory->invoke(
"unsubscribe", request);
1160 BEAST_EXPECT(goodSubRPC(jv));
1162 sendPayments(env, env.
master, alice, 1, 1);
1163 r = getTxHash(*wscTxHistory, vec, 1, 10ms);
1164 BEAST_EXPECT(!r.first);
1175 request[jss::account_history_tx_stream][jss::account] =
1176 "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
1177 auto jv = wscTxHistory->invoke(
"subscribe", request);
1178 if (!BEAST_EXPECT(goodSubRPC(jv)))
1180 IdxHashVec genesisFullHistoryVec;
1182 if (!BEAST_EXPECT(!getTxHash(*wscTxHistory, genesisFullHistoryVec, 1, 10ms).first))
1189 sendPayments(env, env.
master, bob, 1, 1, 654321);
1191 auto r = getTxHash(*wscTxHistory, genesisFullHistoryVec, 1);
1192 if (!BEAST_EXPECT(r.first && r.second))
1195 request[jss::account_history_tx_stream][jss::account] = bob.
human();
1196 jv = wscTxHistory->invoke(
"subscribe", request);
1197 if (!BEAST_EXPECT(goodSubRPC(jv)))
1199 IdxHashVec bobFullHistoryVec;
1201 r = getTxHash(*wscTxHistory, bobFullHistoryVec, 1);
1202 if (!BEAST_EXPECT(r.first && r.second))
1205 std::get<1>(bobFullHistoryVec.back()) == std::get<1>(genesisFullHistoryVec.back()));
1210 jv = wscTxHistory->invoke(
"unsubscribe", request);
1211 if (!BEAST_EXPECT(goodSubRPC(jv)))
1213 request[jss::account_history_tx_stream][jss::account] =
1214 "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
1215 jv = wscTxHistory->invoke(
"unsubscribe", request);
1216 BEAST_EXPECT(goodSubRPC(jv));
1222 sendPayments(env, env.
master, bob, 30, 300);
1224 request[jss::account_history_tx_stream][jss::account] = bob.
human();
1225 jv = wscTxHistory->invoke(
"subscribe", request);
1227 bobFullHistoryVec.
clear();
1228 BEAST_EXPECT(getTxHash(*wscTxHistory, bobFullHistoryVec, 31).second);
1229 jv = wscTxHistory->invoke(
"unsubscribe", request);
1231 request[jss::account_history_tx_stream][jss::account] =
1232 "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
1233 jv = wscTxHistory->invoke(
"subscribe", request);
1234 genesisFullHistoryVec.
clear();
1236 BEAST_EXPECT(getTxHash(*wscTxHistory, genesisFullHistoryVec, 31).second);
1237 jv = wscTxHistory->invoke(
"unsubscribe", request);
1240 std::get<1>(bobFullHistoryVec.back()) == std::get<1>(genesisFullHistoryVec.back()));
1253 env.
fund(
XRP(222222), accounts);
1259 stream[jss::accounts].append(alice.
human());
1260 auto jv = wscAccount->invoke(
"subscribe", stream);
1262 sendPayments(env, alice, bob, 5, 1);
1263 sendPayments(env, alice, bob, 5, 1);
1264 IdxHashVec accountVec;
1265 if (!BEAST_EXPECT(getTxHash(*wscAccount, accountVec, 10).first))
1271 request[jss::account_history_tx_stream][jss::account] = alice.
human();
1272 jv = wscTxHistory->invoke(
"subscribe", request);
1275 IdxHashVec txHistoryVec;
1276 if (!BEAST_EXPECT(getTxHash(*wscTxHistory, txHistoryVec, 10).first))
1278 if (!BEAST_EXPECT(hashCompare(accountVec, txHistoryVec,
true)))
1283 if (!BEAST_EXPECT(checkBoundary(txHistoryVec,
false)))
1288 IdxHashVec initFundTxns;
1289 if (!BEAST_EXPECT(getTxHash(*wscTxHistory, initFundTxns, 10).second) ||
1290 !BEAST_EXPECT(checkBoundary(initFundTxns,
false)))
1295 sendPayments(env, alice, bob, 10, 1);
1296 if (!BEAST_EXPECT(getTxHash(*wscAccount, accountVec, 10).first))
1298 if (!BEAST_EXPECT(getTxHash(*wscTxHistory, txHistoryVec, 10).first))
1300 if (!BEAST_EXPECT(hashCompare(accountVec, txHistoryVec,
true)))
1305 if (!BEAST_EXPECT(checkBoundary(txHistoryVec,
false)))
1308 wscTxHistory->invoke(
"unsubscribe", request);
1309 wscAccount->invoke(
"unsubscribe", stream);
1318 auto const usdA = alice[
"USD"];
1321 env.
fund(
XRP(333333), accounts);
1322 env.
trust(usdA(20000), carol);
1325 auto const mixedPayments = [&] ->
int {
1326 sendPayments(env, alice, carol, 1, 0);
1327 env(
pay(alice, carol, usdA(100)));
1335 request[jss::account_history_tx_stream][jss::account] = carol.
human();
1337 auto const jv = ws->invoke(
"subscribe", request);
1342 getTxHash(*ws, tempVec, 100, 1000ms);
1345 auto const count = mixedPayments();
1347 if (!BEAST_EXPECT(getTxHash(*ws, vec1, count).first))
1349 ws->invoke(
"unsubscribe", request);
1358 env.
fund(
XRP(444444), accounts);
1362 auto const oneRound = [&](
int numPayments) {
1363 return sendPayments(env, alice, carol, numPayments, 300);
1369 request[jss::account_history_tx_stream][jss::account] = carol.
human();
1371 auto const jv = wscLong->invoke(
"subscribe", request);
1376 getTxHash(*wscLong, tempVec, 100, 1000ms);
1380 for (
int kk = 2; kk < 10; ++kk)
1382 auto const count = oneRound(kk);
1384 if (!BEAST_EXPECT(getTxHash(*wscLong, vec1, count).first))
1389 auto const jv = wscShort->invoke(
"subscribe", request);
1391 if (!BEAST_EXPECT(getTxHash(*wscShort, vec2, count).first))
1393 if (!BEAST_EXPECT(hashCompare(vec1, vec2,
true)))
1395 wscShort->invoke(
"unsubscribe", request);
1404 using namespace jtx;
1405 using namespace std::chrono_literals;
1408 featurePermissionedDEX,
1413 auto const alice = permDex.
alice;
1414 auto const bob = permDex.
bob;
1415 auto const carol = permDex.
carol;
1416 auto const domainID = permDex.
domainID;
1417 auto const gw = permDex.
gw;
1418 auto const usd = permDex.
usd;
1424 streams[jss::streams][0u] =
"book_changes";
1426 auto jv = wsc->invoke(
"subscribe", streams);
1427 if (!BEAST_EXPECT(jv[jss::status] ==
"success"))
1435 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
1436 if (jv[jss::changes].size() != 1)
1439 auto const jrOffer = jv[jss::changes][0u];
1440 return (jv[jss::changes][0u][jss::domain]).asString() == strHex(domainID) &&
1441 jrOffer[jss::currency_a].asString() ==
"XRP_drops" &&
1442 jrOffer[jss::volume_a].asString() ==
"5000000" &&
1443 jrOffer[jss::currency_b].asString() ==
"rHUKYAZyUFn8PCZWbPfwHfbVQXTYrYKkHb/USD" &&
1444 jrOffer[jss::volume_b].asString() ==
"5";
1464 testcase(
"Test synthetic fields from Subscribe response");
1467 using namespace std::chrono_literals;
1471 Account const broker{
"broker"};
1474 env.
fund(
XRP(10000), alice, bob, broker);
1480 stream[jss::streams].append(
"transactions");
1481 auto const jv = wsc->invoke(
"subscribe", stream);
1486 auto const verifyNFTokenID = [&](
UInt256 const& actualNftID) {
1487 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
1489 BEAST_EXPECT(nftID.parseHex(jv[jss::meta][jss::nftoken_id].asString()));
1490 return nftID == actualNftID;
1497 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
1498 std::vector<UInt256> metaIDs;
1500 jv[jss::meta][jss::nftoken_ids].begin(),
1501 jv[jss::meta][jss::nftoken_ids].end(),
1502 std::back_inserter(metaIDs),
1503 [this](json::Value id) {
1505 BEAST_EXPECT(nftID.parseHex(id.asString()));
1513 BEAST_EXPECT(metaIDs.size() == actualNftIDs.size());
1517 for (
size_t i = 0; i < metaIDs.size(); ++i)
1519 BEAST_EXPECT(metaIDs[i] == actualNftIDs[i]);
1527 auto const verifyNFTokenOfferID = [&](
UInt256 const& offerID) {
1528 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
1529 UInt256 metaOfferID;
1530 BEAST_EXPECT(metaOfferID.parseHex(jv[jss::meta][jss::offer_id].asString()));
1531 return metaOfferID == offerID;
1540 env(
token::mint(alice, 0u), Txflags(tfTransferable));
1541 BEAST_EXPECT(env.syncClose());
1542 verifyNFTokenID(nftId1);
1545 env(
token::mint(alice, 0u), Txflags(tfTransferable));
1546 BEAST_EXPECT(env.syncClose());
1547 verifyNFTokenID(nftId2);
1552 UInt256 const aliceOfferIndex1 =
1555 BEAST_EXPECT(env.syncClose());
1556 verifyNFTokenOfferID(aliceOfferIndex1);
1558 UInt256 const aliceOfferIndex2 =
1561 BEAST_EXPECT(env.syncClose());
1562 verifyNFTokenOfferID(aliceOfferIndex2);
1568 BEAST_EXPECT(env.syncClose());
1569 verifyNFTokenIDsInCancelOffer({nftId1, nftId2});
1573 auto const bobBuyOfferIndex =
1576 BEAST_EXPECT(env.syncClose());
1577 verifyNFTokenOfferID(bobBuyOfferIndex);
1582 BEAST_EXPECT(env.syncClose());
1583 verifyNFTokenID(nftId1);
1590 env(
token::mint(alice, 0u), Txflags(tfTransferable));
1591 BEAST_EXPECT(env.syncClose());
1592 verifyNFTokenID(nftId);
1595 UInt256 const offerAliceToBroker =
1598 token::Destination(broker),
1599 Txflags(tfSellNFToken));
1600 BEAST_EXPECT(env.syncClose());
1601 verifyNFTokenOfferID(offerAliceToBroker);
1604 UInt256 const offerBobToBroker =
1607 BEAST_EXPECT(env.syncClose());
1608 verifyNFTokenOfferID(offerBobToBroker);
1612 BEAST_EXPECT(env.syncClose());
1613 verifyNFTokenID(nftId);
1621 env(
token::mint(alice, 0u), Txflags(tfTransferable));
1622 BEAST_EXPECT(env.syncClose());
1623 verifyNFTokenID(nftId);
1626 UInt256 const aliceOfferIndex1 =
1629 BEAST_EXPECT(env.syncClose());
1630 verifyNFTokenOfferID(aliceOfferIndex1);
1632 UInt256 const aliceOfferIndex2 =
1635 BEAST_EXPECT(env.syncClose());
1636 verifyNFTokenOfferID(aliceOfferIndex2);
1641 BEAST_EXPECT(env.syncClose());
1642 verifyNFTokenIDsInCancelOffer({nftId});
1645 if (features[featureNFTokenMintOffer])
1647 UInt256 const aliceMintWithOfferIndex1 =
1650 BEAST_EXPECT(env.syncClose());
1651 verifyNFTokenOfferID(aliceMintWithOfferIndex1);
1674 static std::vector<std::string>
1697 for (
auto const& a : accts)
1698 jv[jss::accounts].
append(a);
1709 for (
auto const& a : accts)
1710 jv[jss::accounts_proposed].
append(a);
1741 for (
auto const&
id : mptIDs)
1742 jv[jss::mpt_issuances].
append(
id);
1751 using namespace jtx;
1756 book[jss::taker_gets][jss::currency] =
"XRP";
1758 book[jss::taker_pays][jss::currency] =
"USD";
1759 book[jss::taker_pays][jss::issuer] =
Account(
"alice").human();
1769 jv[jss::account_history_tx_stream][jss::account] = acct;
1781 cfg->maxSubscriptionsPerConnection = cap;
1791 testcase(
"subscription cap rejects an over-cap request");
1793 using namespace jtx;
1800 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
1802 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
1811 testcase(
"re-subscribe at the cap is not over-counted");
1813 using namespace jtx;
1821 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1828 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1838 testcase(
"books cap is independent of account count");
1840 using namespace jtx;
1851 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1858 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1869 testcase(
"multi-field subscribe does not partially subscribe");
1871 using namespace jtx;
1880 req[jss::accounts].
append(a);
1882 auto const jr = wsc->invoke(
"subscribe", req)[jss::result];
1883 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
1885 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
1893 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1908 testcase(
"account_history re-subscribe at the cap is not over-counted");
1910 using namespace jtx;
1922 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1934 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
1936 BEAST_EXPECT(jr[jss::error_message] ==
"Invalid parameters.");
1937 BEAST_EXPECT(jr[jss::error_message] !=
"Too many subscriptions for this connection.");
1948 testcase(
"account_history net-new subscribe is rejected at the cap");
1950 using namespace jtx;
1954 env.
fund(
XRP(10000), alice, bob);
1962 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
1970 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
1972 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
1984 testcase(
"mpt_issuances cap rejects an over-cap request");
1986 using namespace jtx;
1992 auto const jr = wsc->invoke(
1994 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
1996 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
2004 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2014 testcase(
"mpt_issuances re-subscribe at the cap is not over-counted");
2016 using namespace jtx;
2024 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2031 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2036 auto const jr = wsc->invoke(
2038 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
2040 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
2049 testcase(
"mpt_issuances and accounts share one cap");
2051 using namespace jtx;
2059 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2061 auto const jr = wsc->invoke(
2063 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
2065 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
2070 BEAST_EXPECTS(r2[jss::status] ==
"success",
to_string(r2));
2081 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2085 BEAST_EXPECT(jr[jss::error] ==
"invalidParams");
2087 BEAST_EXPECT(jr[jss::error_message] ==
"Too many subscriptions for this connection.");
2098 testcase(
"mpt_issuances unsubscribe frees cap allowance");
2100 using namespace jtx;
2107 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2112 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2119 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2130 testcase(
"async teardown does not stall publishing");
2132 using namespace std::chrono_literals;
2133 using namespace jtx;
2147 auto const r = wscLive->invoke(
"subscribe", jv);
2148 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2159 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2172 BEAST_EXPECT(info.isMember(jss::server_state));
2181 BEAST_EXPECT(wscLive->findMsg(5s, [&](
auto const& jv) {
2182 return jv.isMember(jss::transaction) &&
2183 jv[jss::transaction][jss::TransactionType] == jss::Payment &&
2184 jv[jss::transaction][jss::Destination] == alice.human();
2198 testcase(
"re-subscribe after disconnect still delivers");
2200 using namespace std::chrono_literals;
2201 using namespace jtx;
2213 bulk.push_back(alice.
human());
2215 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2226 auto const r = wscB->invoke(
"subscribe", jv);
2227 BEAST_EXPECTS(r[jss::status] ==
"success",
to_string(r));
2235 BEAST_EXPECT(wscB->findMsg(5s, [&](
auto const& jv) {
2236 return jv.isMember(jss::transaction) &&
2237 jv[jss::transaction][jss::TransactionType] == jss::Payment &&
2238 jv[jss::transaction][jss::Destination] == alice.human();
2250 using namespace jtx;
2251 using namespace std::chrono_literals;
2262 MPTTester mptAlice(env, alice, {.holders = {bob}});
2263 MPTTester mptCarol(env, carol, {.holders = {dan}});
2267 {.transferFee = 10'000, .ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanLock});
2268 mptCarol.create({.ownerCount = 1, .flags = tfMPTCanTransfer});
2273 stream[jss::mpt_issuances].append(
to_string(mptAlice.issuanceID()));
2274 stream[jss::mpt_issuances].append(
to_string(mptCarol.issuanceID()));
2275 auto jv = wsc->invoke(
"subscribe", stream);
2276 BEAST_EXPECT(jv[jss::status] ==
"success");
2279 mptAlice.authorize({.account = bob});
2280 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2281 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2282 jv[jss::transaction][jss::Account] == bob.human() &&
2283 jv[jss::transaction][jss::Flags] == 0 &&
2284 jv[jss::transaction][sfMPTokenIssuanceID.jsonName] ==
2285 to_string(mptAlice.issuanceID()) &&
2286 jv[jss::transaction][jss::TransactionType] ==
"MPTokenAuthorize" &&
2287 jv[jss::type] ==
"transaction";
2291 mptCarol.authorize({.account = dan});
2292 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2293 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2294 jv[jss::transaction][jss::Account] == dan.human() &&
2295 jv[jss::transaction][jss::Flags] == 0 &&
2296 jv[jss::transaction][sfMPTokenIssuanceID.jsonName] ==
2297 to_string(mptCarol.issuanceID()) &&
2298 jv[jss::transaction][jss::Sequence] == 5 &&
2299 jv[jss::transaction][jss::TransactionType] ==
"MPTokenAuthorize" &&
2300 jv[jss::type] ==
"transaction";
2304 mptAlice.pay(alice, bob, 2000);
2305 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2306 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2307 jv[jss::transaction][jss::Account] == alice.human() &&
2308 jv[jss::transaction][jss::Amount][jss::mpt_issuance_id] ==
2309 to_string(mptAlice.issuanceID()) &&
2310 jv[jss::transaction][jss::Amount][jss::value] ==
"2000" &&
2311 jv[jss::transaction][jss::DeliverMax][jss::mpt_issuance_id] ==
2312 to_string(mptAlice.issuanceID()) &&
2313 jv[jss::transaction][jss::DeliverMax][jss::value] ==
"2000" &&
2314 jv[jss::transaction][jss::Destination] == bob.human() &&
2315 jv[jss::transaction][jss::Flags] == tfFullyCanonicalSig &&
2316 jv[jss::transaction][jss::TransactionType] ==
"Payment" &&
2317 jv[jss::type] ==
"transaction";
2321 mptCarol.pay(carol, dan, 1000);
2322 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2323 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2324 jv[jss::transaction][jss::Account] == carol.human() &&
2325 jv[jss::transaction][jss::Amount][jss::mpt_issuance_id] ==
2326 to_string(mptCarol.issuanceID()) &&
2327 jv[jss::transaction][jss::Amount][jss::value] ==
"1000" &&
2328 jv[jss::transaction][jss::DeliverMax][jss::mpt_issuance_id] ==
2329 to_string(mptCarol.issuanceID()) &&
2330 jv[jss::transaction][jss::DeliverMax][jss::value] ==
"1000" &&
2331 jv[jss::transaction][jss::Destination] == dan.human() &&
2332 jv[jss::transaction][jss::Flags] == tfFullyCanonicalSig &&
2333 jv[jss::transaction][jss::Sequence] == 6 &&
2334 jv[jss::transaction][jss::TransactionType] ==
"Payment" &&
2335 jv[jss::type] ==
"transaction";
2339 mptAlice.set({.account = alice, .flags = tfMPTLock});
2340 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2341 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2342 jv[jss::transaction][jss::Account] == alice.human() &&
2343 jv[jss::transaction][jss::Flags] == tfMPTLock &&
2344 jv[jss::transaction][sfMPTokenIssuanceID.jsonName] ==
2345 to_string(mptAlice.issuanceID()) &&
2346 jv[jss::transaction][jss::TransactionType] ==
"MPTokenIssuanceSet" &&
2347 jv[jss::type] ==
"transaction";
2351 mptAlice.set({.account = alice, .flags = tfMPTUnlock});
2352 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2353 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2354 jv[jss::transaction][jss::Account] == alice.human() &&
2355 jv[jss::transaction][jss::Flags] == tfMPTUnlock &&
2356 jv[jss::transaction][sfMPTokenIssuanceID.jsonName] ==
2357 to_string(mptAlice.issuanceID()) &&
2358 jv[jss::transaction][jss::TransactionType] ==
"MPTokenIssuanceSet" &&
2359 jv[jss::type] ==
"transaction";
2366 unsubStream[jss::mpt_issuances].
append(
to_string(mptAlice.issuanceID()));
2367 auto unsubJv = wsc->invoke(
"unsubscribe", unsubStream);
2368 BEAST_EXPECT(unsubJv[jss::status] ==
"success");
2371 mptAlice.pay(bob, alice, 500);
2374 BEAST_EXPECT(!wsc->findMsg(5s, [&](
auto const& jv) {
2375 return jv[jss::transaction][jss::Amount][jss::mpt_issuance_id] ==
2376 to_string(mptAlice.issuanceID()) &&
2377 jv[jss::transaction][jss::Amount][jss::value] ==
"500";
2381 mptCarol.pay(dan, carol, 100);
2384 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2385 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2386 jv[jss::transaction][jss::Account] == dan.human() &&
2387 jv[jss::transaction][jss::Amount][jss::mpt_issuance_id] ==
2388 to_string(mptCarol.issuanceID()) &&
2389 jv[jss::transaction][jss::Amount][jss::value] ==
"100" &&
2390 jv[jss::transaction][jss::DeliverMax][jss::mpt_issuance_id] ==
2391 to_string(mptCarol.issuanceID()) &&
2392 jv[jss::transaction][jss::DeliverMax][jss::value] ==
"100" &&
2393 jv[jss::transaction][jss::Destination] == carol.human() &&
2394 jv[jss::transaction][jss::Flags] == tfFullyCanonicalSig &&
2395 jv[jss::transaction][jss::TransactionType] ==
"Payment" &&
2396 jv[jss::type] ==
"transaction";
2407 using namespace jtx;
2408 using namespace std::chrono_literals;
2419 mptAlice1.
create({.ownerCount = 1});
2420 auto const mptID1 = mptAlice1.issuanceID();
2423 mptAlice2.
create({.ownerCount = 2});
2424 auto const mptID2 = mptAlice2.issuanceID();
2429 stream[jss::mpt_issuances].append(
to_string(mptID1));
2430 stream[jss::mpt_issuances].append(
to_string(mptID2));
2431 auto const jv = wsc->invoke(
"subscribe", stream);
2432 BEAST_EXPECT(jv[jss::status] ==
"success");
2435 auto const seq = env.
seq(alice);
2437 env(
batch::outer(alice, seq, batchFee, tfAllOrNothing),
2438 batch::Inner(mptAlice1.destroyJV({.issuer = alice, .id = mptID1}), seq + 1),
2439 batch::Inner(mptAlice2.destroyJV({.issuer = alice, .id = mptID2}), seq + 2));
2443 for (
auto const& mptID : {mptID1, mptID2})
2445 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2446 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2447 jv[jss::transaction][jss::Account] == alice.human() &&
2448 jv[jss::transaction][sfMPTokenIssuanceID.jsonName] == to_string(mptID) &&
2449 jv[jss::transaction][jss::TransactionType] ==
"MPTokenIssuanceDestroy" &&
2450 jv[jss::type] ==
"transaction";
2456 BEAST_EXPECT(!wsc->findMsg(1s, [](
auto const& jv) {
2457 return jv[jss::transaction][jss::TransactionType] ==
"Batch";
2465 BEAST_EXPECT(wsc->invoke(
"unsubscribe", unsubStream)[jss::status] ==
"success");
2472 using namespace jtx;
2473 using namespace std::chrono_literals;
2480 MPTTester mpt(env, alice, {.holders = {bob, carol}});
2484 auto const subscribed =
2486 BEAST_EXPECT(subscribed[jss::status] ==
"success");
2488 auto const expectTransaction = [&](
std::string const& type) {
2489 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
2490 return jv[jss::engine_result] ==
"tesSUCCESS" &&
2491 jv[jss::transaction][jss::TransactionType] == type &&
2492 jv[jss::type] ==
"transaction";
2499 expectTransaction(
"OfferCreate");
2501 env(
offer(carol, mpt(5),
XRP(10)));
2503 expectTransaction(
"OfferCreate");
2506 auto const baseFee = env.
current()->fees().base;
2509 Fee(baseFee * 150));
2511 expectTransaction(
"EscrowCreate");
TestcaseT testcase
Memberspace for declaring test cases.
Value & append(Value const &value)
Append value to array at the end.
void clear()
Remove all object members and array elements.
virtual Config & config()=0
virtual std::uint32_t getNetworkID() const noexcept=0
Get the configured network ID.
virtual json::Value getServerInfo(bool human, bool admin, bool counters)=0
virtual void reportFeeChange()=0
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
virtual NetworkOPs & getOPs()=0
virtual LoadManager & getLoadManager()=0
virtual NetworkIDService & getNetworkIDService()=0
virtual LoadFeeTrack & getFeeTrack()=0
static json::Value oneBookRequest()
void run() override
Runs the suite.
void testTransactionsAPIv1()
static std::vector< std::string > makeAccountStrings(std::size_t count, std::uint32_t seed=1)
void testMPTReSubscribeNotOvercounted()
void testMPTSharesCapWithAccounts()
static json::Value accountsRequest(std::vector< std::string > const &accts)
void testReSubscribeNotOvercounted()
void testHistoryCapRejectsNetNew()
void testMultiFieldNoPartialSubscribe()
void testSubscriptionCapRejects()
static json::Value accountHistoryRequest(std::string const &acct)
void testValidations(FeatureBitset features=test::jtx::testableAmendments())
void testHistoryTxStream()
void testSubMPTAmountFields()
static auto cappedConfig(std::size_t cap)
void testBooksCapIndependentOfAccounts()
void testResubscribeAfterDisconnect()
void testHistoryReSubscribeNotOvercounted()
void testSubBookChanges()
void testNFToken(FeatureBitset features)
void testMPTUnsubscribeFreesCap()
void testTransactionsAPIv2()
static std::vector< std::string > makeMPTIssuanceStrings(std::size_t count, std::uint32_t seed=1)
static json::Value accountsProposedRequest(std::vector< std::string > const &accts)
void testSubErrors(bool subscribe)
void testAsyncTeardownDoesNotStall()
static json::Value mptIssuancesRequest(std::vector< std::string > const &mptIDs)
virtual std::optional< json::Value > getMsg(std::chrono::milliseconds const &timeout=std::chrono::milliseconds{0})=0
Retrieve a message.
Immutable cryptographic account descriptor.
std::string const & human() const
Returns the human readable public key.
A transaction testing environment.
bool syncClose(std::chrono::steady_clock::duration timeout=std::chrono::seconds{1})
Close and advance the ledger, then synchronize with the server's io_context to ensure all async opera...
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
std::shared_ptr< ReadView const > closed()
Returns the last closed ledger.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
void memoize(Account const &account)
Associate AccountID with account.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
NetClock::time_point now()
Returns the current network time.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Sets the SendMax on a JTx.
Set the regular signature on a JTx.
Adds an inner Batch transaction to a JTx and autofills it.
@ UInt
unsigned integer value
@ Int
signed integer value
@ Array
array value (ordered list)
@ Object
object value (collection of name/value pairs).
Keylet nftokenOffer(AccountID const &owner, SeqProxy const &seq)
An offer from an account to buy or sell an NFT.
The api_version numbers this server serves.
json::Value outer(jtx::Account const &account, uint32_t seq, STAmount const &fee, std::uint32_t flags)
Build an outer Batch transaction JSON object.
XRPAmount calcBatchFee(jtx::Env const &env, uint32_t const &numSigners, uint32_t const &txns=0)
Calculate the expected outer Batch transaction fee.
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount)
auto const kFinishTime
Set the "FinishAfter" time tag on a JTx.
json::Value mint(jtx::Account const &account, std::uint32_t nfTokenTaxon)
Mint an NFToken.
json::Value brokerOffers(jtx::Account const &account, UInt256 const &buyOfferIndex, UInt256 const &sellOfferIndex)
Broker two NFToken offers.
json::Value createOffer(jtx::Account const &account, UInt256 const &nftokenID, STAmount const &amount)
Create an NFTokenOffer.
json::Value cancelOffer(jtx::Account const &account, std::initializer_list< UInt256 > const &nftokenOffers)
Cancel NFTokenOffers.
UInt256 getNextID(jtx::Env const &env, jtx::Account const &issuer, std::uint32_t nfTokenTaxon, std::uint16_t flags, std::uint16_t xferFee)
Get the next NFTokenID that will be issued.
json::Value acceptBuyOffer(jtx::Account const &account, UInt256 const &offerIndex)
Accept an NFToken buy offer.
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
XrpT const XRP
Converts to XRP Issue or STAmount.
bool hasEnvelope2(json::Value const &reply)
Reports whether reply carries the version 2 envelope: jsonrpc equal to rpc::kJsonRpcVersion and rippl...
FeatureBitset testableAmendments()
std::unique_ptr< Config > singleThreadIo(std::unique_ptr< Config >)
json::Value offer(Account const &account, STAmount const &takerPays, STAmount const &takerGets, std::uint32_t flags)
Create an offer.
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
std::unique_ptr< Config > noAdmin(std::unique_ptr< Config >)
adjust config so no admin ports are enabled
static AutofillT const kAutofill
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
std::unique_ptr< Config > validator(std::unique_ptr< Config >, std::string const &)
adjust configuration with params needed to be a validator
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
std::unique_ptr< WSClient > makeWSClient(Config const &cfg, bool v2, unsigned rpcVersion, std::unordered_map< std::string, std::string > const &headers)
Returns a client operating through WebSockets/S.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
PublicKey derivePublicKey(KeyType type, SecretKey const &sk)
Derive the public key from a secret key.
constexpr std::uint32_t kDefaultGasLimit
bool isFlagLedger(LedgerIndex seq)
Returns true if the given ledgerIndex is a flag ledgerIndex.
std::optional< AccountID > parseBase58(std::string const &s)
Parse AccountID from checked, base58 string.
BaseUInt< 256 > Domain
Domain is a 256-bit hash representing a specific domain.
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
SecretKey generateSecretKey(KeyType type, Seed const &seed)
Generate a new secret key deterministically.
std::string to_string(BaseUInt< Bits, Tag > const &a)
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
constexpr std::uint32_t kDefaultGasPrice
constexpr std::uint32_t kVfFullValidation
constexpr std::uint32_t kDefaultBytecodeSizeLimit
constexpr std::uint32_t kVfFullyCanonicalSig
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
std::unordered_map< Key, Value, Hash, Pred, Allocator > HashMap
static constexpr auto kGasLimit
static constexpr auto kBytecodeSizeLimit
static constexpr auto kGasPrice
static constexpr auto kValidationSeed
static constexpr auto kVoting
Arguments for initializing funded MPT test accounts and issuance.
Set the sequence number on a JTx.