xrpld
Loading...
Searching...
No Matches
MPTokenIssuanceTests.cpp
1// Auto-generated unit tests for ledger entry MPTokenIssuance
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/MPTokenIssuance.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(MPTokenIssuanceTests, BuilderSettersRoundTrip)
20{
21 UInt256 const index{1u};
22
23 auto const issuerValue = canonical_ACCOUNT();
24 auto const sequenceValue = canonical_UINT32();
25 auto const transferFeeValue = canonical_UINT16();
26 auto const ownerNodeValue = canonical_UINT64();
27 auto const assetScaleValue = canonical_UINT8();
28 auto const maximumAmountValue = canonical_UINT64();
29 auto const outstandingAmountValue = canonical_UINT64();
30 auto const lockedAmountValue = canonical_UINT64();
31 auto const mPTokenMetadataValue = canonical_VL();
32 auto const previousTxnIDValue = canonical_UINT256();
33 auto const previousTxnLgrSeqValue = canonical_UINT32();
34 auto const domainIDValue = canonical_UINT256();
35 auto const immutableFlagsValue = canonical_UINT32();
36 auto const referenceHoldingValue = canonical_UINT256();
37 auto const issuerEncryptionKeyValue = canonical_VL();
38 auto const auditorEncryptionKeyValue = canonical_VL();
39 auto const issuerKeyEpochValue = canonical_UINT32();
40 auto const auditorKeyEpochValue = canonical_UINT32();
41 auto const initialIssuerEncryptionKeyValue = canonical_VL();
42 auto const confidentialOutstandingAmountValue = canonical_UINT64();
43
45 issuerValue,
46 sequenceValue,
47 ownerNodeValue,
48 outstandingAmountValue,
49 previousTxnIDValue,
50 previousTxnLgrSeqValue
51 };
52
53 builder.setTransferFee(transferFeeValue);
54 builder.setAssetScale(assetScaleValue);
55 builder.setMaximumAmount(maximumAmountValue);
56 builder.setLockedAmount(lockedAmountValue);
57 builder.setMPTokenMetadata(mPTokenMetadataValue);
58 builder.setDomainID(domainIDValue);
59 builder.setImmutableFlags(immutableFlagsValue);
60 builder.setReferenceHolding(referenceHoldingValue);
61 builder.setIssuerEncryptionKey(issuerEncryptionKeyValue);
62 builder.setAuditorEncryptionKey(auditorEncryptionKeyValue);
63 builder.setIssuerKeyEpoch(issuerKeyEpochValue);
64 builder.setAuditorKeyEpoch(auditorKeyEpochValue);
65 builder.setInitialIssuerEncryptionKey(initialIssuerEncryptionKeyValue);
66 builder.setConfidentialOutstandingAmount(confidentialOutstandingAmountValue);
67
68 builder.setLedgerIndex(index);
69 builder.setFlags(0x1u);
70
71 EXPECT_TRUE(builder.validate());
72
73 auto const entry = builder.build(index);
74
75 EXPECT_TRUE(entry.validate());
76
77 {
78 auto const& expected = issuerValue;
79 auto const actual = entry.getIssuer();
80 expectEqualField(expected, actual, "sfIssuer");
81 }
82
83 {
84 auto const& expected = sequenceValue;
85 auto const actual = entry.getSequence();
86 expectEqualField(expected, actual, "sfSequence");
87 }
88
89 {
90 auto const& expected = ownerNodeValue;
91 auto const actual = entry.getOwnerNode();
92 expectEqualField(expected, actual, "sfOwnerNode");
93 }
94
95 {
96 auto const& expected = outstandingAmountValue;
97 auto const actual = entry.getOutstandingAmount();
98 expectEqualField(expected, actual, "sfOutstandingAmount");
99 }
100
101 {
102 auto const& expected = previousTxnIDValue;
103 auto const actual = entry.getPreviousTxnID();
104 expectEqualField(expected, actual, "sfPreviousTxnID");
105 }
106
107 {
108 auto const& expected = previousTxnLgrSeqValue;
109 auto const actual = entry.getPreviousTxnLgrSeq();
110 expectEqualField(expected, actual, "sfPreviousTxnLgrSeq");
111 }
112
113 {
114 auto const& expected = transferFeeValue;
115 auto const actualOpt = entry.getTransferFee();
116 ASSERT_TRUE(actualOpt.has_value());
117 expectEqualField(expected, *actualOpt, "sfTransferFee");
118 EXPECT_TRUE(entry.hasTransferFee());
119 }
120
121 {
122 auto const& expected = assetScaleValue;
123 auto const actualOpt = entry.getAssetScale();
124 ASSERT_TRUE(actualOpt.has_value());
125 expectEqualField(expected, *actualOpt, "sfAssetScale");
126 EXPECT_TRUE(entry.hasAssetScale());
127 }
128
129 {
130 auto const& expected = maximumAmountValue;
131 auto const actualOpt = entry.getMaximumAmount();
132 ASSERT_TRUE(actualOpt.has_value());
133 expectEqualField(expected, *actualOpt, "sfMaximumAmount");
134 EXPECT_TRUE(entry.hasMaximumAmount());
135 }
136
137 {
138 auto const& expected = lockedAmountValue;
139 auto const actualOpt = entry.getLockedAmount();
140 ASSERT_TRUE(actualOpt.has_value());
141 expectEqualField(expected, *actualOpt, "sfLockedAmount");
142 EXPECT_TRUE(entry.hasLockedAmount());
143 }
144
145 {
146 auto const& expected = mPTokenMetadataValue;
147 auto const actualOpt = entry.getMPTokenMetadata();
148 ASSERT_TRUE(actualOpt.has_value());
149 expectEqualField(expected, *actualOpt, "sfMPTokenMetadata");
150 EXPECT_TRUE(entry.hasMPTokenMetadata());
151 }
152
153 {
154 auto const& expected = domainIDValue;
155 auto const actualOpt = entry.getDomainID();
156 ASSERT_TRUE(actualOpt.has_value());
157 expectEqualField(expected, *actualOpt, "sfDomainID");
158 EXPECT_TRUE(entry.hasDomainID());
159 }
160
161 {
162 auto const& expected = immutableFlagsValue;
163 auto const actualOpt = entry.getImmutableFlags();
164 ASSERT_TRUE(actualOpt.has_value());
165 expectEqualField(expected, *actualOpt, "sfImmutableFlags");
166 EXPECT_TRUE(entry.hasImmutableFlags());
167 }
168
169 {
170 auto const& expected = referenceHoldingValue;
171 auto const actualOpt = entry.getReferenceHolding();
172 ASSERT_TRUE(actualOpt.has_value());
173 expectEqualField(expected, *actualOpt, "sfReferenceHolding");
174 EXPECT_TRUE(entry.hasReferenceHolding());
175 }
176
177 {
178 auto const& expected = issuerEncryptionKeyValue;
179 auto const actualOpt = entry.getIssuerEncryptionKey();
180 ASSERT_TRUE(actualOpt.has_value());
181 expectEqualField(expected, *actualOpt, "sfIssuerEncryptionKey");
182 EXPECT_TRUE(entry.hasIssuerEncryptionKey());
183 }
184
185 {
186 auto const& expected = auditorEncryptionKeyValue;
187 auto const actualOpt = entry.getAuditorEncryptionKey();
188 ASSERT_TRUE(actualOpt.has_value());
189 expectEqualField(expected, *actualOpt, "sfAuditorEncryptionKey");
190 EXPECT_TRUE(entry.hasAuditorEncryptionKey());
191 }
192
193 {
194 auto const& expected = issuerKeyEpochValue;
195 auto const actualOpt = entry.getIssuerKeyEpoch();
196 ASSERT_TRUE(actualOpt.has_value());
197 expectEqualField(expected, *actualOpt, "sfIssuerKeyEpoch");
198 EXPECT_TRUE(entry.hasIssuerKeyEpoch());
199 }
200
201 {
202 auto const& expected = auditorKeyEpochValue;
203 auto const actualOpt = entry.getAuditorKeyEpoch();
204 ASSERT_TRUE(actualOpt.has_value());
205 expectEqualField(expected, *actualOpt, "sfAuditorKeyEpoch");
206 EXPECT_TRUE(entry.hasAuditorKeyEpoch());
207 }
208
209 {
210 auto const& expected = initialIssuerEncryptionKeyValue;
211 auto const actualOpt = entry.getInitialIssuerEncryptionKey();
212 ASSERT_TRUE(actualOpt.has_value());
213 expectEqualField(expected, *actualOpt, "sfInitialIssuerEncryptionKey");
214 EXPECT_TRUE(entry.hasInitialIssuerEncryptionKey());
215 }
216
217 {
218 auto const& expected = confidentialOutstandingAmountValue;
219 auto const actualOpt = entry.getConfidentialOutstandingAmount();
220 ASSERT_TRUE(actualOpt.has_value());
221 expectEqualField(expected, *actualOpt, "sfConfidentialOutstandingAmount");
222 EXPECT_TRUE(entry.hasConfidentialOutstandingAmount());
223 }
224
225 EXPECT_TRUE(entry.hasLedgerIndex());
226 auto const ledgerIndex = entry.getLedgerIndex();
227 ASSERT_TRUE(ledgerIndex.has_value());
228 EXPECT_EQ(*ledgerIndex, index);
229 EXPECT_EQ(entry.getKey(), index);
230}
231
232// 2 & 4) Start from an SLE, set fields directly on it, construct a builder
233// from that SLE, build a new wrapper, and verify all fields (and validate()).
234TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip)
235{
236 UInt256 const index{2u};
237
238 auto const issuerValue = canonical_ACCOUNT();
239 auto const sequenceValue = canonical_UINT32();
240 auto const transferFeeValue = canonical_UINT16();
241 auto const ownerNodeValue = canonical_UINT64();
242 auto const assetScaleValue = canonical_UINT8();
243 auto const maximumAmountValue = canonical_UINT64();
244 auto const outstandingAmountValue = canonical_UINT64();
245 auto const lockedAmountValue = canonical_UINT64();
246 auto const mPTokenMetadataValue = canonical_VL();
247 auto const previousTxnIDValue = canonical_UINT256();
248 auto const previousTxnLgrSeqValue = canonical_UINT32();
249 auto const domainIDValue = canonical_UINT256();
250 auto const immutableFlagsValue = canonical_UINT32();
251 auto const referenceHoldingValue = canonical_UINT256();
252 auto const issuerEncryptionKeyValue = canonical_VL();
253 auto const auditorEncryptionKeyValue = canonical_VL();
254 auto const issuerKeyEpochValue = canonical_UINT32();
255 auto const auditorKeyEpochValue = canonical_UINT32();
256 auto const initialIssuerEncryptionKeyValue = canonical_VL();
257 auto const confidentialOutstandingAmountValue = canonical_UINT64();
258
260
261 sle->at(sfIssuer) = issuerValue;
262 sle->at(sfSequence) = sequenceValue;
263 sle->at(sfTransferFee) = transferFeeValue;
264 sle->at(sfOwnerNode) = ownerNodeValue;
265 sle->at(sfAssetScale) = assetScaleValue;
266 sle->at(sfMaximumAmount) = maximumAmountValue;
267 sle->at(sfOutstandingAmount) = outstandingAmountValue;
268 sle->at(sfLockedAmount) = lockedAmountValue;
269 sle->at(sfMPTokenMetadata) = mPTokenMetadataValue;
270 sle->at(sfPreviousTxnID) = previousTxnIDValue;
271 sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue;
272 sle->at(sfDomainID) = domainIDValue;
273 sle->at(sfImmutableFlags) = immutableFlagsValue;
274 sle->at(sfReferenceHolding) = referenceHoldingValue;
275 sle->at(sfIssuerEncryptionKey) = issuerEncryptionKeyValue;
276 sle->at(sfAuditorEncryptionKey) = auditorEncryptionKeyValue;
277 sle->at(sfIssuerKeyEpoch) = issuerKeyEpochValue;
278 sle->at(sfAuditorKeyEpoch) = auditorKeyEpochValue;
279 sle->at(sfInitialIssuerEncryptionKey) = initialIssuerEncryptionKeyValue;
280 sle->at(sfConfidentialOutstandingAmount) = confidentialOutstandingAmountValue;
281
282 MPTokenIssuanceBuilder builderFromSle{sle};
283 EXPECT_TRUE(builderFromSle.validate());
284
285 auto const entryFromBuilder = builderFromSle.build(index);
286
287 MPTokenIssuance entryFromSle{sle};
288 EXPECT_TRUE(entryFromBuilder.validate());
289 EXPECT_TRUE(entryFromSle.validate());
290
291 {
292 auto const& expected = issuerValue;
293
294 auto const fromSle = entryFromSle.getIssuer();
295 auto const fromBuilder = entryFromBuilder.getIssuer();
296
297 expectEqualField(expected, fromSle, "sfIssuer");
298 expectEqualField(expected, fromBuilder, "sfIssuer");
299 }
300
301 {
302 auto const& expected = sequenceValue;
303
304 auto const fromSle = entryFromSle.getSequence();
305 auto const fromBuilder = entryFromBuilder.getSequence();
306
307 expectEqualField(expected, fromSle, "sfSequence");
308 expectEqualField(expected, fromBuilder, "sfSequence");
309 }
310
311 {
312 auto const& expected = ownerNodeValue;
313
314 auto const fromSle = entryFromSle.getOwnerNode();
315 auto const fromBuilder = entryFromBuilder.getOwnerNode();
316
317 expectEqualField(expected, fromSle, "sfOwnerNode");
318 expectEqualField(expected, fromBuilder, "sfOwnerNode");
319 }
320
321 {
322 auto const& expected = outstandingAmountValue;
323
324 auto const fromSle = entryFromSle.getOutstandingAmount();
325 auto const fromBuilder = entryFromBuilder.getOutstandingAmount();
326
327 expectEqualField(expected, fromSle, "sfOutstandingAmount");
328 expectEqualField(expected, fromBuilder, "sfOutstandingAmount");
329 }
330
331 {
332 auto const& expected = previousTxnIDValue;
333
334 auto const fromSle = entryFromSle.getPreviousTxnID();
335 auto const fromBuilder = entryFromBuilder.getPreviousTxnID();
336
337 expectEqualField(expected, fromSle, "sfPreviousTxnID");
338 expectEqualField(expected, fromBuilder, "sfPreviousTxnID");
339 }
340
341 {
342 auto const& expected = previousTxnLgrSeqValue;
343
344 auto const fromSle = entryFromSle.getPreviousTxnLgrSeq();
345 auto const fromBuilder = entryFromBuilder.getPreviousTxnLgrSeq();
346
347 expectEqualField(expected, fromSle, "sfPreviousTxnLgrSeq");
348 expectEqualField(expected, fromBuilder, "sfPreviousTxnLgrSeq");
349 }
350
351 {
352 auto const& expected = transferFeeValue;
353
354 auto const fromSleOpt = entryFromSle.getTransferFee();
355 auto const fromBuilderOpt = entryFromBuilder.getTransferFee();
356
357 ASSERT_TRUE(fromSleOpt.has_value());
358 ASSERT_TRUE(fromBuilderOpt.has_value());
359
360 expectEqualField(expected, *fromSleOpt, "sfTransferFee");
361 expectEqualField(expected, *fromBuilderOpt, "sfTransferFee");
362 }
363
364 {
365 auto const& expected = assetScaleValue;
366
367 auto const fromSleOpt = entryFromSle.getAssetScale();
368 auto const fromBuilderOpt = entryFromBuilder.getAssetScale();
369
370 ASSERT_TRUE(fromSleOpt.has_value());
371 ASSERT_TRUE(fromBuilderOpt.has_value());
372
373 expectEqualField(expected, *fromSleOpt, "sfAssetScale");
374 expectEqualField(expected, *fromBuilderOpt, "sfAssetScale");
375 }
376
377 {
378 auto const& expected = maximumAmountValue;
379
380 auto const fromSleOpt = entryFromSle.getMaximumAmount();
381 auto const fromBuilderOpt = entryFromBuilder.getMaximumAmount();
382
383 ASSERT_TRUE(fromSleOpt.has_value());
384 ASSERT_TRUE(fromBuilderOpt.has_value());
385
386 expectEqualField(expected, *fromSleOpt, "sfMaximumAmount");
387 expectEqualField(expected, *fromBuilderOpt, "sfMaximumAmount");
388 }
389
390 {
391 auto const& expected = lockedAmountValue;
392
393 auto const fromSleOpt = entryFromSle.getLockedAmount();
394 auto const fromBuilderOpt = entryFromBuilder.getLockedAmount();
395
396 ASSERT_TRUE(fromSleOpt.has_value());
397 ASSERT_TRUE(fromBuilderOpt.has_value());
398
399 expectEqualField(expected, *fromSleOpt, "sfLockedAmount");
400 expectEqualField(expected, *fromBuilderOpt, "sfLockedAmount");
401 }
402
403 {
404 auto const& expected = mPTokenMetadataValue;
405
406 auto const fromSleOpt = entryFromSle.getMPTokenMetadata();
407 auto const fromBuilderOpt = entryFromBuilder.getMPTokenMetadata();
408
409 ASSERT_TRUE(fromSleOpt.has_value());
410 ASSERT_TRUE(fromBuilderOpt.has_value());
411
412 expectEqualField(expected, *fromSleOpt, "sfMPTokenMetadata");
413 expectEqualField(expected, *fromBuilderOpt, "sfMPTokenMetadata");
414 }
415
416 {
417 auto const& expected = domainIDValue;
418
419 auto const fromSleOpt = entryFromSle.getDomainID();
420 auto const fromBuilderOpt = entryFromBuilder.getDomainID();
421
422 ASSERT_TRUE(fromSleOpt.has_value());
423 ASSERT_TRUE(fromBuilderOpt.has_value());
424
425 expectEqualField(expected, *fromSleOpt, "sfDomainID");
426 expectEqualField(expected, *fromBuilderOpt, "sfDomainID");
427 }
428
429 {
430 auto const& expected = immutableFlagsValue;
431
432 auto const fromSleOpt = entryFromSle.getImmutableFlags();
433 auto const fromBuilderOpt = entryFromBuilder.getImmutableFlags();
434
435 ASSERT_TRUE(fromSleOpt.has_value());
436 ASSERT_TRUE(fromBuilderOpt.has_value());
437
438 expectEqualField(expected, *fromSleOpt, "sfImmutableFlags");
439 expectEqualField(expected, *fromBuilderOpt, "sfImmutableFlags");
440 }
441
442 {
443 auto const& expected = referenceHoldingValue;
444
445 auto const fromSleOpt = entryFromSle.getReferenceHolding();
446 auto const fromBuilderOpt = entryFromBuilder.getReferenceHolding();
447
448 ASSERT_TRUE(fromSleOpt.has_value());
449 ASSERT_TRUE(fromBuilderOpt.has_value());
450
451 expectEqualField(expected, *fromSleOpt, "sfReferenceHolding");
452 expectEqualField(expected, *fromBuilderOpt, "sfReferenceHolding");
453 }
454
455 {
456 auto const& expected = issuerEncryptionKeyValue;
457
458 auto const fromSleOpt = entryFromSle.getIssuerEncryptionKey();
459 auto const fromBuilderOpt = entryFromBuilder.getIssuerEncryptionKey();
460
461 ASSERT_TRUE(fromSleOpt.has_value());
462 ASSERT_TRUE(fromBuilderOpt.has_value());
463
464 expectEqualField(expected, *fromSleOpt, "sfIssuerEncryptionKey");
465 expectEqualField(expected, *fromBuilderOpt, "sfIssuerEncryptionKey");
466 }
467
468 {
469 auto const& expected = auditorEncryptionKeyValue;
470
471 auto const fromSleOpt = entryFromSle.getAuditorEncryptionKey();
472 auto const fromBuilderOpt = entryFromBuilder.getAuditorEncryptionKey();
473
474 ASSERT_TRUE(fromSleOpt.has_value());
475 ASSERT_TRUE(fromBuilderOpt.has_value());
476
477 expectEqualField(expected, *fromSleOpt, "sfAuditorEncryptionKey");
478 expectEqualField(expected, *fromBuilderOpt, "sfAuditorEncryptionKey");
479 }
480
481 {
482 auto const& expected = issuerKeyEpochValue;
483
484 auto const fromSleOpt = entryFromSle.getIssuerKeyEpoch();
485 auto const fromBuilderOpt = entryFromBuilder.getIssuerKeyEpoch();
486
487 ASSERT_TRUE(fromSleOpt.has_value());
488 ASSERT_TRUE(fromBuilderOpt.has_value());
489
490 expectEqualField(expected, *fromSleOpt, "sfIssuerKeyEpoch");
491 expectEqualField(expected, *fromBuilderOpt, "sfIssuerKeyEpoch");
492 }
493
494 {
495 auto const& expected = auditorKeyEpochValue;
496
497 auto const fromSleOpt = entryFromSle.getAuditorKeyEpoch();
498 auto const fromBuilderOpt = entryFromBuilder.getAuditorKeyEpoch();
499
500 ASSERT_TRUE(fromSleOpt.has_value());
501 ASSERT_TRUE(fromBuilderOpt.has_value());
502
503 expectEqualField(expected, *fromSleOpt, "sfAuditorKeyEpoch");
504 expectEqualField(expected, *fromBuilderOpt, "sfAuditorKeyEpoch");
505 }
506
507 {
508 auto const& expected = initialIssuerEncryptionKeyValue;
509
510 auto const fromSleOpt = entryFromSle.getInitialIssuerEncryptionKey();
511 auto const fromBuilderOpt = entryFromBuilder.getInitialIssuerEncryptionKey();
512
513 ASSERT_TRUE(fromSleOpt.has_value());
514 ASSERT_TRUE(fromBuilderOpt.has_value());
515
516 expectEqualField(expected, *fromSleOpt, "sfInitialIssuerEncryptionKey");
517 expectEqualField(expected, *fromBuilderOpt, "sfInitialIssuerEncryptionKey");
518 }
519
520 {
521 auto const& expected = confidentialOutstandingAmountValue;
522
523 auto const fromSleOpt = entryFromSle.getConfidentialOutstandingAmount();
524 auto const fromBuilderOpt = entryFromBuilder.getConfidentialOutstandingAmount();
525
526 ASSERT_TRUE(fromSleOpt.has_value());
527 ASSERT_TRUE(fromBuilderOpt.has_value());
528
529 expectEqualField(expected, *fromSleOpt, "sfConfidentialOutstandingAmount");
530 expectEqualField(expected, *fromBuilderOpt, "sfConfidentialOutstandingAmount");
531 }
532
533 EXPECT_EQ(entryFromSle.getKey(), index);
534 EXPECT_EQ(entryFromBuilder.getKey(), index);
535}
536
537// 3) Verify wrapper throws when constructed from wrong ledger entry type.
538TEST(MPTokenIssuanceTests, WrapperThrowsOnWrongEntryType)
539{
540 UInt256 const index{3u};
541
542 // Build a valid ledger entry of a different type
543 // Ticket requires: Account, OwnerNode, TicketSequence, PreviousTxnID, PreviousTxnLgrSeq
544 // Check requires: Account, Destination, SendMax, Sequence, OwnerNode, DestinationNode, PreviousTxnID, PreviousTxnLgrSeq
545 TicketBuilder wrongBuilder{
551 auto wrongEntry = wrongBuilder.build(index);
552
553 EXPECT_THROW(MPTokenIssuance{wrongEntry.getSle()}, std::runtime_error);
554}
555
556// 4) Verify builder throws when constructed from wrong ledger entry type.
557TEST(MPTokenIssuanceTests, BuilderThrowsOnWrongEntryType)
558{
559 UInt256 const index{4u};
560
561 // Build a valid ledger entry of a different type
562 TicketBuilder wrongBuilder{
568 auto wrongEntry = wrongBuilder.build(index);
569
570 EXPECT_THROW(MPTokenIssuanceBuilder{wrongEntry.getSle()}, std::runtime_error);
571}
572
573// 5) Build with only required fields and verify optional fields return nullopt.
574TEST(MPTokenIssuanceTests, OptionalFieldsReturnNullopt)
575{
576 UInt256 const index{3u};
577
578 auto const issuerValue = canonical_ACCOUNT();
579 auto const sequenceValue = canonical_UINT32();
580 auto const ownerNodeValue = canonical_UINT64();
581 auto const outstandingAmountValue = canonical_UINT64();
582 auto const previousTxnIDValue = canonical_UINT256();
583 auto const previousTxnLgrSeqValue = canonical_UINT32();
584
586 issuerValue,
587 sequenceValue,
588 ownerNodeValue,
589 outstandingAmountValue,
590 previousTxnIDValue,
591 previousTxnLgrSeqValue
592 };
593
594 auto const entry = builder.build(index);
595
596 // Verify optional fields are not present
597 EXPECT_FALSE(entry.hasTransferFee());
598 EXPECT_FALSE(entry.getTransferFee().has_value());
599 EXPECT_FALSE(entry.hasAssetScale());
600 EXPECT_FALSE(entry.getAssetScale().has_value());
601 EXPECT_FALSE(entry.hasMaximumAmount());
602 EXPECT_FALSE(entry.getMaximumAmount().has_value());
603 EXPECT_FALSE(entry.hasLockedAmount());
604 EXPECT_FALSE(entry.getLockedAmount().has_value());
605 EXPECT_FALSE(entry.hasMPTokenMetadata());
606 EXPECT_FALSE(entry.getMPTokenMetadata().has_value());
607 EXPECT_FALSE(entry.hasDomainID());
608 EXPECT_FALSE(entry.getDomainID().has_value());
609 EXPECT_FALSE(entry.hasImmutableFlags());
610 EXPECT_FALSE(entry.getImmutableFlags().has_value());
611 EXPECT_FALSE(entry.hasReferenceHolding());
612 EXPECT_FALSE(entry.getReferenceHolding().has_value());
613 EXPECT_FALSE(entry.hasIssuerEncryptionKey());
614 EXPECT_FALSE(entry.getIssuerEncryptionKey().has_value());
615 EXPECT_FALSE(entry.hasAuditorEncryptionKey());
616 EXPECT_FALSE(entry.getAuditorEncryptionKey().has_value());
617 EXPECT_FALSE(entry.hasIssuerKeyEpoch());
618 EXPECT_FALSE(entry.getIssuerKeyEpoch().has_value());
619 EXPECT_FALSE(entry.hasAuditorKeyEpoch());
620 EXPECT_FALSE(entry.getAuditorKeyEpoch().has_value());
621 EXPECT_FALSE(entry.hasInitialIssuerEncryptionKey());
622 EXPECT_FALSE(entry.getInitialIssuerEncryptionKey().has_value());
623 EXPECT_FALSE(entry.hasConfidentialOutstandingAmount());
624 EXPECT_FALSE(entry.getConfidentialOutstandingAmount().has_value());
625}
626}
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 MPTokenIssuance ledger entries.
MPTokenIssuanceBuilder & setImmutableFlags(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfImmutableFlags (SoeDefault).
MPTokenIssuanceBuilder & setInitialIssuerEncryptionKey(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfInitialIssuerEncryptionKey (SoeOptional).
MPTokenIssuanceBuilder & setIssuerEncryptionKey(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfIssuerEncryptionKey (SoeOptional).
MPTokenIssuanceBuilder & setAuditorEncryptionKey(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfAuditorEncryptionKey (SoeOptional).
MPTokenIssuanceBuilder & setLockedAmount(std::decay_t< typename SF_UINT64::type::value_type > const &value)
Set sfLockedAmount (SoeOptional).
MPTokenIssuanceBuilder & setMaximumAmount(std::decay_t< typename SF_UINT64::type::value_type > const &value)
Set sfMaximumAmount (SoeOptional).
MPTokenIssuanceBuilder & setDomainID(std::decay_t< typename SF_UINT256::type::value_type > const &value)
Set sfDomainID (SoeOptional).
MPTokenIssuanceBuilder & setTransferFee(std::decay_t< typename SF_UINT16::type::value_type > const &value)
Set sfTransferFee (SoeDefault).
MPTokenIssuanceBuilder & setConfidentialOutstandingAmount(std::decay_t< typename SF_UINT64::type::value_type > const &value)
Set sfConfidentialOutstandingAmount (SoeDefault).
MPTokenIssuanceBuilder & setMPTokenMetadata(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfMPTokenMetadata (SoeOptional).
MPTokenIssuanceBuilder & setAssetScale(std::decay_t< typename SF_UINT8::type::value_type > const &value)
Set sfAssetScale (SoeDefault).
MPTokenIssuanceBuilder & setIssuerKeyEpoch(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfIssuerKeyEpoch (SoeOptional).
MPTokenIssuanceBuilder & setAuditorKeyEpoch(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfAuditorKeyEpoch (SoeOptional).
MPTokenIssuanceBuilder & setReferenceHolding(std::decay_t< typename SF_UINT256::type::value_type > const &value)
Set sfReferenceHolding (SoeOptional).
MPTokenIssuance build(UInt256 const &index)
Build and return the completed MPTokenIssuance wrapper.
Ledger Entry: MPTokenIssuance.
protocol_autogen::Optional< SF_UINT64::type::value_type > getMaximumAmount() const
Get sfMaximumAmount (SoeOptional).
SF_UINT64::type::value_type getOutstandingAmount() const
Get sfOutstandingAmount (SoeRequired).
protocol_autogen::Optional< SF_UINT8::type::value_type > getAssetScale() const
Get sfAssetScale (SoeDefault).
protocol_autogen::Optional< SF_UINT32::type::value_type > getAuditorKeyEpoch() const
Get sfAuditorKeyEpoch (SoeOptional).
protocol_autogen::Optional< SF_UINT64::type::value_type > getLockedAmount() const
Get sfLockedAmount (SoeOptional).
protocol_autogen::Optional< SF_UINT256::type::value_type > getDomainID() const
Get sfDomainID (SoeOptional).
SF_ACCOUNT::type::value_type getIssuer() const
Get sfIssuer (SoeRequired).
protocol_autogen::Optional< SF_UINT32::type::value_type > getImmutableFlags() const
Get sfImmutableFlags (SoeDefault).
protocol_autogen::Optional< SF_VL::type::value_type > getAuditorEncryptionKey() const
Get sfAuditorEncryptionKey (SoeOptional).
SF_UINT32::type::value_type getSequence() const
Get sfSequence (SoeRequired).
protocol_autogen::Optional< SF_UINT256::type::value_type > getReferenceHolding() const
Get sfReferenceHolding (SoeOptional).
SF_UINT256::type::value_type getPreviousTxnID() const
Get sfPreviousTxnID (SoeRequired).
SF_UINT64::type::value_type getOwnerNode() const
Get sfOwnerNode (SoeRequired).
protocol_autogen::Optional< SF_UINT32::type::value_type > getIssuerKeyEpoch() const
Get sfIssuerKeyEpoch (SoeOptional).
protocol_autogen::Optional< SF_VL::type::value_type > getInitialIssuerEncryptionKey() const
Get sfInitialIssuerEncryptionKey (SoeOptional).
protocol_autogen::Optional< SF_VL::type::value_type > getIssuerEncryptionKey() const
Get sfIssuerEncryptionKey (SoeOptional).
protocol_autogen::Optional< SF_UINT64::type::value_type > getConfidentialOutstandingAmount() const
Get sfConfidentialOutstandingAmount (SoeDefault).
protocol_autogen::Optional< SF_VL::type::value_type > getMPTokenMetadata() const
Get sfMPTokenMetadata (SoeOptional).
protocol_autogen::Optional< SF_UINT16::type::value_type > getTransferFee() const
Get sfTransferFee (SoeDefault).
SF_UINT32::type::value_type getPreviousTxnLgrSeq() const
Get sfPreviousTxnLgrSeq (SoeRequired).
static constexpr LedgerEntryType entryType
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)