rippled
GRPCHelpers.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2020 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #include <ripple/rpc/impl/GRPCHelpers.h>
21 
22 namespace ripple {
23 namespace RPC {
24 
25 // In the below populateProto* functions, getProto is a function that returns
26 // a reference to the mutable protobuf message to be populated. The reason this
27 // is a function, as opposed to just a pointer or reference to the object,
28 // is that there is no way to get a non-const reference, and getting a pointer
29 // to the proto object causes default initialization of the object. However,
30 // if the corresponding field is not present in the STObject, we don't want to
31 // initialize the proto object. To get around this, getProto is a function that
32 // is called only if the field is present in the STObject
33 template <class T, class L>
34 void
35 populateProtoPrimitive(
36  L const& getProto,
37  STObject const& from,
38  TypedField<T> const& field)
39 {
40  if (!from.isFieldPresent(field))
41  return;
42 
43  if constexpr (std::is_integral_v<typename T::value_type>)
44  {
45  getProto()->set_value(from[field]);
46  }
47  else
48  {
49  auto v = from[field];
50  getProto()->set_value(v.data(), v.size());
51  }
52 }
53 
54 template <class T>
55 void
56 populateProtoVLasString(
57  T const& getProto,
58  STObject const& from,
59  SF_VL const& field)
60 {
61  if (from.isFieldPresent(field))
62  {
63  auto data = from.getFieldVL(field);
64  getProto()->set_value(
65  reinterpret_cast<const char*>(data.data()), data.size());
66  }
67 }
68 
69 template <class T>
70 void
71 populateProtoVec256(
72  T const& getProto,
73  STObject const& from,
74  SF_VECTOR256 const& field)
75 {
76  if (from.isFieldPresent(field))
77  {
78  const STVector256& vec = from.getFieldV256(field);
79  for (size_t i = 0; i < vec.size(); ++i)
80  {
81  uint256 const& elt = vec[i];
82  getProto()->set_value(elt.data(), elt.size());
83  }
84  }
85 }
86 
87 template <class T>
88 void
89 populateProtoAccount(
90  T const& getProto,
91  STObject const& from,
92  SF_ACCOUNT const& field)
93 {
94  if (from.isFieldPresent(field))
95  {
96  getProto()->mutable_value()->set_address(
97  toBase58(from.getAccountID(field)));
98  }
99 }
100 
101 template <class T>
102 void
103 populateProtoAmount(
104  T const& getProto,
105  STObject const& from,
106  SF_AMOUNT const& field)
107 {
108  if (from.isFieldPresent(field))
109  {
110  auto amount = from.getFieldAmount(field);
111  convert(*getProto(), amount);
112  }
113 }
114 
115 template <class T>
116 void
117 populateProtoCurrency(
118  T const& getProto,
119  STObject const& from,
120  SF_UINT160 const& field)
121 {
122  if (from.isFieldPresent(field))
123  {
124  auto cur = from.getFieldH160(field);
125  auto proto = getProto()->mutable_value();
126  proto->set_code(cur.data(), cur.size());
127  proto->set_name(to_string(cur));
128  }
129 }
130 
131 template <class T, class R>
132 void
133 populateProtoArray(
134  T const& getProto,
135  R const& populateProto,
136  STObject const& from,
137  SField const& outerField,
138  SField const& innerField)
139 {
140  if (from.isFieldPresent(outerField) &&
141  from.peekAtField(outerField).getSType() == SerializedTypeID::STI_ARRAY)
142  {
143  auto arr = from.getFieldArray(outerField);
144  for (auto it = arr.begin(); it != arr.end(); ++it)
145  {
146  populateProto(*it, *getProto());
147  }
148  }
149 }
150 
151 template <class T>
152 void
153 populateClearFlag(T& to, STObject const& from)
154 {
155  populateProtoPrimitive(
156  [&to]() { return to.mutable_clear_flag(); }, from, sfClearFlag);
157 }
158 
159 template <class T>
160 void
161 populateDomain(T& to, STObject const& from)
162 {
163  populateProtoVLasString(
164  [&to]() { return to.mutable_domain(); }, from, sfDomain);
165 }
166 
167 template <class T>
168 void
169 populateEmailHash(T& to, STObject const& from)
170 {
171  populateProtoPrimitive(
172  [&to]() { return to.mutable_email_hash(); }, from, sfEmailHash);
173 }
174 
175 template <class T>
176 void
177 populateMessageKey(T& to, STObject const& from)
178 {
179  populateProtoPrimitive(
180  [&to]() { return to.mutable_message_key(); }, from, sfMessageKey);
181 }
182 
183 template <class T>
184 void
185 populateSetFlag(T& to, STObject const& from)
186 {
187  populateProtoPrimitive(
188  [&to]() { return to.mutable_set_flag(); }, from, sfSetFlag);
189 }
190 
191 template <class T>
192 void
193 populateTransferRate(T& to, STObject const& from)
194 {
195  populateProtoPrimitive(
196  [&to]() { return to.mutable_transfer_rate(); }, from, sfTransferRate);
197 }
198 
199 template <class T>
200 void
201 populateTickSize(T& to, STObject const& from)
202 {
203  populateProtoPrimitive(
204  [&to]() { return to.mutable_tick_size(); }, from, sfTickSize);
205 }
206 
207 template <class T>
208 void
209 populateExpiration(T& to, STObject const& from)
210 {
211  populateProtoPrimitive(
212  [&to]() { return to.mutable_expiration(); }, from, sfExpiration);
213 }
214 
215 template <class T>
216 void
217 populateOfferSequence(T& to, STObject const& from)
218 {
219  populateProtoPrimitive(
220  [&to]() { return to.mutable_offer_sequence(); }, from, sfOfferSequence);
221 }
222 
223 template <class T>
224 void
225 populateTakerGets(T& to, STObject const& from)
226 {
227  populateProtoAmount(
228  [&to]() { return to.mutable_taker_gets(); }, from, sfTakerGets);
229 }
230 
231 template <class T>
232 void
233 populateTakerPays(T& to, STObject const& from)
234 {
235  populateProtoAmount(
236  [&to]() { return to.mutable_taker_pays(); }, from, sfTakerPays);
237 }
238 
239 template <class T>
240 void
241 populateDestination(T& to, STObject const& from)
242 {
243  populateProtoAccount(
244  [&to]() { return to.mutable_destination(); }, from, sfDestination);
245 }
246 
247 template <class T>
248 void
249 populateCheckID(T& to, STObject const& from)
250 {
251  populateProtoPrimitive(
252  [&to]() { return to.mutable_check_id(); }, from, sfCheckID);
253 }
254 
255 template <class T>
256 void
257 populateAmount(T& to, STObject const& from)
258 {
259  populateProtoAmount(
260  [&to]() { return to.mutable_amount(); }, from, sfAmount);
261 }
262 
263 template <class T>
264 void
265 populateDeliverMin(T& to, STObject const& from)
266 {
267  populateProtoAmount(
268  [&to]() { return to.mutable_deliver_min(); }, from, sfDeliverMin);
269 }
270 
271 template <class T>
272 void
273 populateSendMax(T& to, STObject const& from)
274 {
275  populateProtoAmount(
276  [&to]() { return to.mutable_send_max(); }, from, sfSendMax);
277 }
278 
279 template <class T>
280 void
281 populateDeliveredAmount(T& to, STObject const& from)
282 {
283  populateProtoAmount(
284  [&to]() { return to.mutable_delivered_amount(); },
285  from,
286  sfDeliveredAmount);
287 }
288 
289 template <class T>
290 void
291 populateDestinationTag(T& to, STObject const& from)
292 {
293  populateProtoPrimitive(
294  [&to]() { return to.mutable_destination_tag(); },
295  from,
296  sfDestinationTag);
297 }
298 
299 template <class T>
300 void
301 populateInvoiceID(T& to, STObject const& from)
302 {
303  populateProtoPrimitive(
304  [&to]() { return to.mutable_invoice_id(); }, from, sfInvoiceID);
305 }
306 
307 template <class T>
308 void
309 populateAuthorize(T& to, STObject const& from)
310 {
311  populateProtoAccount(
312  [&to]() { return to.mutable_authorize(); }, from, sfAuthorize);
313 }
314 
315 template <class T>
316 void
317 populateUnauthorize(T& to, STObject const& from)
318 {
319  populateProtoAccount(
320  [&to]() { return to.mutable_unauthorize(); }, from, sfUnauthorize);
321 }
322 
323 template <class T>
324 void
325 populateOwner(T& to, STObject const& from)
326 {
327  populateProtoAccount([&to]() { return to.mutable_owner(); }, from, sfOwner);
328 }
329 
330 template <class T>
331 void
332 populateCancelAfter(T& to, STObject const& from)
333 {
334  populateProtoPrimitive(
335  [&to]() { return to.mutable_cancel_after(); }, from, sfCancelAfter);
336 }
337 
338 template <class T>
339 void
340 populateFinishAfter(T& to, STObject const& from)
341 {
342  populateProtoPrimitive(
343  [&to]() { return to.mutable_finish_after(); }, from, sfFinishAfter);
344 }
345 
346 template <class T>
347 void
348 populateCondition(T& to, STObject const& from)
349 {
350  populateProtoPrimitive(
351  [&to]() { return to.mutable_condition(); }, from, sfCondition);
352 }
353 
354 template <class T>
355 void
356 populateFulfillment(T& to, STObject const& from)
357 {
358  populateProtoPrimitive(
359  [&to]() { return to.mutable_fulfillment(); }, from, sfFulfillment);
360 }
361 
362 template <class T>
363 void
364 populateChannel(T& to, STObject const& from)
365 {
366  populateProtoPrimitive(
367  [&to]() { return to.mutable_channel(); }, from, sfChannel);
368 }
369 
370 template <class T>
371 void
372 populateBalance(T& to, STObject const& from)
373 {
374  populateProtoAmount(
375  [&to]() { return to.mutable_balance(); }, from, sfBalance);
376 }
377 
378 template <class T>
379 void
380 populatePaymentChannelSignature(T& to, STObject const& from)
381 {
382  populateProtoPrimitive(
383  [&to]() { return to.mutable_payment_channel_signature(); },
384  from,
385  sfSignature);
386 }
387 
388 template <class T>
389 void
390 populatePublicKey(T& to, STObject const& from)
391 {
392  populateProtoPrimitive(
393  [&to]() { return to.mutable_public_key(); }, from, sfPublicKey);
394 }
395 
396 template <class T>
397 void
398 populateSettleDelay(T& to, STObject const& from)
399 {
400  populateProtoPrimitive(
401  [&to]() { return to.mutable_settle_delay(); }, from, sfSettleDelay);
402 }
403 
404 template <class T>
405 void
406 populateRegularKey(T& to, STObject const& from)
407 {
408  populateProtoAccount(
409  [&to]() { return to.mutable_regular_key(); }, from, sfRegularKey);
410 }
411 
412 template <class T>
413 void
414 populateSignerQuorum(T& to, STObject const& from)
415 {
416  populateProtoPrimitive(
417  [&to]() { return to.mutable_signer_quorum(); }, from, sfSignerQuorum);
418 }
419 
420 template <class T>
421 void
422 populateTicketCount(T& to, STObject const& from)
423 {
424  populateProtoPrimitive(
425  [&to]() { return to.mutable_count(); }, from, sfTicketCount);
426 }
427 
428 template <class T>
429 void
430 populateLimitAmount(T& to, STObject const& from)
431 {
432  populateProtoAmount(
433  [&to]() { return to.mutable_limit_amount(); }, from, sfLimitAmount);
434 }
435 template <class T>
436 void
437 populateQualityIn(T& to, STObject const& from)
438 {
439  populateProtoPrimitive(
440  [&to]() { return to.mutable_quality_in(); }, from, sfQualityIn);
441 }
442 
443 template <class T>
444 void
445 populateQualityOut(T& to, STObject const& from)
446 {
447  populateProtoPrimitive(
448  [&to]() { return to.mutable_quality_out(); }, from, sfQualityOut);
449 }
450 
451 template <class T>
452 void
453 populateAccount(T& to, STObject const& from)
454 {
455  populateProtoAccount(
456  [&to]() { return to.mutable_account(); }, from, sfAccount);
457 }
458 
459 template <class T>
460 void
461 populateFee(T& to, STObject const& from)
462 {
463  if (from.isFieldPresent(sfFee))
464  {
465  to.mutable_fee()->set_drops(from.getFieldAmount(sfFee).xrp().drops());
466  }
467 }
468 
469 template <class T>
470 void
471 populateSigningPublicKey(T& to, STObject const& from)
472 {
473  populateProtoPrimitive(
474  [&to]() { return to.mutable_signing_public_key(); },
475  from,
476  sfSigningPubKey);
477 }
478 
479 template <class T>
480 void
481 populateTransactionSignature(T& to, STObject const& from)
482 {
483  populateProtoPrimitive(
484  [&to]() { return to.mutable_transaction_signature(); },
485  from,
486  sfTxnSignature);
487 }
488 
489 template <class T>
490 void
491 populateFlags(T& to, STObject const& from)
492 {
493  populateProtoPrimitive(
494  [&to]() { return to.mutable_flags(); }, from, sfFlags);
495 }
496 
497 template <class T>
498 void
499 populateFirstLedgerSequence(T& to, STObject const& from)
500 {
501  populateProtoPrimitive(
502  [&to]() { return to.mutable_ledger_sequence(); },
503  from,
504  sfFirstLedgerSequence);
505 }
506 
507 template <class T>
508 void
509 populateValidatorToDisable(T& to, STObject const& from)
510 {
511  populateProtoPrimitive(
512  [&to]() { return to.mutable_validator_to_disable(); },
513  from,
514  sfValidatorToDisable);
515 }
516 
517 template <class T>
518 void
519 populateValidatorToReEnable(T& to, STObject const& from)
520 {
521  populateProtoPrimitive(
522  [&to]() { return to.mutable_validator_to_re_enable(); },
523  from,
524  sfValidatorToReEnable);
525 }
526 
527 template <class T>
528 void
529 populateLastLedgerSequence(T& to, STObject const& from)
530 {
531  populateProtoPrimitive(
532  [&to]() { return to.mutable_last_ledger_sequence(); },
533  from,
534  sfLastLedgerSequence);
535 }
536 
537 template <class T>
538 void
539 populateSourceTag(T& to, STObject const& from)
540 {
541  populateProtoPrimitive(
542  [&to]() { return to.mutable_source_tag(); }, from, sfSourceTag);
543 }
544 
545 template <class T>
546 void
547 populateAccountTransactionID(T& to, STObject const& from)
548 {
549  populateProtoPrimitive(
550  [&to]() { return to.mutable_account_transaction_id(); },
551  from,
552  sfAccountTxnID);
553 }
554 
555 template <class T>
556 void
557 populateMemoData(T& to, STObject const& from)
558 {
559  populateProtoPrimitive(
560  [&to]() { return to.mutable_memo_data(); }, from, sfMemoData);
561 }
562 
563 template <class T>
564 void
565 populateMemoFormat(T& to, STObject const& from)
566 {
567  populateProtoPrimitive(
568  [&to]() { return to.mutable_memo_format(); }, from, sfMemoFormat);
569 }
570 
571 template <class T>
572 void
573 populateMemoType(T& to, STObject const& from)
574 {
575  populateProtoPrimitive(
576  [&to]() { return to.mutable_memo_type(); }, from, sfMemoType);
577 }
578 
579 template <class T>
580 void
581 populateSequence(T& to, STObject const& from)
582 {
583  populateProtoPrimitive(
584  [&to]() { return to.mutable_sequence(); }, from, sfSequence);
585 }
586 
587 template <class T>
588 void
589 populateAmendment(T& to, STObject const& from)
590 {
591  populateProtoPrimitive(
592  [&to]() { return to.mutable_amendment(); }, from, sfAmendment);
593 }
594 
595 template <class T>
596 void
597 populateCloseTime(T& to, STObject const& from)
598 {
599  populateProtoPrimitive(
600  [&to]() { return to.mutable_close_time(); }, from, sfCloseTime);
601 }
602 
603 template <class T>
604 void
605 populateSignerWeight(T& to, STObject const& from)
606 {
607  populateProtoPrimitive(
608  [&to]() { return to.mutable_signer_weight(); }, from, sfSignerWeight);
609 }
610 
611 template <class T>
612 void
613 populateAmendments(T& to, STObject const& from)
614 {
615  populateProtoVec256(
616  [&to]() { return to.add_amendments(); }, from, sfAmendments);
617 }
618 
619 template <class T>
620 void
621 populateOwnerCount(T& to, STObject const& from)
622 {
623  populateProtoPrimitive(
624  [&to]() { return to.mutable_owner_count(); }, from, sfOwnerCount);
625 }
626 
627 template <class T>
628 void
629 populatePreviousTransactionID(T& to, STObject const& from)
630 {
631  populateProtoPrimitive(
632  [&to]() { return to.mutable_previous_transaction_id(); },
633  from,
634  sfPreviousTxnID);
635 }
636 
637 template <class T>
638 void
639 populatePreviousTransactionLedgerSequence(T& to, STObject const& from)
640 {
641  populateProtoPrimitive(
642  [&to]() { return to.mutable_previous_transaction_ledger_sequence(); },
643  from,
644  sfPreviousTxnLgrSeq);
645 }
646 
647 template <class T>
648 void
649 populateLowLimit(T& to, STObject const& from)
650 {
651  populateProtoAmount(
652  [&to]() { return to.mutable_low_limit(); }, from, sfLowLimit);
653 }
654 
655 template <class T>
656 void
657 populateHighLimit(T& to, STObject const& from)
658 {
659  populateProtoAmount(
660  [&to]() { return to.mutable_high_limit(); }, from, sfHighLimit);
661 }
662 
663 template <class T>
664 void
665 populateLowNode(T& to, STObject const& from)
666 {
667  populateProtoPrimitive(
668  [&to]() { return to.mutable_low_node(); }, from, sfLowNode);
669 }
670 
671 template <class T>
672 void
673 populateHighNode(T& to, STObject const& from)
674 {
675  populateProtoPrimitive(
676  [&to]() { return to.mutable_high_node(); }, from, sfHighNode);
677 }
678 
679 template <class T>
680 void
681 populateLowQualityIn(T& to, STObject const& from)
682 {
683  populateProtoPrimitive(
684  [&to]() { return to.mutable_low_quality_in(); }, from, sfLowQualityIn);
685 }
686 
687 template <class T>
688 void
689 populateLowQualityOut(T& to, STObject const& from)
690 {
691  populateProtoPrimitive(
692  [&to]() { return to.mutable_low_quality_out(); },
693  from,
694  sfLowQualityOut);
695 }
696 
697 template <class T>
698 void
699 populateHighQualityIn(T& to, STObject const& from)
700 {
701  populateProtoPrimitive(
702  [&to]() { return to.mutable_high_quality_in(); },
703  from,
704  sfHighQualityIn);
705 }
706 
707 template <class T>
708 void
709 populateHighQualityOut(T& to, STObject const& from)
710 {
711  populateProtoPrimitive(
712  [&to]() { return to.mutable_high_quality_out(); },
713  from,
714  sfHighQualityOut);
715 }
716 
717 template <class T>
718 void
719 populateBookDirectory(T& to, STObject const& from)
720 {
721  populateProtoPrimitive(
722  [&to]() { return to.mutable_book_directory(); }, from, sfBookDirectory);
723 }
724 
725 template <class T>
726 void
727 populateBookNode(T& to, STObject const& from)
728 {
729  populateProtoPrimitive(
730  [&to]() { return to.mutable_book_node(); }, from, sfBookNode);
731 }
732 
733 template <class T>
734 void
735 populateOwnerNode(T& to, STObject const& from)
736 {
737  populateProtoPrimitive(
738  [&to]() { return to.mutable_owner_node(); }, from, sfOwnerNode);
739 }
740 
741 template <class T>
742 void
743 populateSignerListID(T& to, STObject const& from)
744 {
745  populateProtoPrimitive(
746  [&to]() { return to.mutable_signer_list_id(); }, from, sfSignerListID);
747 }
748 
749 template <class T>
750 void
751 populateWalletLocator(T& to, STObject const& from)
752 {
753  populateProtoPrimitive(
754  [&to]() { return to.mutable_wallet_locator(); }, from, sfWalletLocator);
755 }
756 
757 template <class T>
758 void
759 populateTicketSequence(T& to, STObject const& from)
760 {
761  populateProtoPrimitive(
762  [&to]() { return to.mutable_ticket_sequence(); },
763  from,
764  sfTicketSequence);
765 }
766 
767 template <class T>
768 void
769 populateHashes(T& to, STObject const& from)
770 {
771  populateProtoVec256([&to]() { return to.add_hashes(); }, from, sfHashes);
772 }
773 
774 template <class T>
775 void
776 populateIndexes(T& to, STObject const& from)
777 {
778  populateProtoVec256([&to]() { return to.add_indexes(); }, from, sfIndexes);
779 }
780 
781 template <class T>
782 void
783 populateNFTokenOffers(T& to, STObject const& from)
784 {
785  populateProtoVec256(
786  [&to]() { return to.add_nftoken_offers(); }, from, sfNFTokenOffers);
787 }
788 
789 template <class T>
790 void
791 populateRootIndex(T& to, STObject const& from)
792 {
793  populateProtoPrimitive(
794  [&to]() { return to.mutable_root_index(); }, from, sfRootIndex);
795 }
796 
797 template <class T>
798 void
799 populateIndexNext(T& to, STObject const& from)
800 {
801  populateProtoPrimitive(
802  [&to]() { return to.mutable_index_next(); }, from, sfIndexNext);
803 }
804 
805 template <class T>
806 void
807 populateIndexPrevious(T& to, STObject const& from)
808 {
809  populateProtoPrimitive(
810  [&to]() { return to.mutable_index_previous(); }, from, sfIndexPrevious);
811 }
812 
813 template <class T>
814 void
815 populateTakerPaysCurrency(T& to, STObject const& from)
816 {
817  populateProtoCurrency(
818  [&to]() { return to.mutable_taker_pays_currency(); },
819  from,
820  sfTakerPaysCurrency);
821 }
822 
823 template <class T>
824 void
825 populateTakerPaysIssuer(T& to, STObject const& from)
826 {
827  populateProtoPrimitive(
828  [&to]() { return to.mutable_taker_pays_issuer(); },
829  from,
830  sfTakerPaysIssuer);
831 }
832 
833 template <class T>
834 void
835 populateTakerGetsCurrency(T& to, STObject const& from)
836 {
837  populateProtoCurrency(
838  [&to]() { return to.mutable_taker_gets_currency(); },
839  from,
840  sfTakerGetsCurrency);
841 }
842 
843 template <class T>
844 void
845 populateTakerGetsIssuer(T& to, STObject const& from)
846 {
847  populateProtoPrimitive(
848  [&to]() { return to.mutable_taker_gets_issuer(); },
849  from,
850  sfTakerGetsIssuer);
851 }
852 
853 template <class T>
854 void
855 populateDestinationNode(T& to, STObject const& from)
856 {
857  populateProtoPrimitive(
858  [&to]() { return to.mutable_destination_node(); },
859  from,
860  sfDestinationNode);
861 }
862 
863 template <class T>
864 void
865 populateBaseFee(T& to, STObject const& from)
866 {
867  populateProtoPrimitive(
868  [&to]() { return to.mutable_base_fee(); }, from, sfBaseFee);
869 }
870 
871 template <class T>
872 void
873 populateReferenceFeeUnits(T& to, STObject const& from)
874 {
875  populateProtoPrimitive(
876  [&to]() { return to.mutable_reference_fee_units(); },
877  from,
878  sfReferenceFeeUnits);
879 }
880 
881 template <class T>
882 void
883 populatePreviousPageMin(T& to, STObject const& from)
884 {
885  populateProtoPrimitive(
886  [&to]() { return to.mutable_previous_page_min(); },
887  from,
888  sfPreviousPageMin);
889 }
890 
891 template <class T>
892 void
893 populateNextPageMin(T& to, STObject const& from)
894 {
895  populateProtoPrimitive(
896  [&to]() { return to.mutable_next_page_min(); }, from, sfNextPageMin);
897 }
898 
899 template <class T>
900 void
901 populateNFTokenID(T& to, STObject const& from)
902 {
903  populateProtoPrimitive(
904  [&to]() { return to.mutable_nftoken_id(); }, from, sfNFTokenID);
905 }
906 
907 template <class T>
908 void
909 populateURI(T& to, STObject const& from)
910 {
911  populateProtoVLasString([&to]() { return to.mutable_uri(); }, from, sfURI);
912 }
913 
914 template <class T>
915 void
916 populateBurnedNFTokens(T& to, STObject const& from)
917 {
918  populateProtoPrimitive(
919  [&to]() { return to.mutable_burned_nftokens(); },
920  from,
921  sfBurnedNFTokens);
922 }
923 
924 template <class T>
925 void
926 populateMintedNFTokens(T& to, STObject const& from)
927 {
928  populateProtoPrimitive(
929  [&to]() { return to.mutable_minted_nftokens(); },
930  from,
931  sfMintedNFTokens);
932 }
933 
934 template <class T>
935 void
936 populateNFTokenMinter(T& to, STObject const& from)
937 {
938  populateProtoAccount(
939  [&to]() { return to.mutable_nftoken_minter(); }, from, sfNFTokenMinter);
940 }
941 
942 template <class T>
943 void
944 populateNFTokenBrokerFee(T& to, STObject const& from)
945 {
946  populateProtoAmount(
947  [&to]() { return to.mutable_nftoken_broker_fee(); },
948  from,
949  sfNFTokenBrokerFee);
950 }
951 
952 template <class T>
953 void
954 populateNFTokenBuyOffer(T& to, STObject const& from)
955 {
956  populateProtoPrimitive(
957  [&to]() { return to.mutable_nftoken_buy_offer(); },
958  from,
959  sfNFTokenBuyOffer);
960 }
961 
962 template <class T>
963 void
964 populateNFTokenSellOffer(T& to, STObject const& from)
965 {
966  populateProtoPrimitive(
967  [&to]() { return to.mutable_nftoken_sell_offer(); },
968  from,
969  sfNFTokenSellOffer);
970 }
971 
972 template <class T>
973 void
974 populateIssuer(T& to, STObject const& from)
975 {
976  populateProtoAccount(
977  [&to]() { return to.mutable_issuer(); }, from, sfIssuer);
978 }
979 
980 template <class T>
981 void
982 populateNFTokenTaxon(T& to, STObject const& from)
983 {
984  populateProtoPrimitive(
985  [&to]() { return to.mutable_nftoken_taxon(); }, from, sfNFTokenTaxon);
986 }
987 
988 template <class T>
989 void
990 populateTransferFee(T& to, STObject const& from)
991 {
992  populateProtoPrimitive(
993  [&to]() { return to.mutable_transfer_fee(); }, from, sfTransferFee);
994 }
995 
996 template <class T>
997 void
998 populateReserveBase(T& to, STObject const& from)
999 {
1000  populateProtoPrimitive(
1001  [&to]() { return to.mutable_reserve_base(); }, from, sfReserveBase);
1002 }
1003 
1004 template <class T>
1005 void
1006 populateReserveIncrement(T& to, STObject const& from)
1007 {
1008  populateProtoPrimitive(
1009  [&to]() { return to.mutable_reserve_increment(); },
1010  from,
1011  sfReserveIncrement);
1012 }
1013 
1014 template <class T>
1015 void
1016 populateSignerEntries(T& to, STObject const& from)
1017 {
1018  populateProtoArray(
1019  [&to]() { return to.add_signer_entries(); },
1020  [](auto& innerObj, auto& innerProto) {
1021  populateAccount(innerProto, innerObj);
1022  populateSignerWeight(innerProto, innerObj);
1023  populateWalletLocator(innerProto, innerObj);
1024  },
1025  from,
1026  sfSignerEntries,
1027  sfSignerEntry);
1028 }
1029 
1030 template <class T>
1031 void
1032 populateDisabledValidators(T& to, STObject const& from)
1033 {
1034  populateProtoArray(
1035  [&to]() { return to.add_disabled_validators(); },
1036  [](auto& innerObj, auto& innerProto) {
1037  populatePublicKey(innerProto, innerObj);
1038  populateFirstLedgerSequence(innerProto, innerObj);
1039  },
1040  from,
1041  sfDisabledValidators,
1042  sfDisabledValidator);
1043 }
1044 
1045 template <class T>
1046 void
1047 populateMemos(T& to, STObject const& from)
1048 {
1049  populateProtoArray(
1050  [&to]() { return to.add_memos(); },
1051  [](auto& innerObj, auto& innerProto) {
1052  populateMemoData(innerProto, innerObj);
1053  populateMemoType(innerProto, innerObj);
1054  populateMemoFormat(innerProto, innerObj);
1055  },
1056  from,
1057  sfMemos,
1058  sfMemo);
1059 }
1060 
1061 template <class T>
1062 void
1063 populateSigners(T& to, STObject const& from)
1064 {
1065  populateProtoArray(
1066  [&to]() { return to.add_signers(); },
1067  [](auto& innerObj, auto& innerProto) {
1068  populateAccount(innerProto, innerObj);
1069  populateTransactionSignature(innerProto, innerObj);
1070  populateSigningPublicKey(innerProto, innerObj);
1071  },
1072  from,
1073  sfSigners,
1074  sfSigner);
1075 }
1076 
1077 template <class T>
1078 void
1079 populateMajorities(T& to, STObject const& from)
1080 {
1081  populateProtoArray(
1082  [&to]() { return to.add_majorities(); },
1083  [](auto innerObj, auto innerProto) {
1084  populateAmendment(innerProto, innerObj);
1085  populateCloseTime(innerProto, innerObj);
1086  },
1087  from,
1088  sfMajorities,
1089  sfMajority);
1090 }
1091 
1092 template <class T>
1093 void
1094 populateNFTokens(T& to, STObject const& from)
1095 {
1096  populateProtoArray(
1097  [&to]() { return to.add_nftokens(); },
1098  [](auto innerObj, auto innerProto) {
1099  populateNFTokenID(innerProto, innerObj);
1100  populateURI(innerProto, innerObj);
1101  },
1102  from,
1103  sfNFTokens,
1104  sfNFToken);
1105 }
1106 
1107 void
1108 convert(org::xrpl::rpc::v1::TransactionResult& to, TER from)
1109 {
1110  if (isTecClaim(from))
1111  {
1112  to.set_result_type(
1113  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEC);
1114  }
1115  if (isTefFailure(from))
1116  {
1117  to.set_result_type(
1118  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEF);
1119  }
1120  if (isTelLocal(from))
1121  {
1122  to.set_result_type(
1123  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEL);
1124  }
1125  if (isTemMalformed(from))
1126  {
1127  to.set_result_type(
1128  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEM);
1129  }
1130  if (isTerRetry(from))
1131  {
1132  to.set_result_type(
1133  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TER);
1134  }
1135  if (isTesSuccess(from))
1136  {
1137  to.set_result_type(
1138  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TES);
1139  }
1140 }
1141 
1142 void
1143 convert(org::xrpl::rpc::v1::AccountSet& to, STObject const& from)
1144 {
1145  populateClearFlag(to, from);
1146 
1147  populateDomain(to, from);
1148 
1149  populateEmailHash(to, from);
1150 
1151  populateMessageKey(to, from);
1152 
1153  populateNFTokenMinter(to, from);
1154 
1155  populateSetFlag(to, from);
1156 
1157  populateTransferRate(to, from);
1158 
1159  populateTickSize(to, from);
1160 }
1161 
1162 void
1163 convert(org::xrpl::rpc::v1::OfferCreate& to, STObject const& from)
1164 {
1165  populateExpiration(to, from);
1166 
1167  populateOfferSequence(to, from);
1168 
1169  populateTakerGets(to, from);
1170 
1171  populateTakerPays(to, from);
1172 }
1173 
1174 void
1175 convert(org::xrpl::rpc::v1::OfferCancel& to, STObject const& from)
1176 {
1177  populateOfferSequence(to, from);
1178 }
1179 
1180 void
1181 convert(org::xrpl::rpc::v1::AccountDelete& to, STObject const& from)
1182 {
1183  populateDestination(to, from);
1184 }
1185 
1186 void
1187 convert(org::xrpl::rpc::v1::CheckCancel& to, STObject const& from)
1188 {
1189  populateCheckID(to, from);
1190 }
1191 
1192 void
1193 convert(org::xrpl::rpc::v1::CheckCash& to, STObject const& from)
1194 {
1195  populateCheckID(to, from);
1196 
1197  populateAmount(to, from);
1198 
1199  populateDeliverMin(to, from);
1200 }
1201 
1202 void
1203 convert(org::xrpl::rpc::v1::CheckCreate& to, STObject const& from)
1204 {
1205  populateDestination(to, from);
1206 
1207  populateSendMax(to, from);
1208 
1209  populateDestinationTag(to, from);
1210 
1211  populateExpiration(to, from);
1212 
1213  populateInvoiceID(to, from);
1214 }
1215 
1216 void
1217 convert(org::xrpl::rpc::v1::DepositPreauth& to, STObject const& from)
1218 {
1219  populateAuthorize(to, from);
1220 
1221  populateUnauthorize(to, from);
1222 }
1223 
1224 void
1225 convert(org::xrpl::rpc::v1::EscrowCancel& to, STObject const& from)
1226 {
1227  populateOwner(to, from);
1228 
1229  populateOfferSequence(to, from);
1230 }
1231 
1232 void
1233 convert(org::xrpl::rpc::v1::EscrowCreate& to, STObject const& from)
1234 {
1235  populateAmount(to, from);
1236 
1237  populateDestination(to, from);
1238 
1239  populateCancelAfter(to, from);
1240 
1241  populateFinishAfter(to, from);
1242 
1243  populateCondition(to, from);
1244 
1245  populateDestinationTag(to, from);
1246 }
1247 
1248 void
1249 convert(org::xrpl::rpc::v1::EscrowFinish& to, STObject const& from)
1250 {
1251  populateOwner(to, from);
1252 
1253  populateOfferSequence(to, from);
1254 
1255  populateCondition(to, from);
1256 
1257  populateFulfillment(to, from);
1258 }
1259 
1260 void
1261 convert(org::xrpl::rpc::v1::NFTokenAcceptOffer& to, STObject const& from)
1262 {
1263  populateNFTokenBrokerFee(to, from);
1264 
1265  populateNFTokenBuyOffer(to, from);
1266 
1267  populateNFTokenSellOffer(to, from);
1268 }
1269 
1270 void
1271 convert(org::xrpl::rpc::v1::NFTokenBurn& to, STObject const& from)
1272 {
1273  populateOwner(to, from);
1274 
1275  populateNFTokenID(to, from);
1276 }
1277 
1278 void
1279 convert(org::xrpl::rpc::v1::NFTokenCancelOffer& to, STObject const& from)
1280 {
1281  populateNFTokenOffers(to, from);
1282 }
1283 
1284 void
1285 convert(org::xrpl::rpc::v1::NFTokenCreateOffer& to, STObject const& from)
1286 {
1287  populateAmount(to, from);
1288 
1289  populateDestination(to, from);
1290 
1291  populateExpiration(to, from);
1292 
1293  populateOwner(to, from);
1294 
1295  populateNFTokenID(to, from);
1296 }
1297 
1298 void
1299 convert(org::xrpl::rpc::v1::NFTokenMint& to, STObject const& from)
1300 {
1301  populateIssuer(to, from);
1302 
1303  populateNFTokenTaxon(to, from);
1304 
1305  populateTransferFee(to, from);
1306 
1307  populateURI(to, from);
1308 }
1309 
1310 void
1311 convert(org::xrpl::rpc::v1::PaymentChannelClaim& to, STObject const& from)
1312 {
1313  populateChannel(to, from);
1314 
1315  populateBalance(to, from);
1316 
1317  populateAmount(to, from);
1318 
1319  populatePaymentChannelSignature(to, from);
1320 
1321  populatePublicKey(to, from);
1322 }
1323 
1324 void
1325 convert(org::xrpl::rpc::v1::PaymentChannelCreate& to, STObject const& from)
1326 {
1327  populateAmount(to, from);
1328 
1329  populateDestination(to, from);
1330 
1331  populateSettleDelay(to, from);
1332 
1333  populatePublicKey(to, from);
1334 
1335  populateCancelAfter(to, from);
1336 
1337  populateDestinationTag(to, from);
1338 }
1339 
1340 void
1341 convert(org::xrpl::rpc::v1::PaymentChannelFund& to, STObject const& from)
1342 {
1343  populateChannel(to, from);
1344 
1345  populateAmount(to, from);
1346 
1347  populateExpiration(to, from);
1348 }
1349 
1350 void
1351 convert(org::xrpl::rpc::v1::SetRegularKey& to, STObject const& from)
1352 {
1353  populateRegularKey(to, from);
1354 }
1355 
1356 void
1357 convert(org::xrpl::rpc::v1::SignerListSet& to, STObject const& from)
1358 {
1359  populateSignerQuorum(to, from);
1360 
1361  populateSignerEntries(to, from);
1362 }
1363 
1364 void
1365 convert(org::xrpl::rpc::v1::TicketCreate& to, STObject const& from)
1366 {
1367  populateTicketCount(to, from);
1368 }
1369 
1370 void
1371 convert(org::xrpl::rpc::v1::TrustSet& to, STObject const& from)
1372 {
1373  populateLimitAmount(to, from);
1374 
1375  populateQualityIn(to, from);
1376 
1377  populateQualityOut(to, from);
1378 }
1379 
1380 void
1381 convert(org::xrpl::rpc::v1::Payment& to, STObject const& from)
1382 {
1383  populateAmount(to, from);
1384 
1385  populateDestination(to, from);
1386 
1387  populateDestinationTag(to, from);
1388 
1389  populateInvoiceID(to, from);
1390 
1391  populateSendMax(to, from);
1392 
1393  populateDeliverMin(to, from);
1394 
1395  if (from.isFieldPresent(sfPaths))
1396  {
1397  // populate path data
1398  STPathSet const& pathset = from.getFieldPathSet(sfPaths);
1399  for (auto it = pathset.begin(); it < pathset.end(); ++it)
1400  {
1401  STPath const& path = *it;
1402 
1403  org::xrpl::rpc::v1::Payment_Path* protoPath = to.add_paths();
1404 
1405  for (auto it2 = path.begin(); it2 != path.end(); ++it2)
1406  {
1407  org::xrpl::rpc::v1::Payment_PathElement* protoElement =
1408  protoPath->add_elements();
1409  STPathElement const& elt = *it2;
1410 
1411  if (elt.isOffer())
1412  {
1413  if (elt.hasCurrency())
1414  {
1415  Currency const& currency = elt.getCurrency();
1416  protoElement->mutable_currency()->set_name(
1417  to_string(currency));
1418  }
1419  if (elt.hasIssuer())
1420  {
1421  AccountID const& issuer = elt.getIssuerID();
1422  protoElement->mutable_issuer()->set_address(
1423  toBase58(issuer));
1424  }
1425  }
1426  else if (elt.isAccount())
1427  {
1428  AccountID const& pathAccount = elt.getAccountID();
1429  protoElement->mutable_account()->set_address(
1430  toBase58(pathAccount));
1431  }
1432  }
1433  }
1434  }
1435 }
1436 
1437 void
1438 convert(org::xrpl::rpc::v1::AccountRoot& to, STObject const& from)
1439 {
1440  populateAccount(to, from);
1441 
1442  populateBalance(to, from);
1443 
1444  populateSequence(to, from);
1445 
1446  populateFlags(to, from);
1447 
1448  populateOwnerCount(to, from);
1449 
1450  populatePreviousTransactionID(to, from);
1451 
1452  populatePreviousTransactionLedgerSequence(to, from);
1453 
1454  populateAccountTransactionID(to, from);
1455 
1456  populateDomain(to, from);
1457 
1458  populateEmailHash(to, from);
1459 
1460  populateMessageKey(to, from);
1461 
1462  populateRegularKey(to, from);
1463 
1464  populateTickSize(to, from);
1465 
1466  populateTransferRate(to, from);
1467 
1468  populateBurnedNFTokens(to, from);
1469 
1470  populateMintedNFTokens(to, from);
1471 
1472  populateNFTokenMinter(to, from);
1473 }
1474 
1475 void
1476 convert(org::xrpl::rpc::v1::Amendments& to, STObject const& from)
1477 {
1478  populateAmendments(to, from);
1479 
1480  populateMajorities(to, from);
1481 }
1482 
1483 void
1484 convert(org::xrpl::rpc::v1::Check& to, STObject const& from)
1485 {
1486  populateAccount(to, from);
1487 
1488  populateDestination(to, from);
1489 
1490  populateFlags(to, from);
1491 
1492  populateOwnerNode(to, from);
1493 
1494  populatePreviousTransactionID(to, from);
1495 
1496  populatePreviousTransactionLedgerSequence(to, from);
1497 
1498  populateSendMax(to, from);
1499 
1500  populateSequence(to, from);
1501 
1502  populateDestinationNode(to, from);
1503 
1504  populateDestinationTag(to, from);
1505 
1506  populateExpiration(to, from);
1507 
1508  populateInvoiceID(to, from);
1509 
1510  populateSourceTag(to, from);
1511 }
1512 
1513 void
1514 convert(org::xrpl::rpc::v1::DepositPreauthObject& to, STObject const& from)
1515 {
1516  populateAccount(to, from);
1517 
1518  populateAuthorize(to, from);
1519 
1520  populateFlags(to, from);
1521 
1522  populateOwnerNode(to, from);
1523 
1524  populatePreviousTransactionID(to, from);
1525 
1526  populatePreviousTransactionLedgerSequence(to, from);
1527 }
1528 
1529 void
1530 convert(org::xrpl::rpc::v1::FeeSettings& to, STObject const& from)
1531 {
1532  populateBaseFee(to, from);
1533 
1534  populateReferenceFeeUnits(to, from);
1535 
1536  populateReserveBase(to, from);
1537 
1538  populateReserveIncrement(to, from);
1539 
1540  populateFlags(to, from);
1541 }
1542 
1543 void
1544 convert(org::xrpl::rpc::v1::Escrow& to, STObject const& from)
1545 {
1546  populateAccount(to, from);
1547 
1548  populateDestination(to, from);
1549 
1550  populateAmount(to, from);
1551 
1552  populateCondition(to, from);
1553 
1554  populateCancelAfter(to, from);
1555 
1556  populateFinishAfter(to, from);
1557 
1558  populateFlags(to, from);
1559 
1560  populateSourceTag(to, from);
1561 
1562  populateDestinationTag(to, from);
1563 
1564  populateOwnerNode(to, from);
1565 
1566  populateDestinationNode(to, from);
1567 
1568  populatePreviousTransactionID(to, from);
1569 
1570  populatePreviousTransactionLedgerSequence(to, from);
1571 }
1572 
1573 void
1574 convert(org::xrpl::rpc::v1::LedgerHashes& to, STObject const& from)
1575 {
1576  populateLastLedgerSequence(to, from);
1577 
1578  populateHashes(to, from);
1579 
1580  populateFlags(to, from);
1581 }
1582 
1583 void
1584 convert(org::xrpl::rpc::v1::PayChannel& to, STObject const& from)
1585 {
1586  populateAccount(to, from);
1587 
1588  populateAmount(to, from);
1589 
1590  populateBalance(to, from);
1591 
1592  populatePublicKey(to, from);
1593 
1594  populateSettleDelay(to, from);
1595 
1596  populateOwnerNode(to, from);
1597 
1598  populatePreviousTransactionID(to, from);
1599 
1600  populatePreviousTransactionLedgerSequence(to, from);
1601 
1602  populateFlags(to, from);
1603 
1604  populateExpiration(to, from);
1605 
1606  populateCancelAfter(to, from);
1607 
1608  populateSourceTag(to, from);
1609 
1610  populateDestinationTag(to, from);
1611 
1612  populateDestinationNode(to, from);
1613 }
1614 
1615 void
1616 convert(org::xrpl::rpc::v1::DirectoryNode& to, STObject const& from)
1617 {
1618  populateFlags(to, from);
1619 
1620  populateRootIndex(to, from);
1621 
1622  populateIndexes(to, from);
1623 
1624  populateIndexNext(to, from);
1625 
1626  populateIndexPrevious(to, from);
1627 
1628  populateTakerPaysIssuer(to, from);
1629 
1630  populateTakerPaysCurrency(to, from);
1631 
1632  populateTakerGetsCurrency(to, from);
1633 
1634  populateTakerGetsIssuer(to, from);
1635 
1636  populateNFTokenID(to, from);
1637 }
1638 
1639 void
1640 convert(org::xrpl::rpc::v1::Offer& to, STObject const& from)
1641 {
1642  populateAccount(to, from);
1643 
1644  populateSequence(to, from);
1645 
1646  populateFlags(to, from);
1647 
1648  populateTakerPays(to, from);
1649 
1650  populateTakerGets(to, from);
1651 
1652  populateBookDirectory(to, from);
1653 
1654  populateBookNode(to, from);
1655 }
1656 
1657 void
1658 convert(org::xrpl::rpc::v1::RippleState& to, STObject const& from)
1659 {
1660  populateBalance(to, from);
1661 
1662  populateFlags(to, from);
1663 
1664  populateLowNode(to, from);
1665 
1666  populateHighNode(to, from);
1667 
1668  populateLowQualityIn(to, from);
1669 
1670  populateLowQualityOut(to, from);
1671 
1672  populateHighQualityIn(to, from);
1673 
1674  populateHighQualityOut(to, from);
1675 
1676  populatePreviousTransactionID(to, from);
1677 
1678  populatePreviousTransactionLedgerSequence(to, from);
1679 }
1680 
1681 void
1682 convert(org::xrpl::rpc::v1::SignerList& to, STObject const& from)
1683 {
1684  populateFlags(to, from);
1685 
1686  populatePreviousTransactionID(to, from);
1687 
1688  populatePreviousTransactionLedgerSequence(to, from);
1689 
1690  populateOwnerNode(to, from);
1691 
1692  populateSignerEntries(to, from);
1693 
1694  populateSignerQuorum(to, from);
1695 
1696  populateSignerListID(to, from);
1697 }
1698 
1699 void
1700 convert(org::xrpl::rpc::v1::NegativeUNL& to, STObject const& from)
1701 {
1702  populateDisabledValidators(to, from);
1703 
1704  populateValidatorToDisable(to, from);
1705 
1706  populateValidatorToReEnable(to, from);
1707 
1708  populateFlags(to, from);
1709 }
1710 
1711 void
1712 convert(org::xrpl::rpc::v1::TicketObject& to, STObject const& from)
1713 {
1714  populateAccount(to, from);
1715 
1716  populateFlags(to, from);
1717 
1718  populateOwnerNode(to, from);
1719 
1720  populatePreviousTransactionID(to, from);
1721 
1722  populatePreviousTransactionLedgerSequence(to, from);
1723 
1724  populateTicketSequence(to, from);
1725 }
1726 
1727 void
1728 convert(org::xrpl::rpc::v1::NFTokenOffer& to, STObject const& from)
1729 {
1730  populateFlags(to, from);
1731 
1732  populateOwner(to, from);
1733 
1734  populateNFTokenID(to, from);
1735 
1736  populateAmount(to, from);
1737 
1738  populateOwnerNode(to, from);
1739 
1740  populateDestination(to, from);
1741 
1742  populateExpiration(to, from);
1743 
1744  populatePreviousTransactionID(to, from);
1745 
1746  populatePreviousTransactionLedgerSequence(to, from);
1747 }
1748 
1749 void
1750 convert(org::xrpl::rpc::v1::NFTokenPage& to, STObject const& from)
1751 {
1752  populateFlags(to, from);
1753 
1754  populatePreviousPageMin(to, from);
1755 
1756  populateNextPageMin(to, from);
1757 
1758  populateNFTokens(to, from);
1759 
1760  populatePreviousTransactionID(to, from);
1761 
1762  populatePreviousTransactionLedgerSequence(to, from);
1763 }
1764 
1765 void
1766 setLedgerEntryType(
1767  org::xrpl::rpc::v1::AffectedNode& proto,
1768  std::uint16_t lgrType)
1769 {
1770  switch (lgrType)
1771  {
1772  case ltACCOUNT_ROOT:
1773  proto.set_ledger_entry_type(
1774  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_ACCOUNT_ROOT);
1775  break;
1776  case ltDIR_NODE:
1777  proto.set_ledger_entry_type(
1778  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_DIRECTORY_NODE);
1779  break;
1780  case ltRIPPLE_STATE:
1781  proto.set_ledger_entry_type(
1782  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_RIPPLE_STATE);
1783  break;
1784  case ltSIGNER_LIST:
1785  proto.set_ledger_entry_type(
1786  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_SIGNER_LIST);
1787  break;
1788  case ltOFFER:
1789  proto.set_ledger_entry_type(
1790  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_OFFER);
1791  break;
1792  case ltLEDGER_HASHES:
1793  proto.set_ledger_entry_type(
1794  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_LEDGER_HASHES);
1795  break;
1796  case ltAMENDMENTS:
1797  proto.set_ledger_entry_type(
1798  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_AMENDMENTS);
1799  break;
1800  case ltFEE_SETTINGS:
1801  proto.set_ledger_entry_type(
1802  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_FEE_SETTINGS);
1803  break;
1804  case ltESCROW:
1805  proto.set_ledger_entry_type(
1806  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_ESCROW);
1807  break;
1808  case ltPAYCHAN:
1809  proto.set_ledger_entry_type(
1810  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_PAY_CHANNEL);
1811  break;
1812  case ltCHECK:
1813  proto.set_ledger_entry_type(
1814  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_CHECK);
1815  break;
1816  case ltDEPOSIT_PREAUTH:
1817  proto.set_ledger_entry_type(
1818  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_DEPOSIT_PREAUTH);
1819  break;
1820  case ltNEGATIVE_UNL:
1821  proto.set_ledger_entry_type(
1822  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_NEGATIVE_UNL);
1823  break;
1824  case ltTICKET:
1825  proto.set_ledger_entry_type(
1826  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_TICKET);
1827  break;
1828  case ltNFTOKEN_OFFER:
1829  proto.set_ledger_entry_type(
1830  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_NFTOKEN_OFFER);
1831  break;
1832  case ltNFTOKEN_PAGE:
1833  proto.set_ledger_entry_type(
1834  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_NFTOKEN_PAGE);
1835  break;
1836  }
1837 }
1838 
1839 template <class T>
1840 void
1841 convert(T& to, STObject& from, std::uint16_t type)
1842 {
1843  switch (type)
1844  {
1845  case ltACCOUNT_ROOT:
1846  RPC::convert(*to.mutable_account_root(), from);
1847  break;
1848  case ltAMENDMENTS:
1849  RPC::convert(*to.mutable_amendments(), from);
1850  break;
1851  case ltDIR_NODE:
1852  RPC::convert(*to.mutable_directory_node(), from);
1853  break;
1854  case ltRIPPLE_STATE:
1855  RPC::convert(*to.mutable_ripple_state(), from);
1856  break;
1857  case ltSIGNER_LIST:
1858  RPC::convert(*to.mutable_signer_list(), from);
1859  break;
1860  case ltOFFER:
1861  RPC::convert(*to.mutable_offer(), from);
1862  break;
1863  case ltLEDGER_HASHES:
1864  RPC::convert(*to.mutable_ledger_hashes(), from);
1865  break;
1866  case ltFEE_SETTINGS:
1867  RPC::convert(*to.mutable_fee_settings(), from);
1868  break;
1869  case ltESCROW:
1870  RPC::convert(*to.mutable_escrow(), from);
1871  break;
1872  case ltPAYCHAN:
1873  RPC::convert(*to.mutable_pay_channel(), from);
1874  break;
1875  case ltCHECK:
1876  RPC::convert(*to.mutable_check(), from);
1877  break;
1878  case ltDEPOSIT_PREAUTH:
1879  RPC::convert(*to.mutable_deposit_preauth(), from);
1880  break;
1881  case ltNEGATIVE_UNL:
1882  RPC::convert(*to.mutable_negative_unl(), from);
1883  break;
1884  case ltTICKET:
1885  RPC::convert(*to.mutable_ticket(), from);
1886  break;
1887  case ltNFTOKEN_OFFER:
1888  RPC::convert(*to.mutable_nftoken_offer(), from);
1889  break;
1890  case ltNFTOKEN_PAGE:
1891  RPC::convert(*to.mutable_nftoken_page(), from);
1892  break;
1893  }
1894 }
1895 
1896 template <class T>
1897 void
1898 populateFields(
1899  T const& getProto,
1900  STObject& obj,
1901  SField const& field,
1902  uint16_t lgrType)
1903 {
1904  // final fields
1905  if (obj.isFieldPresent(field))
1906  {
1907  STObject& data = obj.getField(field).downcast<STObject>();
1908 
1909  convert(*getProto(), data, lgrType);
1910  }
1911 }
1912 
1913 template <class T>
1914 void
1915 populateFinalFields(T const& getProto, STObject& obj, uint16_t lgrType)
1916 {
1917  populateFields(getProto, obj, sfFinalFields, lgrType);
1918 }
1919 
1920 template <class T>
1921 void
1922 populatePreviousFields(T const& getProto, STObject& obj, uint16_t lgrType)
1923 {
1924  populateFields(getProto, obj, sfPreviousFields, lgrType);
1925 }
1926 
1927 template <class T>
1928 void
1929 populateNewFields(T const& getProto, STObject& obj, uint16_t lgrType)
1930 {
1931  populateFields(getProto, obj, sfNewFields, lgrType);
1932 }
1933 
1934 void
1935 convert(org::xrpl::rpc::v1::Meta& to, std::shared_ptr<TxMeta> const& from)
1936 {
1937  to.set_transaction_index(from->getIndex());
1938 
1939  convert(*to.mutable_transaction_result(), from->getResultTER());
1940  to.mutable_transaction_result()->set_result(
1941  transToken(from->getResultTER()));
1942 
1943  if (from->hasDeliveredAmount())
1944  convert(*to.mutable_delivered_amount(), from->getDeliveredAmount());
1945 
1946  STArray& nodes = from->getNodes();
1947  for (auto it = nodes.begin(); it != nodes.end(); ++it)
1948  {
1949  STObject& obj = *it;
1950  org::xrpl::rpc::v1::AffectedNode* node = to.add_affected_nodes();
1951 
1952  // ledger index
1953  uint256 ledgerIndex = obj.getFieldH256(sfLedgerIndex);
1954  node->set_ledger_index(ledgerIndex.data(), ledgerIndex.size());
1955 
1956  // ledger entry type
1957  std::uint16_t lgrType = obj.getFieldU16(sfLedgerEntryType);
1958  setLedgerEntryType(*node, lgrType);
1959 
1960  // modified node
1961  if (obj.getFName() == sfModifiedNode)
1962  {
1963  populateFinalFields(
1964  [&node]() {
1965  return node->mutable_modified_node()
1966  ->mutable_final_fields();
1967  },
1968  obj,
1969  lgrType);
1970 
1971  populatePreviousFields(
1972  [&node]() {
1973  return node->mutable_modified_node()
1974  ->mutable_previous_fields();
1975  },
1976  obj,
1977  lgrType);
1978 
1979  populatePreviousTransactionID(*node->mutable_modified_node(), obj);
1980 
1981  populatePreviousTransactionLedgerSequence(
1982  *node->mutable_modified_node(), obj);
1983  }
1984  // created node
1985  else if (obj.getFName() == sfCreatedNode)
1986  {
1987  populateNewFields(
1988  [&node]() {
1989  return node->mutable_created_node()->mutable_new_fields();
1990  },
1991  obj,
1992  lgrType);
1993  }
1994  // deleted node
1995  else if (obj.getFName() == sfDeletedNode)
1996  {
1997  populateFinalFields(
1998  [&node]() {
1999  return node->mutable_deleted_node()->mutable_final_fields();
2000  },
2001  obj,
2002  lgrType);
2003  }
2004  }
2005 }
2006 
2007 void
2008 convert(
2009  org::xrpl::rpc::v1::QueueData& to,
2010  std::vector<TxQ::TxDetails> const& from)
2011 {
2012  if (!from.empty())
2013  {
2014  to.set_txn_count(from.size());
2015 
2016  std::uint32_t seqCount = 0;
2017  std::uint32_t ticketCount = 0;
2018  std::optional<std::uint32_t> lowestSeq;
2019  std::optional<std::uint32_t> highestSeq;
2020  std::optional<std::uint32_t> lowestTicket;
2021  std::optional<std::uint32_t> highestTicket;
2022  bool anyAuthChanged = false;
2023  XRPAmount totalSpend(0);
2024 
2025  for (auto const& tx : from)
2026  {
2027  org::xrpl::rpc::v1::QueuedTransaction& qt = *to.add_transactions();
2028 
2029  if (tx.seqProxy.isSeq())
2030  {
2031  qt.mutable_sequence()->set_value(tx.seqProxy.value());
2032  ++seqCount;
2033  if (!lowestSeq)
2034  lowestSeq = tx.seqProxy.value();
2035  highestSeq = tx.seqProxy.value();
2036  }
2037  else
2038  {
2039  qt.mutable_ticket()->set_value(tx.seqProxy.value());
2040  ++ticketCount;
2041  if (!lowestTicket)
2042  lowestTicket = tx.seqProxy.value();
2043  highestTicket = tx.seqProxy.value();
2044  }
2045 
2046  qt.set_fee_level(tx.feeLevel.fee());
2047  if (tx.lastValid)
2048  qt.mutable_last_ledger_sequence()->set_value(*tx.lastValid);
2049 
2050  qt.mutable_fee()->set_drops(tx.consequences.fee().drops());
2051  auto const spend =
2052  tx.consequences.potentialSpend() + tx.consequences.fee();
2053  qt.mutable_max_spend_drops()->set_drops(spend.drops());
2054  totalSpend += spend;
2055  bool const authChanged = tx.consequences.isBlocker();
2056  if (authChanged)
2057  anyAuthChanged = true;
2058  qt.set_auth_change(authChanged);
2059  }
2060 
2061  if (seqCount)
2062  to.set_sequence_count(seqCount);
2063  if (ticketCount)
2064  to.set_ticket_count(ticketCount);
2065  if (lowestSeq)
2066  to.set_lowest_sequence(*lowestSeq);
2067  if (highestSeq)
2068  to.set_highest_sequence(*highestSeq);
2069  if (lowestTicket)
2070  to.set_lowest_ticket(*lowestTicket);
2071  if (highestTicket)
2072  to.set_highest_ticket(*highestTicket);
2073 
2074  to.set_auth_change_queued(anyAuthChanged);
2075  to.mutable_max_spend_drops_total()->set_drops(totalSpend.drops());
2076  }
2077 }
2078 
2079 void
2080 convert(
2081  org::xrpl::rpc::v1::Transaction& to,
2082  std::shared_ptr<STTx const> const& from)
2083 {
2084  STObject const& fromObj = *from;
2085 
2086  populateAccount(to, fromObj);
2087 
2088  populateFee(to, fromObj);
2089 
2090  populateSequence(to, fromObj);
2091 
2092  populateSigningPublicKey(to, fromObj);
2093 
2094  populateTransactionSignature(to, fromObj);
2095 
2096  populateFlags(to, fromObj);
2097 
2098  populateLastLedgerSequence(to, fromObj);
2099 
2100  populateSourceTag(to, fromObj);
2101 
2102  populateAccountTransactionID(to, fromObj);
2103 
2104  populateMemos(to, fromObj);
2105 
2106  populateSigners(to, fromObj);
2107 
2108  populateTicketSequence(to, fromObj);
2109 
2110  auto type = safe_cast<TxType>(fromObj.getFieldU16(sfTransactionType));
2111 
2112  switch (type)
2113  {
2114  case TxType::ttPAYMENT:
2115  convert(*to.mutable_payment(), fromObj);
2116  break;
2117  case TxType::ttESCROW_CREATE:
2118  convert(*to.mutable_escrow_create(), fromObj);
2119  break;
2120  case TxType::ttESCROW_FINISH:
2121  convert(*to.mutable_escrow_finish(), fromObj);
2122  break;
2123  case TxType::ttACCOUNT_SET:
2124  convert(*to.mutable_account_set(), fromObj);
2125  break;
2126  case TxType::ttESCROW_CANCEL:
2127  convert(*to.mutable_escrow_cancel(), fromObj);
2128  break;
2129  case TxType::ttREGULAR_KEY_SET:
2130  convert(*to.mutable_set_regular_key(), fromObj);
2131  break;
2132  case TxType::ttOFFER_CREATE:
2133  convert(*to.mutable_offer_create(), fromObj);
2134  break;
2135  case TxType::ttOFFER_CANCEL:
2136  convert(*to.mutable_offer_cancel(), fromObj);
2137  break;
2138  case TxType::ttSIGNER_LIST_SET:
2139  convert(*to.mutable_signer_list_set(), fromObj);
2140  break;
2141  case TxType::ttPAYCHAN_CREATE:
2142  convert(*to.mutable_payment_channel_create(), fromObj);
2143  break;
2144  case TxType::ttPAYCHAN_FUND:
2145  convert(*to.mutable_payment_channel_fund(), fromObj);
2146  break;
2147  case TxType::ttPAYCHAN_CLAIM:
2148  convert(*to.mutable_payment_channel_claim(), fromObj);
2149  break;
2150  case TxType::ttCHECK_CREATE:
2151  convert(*to.mutable_check_create(), fromObj);
2152  break;
2153  case TxType::ttCHECK_CASH:
2154  convert(*to.mutable_check_cash(), fromObj);
2155  break;
2156  case TxType::ttCHECK_CANCEL:
2157  convert(*to.mutable_check_cancel(), fromObj);
2158  break;
2159  case TxType::ttDEPOSIT_PREAUTH:
2160  convert(*to.mutable_deposit_preauth(), fromObj);
2161  break;
2162  case TxType::ttTRUST_SET:
2163  convert(*to.mutable_trust_set(), fromObj);
2164  break;
2165  case TxType::ttACCOUNT_DELETE:
2166  convert(*to.mutable_account_delete(), fromObj);
2167  break;
2168  case TxType::ttTICKET_CREATE:
2169  convert(*to.mutable_ticket_create(), fromObj);
2170  break;
2171  case TxType::ttNFTOKEN_MINT:
2172  convert(*to.mutable_nftoken_mint(), fromObj);
2173  break;
2174  case TxType::ttNFTOKEN_BURN:
2175  convert(*to.mutable_nftoken_burn(), fromObj);
2176  break;
2177  case TxType::ttNFTOKEN_CREATE_OFFER:
2178  convert(*to.mutable_nftoken_create_offer(), fromObj);
2179  break;
2180  case TxType::ttNFTOKEN_CANCEL_OFFER:
2181  convert(*to.mutable_nftoken_cancel_offer(), fromObj);
2182  break;
2183  case TxType::ttNFTOKEN_ACCEPT_OFFER:
2184  convert(*to.mutable_nftoken_accept_offer(), fromObj);
2185  break;
2186  default:
2187  break;
2188  }
2189 }
2190 
2191 } // namespace RPC
2192 } // namespace ripple
ripple::RPC::populateTakerPaysCurrency
void populateTakerPaysCurrency(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:815
ripple::RPC::populatePaymentChannelSignature
void populatePaymentChannelSignature(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:380
ripple::RPC::populateIndexNext
void populateIndexNext(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:799
ripple::RPC::populateLowQualityOut
void populateLowQualityOut(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:689
ripple::STObject::peekAtField
const STBase & peekAtField(SField const &field) const
Definition: STObject.cpp:373
ripple::sfIndexNext
const SF_UINT64 sfIndexNext
ripple::sfSignerListID
const SF_UINT32 sfSignerListID
ripple::RPC::populateDisabledValidators
void populateDisabledValidators(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1032
ripple::sfHighQualityIn
const SF_UINT32 sfHighQualityIn
ripple::sfOfferSequence
const SF_UINT32 sfOfferSequence
ripple::sfPreviousTxnLgrSeq
const SF_UINT32 sfPreviousTxnLgrSeq
ripple::RPC::populateNFTokenOffers
void populateNFTokenOffers(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:783
ripple::sfOwnerCount
const SF_UINT32 sfOwnerCount
ripple::sfSignerWeight
const SF_UINT16 sfSignerWeight
ripple::sfPaths
const SField sfPaths
ripple::STObject::getFieldArray
const STArray & getFieldArray(SField const &field) const
Definition: STObject.cpp:624
ripple::sfRootIndex
const SF_UINT256 sfRootIndex
ripple::sfSourceTag
const SF_UINT32 sfSourceTag
ripple::RPC::populatePublicKey
void populatePublicKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:390
ripple::ltTICKET
@ ltTICKET
A ledger object which describes a ticket.
Definition: LedgerFormats.h:80
ripple::RPC::populateTakerPaysIssuer
void populateTakerPaysIssuer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:825
ripple::RPC::populateNFTokens
void populateNFTokens(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1094
ripple::RPC::populateBaseFee
void populateBaseFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:865
ripple::STBase::getSType
virtual SerializedTypeID getSType() const
Definition: STBase.cpp:69
ripple::sfReserveBase
const SF_UINT32 sfReserveBase
ripple::RPC::populateReserveBase
void populateReserveBase(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:998
ripple::RPC::populateAmount
void populateAmount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:257
ripple::sfSendMax
const SF_AMOUNT sfSendMax
ripple::RPC::populateSourceTag
void populateSourceTag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:539
std::shared_ptr
STL class.
ripple::sfSigners
const SField sfSigners
ripple::RPC::populateExpiration
void populateExpiration(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:209
ripple::STPathElement::isOffer
bool isOffer() const
Definition: STPathSet.h:323
ripple::sfOwnerNode
const SF_UINT64 sfOwnerNode
ripple::TypedField
A field with a type known at compile time.
Definition: SField.h:271
ripple::RPC::populateSignerEntries
void populateSignerEntries(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1016
ripple::RPC::populateNFTokenBrokerFee
void populateNFTokenBrokerFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:944
ripple::RPC::populateBurnedNFTokens
void populateBurnedNFTokens(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:916
ripple::sfNFTokenOffers
const SF_VECTOR256 sfNFTokenOffers
ripple::sfDestination
const SF_ACCOUNT sfDestination
ripple::RPC::populateSigners
void populateSigners(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1063
ripple::sfAmount
const SF_AMOUNT sfAmount
ripple::sfNFTokenID
const SF_UINT256 sfNFTokenID
ripple::ltLEDGER_HASHES
@ ltLEDGER_HASHES
A ledger object that contains a list of ledger hashes.
Definition: LedgerFormats.h:102
ripple::isTesSuccess
bool isTesSuccess(TER x)
Definition: TER.h:594
ripple::sfFirstLedgerSequence
const SF_UINT32 sfFirstLedgerSequence
ripple::sfCheckID
const SF_UINT256 sfCheckID
ripple::RPC::populateTicketSequence
void populateTicketSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:759
ripple::RPC::populateValidatorToDisable
void populateValidatorToDisable(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:509
ripple::STObject::getFieldV256
const STVector256 & getFieldV256(SField const &field) const
Definition: STObject.cpp:617
ripple::sfQualityOut
const SF_UINT32 sfQualityOut
ripple::sfOwner
const SF_ACCOUNT sfOwner
ripple::RPC::populateMemoType
void populateMemoType(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:573
ripple::XRPAmount::drops
constexpr value_type drops() const
Returns the number of drops.
Definition: XRPAmount.h:172
ripple::sfSequence
const SF_UINT32 sfSequence
ripple::sfRegularKey
const SF_ACCOUNT sfRegularKey
ripple::RPC::populateHighLimit
void populateHighLimit(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:657
ripple::RPC::populateBookNode
void populateBookNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:727
ripple::RPC::populateAccount
void populateAccount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:453
std::vector
STL class.
ripple::sfBookDirectory
const SF_UINT256 sfBookDirectory
std::vector::size
T size(T... args)
ripple::sfTakerPaysCurrency
const SF_UINT160 sfTakerPaysCurrency
ripple::sfSigningPubKey
const SF_VL sfSigningPubKey
ripple::STPathElement::getCurrency
Currency const & getCurrency() const
Definition: STPathSet.h:361
ripple::sfLedgerIndex
const SF_UINT256 sfLedgerIndex
ripple::ltSIGNER_LIST
@ ltSIGNER_LIST
A ledger object which contains a signer list for an account.
Definition: LedgerFormats.h:86
ripple::sfMintedNFTokens
const SF_UINT32 sfMintedNFTokens
ripple::RPC::populateProtoVLasString
void populateProtoVLasString(T const &getProto, STObject const &from, SF_VL const &field)
Definition: GRPCHelpers.cpp:56
ripple::RPC::populateMemos
void populateMemos(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1047
ripple::toBase58
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition: AccountID.cpp:29
ripple::RPC::populateLimitAmount
void populateLimitAmount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:430
ripple::RPC::populateFee
void populateFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:461
ripple::sfQualityIn
const SF_UINT32 sfQualityIn
ripple::transToken
std::string transToken(TER code)
Definition: TER.cpp:207
ripple::RPC::populateOwner
void populateOwner(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:325
ripple::RPC::populateTransferFee
void populateTransferFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:990
ripple::RPC::populateClearFlag
void populateClearFlag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:153
ripple::sfSetFlag
const SF_UINT32 sfSetFlag
ripple::sfFinalFields
const SField sfFinalFields
ripple::RPC::populateFields
void populateFields(T const &getProto, STObject &obj, SField const &field, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1898
ripple::RPC::populateFulfillment
void populateFulfillment(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:356
ripple::sfCloseTime
const SF_UINT32 sfCloseTime
ripple::sfTicketSequence
const SF_UINT32 sfTicketSequence
ripple::RPC::populateMajorities
void populateMajorities(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1079
ripple::RPC::populateRootIndex
void populateRootIndex(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:791
ripple::RPC::populateNFTokenSellOffer
void populateNFTokenSellOffer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:964
ripple::RPC::populateDomain
void populateDomain(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:161
ripple::RPC::populateTransactionSignature
void populateTransactionSignature(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:481
ripple::RPC::populateQualityIn
void populateQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:437
ripple::STObject::getFieldVL
Blob getFieldVL(SField const &field) const
Definition: STObject.cpp:595
ripple::ltCHECK
@ ltCHECK
A ledger object which describes a check.
Definition: LedgerFormats.h:136
ripple::RPC::populateMessageKey
void populateMessageKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:177
ripple::RPC::populateSettleDelay
void populateSettleDelay(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:398
ripple::ltFEE_SETTINGS
@ ltFEE_SETTINGS
The ledger object which lists the network's fee settings.
Definition: LedgerFormats.h:118
ripple::RPC::populateNFTokenBuyOffer
void populateNFTokenBuyOffer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:954
ripple::RPC::populateValidatorToReEnable
void populateValidatorToReEnable(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:519
ripple::sfTakerGetsCurrency
const SF_UINT160 sfTakerGetsCurrency
ripple::STObject::getFieldH160
uint160 getFieldH160(SField const &field) const
Definition: STObject.cpp:577
ripple::STPathSet::end
std::vector< STPath >::const_iterator end() const
Definition: STPathSet.h:491
ripple::RPC::populateLowQualityIn
void populateLowQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:681
ripple::RPC::populateDeliverMin
void populateDeliverMin(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:265
ripple::sfDeletedNode
const SField sfDeletedNode
ripple::isTecClaim
bool isTecClaim(TER x)
Definition: TER.h:600
ripple::RPC::populateFlags
void populateFlags(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:491
ripple::STPathSet
Definition: STPathSet.h:176
ripple::base_uint::data
pointer data()
Definition: base_uint.h:115
ripple::RPC::populateCheckID
void populateCheckID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:249
ripple::RPC::populateCondition
void populateCondition(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:348
ripple::RPC::populateFirstLedgerSequence
void populateFirstLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:499
ripple::STAmount::xrp
XRPAmount xrp() const
Definition: STAmount.cpp:313
ripple::RPC::populateOfferSequence
void populateOfferSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:217
ripple::RPC::populateFinishAfter
void populateFinishAfter(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:340
ripple::RPC::populatePreviousTransactionID
void populatePreviousTransactionID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:629
ripple::sfTransferFee
const SF_UINT16 sfTransferFee
ripple::base_uint::size
constexpr static std::size_t size()
Definition: base_uint.h:512
ripple::ltDIR_NODE
@ ltDIR_NODE
A ledger object which contains a list of object identifiers.
Definition: LedgerFormats.h:66
ripple::sfExpiration
const SF_UINT32 sfExpiration
ripple::sfSignerQuorum
const SF_UINT32 sfSignerQuorum
ripple::sfIndexes
const SF_VECTOR256 sfIndexes
ripple::RPC::populateNFTokenTaxon
void populateNFTokenTaxon(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:982
ripple::isTerRetry
bool isTerRetry(TER x)
Definition: TER.h:588
ripple::sfTakerGetsIssuer
const SF_UINT160 sfTakerGetsIssuer
ripple::sfLowNode
const SF_UINT64 sfLowNode
ripple::base_uint< 256 >
ripple::sfTakerPays
const SF_AMOUNT sfTakerPays
ripple::ltAMENDMENTS
@ ltAMENDMENTS
The ledger object which lists details about amendments on the network.
Definition: LedgerFormats.h:110
ripple::sfTransactionType
const SF_UINT16 sfTransactionType
ripple::sfDeliverMin
const SF_AMOUNT sfDeliverMin
ripple::sfLowQualityOut
const SF_UINT32 sfLowQualityOut
ripple::sfLimitAmount
const SF_AMOUNT sfLimitAmount
ripple::RPC::convert
void convert(org::xrpl::rpc::v1::TransactionResult &to, TER from)
Definition: GRPCHelpers.cpp:1108
ripple::sfLowLimit
const SF_AMOUNT sfLowLimit
ripple::RPC::populateNewFields
void populateNewFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1929
ripple::RPC::populateDestinationTag
void populateDestinationTag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:291
ripple::ltOFFER
@ ltOFFER
A ledger object which describes an offer on the DEX.
Definition: LedgerFormats.h:92
ripple::sfDeliveredAmount
const SF_AMOUNT sfDeliveredAmount
ripple::RPC::populateHighQualityIn
void populateHighQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:699
ripple::RPC::populateSignerQuorum
void populateSignerQuorum(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:414
ripple::RPC::populateProtoVec256
void populateProtoVec256(T const &getProto, STObject const &from, SF_VECTOR256 const &field)
Definition: GRPCHelpers.cpp:71
ripple::RPC::populateProtoPrimitive
void populateProtoPrimitive(L const &getProto, STObject const &from, TypedField< T > const &field)
Definition: GRPCHelpers.cpp:35
ripple::sfSettleDelay
const SF_UINT32 sfSettleDelay
ripple::sfUnauthorize
const SF_ACCOUNT sfUnauthorize
ripple::sfMemos
const SField sfMemos
ripple::RPC::populateDeliveredAmount
void populateDeliveredAmount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:281
ripple::RPC::populatePreviousPageMin
void populatePreviousPageMin(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:883
ripple::sfNFTokenMinter
const SF_ACCOUNT sfNFTokenMinter
ripple::ltESCROW
@ ltESCROW
A ledger object describing a single escrow.
Definition: LedgerFormats.h:124
ripple::STObject::getAccountID
AccountID getAccountID(SField const &field) const
Definition: STObject.cpp:589
ripple::sfNewFields
const SField sfNewFields
ripple::sfReserveIncrement
const SF_UINT32 sfReserveIncrement
ripple::sfIndexPrevious
const SF_UINT64 sfIndexPrevious
ripple::ltNFTOKEN_OFFER
@ ltNFTOKEN_OFFER
A ledger object which identifies an offer to buy or sell an NFT.
Definition: LedgerFormats.h:162
ripple::TERSubset
Definition: TER.h:337
ripple::RPC::setLedgerEntryType
void setLedgerEntryType(org::xrpl::rpc::v1::AffectedNode &proto, std::uint16_t lgrType)
Definition: GRPCHelpers.cpp:1766
ripple::sfBookNode
const SF_UINT64 sfBookNode
ripple::isTefFailure
bool isTefFailure(TER x)
Definition: TER.h:582
ripple::sfLowQualityIn
const SF_UINT32 sfLowQualityIn
ripple::STArray
Definition: STArray.h:28
ripple::sfValidatorToDisable
const SF_VL sfValidatorToDisable
ripple::sfTicketCount
const SF_UINT32 sfTicketCount
ripple::sfAccountTxnID
const SF_UINT256 sfAccountTxnID
ripple::sfModifiedNode
const SField sfModifiedNode
ripple::ltDEPOSIT_PREAUTH
@ ltDEPOSIT_PREAUTH
A ledger object which describes a deposit preauthorization.
Definition: LedgerFormats.h:142
ripple::RPC::populatePreviousFields
void populatePreviousFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1922
ripple::RPC::populateTransferRate
void populateTransferRate(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:193
ripple::sfDestinationNode
const SF_UINT64 sfDestinationNode
ripple::RPC::populatePreviousTransactionLedgerSequence
void populatePreviousTransactionLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:639
ripple::sfTakerGets
const SF_AMOUNT sfTakerGets
ripple::sfMajority
const SField sfMajority
ripple::sfTransferRate
const SF_UINT32 sfTransferRate
ripple::STVector256::size
std::size_t size() const
Definition: STVector256.h:166
ripple::sfTickSize
const SF_UINT8 sfTickSize
ripple::RPC::populateReserveIncrement
void populateReserveIncrement(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:1006
ripple::sfPreviousTxnID
const SF_UINT256 sfPreviousTxnID
ripple::RPC::populateUnauthorize
void populateUnauthorize(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:317
ripple::sfAuthorize
const SF_ACCOUNT sfAuthorize
std::uint16_t
ripple::sfHighLimit
const SF_AMOUNT sfHighLimit
ripple::RPC::populateDestinationNode
void populateDestinationNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:855
ripple::RPC::populateMemoFormat
void populateMemoFormat(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:565
ripple::RPC::populateCancelAfter
void populateCancelAfter(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:332
ripple::RPC::populateURI
void populateURI(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:909
ripple::STPathElement::hasIssuer
bool hasIssuer() const
Definition: STPathSet.h:335
ripple::STObject::getFieldU16
std::uint16_t getFieldU16(SField const &field) const
Definition: STObject.cpp:553
ripple::RPC::populateTakerPays
void populateTakerPays(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:233
ripple::sfSigner
const SField sfSigner
ripple::sfClearFlag
const SF_UINT32 sfClearFlag
ripple::sfSignerEntry
const SField sfSignerEntry
ripple::RPC::populateChannel
void populateChannel(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:364
ripple::RPC::populateAmendment
void populateAmendment(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:589
ripple::STPathElement::getIssuerID
AccountID const & getIssuerID() const
Definition: STPathSet.h:367
ripple::sfNFToken
const SField sfNFToken
ripple::RPC::populateDestination
void populateDestination(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:241
ripple::RPC::populateBalance
void populateBalance(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:372
ripple::RPC::populateTakerGets
void populateTakerGets(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:225
ripple::sfPreviousFields
const SField sfPreviousFields
ripple::STBase::getFName
SField const & getFName() const
Definition: STBase.cpp:132
ripple::sfEmailHash
const SF_UINT128 sfEmailHash
ripple::STArray::begin
iterator begin()
Definition: STArray.h:224
ripple::sfNFTokens
const SField sfNFTokens
ripple::sfSignerEntries
const SField sfSignerEntries
ripple::STPathElement::hasCurrency
bool hasCurrency() const
Definition: STPathSet.h:341
std::optional::value
T value(T... args)
ripple::sfBaseFee
const SF_UINT64 sfBaseFee
ripple::RPC::populateIssuer
void populateIssuer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:974
ripple::sfHashes
const SF_VECTOR256 sfHashes
ripple::sfMemoData
const SF_VL sfMemoData
ripple::RPC::populateCloseTime
void populateCloseTime(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:597
ripple::sfNFTokenBuyOffer
const SF_UINT256 sfNFTokenBuyOffer
ripple::RPC::populateTakerGetsIssuer
void populateTakerGetsIssuer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:845
ripple::RPC::populateSendMax
void populateSendMax(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:273
ripple::sfTxnSignature
const SF_VL sfTxnSignature
ripple::STObject
Definition: STObject.h:51
ripple::sfURI
const SF_VL sfURI
ripple::RPC::populateWalletLocator
void populateWalletLocator(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:751
ripple::RPC::populateSignerWeight
void populateSignerWeight(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:605
ripple::ltNFTOKEN_PAGE
@ ltNFTOKEN_PAGE
A ledger object which contains a list of NFTs.
Definition: LedgerFormats.h:156
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::RPC::populateLastLedgerSequence
void populateLastLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:529
ripple::sfWalletLocator
const SF_UINT256 sfWalletLocator
ripple::RPC::populateSetFlag
void populateSetFlag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:185
ripple::RPC::populateAuthorize
void populateAuthorize(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:309
ripple::sfLedgerEntryType
const SF_UINT16 sfLedgerEntryType
ripple::ltNEGATIVE_UNL
@ ltNEGATIVE_UNL
The ledger object which tracks the current negative UNL state.
Definition: LedgerFormats.h:150
ripple::SField
Identifies fields.
Definition: SField.h:112
ripple::STPathSet::begin
std::vector< STPath >::const_iterator begin() const
Definition: STPathSet.h:485
ripple::sfCondition
const SF_VL sfCondition
ripple::STPathElement
Definition: STPathSet.h:34
ripple::RPC::populateSequence
void populateSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:581
ripple::STObject::getField
STBase & getField(SField const &field)
Definition: STObject.cpp:384
ripple::sfTakerPaysIssuer
const SF_UINT160 sfTakerPaysIssuer
ripple::sfIssuer
const SF_ACCOUNT sfIssuer
ripple::RPC::populateIndexes
void populateIndexes(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:776
ripple::sfInvoiceID
const SF_UINT256 sfInvoiceID
ripple::sfFlags
const SF_UINT32 sfFlags
ripple::ltACCOUNT_ROOT
@ ltACCOUNT_ROOT
A ledger object which describes an account.
Definition: LedgerFormats.h:59
ripple::STObject::isFieldPresent
bool isFieldPresent(SField const &field) const
Definition: STObject.cpp:428
ripple::RPC::populateSignerListID
void populateSignerListID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:743
ripple::RPC::populateHighQualityOut
void populateHighQualityOut(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:709
ripple::sfDisabledValidator
const SField sfDisabledValidator
ripple::isTelLocal
bool isTelLocal(TER x)
Definition: TER.h:570
ripple::sfDestinationTag
const SF_UINT32 sfDestinationTag
ripple::RPC::populateFinalFields
void populateFinalFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1915
ripple::RPC::populateIndexPrevious
void populateIndexPrevious(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:807
ripple::sfCreatedNode
const SField sfCreatedNode
ripple::sfSignature
const SF_VL sfSignature
ripple::sfBalance
const SF_AMOUNT sfBalance
ripple::RPC::populateMemoData
void populateMemoData(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:557
ripple::sfReferenceFeeUnits
const SF_UINT32 sfReferenceFeeUnits
ripple::STVector256
Definition: STVector256.h:29
ripple::RPC::populateProtoAccount
void populateProtoAccount(T const &getProto, STObject const &from, SF_ACCOUNT const &field)
Definition: GRPCHelpers.cpp:89
ripple::RPC::populateInvoiceID
void populateInvoiceID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:301
ripple::sfNextPageMin
const SF_UINT256 sfNextPageMin
std::vector::empty
T empty(T... args)
ripple::sfCancelAfter
const SF_UINT32 sfCancelAfter
ripple::sfMessageKey
const SF_VL sfMessageKey
ripple::sfHighQualityOut
const SF_UINT32 sfHighQualityOut
std::optional< std::uint32_t >
ripple::sfPreviousPageMin
const SF_UINT256 sfPreviousPageMin
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:41
ripple::sfFinishAfter
const SF_UINT32 sfFinishAfter
ripple::RPC::populateHighNode
void populateHighNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:673
ripple::sfChannel
const SF_UINT256 sfChannel
ripple::sfNFTokenTaxon
const SF_UINT32 sfNFTokenTaxon
ripple::sfFee
const SF_AMOUNT sfFee
ripple::sfMemo
const SField sfMemo
ripple::sfAccount
const SF_ACCOUNT sfAccount
ripple::ltRIPPLE_STATE
@ ltRIPPLE_STATE
A ledger object which describes a bidirectional trust line.
Definition: LedgerFormats.h:74
ripple::RPC::populateLowNode
void populateLowNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:665
ripple::STBase::downcast
D & downcast()
Definition: STBase.h:145
ripple::RPC::populateProtoArray
void populateProtoArray(T const &getProto, R const &populateProto, STObject const &from, SField const &outerField, SField const &innerField)
Definition: GRPCHelpers.cpp:133
ripple::RPC::populateProtoAmount
void populateProtoAmount(T const &getProto, STObject const &from, SF_AMOUNT const &field)
Definition: GRPCHelpers.cpp:103
ripple::STPathElement::isAccount
bool isAccount() const
Definition: STPathSet.h:329
ripple::RPC::populateSigningPublicKey
void populateSigningPublicKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:471
ripple::RPC::populateBookDirectory
void populateBookDirectory(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:719
ripple::sfDomain
const SF_VL sfDomain
ripple::sfLastLedgerSequence
const SF_UINT32 sfLastLedgerSequence
ripple::RPC::populateAccountTransactionID
void populateAccountTransactionID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:547
ripple::RPC::populateTicketCount
void populateTicketCount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:422
ripple::sfBurnedNFTokens
const SF_UINT32 sfBurnedNFTokens
ripple::sfAmendment
const SF_UINT256 sfAmendment
ripple::RPC::populateReferenceFeeUnits
void populateReferenceFeeUnits(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:873
ripple::RPC::populateOwnerCount
void populateOwnerCount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:621
ripple::RPC::populateLowLimit
void populateLowLimit(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:649
ripple::RPC::populateRegularKey
void populateRegularKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:406
ripple::STObject::getFieldPathSet
STPathSet const & getFieldPathSet(SField const &field) const
Definition: STObject.cpp:610
ripple::RPC::populateHashes
void populateHashes(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:769
ripple::RPC::populateTakerGetsCurrency
void populateTakerGetsCurrency(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:835
ripple::RPC::populateNFTokenID
void populateNFTokenID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:901
ripple::STPath
Definition: STPathSet.h:118
ripple::sfMajorities
const SField sfMajorities
ripple::RPC::populateAmendments
void populateAmendments(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:613
ripple::RPC::populateMintedNFTokens
void populateMintedNFTokens(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:926
ripple::sfDisabledValidators
const SField sfDisabledValidators
ripple::RPC::populateNextPageMin
void populateNextPageMin(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:893
ripple::sfFulfillment
const SF_VL sfFulfillment
ripple::sfPublicKey
const SF_VL sfPublicKey
ripple::RPC::populateNFTokenMinter
void populateNFTokenMinter(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:936
ripple::sfHighNode
const SF_UINT64 sfHighNode
ripple::sfNFTokenSellOffer
const SF_UINT256 sfNFTokenSellOffer
ripple::STObject::getFieldAmount
STAmount const & getFieldAmount(SField const &field) const
Definition: STObject.cpp:603
ripple::RPC::populateProtoCurrency
void populateProtoCurrency(T const &getProto, STObject const &from, SF_UINT160 const &field)
Definition: GRPCHelpers.cpp:117
ripple::isTemMalformed
bool isTemMalformed(TER x)
Definition: TER.h:576
ripple::RPC::populateOwnerNode
void populateOwnerNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:735
ripple::STArray::end
iterator end()
Definition: STArray.h:230
ripple::sfNFTokenBrokerFee
const SF_AMOUNT sfNFTokenBrokerFee
ripple::sfAmendments
const SF_VECTOR256 sfAmendments
ripple::ltPAYCHAN
@ ltPAYCHAN
A ledger object describing a single unidirectional XRP payment channel.
Definition: LedgerFormats.h:130
ripple::XRPAmount
Definition: XRPAmount.h:46
ripple::sfMemoFormat
const SF_VL sfMemoFormat
ripple::sfValidatorToReEnable
const SF_VL sfValidatorToReEnable
ripple::RPC::populateEmailHash
void populateEmailHash(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:169
ripple::STObject::getFieldH256
uint256 getFieldH256(SField const &field) const
Definition: STObject.cpp:583
ripple::sfMemoType
const SF_VL sfMemoType
ripple::RPC::populateTickSize
void populateTickSize(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:201
ripple::RPC::populateQualityOut
void populateQualityOut(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:445
ripple::STPathElement::getAccountID
AccountID const & getAccountID() const
Definition: STPathSet.h:355
Generated by   doxygen 1.8.17