xrpld
Loading...
Searching...
No Matches
MPTokenTests.cpp
1// Auto-generated unit tests for ledger entry MPToken
2
3
4#include <gtest/gtest.h>
5
6#include <protocol_autogen/TestHelpers.h>
7
8#include <xrpl/protocol/STLedgerEntry.h>
9#include <xrpl/protocol_autogen/ledger_entries/MPToken.h>
10#include <xrpl/protocol_autogen/ledger_entries/Ticket.h>
11
12#include <string>
13
14namespace xrpl::ledger_entries {
15
16// 1 & 4) Set fields via builder setters, build, then read them back via
17// wrapper getters. After build(), validate() should succeed for both the
18// builder's STObject and the wrapper's SLE.
19TEST(MPTokenTests, BuilderSettersRoundTrip)
20{
21 UInt256 const index{1u};
22
23 auto const accountValue = canonical_ACCOUNT();
24 auto const mPTokenIssuanceIDValue = canonical_UINT192();
25 auto const mPTAmountValue = canonical_UINT64();
26 auto const lockedAmountValue = canonical_UINT64();
27 auto const ownerNodeValue = canonical_UINT64();
28 auto const previousTxnIDValue = canonical_UINT256();
29 auto const previousTxnLgrSeqValue = canonical_UINT32();
30 auto const confidentialBalanceInboxValue = canonical_VL();
31 auto const confidentialBalanceSpendingValue = canonical_VL();
32 auto const confidentialBalanceVersionValue = canonical_UINT32();
33 auto const issuerEncryptedBalanceValue = canonical_VL();
34 auto const auditorEncryptedBalanceValue = canonical_VL();
35 auto const issuerKeyMirrorEpochValue = canonical_UINT32();
36 auto const auditorKeyMirrorEpochValue = canonical_UINT32();
37 auto const issuerMirrorEncryptionKeyValue = canonical_VL();
38 auto const holderEncryptionKeyValue = canonical_VL();
39 auto const recoveryKeyValue = canonical_VL();
40
41 MPTokenBuilder builder{
42 accountValue,
43 mPTokenIssuanceIDValue,
44 ownerNodeValue,
45 previousTxnIDValue,
46 previousTxnLgrSeqValue
47 };
48
49 builder.setMPTAmount(mPTAmountValue);
50 builder.setLockedAmount(lockedAmountValue);
51 builder.setConfidentialBalanceInbox(confidentialBalanceInboxValue);
52 builder.setConfidentialBalanceSpending(confidentialBalanceSpendingValue);
53 builder.setConfidentialBalanceVersion(confidentialBalanceVersionValue);
54 builder.setIssuerEncryptedBalance(issuerEncryptedBalanceValue);
55 builder.setAuditorEncryptedBalance(auditorEncryptedBalanceValue);
56 builder.setIssuerKeyMirrorEpoch(issuerKeyMirrorEpochValue);
57 builder.setAuditorKeyMirrorEpoch(auditorKeyMirrorEpochValue);
58 builder.setIssuerMirrorEncryptionKey(issuerMirrorEncryptionKeyValue);
59 builder.setHolderEncryptionKey(holderEncryptionKeyValue);
60 builder.setRecoveryKey(recoveryKeyValue);
61
62 builder.setLedgerIndex(index);
63 builder.setFlags(0x1u);
64
65 EXPECT_TRUE(builder.validate());
66
67 auto const entry = builder.build(index);
68
69 EXPECT_TRUE(entry.validate());
70
71 {
72 auto const& expected = accountValue;
73 auto const actual = entry.getAccount();
74 expectEqualField(expected, actual, "sfAccount");
75 }
76
77 {
78 auto const& expected = mPTokenIssuanceIDValue;
79 auto const actual = entry.getMPTokenIssuanceID();
80 expectEqualField(expected, actual, "sfMPTokenIssuanceID");
81 }
82
83 {
84 auto const& expected = ownerNodeValue;
85 auto const actual = entry.getOwnerNode();
86 expectEqualField(expected, actual, "sfOwnerNode");
87 }
88
89 {
90 auto const& expected = previousTxnIDValue;
91 auto const actual = entry.getPreviousTxnID();
92 expectEqualField(expected, actual, "sfPreviousTxnID");
93 }
94
95 {
96 auto const& expected = previousTxnLgrSeqValue;
97 auto const actual = entry.getPreviousTxnLgrSeq();
98 expectEqualField(expected, actual, "sfPreviousTxnLgrSeq");
99 }
100
101 {
102 auto const& expected = mPTAmountValue;
103 auto const actualOpt = entry.getMPTAmount();
104 ASSERT_TRUE(actualOpt.has_value());
105 expectEqualField(expected, *actualOpt, "sfMPTAmount");
106 EXPECT_TRUE(entry.hasMPTAmount());
107 }
108
109 {
110 auto const& expected = lockedAmountValue;
111 auto const actualOpt = entry.getLockedAmount();
112 ASSERT_TRUE(actualOpt.has_value());
113 expectEqualField(expected, *actualOpt, "sfLockedAmount");
114 EXPECT_TRUE(entry.hasLockedAmount());
115 }
116
117 {
118 auto const& expected = confidentialBalanceInboxValue;
119 auto const actualOpt = entry.getConfidentialBalanceInbox();
120 ASSERT_TRUE(actualOpt.has_value());
121 expectEqualField(expected, *actualOpt, "sfConfidentialBalanceInbox");
122 EXPECT_TRUE(entry.hasConfidentialBalanceInbox());
123 }
124
125 {
126 auto const& expected = confidentialBalanceSpendingValue;
127 auto const actualOpt = entry.getConfidentialBalanceSpending();
128 ASSERT_TRUE(actualOpt.has_value());
129 expectEqualField(expected, *actualOpt, "sfConfidentialBalanceSpending");
130 EXPECT_TRUE(entry.hasConfidentialBalanceSpending());
131 }
132
133 {
134 auto const& expected = confidentialBalanceVersionValue;
135 auto const actualOpt = entry.getConfidentialBalanceVersion();
136 ASSERT_TRUE(actualOpt.has_value());
137 expectEqualField(expected, *actualOpt, "sfConfidentialBalanceVersion");
138 EXPECT_TRUE(entry.hasConfidentialBalanceVersion());
139 }
140
141 {
142 auto const& expected = issuerEncryptedBalanceValue;
143 auto const actualOpt = entry.getIssuerEncryptedBalance();
144 ASSERT_TRUE(actualOpt.has_value());
145 expectEqualField(expected, *actualOpt, "sfIssuerEncryptedBalance");
146 EXPECT_TRUE(entry.hasIssuerEncryptedBalance());
147 }
148
149 {
150 auto const& expected = auditorEncryptedBalanceValue;
151 auto const actualOpt = entry.getAuditorEncryptedBalance();
152 ASSERT_TRUE(actualOpt.has_value());
153 expectEqualField(expected, *actualOpt, "sfAuditorEncryptedBalance");
154 EXPECT_TRUE(entry.hasAuditorEncryptedBalance());
155 }
156
157 {
158 auto const& expected = issuerKeyMirrorEpochValue;
159 auto const actualOpt = entry.getIssuerKeyMirrorEpoch();
160 ASSERT_TRUE(actualOpt.has_value());
161 expectEqualField(expected, *actualOpt, "sfIssuerKeyMirrorEpoch");
162 EXPECT_TRUE(entry.hasIssuerKeyMirrorEpoch());
163 }
164
165 {
166 auto const& expected = auditorKeyMirrorEpochValue;
167 auto const actualOpt = entry.getAuditorKeyMirrorEpoch();
168 ASSERT_TRUE(actualOpt.has_value());
169 expectEqualField(expected, *actualOpt, "sfAuditorKeyMirrorEpoch");
170 EXPECT_TRUE(entry.hasAuditorKeyMirrorEpoch());
171 }
172
173 {
174 auto const& expected = issuerMirrorEncryptionKeyValue;
175 auto const actualOpt = entry.getIssuerMirrorEncryptionKey();
176 ASSERT_TRUE(actualOpt.has_value());
177 expectEqualField(expected, *actualOpt, "sfIssuerMirrorEncryptionKey");
178 EXPECT_TRUE(entry.hasIssuerMirrorEncryptionKey());
179 }
180
181 {
182 auto const& expected = holderEncryptionKeyValue;
183 auto const actualOpt = entry.getHolderEncryptionKey();
184 ASSERT_TRUE(actualOpt.has_value());
185 expectEqualField(expected, *actualOpt, "sfHolderEncryptionKey");
186 EXPECT_TRUE(entry.hasHolderEncryptionKey());
187 }
188
189 {
190 auto const& expected = recoveryKeyValue;
191 auto const actualOpt = entry.getRecoveryKey();
192 ASSERT_TRUE(actualOpt.has_value());
193 expectEqualField(expected, *actualOpt, "sfRecoveryKey");
194 EXPECT_TRUE(entry.hasRecoveryKey());
195 }
196
197 EXPECT_TRUE(entry.hasLedgerIndex());
198 auto const ledgerIndex = entry.getLedgerIndex();
199 ASSERT_TRUE(ledgerIndex.has_value());
200 EXPECT_EQ(*ledgerIndex, index);
201 EXPECT_EQ(entry.getKey(), index);
202}
203
204// 2 & 4) Start from an SLE, set fields directly on it, construct a builder
205// from that SLE, build a new wrapper, and verify all fields (and validate()).
206TEST(MPTokenTests, BuilderFromSleRoundTrip)
207{
208 UInt256 const index{2u};
209
210 auto const accountValue = canonical_ACCOUNT();
211 auto const mPTokenIssuanceIDValue = canonical_UINT192();
212 auto const mPTAmountValue = canonical_UINT64();
213 auto const lockedAmountValue = canonical_UINT64();
214 auto const ownerNodeValue = canonical_UINT64();
215 auto const previousTxnIDValue = canonical_UINT256();
216 auto const previousTxnLgrSeqValue = canonical_UINT32();
217 auto const confidentialBalanceInboxValue = canonical_VL();
218 auto const confidentialBalanceSpendingValue = canonical_VL();
219 auto const confidentialBalanceVersionValue = canonical_UINT32();
220 auto const issuerEncryptedBalanceValue = canonical_VL();
221 auto const auditorEncryptedBalanceValue = canonical_VL();
222 auto const issuerKeyMirrorEpochValue = canonical_UINT32();
223 auto const auditorKeyMirrorEpochValue = canonical_UINT32();
224 auto const issuerMirrorEncryptionKeyValue = canonical_VL();
225 auto const holderEncryptionKeyValue = canonical_VL();
226 auto const recoveryKeyValue = canonical_VL();
227
228 auto sle = std::make_shared<SLE>(MPToken::entryType, index);
229
230 sle->at(sfAccount) = accountValue;
231 sle->at(sfMPTokenIssuanceID) = mPTokenIssuanceIDValue;
232 sle->at(sfMPTAmount) = mPTAmountValue;
233 sle->at(sfLockedAmount) = lockedAmountValue;
234 sle->at(sfOwnerNode) = ownerNodeValue;
235 sle->at(sfPreviousTxnID) = previousTxnIDValue;
236 sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue;
237 sle->at(sfConfidentialBalanceInbox) = confidentialBalanceInboxValue;
238 sle->at(sfConfidentialBalanceSpending) = confidentialBalanceSpendingValue;
239 sle->at(sfConfidentialBalanceVersion) = confidentialBalanceVersionValue;
240 sle->at(sfIssuerEncryptedBalance) = issuerEncryptedBalanceValue;
241 sle->at(sfAuditorEncryptedBalance) = auditorEncryptedBalanceValue;
242 sle->at(sfIssuerKeyMirrorEpoch) = issuerKeyMirrorEpochValue;
243 sle->at(sfAuditorKeyMirrorEpoch) = auditorKeyMirrorEpochValue;
244 sle->at(sfIssuerMirrorEncryptionKey) = issuerMirrorEncryptionKeyValue;
245 sle->at(sfHolderEncryptionKey) = holderEncryptionKeyValue;
246 sle->at(sfRecoveryKey) = recoveryKeyValue;
247
248 MPTokenBuilder builderFromSle{sle};
249 EXPECT_TRUE(builderFromSle.validate());
250
251 auto const entryFromBuilder = builderFromSle.build(index);
252
253 MPToken entryFromSle{sle};
254 EXPECT_TRUE(entryFromBuilder.validate());
255 EXPECT_TRUE(entryFromSle.validate());
256
257 {
258 auto const& expected = accountValue;
259
260 auto const fromSle = entryFromSle.getAccount();
261 auto const fromBuilder = entryFromBuilder.getAccount();
262
263 expectEqualField(expected, fromSle, "sfAccount");
264 expectEqualField(expected, fromBuilder, "sfAccount");
265 }
266
267 {
268 auto const& expected = mPTokenIssuanceIDValue;
269
270 auto const fromSle = entryFromSle.getMPTokenIssuanceID();
271 auto const fromBuilder = entryFromBuilder.getMPTokenIssuanceID();
272
273 expectEqualField(expected, fromSle, "sfMPTokenIssuanceID");
274 expectEqualField(expected, fromBuilder, "sfMPTokenIssuanceID");
275 }
276
277 {
278 auto const& expected = ownerNodeValue;
279
280 auto const fromSle = entryFromSle.getOwnerNode();
281 auto const fromBuilder = entryFromBuilder.getOwnerNode();
282
283 expectEqualField(expected, fromSle, "sfOwnerNode");
284 expectEqualField(expected, fromBuilder, "sfOwnerNode");
285 }
286
287 {
288 auto const& expected = previousTxnIDValue;
289
290 auto const fromSle = entryFromSle.getPreviousTxnID();
291 auto const fromBuilder = entryFromBuilder.getPreviousTxnID();
292
293 expectEqualField(expected, fromSle, "sfPreviousTxnID");
294 expectEqualField(expected, fromBuilder, "sfPreviousTxnID");
295 }
296
297 {
298 auto const& expected = previousTxnLgrSeqValue;
299
300 auto const fromSle = entryFromSle.getPreviousTxnLgrSeq();
301 auto const fromBuilder = entryFromBuilder.getPreviousTxnLgrSeq();
302
303 expectEqualField(expected, fromSle, "sfPreviousTxnLgrSeq");
304 expectEqualField(expected, fromBuilder, "sfPreviousTxnLgrSeq");
305 }
306
307 {
308 auto const& expected = mPTAmountValue;
309
310 auto const fromSleOpt = entryFromSle.getMPTAmount();
311 auto const fromBuilderOpt = entryFromBuilder.getMPTAmount();
312
313 ASSERT_TRUE(fromSleOpt.has_value());
314 ASSERT_TRUE(fromBuilderOpt.has_value());
315
316 expectEqualField(expected, *fromSleOpt, "sfMPTAmount");
317 expectEqualField(expected, *fromBuilderOpt, "sfMPTAmount");
318 }
319
320 {
321 auto const& expected = lockedAmountValue;
322
323 auto const fromSleOpt = entryFromSle.getLockedAmount();
324 auto const fromBuilderOpt = entryFromBuilder.getLockedAmount();
325
326 ASSERT_TRUE(fromSleOpt.has_value());
327 ASSERT_TRUE(fromBuilderOpt.has_value());
328
329 expectEqualField(expected, *fromSleOpt, "sfLockedAmount");
330 expectEqualField(expected, *fromBuilderOpt, "sfLockedAmount");
331 }
332
333 {
334 auto const& expected = confidentialBalanceInboxValue;
335
336 auto const fromSleOpt = entryFromSle.getConfidentialBalanceInbox();
337 auto const fromBuilderOpt = entryFromBuilder.getConfidentialBalanceInbox();
338
339 ASSERT_TRUE(fromSleOpt.has_value());
340 ASSERT_TRUE(fromBuilderOpt.has_value());
341
342 expectEqualField(expected, *fromSleOpt, "sfConfidentialBalanceInbox");
343 expectEqualField(expected, *fromBuilderOpt, "sfConfidentialBalanceInbox");
344 }
345
346 {
347 auto const& expected = confidentialBalanceSpendingValue;
348
349 auto const fromSleOpt = entryFromSle.getConfidentialBalanceSpending();
350 auto const fromBuilderOpt = entryFromBuilder.getConfidentialBalanceSpending();
351
352 ASSERT_TRUE(fromSleOpt.has_value());
353 ASSERT_TRUE(fromBuilderOpt.has_value());
354
355 expectEqualField(expected, *fromSleOpt, "sfConfidentialBalanceSpending");
356 expectEqualField(expected, *fromBuilderOpt, "sfConfidentialBalanceSpending");
357 }
358
359 {
360 auto const& expected = confidentialBalanceVersionValue;
361
362 auto const fromSleOpt = entryFromSle.getConfidentialBalanceVersion();
363 auto const fromBuilderOpt = entryFromBuilder.getConfidentialBalanceVersion();
364
365 ASSERT_TRUE(fromSleOpt.has_value());
366 ASSERT_TRUE(fromBuilderOpt.has_value());
367
368 expectEqualField(expected, *fromSleOpt, "sfConfidentialBalanceVersion");
369 expectEqualField(expected, *fromBuilderOpt, "sfConfidentialBalanceVersion");
370 }
371
372 {
373 auto const& expected = issuerEncryptedBalanceValue;
374
375 auto const fromSleOpt = entryFromSle.getIssuerEncryptedBalance();
376 auto const fromBuilderOpt = entryFromBuilder.getIssuerEncryptedBalance();
377
378 ASSERT_TRUE(fromSleOpt.has_value());
379 ASSERT_TRUE(fromBuilderOpt.has_value());
380
381 expectEqualField(expected, *fromSleOpt, "sfIssuerEncryptedBalance");
382 expectEqualField(expected, *fromBuilderOpt, "sfIssuerEncryptedBalance");
383 }
384
385 {
386 auto const& expected = auditorEncryptedBalanceValue;
387
388 auto const fromSleOpt = entryFromSle.getAuditorEncryptedBalance();
389 auto const fromBuilderOpt = entryFromBuilder.getAuditorEncryptedBalance();
390
391 ASSERT_TRUE(fromSleOpt.has_value());
392 ASSERT_TRUE(fromBuilderOpt.has_value());
393
394 expectEqualField(expected, *fromSleOpt, "sfAuditorEncryptedBalance");
395 expectEqualField(expected, *fromBuilderOpt, "sfAuditorEncryptedBalance");
396 }
397
398 {
399 auto const& expected = issuerKeyMirrorEpochValue;
400
401 auto const fromSleOpt = entryFromSle.getIssuerKeyMirrorEpoch();
402 auto const fromBuilderOpt = entryFromBuilder.getIssuerKeyMirrorEpoch();
403
404 ASSERT_TRUE(fromSleOpt.has_value());
405 ASSERT_TRUE(fromBuilderOpt.has_value());
406
407 expectEqualField(expected, *fromSleOpt, "sfIssuerKeyMirrorEpoch");
408 expectEqualField(expected, *fromBuilderOpt, "sfIssuerKeyMirrorEpoch");
409 }
410
411 {
412 auto const& expected = auditorKeyMirrorEpochValue;
413
414 auto const fromSleOpt = entryFromSle.getAuditorKeyMirrorEpoch();
415 auto const fromBuilderOpt = entryFromBuilder.getAuditorKeyMirrorEpoch();
416
417 ASSERT_TRUE(fromSleOpt.has_value());
418 ASSERT_TRUE(fromBuilderOpt.has_value());
419
420 expectEqualField(expected, *fromSleOpt, "sfAuditorKeyMirrorEpoch");
421 expectEqualField(expected, *fromBuilderOpt, "sfAuditorKeyMirrorEpoch");
422 }
423
424 {
425 auto const& expected = issuerMirrorEncryptionKeyValue;
426
427 auto const fromSleOpt = entryFromSle.getIssuerMirrorEncryptionKey();
428 auto const fromBuilderOpt = entryFromBuilder.getIssuerMirrorEncryptionKey();
429
430 ASSERT_TRUE(fromSleOpt.has_value());
431 ASSERT_TRUE(fromBuilderOpt.has_value());
432
433 expectEqualField(expected, *fromSleOpt, "sfIssuerMirrorEncryptionKey");
434 expectEqualField(expected, *fromBuilderOpt, "sfIssuerMirrorEncryptionKey");
435 }
436
437 {
438 auto const& expected = holderEncryptionKeyValue;
439
440 auto const fromSleOpt = entryFromSle.getHolderEncryptionKey();
441 auto const fromBuilderOpt = entryFromBuilder.getHolderEncryptionKey();
442
443 ASSERT_TRUE(fromSleOpt.has_value());
444 ASSERT_TRUE(fromBuilderOpt.has_value());
445
446 expectEqualField(expected, *fromSleOpt, "sfHolderEncryptionKey");
447 expectEqualField(expected, *fromBuilderOpt, "sfHolderEncryptionKey");
448 }
449
450 {
451 auto const& expected = recoveryKeyValue;
452
453 auto const fromSleOpt = entryFromSle.getRecoveryKey();
454 auto const fromBuilderOpt = entryFromBuilder.getRecoveryKey();
455
456 ASSERT_TRUE(fromSleOpt.has_value());
457 ASSERT_TRUE(fromBuilderOpt.has_value());
458
459 expectEqualField(expected, *fromSleOpt, "sfRecoveryKey");
460 expectEqualField(expected, *fromBuilderOpt, "sfRecoveryKey");
461 }
462
463 EXPECT_EQ(entryFromSle.getKey(), index);
464 EXPECT_EQ(entryFromBuilder.getKey(), index);
465}
466
467// 3) Verify wrapper throws when constructed from wrong ledger entry type.
468TEST(MPTokenTests, WrapperThrowsOnWrongEntryType)
469{
470 UInt256 const index{3u};
471
472 // Build a valid ledger entry of a different type
473 // Ticket requires: Account, OwnerNode, TicketSequence, PreviousTxnID, PreviousTxnLgrSeq
474 // Check requires: Account, Destination, SendMax, Sequence, OwnerNode, DestinationNode, PreviousTxnID, PreviousTxnLgrSeq
475 TicketBuilder wrongBuilder{
481 auto wrongEntry = wrongBuilder.build(index);
482
483 EXPECT_THROW(MPToken{wrongEntry.getSle()}, std::runtime_error);
484}
485
486// 4) Verify builder throws when constructed from wrong ledger entry type.
487TEST(MPTokenTests, BuilderThrowsOnWrongEntryType)
488{
489 UInt256 const index{4u};
490
491 // Build a valid ledger entry of a different type
492 TicketBuilder wrongBuilder{
498 auto wrongEntry = wrongBuilder.build(index);
499
500 EXPECT_THROW(MPTokenBuilder{wrongEntry.getSle()}, std::runtime_error);
501}
502
503// 5) Build with only required fields and verify optional fields return nullopt.
504TEST(MPTokenTests, OptionalFieldsReturnNullopt)
505{
506 UInt256 const index{3u};
507
508 auto const accountValue = canonical_ACCOUNT();
509 auto const mPTokenIssuanceIDValue = canonical_UINT192();
510 auto const ownerNodeValue = canonical_UINT64();
511 auto const previousTxnIDValue = canonical_UINT256();
512 auto const previousTxnLgrSeqValue = canonical_UINT32();
513
514 MPTokenBuilder builder{
515 accountValue,
516 mPTokenIssuanceIDValue,
517 ownerNodeValue,
518 previousTxnIDValue,
519 previousTxnLgrSeqValue
520 };
521
522 auto const entry = builder.build(index);
523
524 // Verify optional fields are not present
525 EXPECT_FALSE(entry.hasMPTAmount());
526 EXPECT_FALSE(entry.getMPTAmount().has_value());
527 EXPECT_FALSE(entry.hasLockedAmount());
528 EXPECT_FALSE(entry.getLockedAmount().has_value());
529 EXPECT_FALSE(entry.hasConfidentialBalanceInbox());
530 EXPECT_FALSE(entry.getConfidentialBalanceInbox().has_value());
531 EXPECT_FALSE(entry.hasConfidentialBalanceSpending());
532 EXPECT_FALSE(entry.getConfidentialBalanceSpending().has_value());
533 EXPECT_FALSE(entry.hasConfidentialBalanceVersion());
534 EXPECT_FALSE(entry.getConfidentialBalanceVersion().has_value());
535 EXPECT_FALSE(entry.hasIssuerEncryptedBalance());
536 EXPECT_FALSE(entry.getIssuerEncryptedBalance().has_value());
537 EXPECT_FALSE(entry.hasAuditorEncryptedBalance());
538 EXPECT_FALSE(entry.getAuditorEncryptedBalance().has_value());
539 EXPECT_FALSE(entry.hasIssuerKeyMirrorEpoch());
540 EXPECT_FALSE(entry.getIssuerKeyMirrorEpoch().has_value());
541 EXPECT_FALSE(entry.hasAuditorKeyMirrorEpoch());
542 EXPECT_FALSE(entry.getAuditorKeyMirrorEpoch().has_value());
543 EXPECT_FALSE(entry.hasIssuerMirrorEncryptionKey());
544 EXPECT_FALSE(entry.getIssuerMirrorEncryptionKey().has_value());
545 EXPECT_FALSE(entry.hasHolderEncryptionKey());
546 EXPECT_FALSE(entry.getHolderEncryptionKey().has_value());
547 EXPECT_FALSE(entry.hasRecoveryKey());
548 EXPECT_FALSE(entry.getRecoveryKey().has_value());
549}
550}
UInt256 const & getKey() const
Get the key (index) of this ledger entry.
bool validate() const
Validate the ledger entry.
Derived & setLedgerIndex(UInt256 const &value)
Set the ledger index.
Derived & setFlags(uint32_t value)
Set the flags.
bool validate() const
Validate the ledger entry.
Builder for MPToken ledger entries.
Definition MPToken.h:400
MPTokenBuilder & setConfidentialBalanceSpending(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfConfidentialBalanceSpending (SoeOptional).
Definition MPToken.h:531
MPTokenBuilder & setRecoveryKey(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfRecoveryKey (SoeOptional).
Definition MPToken.h:619
MPTokenBuilder & setIssuerMirrorEncryptionKey(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfIssuerMirrorEncryptionKey (SoeOptional).
Definition MPToken.h:597
MPTokenBuilder & setAuditorKeyMirrorEpoch(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfAuditorKeyMirrorEpoch (SoeOptional).
Definition MPToken.h:586
MPTokenBuilder & setIssuerEncryptedBalance(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfIssuerEncryptedBalance (SoeOptional).
Definition MPToken.h:553
MPTokenBuilder & setIssuerKeyMirrorEpoch(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfIssuerKeyMirrorEpoch (SoeOptional).
Definition MPToken.h:575
MPTokenBuilder & setLockedAmount(std::decay_t< typename SF_UINT64::type::value_type > const &value)
Set sfLockedAmount (SoeOptional).
Definition MPToken.h:476
MPTokenBuilder & setConfidentialBalanceInbox(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfConfidentialBalanceInbox (SoeOptional).
Definition MPToken.h:520
MPTokenBuilder & setHolderEncryptionKey(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfHolderEncryptionKey (SoeOptional).
Definition MPToken.h:608
MPTokenBuilder & setMPTAmount(std::decay_t< typename SF_UINT64::type::value_type > const &value)
Set sfMPTAmount (SoeDefault).
Definition MPToken.h:465
MPTokenBuilder & setAuditorEncryptedBalance(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfAuditorEncryptedBalance (SoeOptional).
Definition MPToken.h:564
MPToken build(UInt256 const &index)
Build and return the completed MPToken wrapper.
Definition MPToken.h:631
MPTokenBuilder & setConfidentialBalanceVersion(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfConfidentialBalanceVersion (SoeDefault).
Definition MPToken.h:542
Ledger Entry: MPToken.
Definition MPToken.h:28
SF_UINT256::type::value_type getPreviousTxnID() const
Get sfPreviousTxnID (SoeRequired).
Definition MPToken.h:135
protocol_autogen::Optional< SF_VL::type::value_type > getHolderEncryptionKey() const
Get sfHolderEncryptionKey (SoeOptional).
Definition MPToken.h:349
SF_UINT192::type::value_type getMPTokenIssuanceID() const
Get sfMPTokenIssuanceID (SoeRequired).
Definition MPToken.h:65
SF_ACCOUNT::type::value_type getAccount() const
Get sfAccount (SoeRequired).
Definition MPToken.h:54
static constexpr LedgerEntryType entryType
Definition MPToken.h:30
protocol_autogen::Optional< SF_VL::type::value_type > getIssuerMirrorEncryptionKey() const
Get sfIssuerMirrorEncryptionKey (SoeOptional).
Definition MPToken.h:325
protocol_autogen::Optional< SF_VL::type::value_type > getRecoveryKey() const
Get sfRecoveryKey (SoeOptional).
Definition MPToken.h:373
protocol_autogen::Optional< SF_UINT64::type::value_type > getMPTAmount() const
Get sfMPTAmount (SoeDefault).
Definition MPToken.h:76
protocol_autogen::Optional< SF_VL::type::value_type > getAuditorEncryptedBalance() const
Get sfAuditorEncryptedBalance (SoeOptional).
Definition MPToken.h:253
protocol_autogen::Optional< SF_UINT32::type::value_type > getIssuerKeyMirrorEpoch() const
Get sfIssuerKeyMirrorEpoch (SoeOptional).
Definition MPToken.h:277
SF_UINT32::type::value_type getPreviousTxnLgrSeq() const
Get sfPreviousTxnLgrSeq (SoeRequired).
Definition MPToken.h:146
SF_UINT64::type::value_type getOwnerNode() const
Get sfOwnerNode (SoeRequired).
Definition MPToken.h:124
protocol_autogen::Optional< SF_VL::type::value_type > getIssuerEncryptedBalance() const
Get sfIssuerEncryptedBalance (SoeOptional).
Definition MPToken.h:229
protocol_autogen::Optional< SF_UINT32::type::value_type > getAuditorKeyMirrorEpoch() const
Get sfAuditorKeyMirrorEpoch (SoeOptional).
Definition MPToken.h:301
protocol_autogen::Optional< SF_VL::type::value_type > getConfidentialBalanceInbox() const
Get sfConfidentialBalanceInbox (SoeOptional).
Definition MPToken.h:157
protocol_autogen::Optional< SF_VL::type::value_type > getConfidentialBalanceSpending() const
Get sfConfidentialBalanceSpending (SoeOptional).
Definition MPToken.h:181
protocol_autogen::Optional< SF_UINT32::type::value_type > getConfidentialBalanceVersion() const
Get sfConfidentialBalanceVersion (SoeDefault).
Definition MPToken.h:205
protocol_autogen::Optional< SF_UINT64::type::value_type > getLockedAmount() const
Get sfLockedAmount (SoeOptional).
Definition MPToken.h:100
Builder for Ticket ledger entries.
Definition Ticket.h:112
Ticket build(UInt256 const &index)
Build and return the completed Ticket wrapper.
Definition Ticket.h:211
T make_shared(T... args)
TEST(AccountRootTests, BuilderSettersRoundTrip)
BaseUInt< 256 > UInt256
Definition base_uint.h:581
void expectEqualField(T const &expected, T const &actual, char const *fieldName)