xrpld
Loading...
Searching...
No Matches
Simulate_test.cpp
1#include <test/jtx/Account.h>
2#include <test/jtx/Env.h>
3#include <test/jtx/TestHelpers.h>
4#include <test/jtx/amount.h>
5#include <test/jtx/batch.h>
6#include <test/jtx/credentials.h>
7#include <test/jtx/envconfig.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/multisign.h>
10#include <test/jtx/noop.h>
11#include <test/jtx/pay.h>
12#include <test/jtx/regkey.h>
13#include <test/jtx/sig.h>
14#include <test/jtx/token.h>
15
16#include <xrpld/app/rdb/backend/SQLiteDatabase.h>
17
18#include <xrpl/basics/Slice.h>
19#include <xrpl/basics/StringUtilities.h>
20#include <xrpl/basics/base_uint.h>
21#include <xrpl/basics/chrono.h>
22#include <xrpl/basics/strHex.h>
23#include <xrpl/beast/unit_test/suite.h>
24#include <xrpl/config/Constants.h>
25#include <xrpl/json/json_value.h>
26#include <xrpl/json/to_string.h>
27#include <xrpl/protocol/ErrorCodes.h>
28#include <xrpl/protocol/Indexes.h>
29#include <xrpl/protocol/SField.h>
30#include <xrpl/protocol/STBase.h>
31#include <xrpl/protocol/STParsedJSON.h>
32#include <xrpl/protocol/Serializer.h>
33#include <xrpl/protocol/TxFlags.h>
34#include <xrpl/protocol/XRPAmount.h>
35#include <xrpl/protocol/jss.h>
36
37#include <chrono>
38#include <cstdint>
39#include <functional>
40#include <memory>
41#include <optional>
42#include <string>
43#include <vector>
44
45namespace xrpl::test {
46
48{
49 void
51 json::Value const& result,
52 json::Value const& tx,
53 int const expectedSequence,
54 std::string const& expectedFee)
55 {
56 BEAST_EXPECT(result[jss::applied] == false);
57 BEAST_EXPECT(result.isMember(jss::engine_result));
58 BEAST_EXPECT(result.isMember(jss::engine_result_code));
59 BEAST_EXPECT(result.isMember(jss::engine_result_message));
60 BEAST_EXPECT(result.isMember(jss::tx_json) || result.isMember(jss::tx_blob));
61
62 json::Value txJson;
63 if (result.isMember(jss::tx_json))
64 {
65 txJson = result[jss::tx_json];
66 }
67 else
68 {
69 auto const unHexed = strUnHex(result[jss::tx_blob].asString());
70 SerialIter sitTrans(makeSlice(*unHexed)); // NOLINT(bugprone-unchecked-optional-access)
72 }
73 BEAST_EXPECT(txJson[jss::TransactionType] == tx[jss::TransactionType]);
74 BEAST_EXPECT(txJson[jss::Account] == tx[jss::Account]);
75 BEAST_EXPECT(txJson[jss::SigningPubKey] == tx.get(jss::SigningPubKey, ""));
76 BEAST_EXPECT(txJson[jss::TxnSignature] == tx.get(jss::TxnSignature, ""));
77 BEAST_EXPECT(txJson[jss::Fee] == tx.get(jss::Fee, expectedFee));
78 BEAST_EXPECT(txJson[jss::Sequence] == tx.get(jss::Sequence, expectedSequence));
79 }
80
81 void
83 json::Value const& result,
84 json::Value const& tx,
85 int const expectedSequence,
86 XRPAmount const& expectedFee)
87 {
89 result, tx, expectedSequence, expectedFee.jsonClipped().asString());
90 }
91
92 void
94 jtx::Env& env,
95 json::Value const& tx,
96 std::function<void(json::Value const&, json::Value const&)> const& validate,
97 bool testSerialized = true)
98 {
99 env.close();
100
101 json::Value params;
102 params[jss::tx_json] = tx;
103 validate(env.rpc("json", "simulate", to_string(params)), tx);
104
105 params[jss::binary] = true;
106 validate(env.rpc("json", "simulate", to_string(params)), tx);
107 validate(env.rpc("simulate", to_string(tx)), tx);
108 validate(env.rpc("simulate", to_string(tx), "binary"), tx);
109
110 if (testSerialized)
111 {
112 // This cannot be tested in the multisign autofill scenario
113 // It is technically not a valid STObject, so the following line
114 // will crash
115 STParsedJSONObject const parsed(std::string(jss::tx_json), tx);
116 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
117 auto const txBlob = strHex(parsed.object->getSerializer().peekData());
118 if (BEAST_EXPECT(parsed.object.has_value()))
119 {
120 json::Value params;
121 params[jss::tx_blob] = txBlob;
122 validate(env.rpc("json", "simulate", to_string(params)), tx);
123 params[jss::binary] = true;
124 validate(env.rpc("json", "simulate", to_string(params)), tx);
125 }
126 validate(env.rpc("simulate", txBlob), tx);
127 validate(env.rpc("simulate", txBlob, "binary"), tx);
128 }
129
130 BEAST_EXPECTS(env.current()->txCount() == 0, std::to_string(env.current()->txCount()));
131 }
132
133 void
135 jtx::Env& env,
136 json::Value const& tx,
137 std::function<void(
138 json::Value const&,
139 json::Value const&,
140 json::Value const&,
141 json::Value const&)> const& validate,
142 json::Value const& expectedMetadataKey,
143 json::Value const& expectedMetadataValue)
144 {
145 env.close();
146
147 json::Value params;
148 params[jss::tx_json] = tx;
149 validate(
150 env.rpc("json", "simulate", to_string(params)),
151 tx,
152 expectedMetadataKey,
153 expectedMetadataValue);
154 validate(
155 env.rpc("simulate", to_string(tx)), tx, expectedMetadataKey, expectedMetadataValue);
156
157 BEAST_EXPECTS(env.current()->txCount() == 0, std::to_string(env.current()->txCount()));
158 }
159
160 static json::Value
162 {
163 if (txResult.isMember(jss::meta_blob))
164 {
165 auto unHexed = strUnHex(txResult[jss::meta_blob].asString());
166 SerialIter sitTrans(makeSlice(*unHexed)); // NOLINT(bugprone-unchecked-optional-access)
168 }
169
170 return txResult[jss::meta];
171 }
172
173 void
175 {
176 testcase("Test parameter errors");
177
178 using namespace jtx;
179 Env env(*this);
180 Account const alice("alice");
181
182 {
183 // No params
185 auto const resp = env.rpc("json", "simulate", to_string(params));
186 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
187 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
188 BEAST_EXPECT(
189 resp[jss::result][jss::error_message] ==
190 "Neither `tx_blob` nor `tx_json` included.");
191 }
192 {
193 // Providing both `tx_json` and `tx_blob`
195 params[jss::tx_json] = json::ValueType::Object;
196 params[jss::tx_blob] = "1200";
197
198 auto const resp = env.rpc("json", "simulate", to_string(params));
199 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
200 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
201 BEAST_EXPECT(
202 resp[jss::result][jss::error_message] ==
203 "Can only include one of `tx_blob` and `tx_json`.");
204 }
205 {
206 // `binary` isn't a boolean
208 params[jss::tx_blob] = "1200";
209 params[jss::binary] = "100";
210 auto const resp = env.rpc("json", "simulate", to_string(params));
211 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
212 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
213 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'binary'.");
214 }
215 {
216 // Invalid `tx_blob`
218 params[jss::tx_blob] = "12";
219
220 auto const resp = env.rpc("json", "simulate", to_string(params));
221 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
222 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
223 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
224 }
225 {
226 // Empty `tx_json`
228 params[jss::tx_json] = json::ValueType::Object;
229
230 auto const resp = env.rpc("json", "simulate", to_string(params));
231 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
232 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
233 BEAST_EXPECT(
234 resp[jss::result][jss::error_message] == "Missing field 'tx.TransactionType'.");
235 }
236 {
237 // No tx.Account
240 txJson[jss::TransactionType] = jss::Payment;
241 params[jss::tx_json] = txJson;
242
243 auto const resp = env.rpc("json", "simulate", to_string(params));
244 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
245 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
246 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Missing field 'tx.Account'.");
247 }
248 {
249 // Empty `tx_blob`
251 params[jss::tx_blob] = "";
252
253 auto const resp = env.rpc("json", "simulate", to_string(params));
254 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
255 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
256 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
257 }
258 {
259 // Non-string `tx_blob`
260 json::Value params;
261 params[jss::tx_blob] = 1.1;
262
263 auto const resp = env.rpc("json", "simulate", to_string(params));
264 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
265 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
266 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
267 }
268 {
269 // Non-object `tx_json`
271 params[jss::tx_json] = "";
272
273 auto const resp = env.rpc("json", "simulate", to_string(params));
274 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
275 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
276 BEAST_EXPECT(
277 resp[jss::result][jss::error_message] == "Invalid field 'tx_json', not object.");
278 }
279 {
280 // `seed` field included
282 params[jss::seed] = "random_data";
284 txJson[jss::TransactionType] = jss::AccountSet;
285 txJson[jss::Account] = env.master.human();
286 params[jss::tx_json] = txJson;
287 auto const resp = env.rpc("json", "simulate", to_string(params));
288 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
289 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
290 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'seed'.");
291 }
292 {
293 // `secret` field included
295 params[jss::secret] = "random_data";
297 txJson[jss::TransactionType] = jss::AccountSet;
298 txJson[jss::Account] = env.master.human();
299 params[jss::tx_json] = txJson;
300 auto const resp = env.rpc("json", "simulate", to_string(params));
301 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
302 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
303 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'secret'.");
304 }
305 {
306 // `seed_hex` field included
308 params[jss::seed_hex] = "random_data";
310 txJson[jss::TransactionType] = jss::AccountSet;
311 txJson[jss::Account] = env.master.human();
312 params[jss::tx_json] = txJson;
313 auto const resp = env.rpc("json", "simulate", to_string(params));
314 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
315 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
316 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'seed_hex'.");
317 }
318 {
319 // `passphrase` field included
321 params[jss::passphrase] = "random_data";
323 txJson[jss::TransactionType] = jss::AccountSet;
324 txJson[jss::Account] = env.master.human();
325 params[jss::tx_json] = txJson;
326 auto const resp = env.rpc("json", "simulate", to_string(params));
327 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
328 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
329 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'passphrase'.");
330 }
331 {
332 // Invalid transaction
335 txJson[jss::TransactionType] = jss::Payment;
336 txJson[jss::Account] = env.master.human();
337 params[jss::tx_json] = txJson;
338
339 auto const resp = env.rpc("json", "simulate", to_string(params));
340 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidTransaction");
341 BEAST_EXPECT(!resp[jss::result].isMember(jss::error_code));
342 BEAST_EXPECT(resp[jss::result][jss::error_message].isNull());
343 BEAST_EXPECT(
344 resp[jss::result][jss::error_exception] ==
345 "Field 'Destination' is required but missing.");
346 }
347 {
348 // Bad account
349 json::Value params;
351 txJson[jss::TransactionType] = jss::AccountSet;
352 txJson[jss::Account] = "badAccount";
353 params[jss::tx_json] = txJson;
354
355 auto const resp = env.rpc("json", "simulate", to_string(params));
356 BEAST_EXPECTS(
357 resp[jss::result][jss::error] == "srcActMalformed",
358 resp[jss::result][jss::error].toStyledString());
359 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcSrcActMalformed);
360 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Account'.");
361 }
362 {
363 // Account doesn't exist for Sequence autofill
364 json::Value params;
366 txJson[jss::TransactionType] = jss::AccountSet;
367 txJson[jss::Account] = alice.human();
368 params[jss::tx_json] = txJson;
369
370 auto const resp = env.rpc("json", "simulate", to_string(params));
371 BEAST_EXPECT(resp[jss::result][jss::error] == "srcActNotFound");
372 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcSrcActNotFound);
373 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Source account not found.");
374 }
375 {
376 // Invalid Signers field
377 json::Value params;
379 txJson[jss::TransactionType] = jss::AccountSet;
380 txJson[jss::Account] = env.master.human();
381 txJson[sfSigners] = "1";
382 params[jss::tx_json] = txJson;
383
384 auto const resp = env.rpc("json", "simulate", to_string(params));
385 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
386 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
387 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Signers'.");
388 }
389 {
390 // Invalid Signers field
391 json::Value params;
393 txJson[jss::TransactionType] = jss::AccountSet;
394 txJson[jss::Account] = env.master.human();
395 txJson[sfSigners] = json::ValueType::Array;
396 txJson[sfSigners].append("1");
397 params[jss::tx_json] = txJson;
398
399 auto const resp = env.rpc("json", "simulate", to_string(params));
400 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
401 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
402 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Signers[0]'.");
403 }
404 {
405 // Non-object SponsorSignature field
406 json::Value params;
408 txJson[jss::TransactionType] = jss::AccountSet;
409 txJson[jss::Account] = env.master.human();
410 txJson[sfSponsorSignature] = "";
411 params[jss::tx_json] = txJson;
412
413 auto const resp = env.rpc("json", "simulate", to_string(params));
414 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
415 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
416 BEAST_EXPECT(
417 resp[jss::result][jss::error_message] ==
418 "Invalid field 'SponsorSignature', not object.");
419 }
420 {
421 // Invalid SponsorSignature.Signers field
422 json::Value params;
424 txJson[jss::TransactionType] = jss::AccountSet;
425 txJson[jss::Account] = env.master.human();
426 json::Value sponsorSignature = json::ValueType::Object;
427 sponsorSignature[sfSigners] = "1";
428 txJson[sfSponsorSignature] = sponsorSignature;
429 params[jss::tx_json] = txJson;
430
431 auto const resp = env.rpc("json", "simulate", to_string(params));
432 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
433 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
434 BEAST_EXPECTS(
435 resp[jss::result][jss::error_message] ==
436 "Invalid field 'tx.SponsorSignature.Signers'.",
437 resp.toStyledString());
438 }
439 {
440 // Invalid transaction
441 json::Value params;
443 txJson[jss::TransactionType] = jss::AccountSet;
444 txJson[jss::Account] = env.master.human();
445 txJson["foo"] = "bar";
446 params[jss::tx_json] = txJson;
447
448 auto const resp = env.rpc("json", "simulate", to_string(params));
449 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
450 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
451 BEAST_EXPECT(
452 resp[jss::result][jss::error_message] == "Field 'tx_json.foo' is unknown.");
453 }
454 {
455 // non-`"binary"` second param for CLI
457 txJson[jss::TransactionType] = jss::AccountSet;
458 txJson[jss::Account] = alice.human();
459 auto const resp = env.rpc("simulate", to_string(txJson), "1");
460 BEAST_EXPECT(resp[jss::error] == "invalidParams");
461 BEAST_EXPECT(resp[jss::error_code] == RpcInvalidParams);
462 BEAST_EXPECT(resp[jss::error_message] == "Invalid parameters.");
463 }
464 {
465 // Signed transaction
466 json::Value params;
468 txJson[jss::TransactionType] = jss::AccountSet;
469 txJson[jss::Account] = env.master.human();
470 txJson[jss::TxnSignature] = "1200ABCD";
471 params[jss::tx_json] = txJson;
472
473 auto const resp = env.rpc("json", "simulate", to_string(params));
474 BEAST_EXPECT(resp[jss::result][jss::error] == "transactionSigned");
475 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcTxSigned);
476 BEAST_EXPECT(
477 resp[jss::result][jss::error_message] == "Transaction should not be signed.");
478 }
479 {
480 // Signed multisig transaction
481 json::Value params;
483 txJson[jss::TransactionType] = jss::AccountSet;
484 txJson[jss::Account] = env.master.human();
485 txJson[sfSigners] = json::ValueType::Array;
486 {
487 json::Value signer;
488 signer[jss::Account] = alice.human();
489 signer[jss::SigningPubKey] = alice.human();
490 signer[jss::TxnSignature] = "1200ABCD";
491 json::Value signerOuter;
492 signerOuter[sfSigner] = signer;
493 txJson[sfSigners].append(signerOuter);
494 }
495 params[jss::tx_json] = txJson;
496
497 auto const resp = env.rpc("json", "simulate", to_string(params));
498 BEAST_EXPECT(resp[jss::result][jss::error] == "transactionSigned");
499 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcTxSigned);
500 BEAST_EXPECT(
501 resp[jss::result][jss::error_message] == "Transaction should not be signed.");
502 }
503 {
504 // tfInnerBatchTxn flag on top-level transaction
505 json::Value params;
507 txJson[jss::TransactionType] = jss::AccountSet;
508 txJson[jss::Account] = env.master.human();
509 txJson[jss::Flags] = tfInnerBatchTxn;
510 params[jss::tx_json] = txJson;
511
512 auto const resp = env.rpc("json", "simulate", to_string(params));
513 BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
514 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
515 BEAST_EXPECT(
516 resp[jss::result][jss::error_message] ==
517 "tfInnerBatchTxn flag is not allowed on top-level transactions.");
518 }
519 }
520
521 void
523 {
524 testcase("WASM transactions require admin");
525
526 using namespace jtx;
527
528 Account const alice{"alice"};
529 Account const bob{"bob"};
530
531 auto const escrowCreate = [&alice, &bob] {
532 json::Value tx;
533 tx[jss::TransactionType] = jss::EscrowCreate;
534 tx[jss::Account] = alice.human();
535 tx[jss::Destination] = bob.human();
536 tx[jss::Amount] = "1000000";
537 tx[sfCancelAfter.jsonName] = 1'000'000'000;
538 return tx;
539 };
540
541 auto const escrowFinish = [&alice, &bob] {
542 json::Value tx;
543 tx[jss::TransactionType] = jss::EscrowFinish;
544 tx[jss::Account] = bob.human();
545 tx[jss::Owner] = alice.human();
546 tx[sfOfferSequence.jsonName] = 1;
547 return tx;
548 };
549
551 {
552 auto tx = escrowCreate();
553 tx[sfBytecode.jsonName] = "0061736D01000000";
554 wasmTxs.push_back(tx);
555 }
556 {
557 // Checked on shape, even if the bytecode is not valid WASM.
558 auto tx = escrowCreate();
559 tx[sfBytecode.jsonName] = "DEADBEEF";
560 wasmTxs.push_back(tx);
561 }
562 {
563 auto tx = escrowFinish();
564 tx[sfGas.jsonName] = 10'000;
565 wasmTxs.push_back(tx);
566 }
567
568 auto const simulate = [](Env& env, json::Value const& tx) {
569 json::Value params;
570 params[jss::tx_json] = tx;
571 return env.rpc("json", "simulate", to_string(params))[jss::result];
572 };
573
574 {
575 // `env.close()` is admin-only, so the accounts stay in the open ledger.
576 Env env(*this, envconfig(noAdmin));
577 env.fund(XRP(10000), alice, bob);
578
579 for (auto const& tx : wasmTxs)
580 {
581 auto const resp = simulate(env, tx);
582 BEAST_EXPECT(resp[jss::error] == "noPermission");
583 BEAST_EXPECT(resp[jss::error_code] == RpcNoPermission);
584 BEAST_EXPECT(
585 resp[jss::error_message] ==
586 "WASM transactions are only supported in admin mode.");
587 }
588
589 // Without these fields, simulate runs as usual.
590 BEAST_EXPECT(!simulate(env, escrowCreate()).isMember(jss::error));
591 BEAST_EXPECT(!simulate(env, escrowFinish()).isMember(jss::error));
592 }
593
594 {
595 Env env(*this);
596 env.fund(XRP(10000), alice, bob);
597 env.close();
598
599 for (auto const& tx : wasmTxs)
600 {
601 BEAST_EXPECT(!simulate(env, tx).isMember(jss::error));
602 }
603 }
604 }
605
606 void
608 {
609 testcase("Fee failure");
610
611 using namespace jtx;
612
613 // Pin the reference fee so the asserted error message doesn't depend on
614 // UNIT_TEST_REFERENCE_FEE.
615 Env env(*this, envconfig([](std::unique_ptr<Config> cfg) {
616 cfg->fees.referenceFee = 10;
618 return cfg;
619 }));
620
621 Account const alice{"alice"};
622 env.fund(XRP(1000000), alice);
623 env.close();
624
625 // fill queue
626 auto const metrics = env.app().getTxQ().getMetrics(*env.current());
627 for (int i = metrics.txInLedger; i <= metrics.txPerLedger; ++i)
628 env(noop(alice));
629
630 {
631 json::Value params;
632 params[jss::tx_json] = noop(alice);
633
634 auto const resp = env.rpc("json", "simulate", to_string(params));
635 auto const result = resp[jss::result];
636 BEAST_EXPECT(result[jss::error] == "highFee");
637 BEAST_EXPECT(result[jss::error_code] == RpcHighFee);
638 BEAST_EXPECT(
639 result[jss::error_message] == "Fee of 8889 exceeds the requested tx limit of 100");
640 }
641 }
642
643 void
645 {
646 testcase("Invalid transaction type");
647
648 using namespace jtx;
649
650 Env env(*this);
651
652 Account const alice{"alice"};
653 Account const bob{"bob"};
654 env.fund(XRP(1000000), alice, bob);
655 env.close();
656
657 auto const batchFee = batch::calcBatchFee(env, 0, 2);
658 auto const seq = env.seq(alice);
659 auto jt = env.jtnofill(
660 batch::outer(alice, env.seq(alice), batchFee, tfAllOrNothing),
661 batch::Inner(pay(alice, bob, XRP(10)), seq + 1),
662 batch::Inner(pay(alice, bob, XRP(10)), seq + 2));
663
664 jt.jv.removeMember(jss::TxnSignature);
665 json::Value params;
666 params[jss::tx_json] = jt.jv;
667 auto const resp = env.rpc("json", "simulate", to_string(params));
668 BEAST_EXPECT(resp[jss::result][jss::error] == "notImpl");
669 BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcNotImpl);
670 BEAST_EXPECT(resp[jss::result][jss::error_message] == "Not implemented.");
671 }
672
673 void
675 {
676 testcase("Successful transaction");
677
678 using namespace jtx;
679 Env env{*this, envconfig([&](std::unique_ptr<Config> cfg) {
680 cfg->networkId = 0;
681 return cfg;
682 })};
683 static auto const kNewDomain = "123ABC";
684
685 {
686 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
687 auto result = resp[jss::result];
688 checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
689
690 BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
691 BEAST_EXPECT(result[jss::engine_result_code] == 0);
692 BEAST_EXPECT(
693 result[jss::engine_result_message] ==
694 "The simulated transaction would have been applied.");
695
696 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
697 {
698 json::Value const metadata = getJsonMetadata(result);
699
700 if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
701 {
702 BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
703 auto node = metadata[sfAffectedNodes.jsonName][0u];
704 if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
705 {
706 auto modifiedNode = node[sfModifiedNode];
707 BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
708 auto finalFields = modifiedNode[sfFinalFields];
709 BEAST_EXPECT(finalFields[sfDomain] == kNewDomain);
710 }
711 }
712 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
713 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
714 }
715 };
716
717 json::Value tx;
718
719 tx[jss::Account] = env.master.human();
720 tx[jss::TransactionType] = jss::AccountSet;
721 tx[sfDomain] = kNewDomain;
722
723 // test with autofill
724 testTx(env, tx, validateOutput);
725
726 tx[sfSigningPubKey] = "";
727 tx[sfTxnSignature] = "";
728 tx[sfSequence] = 1;
729 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
730
731 // test without autofill
732 testTx(env, tx, validateOutput);
733 }
734
735 {
736 // autofill sponsor signature
737
738 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
739 auto result = resp[jss::result];
741 result, tx, env.seq(env.master), env.current()->fees().base);
742
743 BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
744 BEAST_EXPECT(result[jss::engine_result_code] == 0);
745 BEAST_EXPECT(
746 result[jss::engine_result_message] ==
747 "The simulated transaction would have been applied.");
748
749 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
750 {
751 json::Value const metadata = getJsonMetadata(result);
752
753 if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
754 {
755 BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 2);
756
757 auto node = metadata[sfAffectedNodes.jsonName][0u];
758 if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
759 {
760 auto modifiedNode = node[sfModifiedNode];
761 BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
762 auto const previousFields = modifiedNode[sfPreviousFields];
763 BEAST_EXPECT(!previousFields.isMember(sfBalance.jsonName));
764 }
765
766 auto node2 = metadata[sfAffectedNodes.jsonName][1u];
767 if (BEAST_EXPECT(node2.isMember(sfModifiedNode.jsonName)))
768 {
769 auto modifiedNode = node2[sfModifiedNode];
770 BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
771
772 auto const previousFields = modifiedNode[sfPreviousFields];
773 BEAST_EXPECT(previousFields.isMember(sfBalance.jsonName));
774 }
775 }
776 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
777 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
778 }
779 };
780
781 Account const sponsor("sponsor");
782 env.fund(XRP(10000), sponsor);
783 env.close();
784
785 json::Value tx;
786
787 tx[jss::Account] = env.master.human();
788 tx[jss::TransactionType] = jss::AccountSet;
789 tx[sfDomain.jsonName] = kNewDomain;
790 tx[sfSponsor.jsonName] = sponsor.human();
791 tx[sfSponsorFlags.jsonName] = spfSponsorFee;
792 tx[sfSponsorSignature.jsonName] = json::ValueType::Object;
793
794 // test with autofill
795 testTx(env, tx, validateOutput);
796
797 tx[sfSponsorSignature.jsonName][sfTxnSignature.jsonName] = "";
798 tx[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] = "";
799
800 // test without autofill
801 testTx(env, tx, validateOutput);
802 }
803 }
804
805 void
807 {
808 testcase("Transaction non-tec failure");
809
810 using namespace jtx;
811 Env env(*this);
812 Account const alice("alice");
813
814 {
815 std::function<void(json::Value const&, json::Value const&)> const& testSimulation =
816 [&](json::Value const& resp, json::Value const& tx) {
817 auto result = resp[jss::result];
818 checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
819
820 BEAST_EXPECT(result[jss::engine_result] == "temBAD_AMOUNT");
821 BEAST_EXPECT(result[jss::engine_result_code] == -298);
822 BEAST_EXPECT(result[jss::engine_result_message] == "Malformed: Bad amount.");
823
824 BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
825 };
826
827 json::Value tx;
828
829 tx[jss::Account] = env.master.human();
830 tx[jss::TransactionType] = jss::Payment;
831 tx[sfDestination] = alice.human();
832 tx[sfAmount] = "0"; // invalid amount
833
834 // test with autofill
835 testTx(env, tx, testSimulation);
836
837 tx[sfSigningPubKey] = "";
838 tx[sfTxnSignature] = "";
839 tx[sfSequence] = 1;
840 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
841
842 // test without autofill
843 testTx(env, tx, testSimulation);
844 }
845 }
846
847 void
849 {
850 testcase("Transaction tec failure");
851
852 using namespace jtx;
853 Env env(*this);
854 Account const alice("alice");
855
856 {
857 std::function<void(json::Value const&, json::Value const&)> const& testSimulation =
858 [&](json::Value const& resp, json::Value const& tx) {
859 auto result = resp[jss::result];
860 checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
861
862 BEAST_EXPECT(result[jss::engine_result] == "tecNO_DST_INSUF_XRP");
863 BEAST_EXPECT(result[jss::engine_result_code] == 125);
864 BEAST_EXPECT(
865 result[jss::engine_result_message] ==
866 "Destination does not exist. Too little XRP sent to "
867 "create "
868 "it.");
869
870 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
871 {
872 json::Value const metadata = getJsonMetadata(result);
873
874 if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
875 {
876 BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
877 auto node = metadata[sfAffectedNodes.jsonName][0u];
878 if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
879 {
880 auto modifiedNode = node[sfModifiedNode];
881 BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
882 auto finalFields = modifiedNode[sfFinalFields];
883 BEAST_EXPECT(
884 finalFields[sfBalance] ==
886 100'000'000'000'000'000 -
887 env.current()->fees().base.drops()));
888 }
889 }
890 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
891 BEAST_EXPECT(
892 metadata[sfTransactionResult.jsonName] == "tecNO_DST_INSUF_XRP");
893 }
894 };
895
896 json::Value tx;
897
898 tx[jss::Account] = env.master.human();
899 tx[jss::TransactionType] = jss::Payment;
900 tx[sfDestination] = alice.human();
901 tx[sfAmount] = "1"; // not enough to create an account
902
903 // test with autofill
904 testTx(env, tx, testSimulation);
905
906 tx[sfSigningPubKey] = "";
907 tx[sfTxnSignature] = "";
908 tx[sfSequence] = 1;
909 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
910
911 // test without autofill
912 testTx(env, tx, testSimulation);
913 }
914 }
915
916 void
918 {
919 testcase("Successful multi-signed transaction");
920
921 using namespace jtx;
922 Env env(*this);
923 static auto const kNewDomain = "123ABC";
924 Account const alice("alice");
925 Account const becky("becky");
926 Account const carol("carol");
927 env.fund(XRP(10000), alice);
928 env.close();
929
930 // set up valid multisign
931 env(signers(alice, 1, {{becky, 1}, {carol, 1}}));
932 env.close();
933
934 {
935 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
936 auto result = resp[jss::result];
938 result,
939 tx,
940 env.seq(alice),
941 tx.isMember(jss::Signers) ? env.current()->fees().base * 2
942 : env.current()->fees().base);
943
944 BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
945 BEAST_EXPECT(result[jss::engine_result_code] == 0);
946 BEAST_EXPECT(
947 result[jss::engine_result_message] ==
948 "The simulated transaction would have been applied.");
949
950 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
951 {
952 json::Value const metadata = getJsonMetadata(result);
953
954 if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
955 {
956 BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
957 auto node = metadata[sfAffectedNodes.jsonName][0u];
958 if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
959 {
960 auto modifiedNode = node[sfModifiedNode];
961 BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
962 auto finalFields = modifiedNode[sfFinalFields];
963 BEAST_EXPECT(finalFields[sfDomain] == kNewDomain);
964 }
965 }
966 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
967 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
968 }
969 };
970
971 json::Value tx;
972
973 tx[jss::Account] = alice.human();
974 tx[jss::TransactionType] = jss::AccountSet;
975 tx[sfDomain] = kNewDomain;
976
977 // test with autofill
978 testTx(env, tx, validateOutput, false);
979
980 tx[sfSigners] = json::ValueType::Array;
981 {
982 json::Value signer;
983 signer[jss::Account] = becky.human();
984 json::Value signerOuter;
985 signerOuter[sfSigner] = signer;
986 tx[sfSigners].append(signerOuter);
987 }
988
989 // test with just signer accounts
990 testTx(env, tx, validateOutput, false);
991
992 tx[sfSigningPubKey] = "";
993 tx[sfTxnSignature] = "";
994 tx[sfSequence] = env.seq(alice);
995 // transaction requires a non-base fee
996 tx[sfFee] = (env.current()->fees().base * 2).jsonClipped().asString();
997 tx[sfSigners][0u][sfSigner][jss::SigningPubKey] = "";
998 tx[sfSigners][0u][sfSigner][jss::TxnSignature] = "";
999
1000 // test without autofill
1001 testTx(env, tx, validateOutput);
1002 }
1003 }
1004
1005 void
1007 {
1008 testcase("Successful sponsored multi-signed transaction");
1009
1010 using namespace jtx;
1011 Env env(*this);
1012 Account const sponsor("sponsor");
1013 Account const signer("signer");
1014 env.fund(XRP(10000), sponsor, signer);
1015 env.close();
1016
1017 env(signers(sponsor, 1, {{signer, 1}}));
1018 env.close();
1019
1020 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
1021 auto const result = resp[jss::result];
1022 // Verifies Fee autofill counts nested sponsor-signature signers.
1023 auto const expectedFee = env.current()->fees().base * 2;
1024 checkBasicReturnValidity(result, tx, env.seq(env.master), expectedFee);
1025
1026 BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
1027 BEAST_EXPECT(result[jss::engine_result_code] == 0);
1028 BEAST_EXPECT(
1029 result[jss::engine_result_message] ==
1030 "The simulated transaction would have been applied.");
1031
1032 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
1033 {
1034 json::Value const metadata = getJsonMetadata(result);
1035 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
1036 }
1037 };
1038
1039 json::Value tx;
1040 tx[jss::Account] = env.master.human();
1041 tx[jss::TransactionType] = jss::AccountSet;
1042 tx[sfDomain] = "123ABC";
1043 tx[sfSponsor.jsonName] = sponsor.human();
1044 tx[sfSponsorFlags.jsonName] = spfSponsorFee;
1045 tx[sfSponsorSignature.jsonName] = json::ValueType::Object;
1046 tx[sfSponsorSignature.jsonName][sfSigners.jsonName] = json::ValueType::Array;
1047
1048 json::Value signerObj;
1049 signerObj[sfSigner][jss::Account] = signer.human();
1050 tx[sfSponsorSignature.jsonName][sfSigners.jsonName].append(signerObj);
1051
1052 // Leave Fee unset so simulate must autofill it after sponsor signer normalization.
1053 BEAST_EXPECT(!tx.isMember(jss::Fee));
1054 testTx(env, tx, validateOutput, false);
1055 }
1056
1057 void
1059 {
1060 testcase("Transaction with a key-related failure");
1061
1062 using namespace jtx;
1063 Env env(*this);
1064 static auto const kNewDomain = "123ABC";
1065 Account const alice{"alice"};
1066 env(regkey(env.master, alice));
1067 env(fset(env.master, asfDisableMaster), Sig(env.master));
1068 env.close();
1069
1070 {
1071 std::function<void(json::Value const&, json::Value const&)> const& testSimulation =
1072 [&](json::Value const& resp, json::Value const& tx) {
1073 auto result = resp[jss::result];
1075 result, tx, env.seq(env.master), env.current()->fees().base);
1076
1077 BEAST_EXPECT(result[jss::engine_result] == "tefMASTER_DISABLED");
1078 BEAST_EXPECT(result[jss::engine_result_code] == -188);
1079 BEAST_EXPECT(result[jss::engine_result_message] == "Master key is disabled.");
1080
1081 BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
1082 };
1083
1084 json::Value tx;
1085
1086 tx[jss::Account] = env.master.human();
1087 tx[jss::TransactionType] = jss::AccountSet;
1088 tx[sfDomain] = kNewDomain;
1089 // master key is disabled, so this is invalid
1090 tx[jss::SigningPubKey] = strHex(env.master.pk().slice());
1091
1092 // test with autofill
1093 testTx(env, tx, testSimulation);
1094
1095 tx[sfTxnSignature] = "";
1096 tx[sfSequence] = env.seq(env.master);
1097 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
1098
1099 // test without autofill
1100 testTx(env, tx, testSimulation);
1101 }
1102 }
1103
1104 void
1106 {
1107 testcase(
1108 "Transaction with both single-signing SigningPubKey and "
1109 "multi-signing Signers");
1110
1111 using namespace jtx;
1112 Env env(*this);
1113 static auto const kNewDomain = "123ABC";
1114 Account const alice("alice");
1115 Account const becky("becky");
1116 Account const carol("carol");
1117 env.fund(XRP(10000), alice);
1118 env.close();
1119
1120 // set up valid multisign
1121 env(signers(alice, 1, {{becky, 1}, {carol, 1}}));
1122 env.close();
1123
1124 {
1125 std::function<void(json::Value const&, json::Value const&)> const& testSimulation =
1126 [&](json::Value const& resp, json::Value const& tx) {
1127 auto result = resp[jss::result];
1129 result, tx, env.seq(env.master), env.current()->fees().base * 2);
1130
1131 BEAST_EXPECT(result[jss::engine_result] == "temINVALID");
1132 BEAST_EXPECT(result[jss::engine_result_code] == -277);
1133 BEAST_EXPECT(
1134 result[jss::engine_result_message] == "The transaction is ill-formed.");
1135
1136 BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
1137 };
1138
1139 json::Value tx;
1140
1141 tx[jss::Account] = env.master.human();
1142 tx[jss::TransactionType] = jss::AccountSet;
1143 tx[sfDomain] = kNewDomain;
1144 // master key is disabled, so this is invalid
1145 tx[jss::SigningPubKey] = strHex(env.master.pk().slice());
1146 tx[sfSigners] = json::ValueType::Array;
1147 {
1148 json::Value signer;
1149 signer[jss::Account] = becky.human();
1150 json::Value signerOuter;
1151 signerOuter[sfSigner] = signer;
1152 tx[sfSigners].append(signerOuter);
1153 }
1154
1155 // test with autofill
1156 testTx(env, tx, testSimulation, false);
1157
1158 tx[sfTxnSignature] = "";
1159 tx[sfSequence] = env.seq(env.master);
1160 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
1161 tx[sfSigners][0u][sfSigner][jss::SigningPubKey] = strHex(becky.pk().slice());
1162 tx[sfSigners][0u][sfSigner][jss::TxnSignature] = "";
1163
1164 // test without autofill
1165 testTx(env, tx, testSimulation);
1166 }
1167 }
1168
1169 void
1171 {
1172 testcase("Multi-signed transaction with a bad public key");
1173
1174 using namespace jtx;
1175 Env env(*this);
1176 static auto const kNewDomain = "123ABC";
1177 Account const alice("alice");
1178 Account const becky("becky");
1179 Account const carol("carol");
1180 Account const dylan("dylan");
1181 env.fund(XRP(10000), alice);
1182 env.close();
1183
1184 // set up valid multisign
1185 env(signers(alice, 1, {{becky, 1}, {carol, 1}}));
1186
1187 {
1188 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
1189 auto result = resp[jss::result];
1191 result, tx, env.seq(alice), env.current()->fees().base * 2);
1192
1193 BEAST_EXPECTS(
1194 result[jss::engine_result] == "tefBAD_SIGNATURE",
1195 result[jss::engine_result].toStyledString());
1196 BEAST_EXPECT(result[jss::engine_result_code] == -186);
1197 BEAST_EXPECT(
1198 result[jss::engine_result_message] ==
1199 "A signature is provided for a non-signer.");
1200
1201 BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
1202 };
1203
1204 json::Value tx;
1205
1206 tx[jss::Account] = alice.human();
1207 tx[jss::TransactionType] = jss::AccountSet;
1208 tx[sfDomain] = kNewDomain;
1209 tx[sfSigners] = json::ValueType::Array;
1210 {
1211 json::Value signer;
1212 signer[jss::Account] = becky.human();
1213 signer[jss::SigningPubKey] = strHex(dylan.pk().slice());
1214 json::Value signerOuter;
1215 signerOuter[sfSigner] = signer;
1216 tx[sfSigners].append(signerOuter);
1217 }
1218
1219 // test with autofill
1220 testTx(env, tx, validateOutput, false);
1221
1222 tx[sfSigningPubKey] = "";
1223 tx[sfTxnSignature] = "";
1224 tx[sfSequence] = env.seq(alice);
1225 // transaction requires a non-base fee
1226 tx[sfFee] = (env.current()->fees().base * 2).jsonClipped().asString();
1227 tx[sfSigners][0u][sfSigner][jss::TxnSignature] = "";
1228
1229 // test without autofill
1230 testTx(env, tx, validateOutput);
1231 }
1232 }
1233
1234 void
1236 {
1237 testcase("Credentials aren't actually deleted on `tecEXPIRED`");
1238
1239 // scenario setup
1240
1241 using namespace jtx;
1242 Env env(*this);
1243
1244 Account const subject{"subject"};
1245 Account const issuer{"issuer"};
1246
1247 env.fund(XRP(10000), subject, issuer);
1248 env.close();
1249
1250 auto const credType = "123ABC";
1251
1252 auto jv = credentials::create(subject, issuer, credType);
1253 uint32_t const t = env.current()->header().parentCloseTime.time_since_epoch().count();
1254 jv[sfExpiration.jsonName] = t;
1255 env(jv);
1256 env.close();
1257
1258 {
1259 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
1260 auto result = resp[jss::result];
1261 checkBasicReturnValidity(result, tx, env.seq(subject), env.current()->fees().base);
1262
1263 BEAST_EXPECT(result[jss::engine_result] == "tecEXPIRED");
1264 BEAST_EXPECT(result[jss::engine_result_code] == 148);
1265 BEAST_EXPECT(result[jss::engine_result_message] == "Expiration time is passed.");
1266
1267 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
1268 {
1269 json::Value const metadata = getJsonMetadata(result);
1270
1271 if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
1272 {
1273 BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 5);
1274
1275 try
1276 {
1277 bool found = false;
1278 for (auto const& node : metadata[sfAffectedNodes.jsonName])
1279 {
1280 if (node.isMember(sfDeletedNode.jsonName) &&
1281 node[sfDeletedNode.jsonName][sfLedgerEntryType.jsonName]
1282 .asString() == "Credential")
1283 {
1284 auto const deleted =
1285 node[sfDeletedNode.jsonName][sfFinalFields.jsonName];
1286 found = deleted[jss::Issuer] == issuer.human() &&
1287 deleted[jss::Subject] == subject.human() &&
1288 deleted["CredentialType"] ==
1289 strHex(std::string_view(credType));
1290 break;
1291 }
1292 }
1293 BEAST_EXPECT(found);
1294 }
1295 catch (...)
1296 {
1297 fail();
1298 }
1299 }
1300 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
1301 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tecEXPIRED");
1302 }
1303 };
1304
1305 json::Value tx = credentials::accept(subject, issuer, credType);
1306
1307 // test with autofill
1308 testTx(env, tx, validateOutput);
1309
1310 tx[sfSigningPubKey] = "";
1311 tx[sfTxnSignature] = "";
1312 tx[sfSequence] = env.seq(subject);
1313 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
1314
1315 // test without autofill
1316 testTx(env, tx, validateOutput);
1317 }
1318
1319 // check that expired credentials weren't deleted
1320 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
1321 BEAST_EXPECT(
1322 jle.isObject() && jle.isMember(jss::result) && !jle[jss::result].isMember(jss::error) &&
1323 jle[jss::result].isMember(jss::node) &&
1324 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
1325 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
1326 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
1327 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
1328 jle[jss::result][jss::node]["CredentialType"] == strHex(std::string_view(credType)));
1329
1330 BEAST_EXPECT(ownerCount(env, issuer) == 1);
1331 BEAST_EXPECT(ownerCount(env, subject) == 0);
1332 }
1333
1334 void
1336 {
1337 testcase("Successful transaction with a custom network ID");
1338
1339 using namespace jtx;
1340 Env env{*this, envconfig([&](std::unique_ptr<Config> cfg) {
1341 cfg->networkId = 1025;
1342 return cfg;
1343 })};
1344 static auto const kNewDomain = "123ABC";
1345
1346 {
1347 auto const validateOutput = [&](json::Value const& resp, json::Value const& tx) {
1348 auto result = resp[jss::result];
1349 checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
1350
1351 BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
1352 BEAST_EXPECT(result[jss::engine_result_code] == 0);
1353 BEAST_EXPECT(
1354 result[jss::engine_result_message] ==
1355 "The simulated transaction would have been applied.");
1356
1357 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
1358 {
1359 json::Value const metadata = getJsonMetadata(result);
1360
1361 if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
1362 {
1363 BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
1364 auto node = metadata[sfAffectedNodes.jsonName][0u];
1365 if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
1366 {
1367 auto modifiedNode = node[sfModifiedNode];
1368 BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
1369 auto finalFields = modifiedNode[sfFinalFields];
1370 BEAST_EXPECT(finalFields[sfDomain] == kNewDomain);
1371 }
1372 }
1373 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
1374 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
1375 }
1376 };
1377
1378 json::Value tx;
1379
1380 tx[jss::Account] = env.master.human();
1381 tx[jss::TransactionType] = jss::AccountSet;
1382 tx[sfDomain] = kNewDomain;
1383
1384 // test with autofill
1385 testTx(env, tx, validateOutput);
1386
1387 tx[sfSigningPubKey] = "";
1388 tx[sfTxnSignature] = "";
1389 tx[sfSequence] = 1;
1390 tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
1391 tx[sfNetworkID] = 1025;
1392
1393 // test without autofill
1394 testTx(env, tx, validateOutput);
1395 }
1396 }
1397
1398 void
1400 {
1401 testcase("Successful transaction with additional metadata");
1402
1403 using namespace jtx;
1404 using namespace std::chrono_literals;
1405 Env env{*this, envconfig([&](std::unique_ptr<Config> cfg) {
1406 cfg->networkId = 1025;
1407 return cfg;
1408 })};
1409
1410 Account const alice("alice");
1411 Account const bob("bob");
1412
1413 env.fund(XRP(10000), alice, bob);
1414 env.close();
1415 // deliver_amount is unavailable in the metadata before 2014-02-01
1416 // so proceed to 2014-02-01
1417 env.close(NetClock::time_point{446000000s});
1418
1419 {
1420 auto const validateOutput = [&](json::Value const& resp,
1421 json::Value const& tx,
1422 json::Value const& expectedMetadataKey,
1423 json::Value const& expectedMetadataValue) {
1424 auto result = resp[jss::result];
1425
1426 BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
1427 BEAST_EXPECT(result[jss::engine_result_code] == 0);
1428 BEAST_EXPECT(
1429 result[jss::engine_result_message] ==
1430 "The simulated transaction would have been applied.");
1431
1432 if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
1433 {
1434 json::Value const metadata = getJsonMetadata(result);
1435
1436 BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
1437 BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
1438 BEAST_EXPECT(metadata.isMember(expectedMetadataKey.asString()));
1439 BEAST_EXPECT(metadata[expectedMetadataKey.asString()] == expectedMetadataValue);
1440 }
1441 };
1442
1443 {
1444 json::Value tx;
1445 tx[jss::Account] = alice.human();
1446 tx[jss::TransactionType] = jss::Payment;
1447 tx[sfDestination] = bob.human();
1448 tx[sfAmount] = "100";
1449
1450 // test delivered amount
1451 testTxJsonMetadataField(env, tx, validateOutput, jss::delivered_amount, "100");
1452 }
1453
1454 {
1455 json::Value tx;
1456 tx[jss::Account] = alice.human();
1457 tx[jss::TransactionType] = jss::NFTokenMint;
1458 tx[sfNFTokenTaxon] = 1;
1459
1460 json::Value const nftokenId = to_string(token::getNextID(env, alice, 1));
1461 // test nft synthetic
1462 testTxJsonMetadataField(env, tx, validateOutput, jss::nftoken_id, nftokenId);
1463 }
1464
1465 {
1466 json::Value tx;
1467 tx[jss::Account] = alice.human();
1468 tx[jss::TransactionType] = jss::MPTokenIssuanceCreate;
1469
1470 json::Value const mptIssuanceId = to_string(makeMptID(env.seq(alice), alice));
1471 // test mpt issuance id
1473 env, tx, validateOutput, jss::mpt_issuance_id, mptIssuanceId);
1474 }
1475 }
1476 }
1477
1478public:
1479 void
1498};
1499
1501
1502} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
void fail(String const &reason, char const *file, int line)
Record a failure.
Definition suite.h:554
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
Value removeMember(char const *key)
Remove and return the named member.
Value get(UInt index, Value const &defaultValue) const
If the array contains at least index+1 elements, returns the element value, otherwise returns default...
Value & append(Value const &value)
Append value to array at the end.
UInt size() const
Number of values in array or object.
std::string asString() const
Returns the unquoted string value.
bool isMember(char const *key) const
Return true if the object has a member named key.
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
Slice slice() const noexcept
Definition PublicKey.h:115
json::Value getJson(JsonOptions=JsonOptions::Values::None) const override
Definition STObject.cpp:845
Holds the serialized result of parsing an input JSON object.
std::optional< STObject > object
The STObject if the parse was successful.
virtual TxQ & getTxQ()=0
Metrics getMetrics(OpenView const &view) const
Returns fee metrics in reference fee level units.
Definition TxQ.cpp:2070
json::Value jsonClipped() const
Definition XRPAmount.h:203
void testSuccessfulSponsoredTransactionMultisigned()
void checkBasicReturnValidity(json::Value const &result, json::Value const &tx, int const expectedSequence, std::string const &expectedFee)
static json::Value getJsonMetadata(json::Value txResult)
void run() override
Runs the suite.
void testTx(jtx::Env &env, json::Value const &tx, std::function< void(json::Value const &, json::Value const &)> const &validate, bool testSerialized=true)
void checkBasicReturnValidity(json::Value const &result, json::Value const &tx, int const expectedSequence, XRPAmount const &expectedFee)
void testTxJsonMetadataField(jtx::Env &env, json::Value const &tx, std::function< void(json::Value const &, json::Value const &, json::Value const &, json::Value const &)> const &validate, json::Value const &expectedMetadataKey, json::Value const &expectedMetadataValue)
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
std::string const & human() const
Returns the human readable public key.
PublicKey const & pk() const
Return the public key.
Definition jtx/Account.h:84
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
Account const & master
Definition Env.h:165
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:1058
JTx jtnofill(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:737
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Set the regular signature on a JTx.
Definition sig.h:19
Adds an inner Batch transaction to a JTx and autofills it.
Definition batch.h:91
@ Array
array value (ordered list)
Definition json_value.h:32
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
The api_version numbers this server serves.
Definition ApiVersion.h:26
json::Value outer(jtx::Account const &account, uint32_t seq, STAmount const &fee, std::uint32_t flags)
Build an outer Batch transaction JSON object.
Definition batch.cpp:55
XRPAmount calcBatchFee(jtx::Env const &env, uint32_t const &numSigners, uint32_t const &txns=0)
Calculate the expected outer Batch transaction fee.
Definition batch.cpp:37
json::Value accept(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:29
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:16
json::Value ledgerEntry(jtx::Env &env, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:56
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.
Definition token.cpp:57
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
json::Value regkey(Account const &account, DisabledT)
Disable the regular key.
Definition regkey.cpp:13
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value noop(Account const &account)
The null transaction.
Definition noop.h:14
std::uint32_t ownerCount(Env const &env, Account const &account)
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition envconfig.h:38
std::unique_ptr< Config > noAdmin(std::unique_ptr< Config >)
adjust config so no admin ports are enabled
Definition envconfig.cpp:76
json::Value signers(Account const &account, std::uint32_t quorum, std::vector< Signer > const &v)
Definition multisign.cpp:31
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition TxTest.h:53
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
constexpr FlagValue spfSponsorFee
Definition TxFlags.h:467
constexpr FlagValue tfInnerBatchTxn
Definition TxFlags.h:44
@ RpcSrcActMalformed
Definition ErrorCodes.h:103
@ RpcNotImpl
Definition ErrorCodes.h:114
@ RpcHighFee
Definition ErrorCodes.h:41
@ RpcInvalidParams
Definition ErrorCodes.h:67
@ RpcNoPermission
Definition ErrorCodes.h:36
@ RpcTxSigned
Definition ErrorCodes.h:138
@ RpcSrcActNotFound
Definition ErrorCodes.h:105
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
SField const sfGeneric
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
Slice makeSlice(std::array< T, N > const &a)
Definition Slice.h:228
std::optional< Blob > strUnHex(std::size_t strSize, Iterator begin, Iterator end)
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
Definition Indexes.cpp:219
T push_back(T... args)
T ref(T... args)
static constexpr auto kMinimumTxnInLedgerStandalone
Definition Constants.h:137
static constexpr auto kTransactionQueue
Definition Constants.h:66
json::Value jv
Definition JTx.h:28
T to_string(T... args)