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_Blob 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_Vec256 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_U160 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, sfPayChannel);
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 template <class T>
420 void
421 populateLimitAmount(T& to, STObject const& from)
422 {
423  populateProtoAmount(
424  [&to]() { return to.mutable_limit_amount(); }, from, sfLimitAmount);
425 }
426 template <class T>
427 void
428 populateQualityIn(T& to, STObject const& from)
429 {
430  populateProtoPrimitive(
431  [&to]() { return to.mutable_quality_in(); }, from, sfQualityIn);
432 }
433 
434 template <class T>
435 void
436 populateQualityOut(T& to, STObject const& from)
437 {
438  populateProtoPrimitive(
439  [&to]() { return to.mutable_quality_out(); }, from, sfQualityOut);
440 }
441 
442 template <class T>
443 void
444 populateAccount(T& to, STObject const& from)
445 {
446  populateProtoAccount(
447  [&to]() { return to.mutable_account(); }, from, sfAccount);
448 }
449 
450 template <class T>
451 void
452 populateFee(T& to, STObject const& from)
453 {
454  if (from.isFieldPresent(sfFee))
455  {
456  to.mutable_fee()->set_drops(from.getFieldAmount(sfFee).xrp().drops());
457  }
458 }
459 
460 template <class T>
461 void
462 populateSigningPublicKey(T& to, STObject const& from)
463 {
464  populateProtoPrimitive(
465  [&to]() { return to.mutable_signing_public_key(); },
466  from,
467  sfSigningPubKey);
468 }
469 
470 template <class T>
471 void
472 populateTransactionSignature(T& to, STObject const& from)
473 {
474  populateProtoPrimitive(
475  [&to]() { return to.mutable_transaction_signature(); },
476  from,
477  sfTxnSignature);
478 }
479 
480 template <class T>
481 void
482 populateFlags(T& to, STObject const& from)
483 {
484  populateProtoPrimitive(
485  [&to]() { return to.mutable_flags(); }, from, sfFlags);
486 }
487 
488 template <class T>
489 void
490 populateFirstLedgerSequence(T& to, STObject const& from)
491 {
492  populateProtoPrimitive(
493  [&to]() { return to.mutable_ledger_sequence(); },
494  from,
495  sfFirstLedgerSequence);
496 }
497 
498 template <class T>
499 void
500 populateValidatorToDisable(T& to, STObject const& from)
501 {
502  populateProtoPrimitive(
503  [&to]() { return to.mutable_validator_to_disable(); },
504  from,
505  sfValidatorToDisable);
506 }
507 
508 template <class T>
509 void
510 populateValidatorToReEnable(T& to, STObject const& from)
511 {
512  populateProtoPrimitive(
513  [&to]() { return to.mutable_validator_to_re_enable(); },
514  from,
515  sfValidatorToReEnable);
516 }
517 
518 template <class T>
519 void
520 populateLastLedgerSequence(T& to, STObject const& from)
521 {
522  populateProtoPrimitive(
523  [&to]() { return to.mutable_last_ledger_sequence(); },
524  from,
525  sfLastLedgerSequence);
526 }
527 
528 template <class T>
529 void
530 populateSourceTag(T& to, STObject const& from)
531 {
532  populateProtoPrimitive(
533  [&to]() { return to.mutable_source_tag(); }, from, sfSourceTag);
534 }
535 
536 template <class T>
537 void
538 populateAccountTransactionID(T& to, STObject const& from)
539 {
540  populateProtoPrimitive(
541  [&to]() { return to.mutable_account_transaction_id(); },
542  from,
543  sfAccountTxnID);
544 }
545 
546 template <class T>
547 void
548 populateMemoData(T& to, STObject const& from)
549 {
550  populateProtoPrimitive(
551  [&to]() { return to.mutable_memo_data(); }, from, sfMemoData);
552 }
553 
554 template <class T>
555 void
556 populateMemoFormat(T& to, STObject const& from)
557 {
558  populateProtoPrimitive(
559  [&to]() { return to.mutable_memo_format(); }, from, sfMemoFormat);
560 }
561 
562 template <class T>
563 void
564 populateMemoType(T& to, STObject const& from)
565 {
566  populateProtoPrimitive(
567  [&to]() { return to.mutable_memo_type(); }, from, sfMemoType);
568 }
569 
570 template <class T>
571 void
572 populateSequence(T& to, STObject const& from)
573 {
574  populateProtoPrimitive(
575  [&to]() { return to.mutable_sequence(); }, from, sfSequence);
576 }
577 
578 template <class T>
579 void
580 populateAmendment(T& to, STObject const& from)
581 {
582  populateProtoPrimitive(
583  [&to]() { return to.mutable_amendment(); }, from, sfAmendment);
584 }
585 
586 template <class T>
587 void
588 populateCloseTime(T& to, STObject const& from)
589 {
590  populateProtoPrimitive(
591  [&to]() { return to.mutable_close_time(); }, from, sfCloseTime);
592 }
593 
594 template <class T>
595 void
596 populateSignerWeight(T& to, STObject const& from)
597 {
598  populateProtoPrimitive(
599  [&to]() { return to.mutable_signer_weight(); }, from, sfSignerWeight);
600 }
601 
602 template <class T>
603 void
604 populateAmendments(T& to, STObject const& from)
605 {
606  populateProtoVec256(
607  [&to]() { return to.add_amendments(); }, from, sfAmendments);
608 }
609 
610 template <class T>
611 void
612 populateOwnerCount(T& to, STObject const& from)
613 {
614  populateProtoPrimitive(
615  [&to]() { return to.mutable_owner_count(); }, from, sfOwnerCount);
616 }
617 
618 template <class T>
619 void
620 populatePreviousTransactionID(T& to, STObject const& from)
621 {
622  populateProtoPrimitive(
623  [&to]() { return to.mutable_previous_transaction_id(); },
624  from,
625  sfPreviousTxnID);
626 }
627 
628 template <class T>
629 void
630 populatePreviousTransactionLedgerSequence(T& to, STObject const& from)
631 {
632  populateProtoPrimitive(
633  [&to]() { return to.mutable_previous_transaction_ledger_sequence(); },
634  from,
635  sfPreviousTxnLgrSeq);
636 }
637 
638 template <class T>
639 void
640 populateLowLimit(T& to, STObject const& from)
641 {
642  populateProtoAmount(
643  [&to]() { return to.mutable_low_limit(); }, from, sfLowLimit);
644 }
645 
646 template <class T>
647 void
648 populateHighLimit(T& to, STObject const& from)
649 {
650  populateProtoAmount(
651  [&to]() { return to.mutable_high_limit(); }, from, sfHighLimit);
652 }
653 
654 template <class T>
655 void
656 populateLowNode(T& to, STObject const& from)
657 {
658  populateProtoPrimitive(
659  [&to]() { return to.mutable_low_node(); }, from, sfLowNode);
660 }
661 
662 template <class T>
663 void
664 populateHighNode(T& to, STObject const& from)
665 {
666  populateProtoPrimitive(
667  [&to]() { return to.mutable_high_node(); }, from, sfHighNode);
668 }
669 
670 template <class T>
671 void
672 populateLowQualityIn(T& to, STObject const& from)
673 {
674  populateProtoPrimitive(
675  [&to]() { return to.mutable_low_quality_in(); }, from, sfLowQualityIn);
676 }
677 
678 template <class T>
679 void
680 populateLowQualityOut(T& to, STObject const& from)
681 {
682  populateProtoPrimitive(
683  [&to]() { return to.mutable_low_quality_out(); },
684  from,
685  sfLowQualityOut);
686 }
687 
688 template <class T>
689 void
690 populateHighQualityIn(T& to, STObject const& from)
691 {
692  populateProtoPrimitive(
693  [&to]() { return to.mutable_high_quality_in(); },
694  from,
695  sfHighQualityIn);
696 }
697 
698 template <class T>
699 void
700 populateHighQualityOut(T& to, STObject const& from)
701 {
702  populateProtoPrimitive(
703  [&to]() { return to.mutable_high_quality_out(); },
704  from,
705  sfHighQualityOut);
706 }
707 
708 template <class T>
709 void
710 populateBookDirectory(T& to, STObject const& from)
711 {
712  populateProtoPrimitive(
713  [&to]() { return to.mutable_book_directory(); }, from, sfBookDirectory);
714 }
715 
716 template <class T>
717 void
718 populateBookNode(T& to, STObject const& from)
719 {
720  populateProtoPrimitive(
721  [&to]() { return to.mutable_book_node(); }, from, sfBookNode);
722 }
723 
724 template <class T>
725 void
726 populateOwnerNode(T& to, STObject const& from)
727 {
728  populateProtoPrimitive(
729  [&to]() { return to.mutable_owner_node(); }, from, sfOwnerNode);
730 }
731 
732 template <class T>
733 void
734 populateSignerListID(T& to, STObject const& from)
735 {
736  populateProtoPrimitive(
737  [&to]() { return to.mutable_signer_list_id(); }, from, sfSignerListID);
738 }
739 
740 template <class T>
741 void
742 populateHashes(T& to, STObject const& from)
743 {
744  populateProtoVec256([&to]() { return to.add_hashes(); }, from, sfHashes);
745 }
746 
747 template <class T>
748 void
749 populateIndexes(T& to, STObject const& from)
750 {
751  populateProtoVec256([&to]() { return to.add_indexes(); }, from, sfIndexes);
752 }
753 
754 template <class T>
755 void
756 populateRootIndex(T& to, STObject const& from)
757 {
758  populateProtoPrimitive(
759  [&to]() { return to.mutable_root_index(); }, from, sfRootIndex);
760 }
761 
762 template <class T>
763 void
764 populateIndexNext(T& to, STObject const& from)
765 {
766  populateProtoPrimitive(
767  [&to]() { return to.mutable_index_next(); }, from, sfIndexNext);
768 }
769 
770 template <class T>
771 void
772 populateIndexPrevious(T& to, STObject const& from)
773 {
774  populateProtoPrimitive(
775  [&to]() { return to.mutable_index_previous(); }, from, sfIndexPrevious);
776 }
777 
778 template <class T>
779 void
780 populateTakerPaysCurrency(T& to, STObject const& from)
781 {
782  populateProtoCurrency(
783  [&to]() { return to.mutable_taker_pays_currency(); },
784  from,
785  sfTakerPaysCurrency);
786 }
787 
788 template <class T>
789 void
790 populateTakerPaysIssuer(T& to, STObject const& from)
791 {
792  populateProtoPrimitive(
793  [&to]() { return to.mutable_taker_pays_issuer(); },
794  from,
795  sfTakerPaysIssuer);
796 }
797 
798 template <class T>
799 void
800 populateTakerGetsCurrency(T& to, STObject const& from)
801 {
802  populateProtoCurrency(
803  [&to]() { return to.mutable_taker_gets_currency(); },
804  from,
805  sfTakerGetsCurrency);
806 }
807 
808 template <class T>
809 void
810 populateTakerGetsIssuer(T& to, STObject const& from)
811 {
812  populateProtoPrimitive(
813  [&to]() { return to.mutable_taker_gets_issuer(); },
814  from,
815  sfTakerGetsIssuer);
816 }
817 
818 template <class T>
819 void
820 populateDestinationNode(T& to, STObject const& from)
821 {
822  populateProtoPrimitive(
823  [&to]() { return to.mutable_destination_node(); },
824  from,
825  sfDestinationNode);
826 }
827 
828 template <class T>
829 void
830 populateBaseFee(T& to, STObject const& from)
831 {
832  populateProtoPrimitive(
833  [&to]() { return to.mutable_base_fee(); }, from, sfBaseFee);
834 }
835 
836 template <class T>
837 void
838 populateReferenceFeeUnits(T& to, STObject const& from)
839 {
840  populateProtoPrimitive(
841  [&to]() { return to.mutable_reference_fee_units(); },
842  from,
843  sfReferenceFeeUnits);
844 }
845 
846 template <class T>
847 void
848 populateReserveBase(T& to, STObject const& from)
849 {
850  populateProtoPrimitive(
851  [&to]() { return to.mutable_reserve_base(); }, from, sfReserveBase);
852 }
853 
854 template <class T>
855 void
856 populateReserveIncrement(T& to, STObject const& from)
857 {
858  populateProtoPrimitive(
859  [&to]() { return to.mutable_reserve_increment(); },
860  from,
861  sfReserveIncrement);
862 }
863 
864 template <class T>
865 void
866 populateSignerEntries(T& to, STObject const& from)
867 {
868  populateProtoArray(
869  [&to]() { return to.add_signer_entries(); },
870  [](auto& innerObj, auto& innerProto) {
871  populateAccount(innerProto, innerObj);
872  populateSignerWeight(innerProto, innerObj);
873  },
874  from,
875  sfSignerEntries,
876  sfSignerEntry);
877 }
878 
879 template <class T>
880 void
881 populateDisabledValidators(T& to, STObject const& from)
882 {
883  populateProtoArray(
884  [&to]() { return to.add_disabled_validators(); },
885  [](auto& innerObj, auto& innerProto) {
886  populatePublicKey(innerProto, innerObj);
887  populateFirstLedgerSequence(innerProto, innerObj);
888  },
889  from,
890  sfDisabledValidators,
891  sfDisabledValidator);
892 }
893 
894 template <class T>
895 void
896 populateMemos(T& to, STObject const& from)
897 {
898  populateProtoArray(
899  [&to]() { return to.add_memos(); },
900  [](auto& innerObj, auto& innerProto) {
901  populateMemoData(innerProto, innerObj);
902  populateMemoType(innerProto, innerObj);
903  populateMemoFormat(innerProto, innerObj);
904  },
905  from,
906  sfMemos,
907  sfMemo);
908 }
909 
910 template <class T>
911 void
912 populateSigners(T& to, STObject const& from)
913 {
914  populateProtoArray(
915  [&to]() { return to.add_signers(); },
916  [](auto& innerObj, auto& innerProto) {
917  populateAccount(innerProto, innerObj);
918  populateTransactionSignature(innerProto, innerObj);
919  populateSigningPublicKey(innerProto, innerObj);
920  },
921  from,
922  sfSigners,
923  sfSigner);
924 }
925 
926 template <class T>
927 void
928 populateMajorities(T& to, STObject const& from)
929 {
930  populateProtoArray(
931  [&to]() { return to.add_majorities(); },
932  [](auto innerObj, auto innerProto) {
933  populateAmendment(innerProto, innerObj);
934  populateCloseTime(innerProto, innerObj);
935  },
936  from,
937  sfMajorities,
938  sfMajority);
939 }
940 
941 void
942 convert(org::xrpl::rpc::v1::TransactionResult& to, TER from)
943 {
944  if (isTecClaim(from))
945  {
946  to.set_result_type(
947  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEC);
948  }
949  if (isTefFailure(from))
950  {
951  to.set_result_type(
952  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEF);
953  }
954  if (isTelLocal(from))
955  {
956  to.set_result_type(
957  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEL);
958  }
959  if (isTemMalformed(from))
960  {
961  to.set_result_type(
962  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEM);
963  }
964  if (isTerRetry(from))
965  {
966  to.set_result_type(
967  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TER);
968  }
969  if (isTesSuccess(from))
970  {
971  to.set_result_type(
972  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TES);
973  }
974 }
975 
976 void
977 convert(org::xrpl::rpc::v1::AccountSet& to, STObject const& from)
978 {
979  populateClearFlag(to, from);
980 
981  populateDomain(to, from);
982 
983  populateEmailHash(to, from);
984 
985  populateMessageKey(to, from);
986 
987  populateSetFlag(to, from);
988 
989  populateTransferRate(to, from);
990 
991  populateTickSize(to, from);
992 }
993 
994 void
995 convert(org::xrpl::rpc::v1::OfferCreate& to, STObject const& from)
996 {
997  populateExpiration(to, from);
998 
999  populateOfferSequence(to, from);
1000 
1001  populateTakerGets(to, from);
1002 
1003  populateTakerPays(to, from);
1004 }
1005 
1006 void
1007 convert(org::xrpl::rpc::v1::OfferCancel& to, STObject const& from)
1008 {
1009  populateOfferSequence(to, from);
1010 }
1011 
1012 void
1013 convert(org::xrpl::rpc::v1::AccountDelete& to, STObject const& from)
1014 {
1015  populateDestination(to, from);
1016 }
1017 
1018 void
1019 convert(org::xrpl::rpc::v1::CheckCancel& to, STObject const& from)
1020 {
1021  populateCheckID(to, from);
1022 }
1023 
1024 void
1025 convert(org::xrpl::rpc::v1::CheckCash& to, STObject const& from)
1026 {
1027  populateCheckID(to, from);
1028 
1029  populateAmount(to, from);
1030 
1031  populateDeliverMin(to, from);
1032 }
1033 
1034 void
1035 convert(org::xrpl::rpc::v1::CheckCreate& to, STObject const& from)
1036 {
1037  populateDestination(to, from);
1038 
1039  populateSendMax(to, from);
1040 
1041  populateDestinationTag(to, from);
1042 
1043  populateExpiration(to, from);
1044 
1045  populateInvoiceID(to, from);
1046 }
1047 
1048 void
1049 convert(org::xrpl::rpc::v1::DepositPreauth& to, STObject const& from)
1050 {
1051  populateAuthorize(to, from);
1052 
1053  populateUnauthorize(to, from);
1054 }
1055 
1056 void
1057 convert(org::xrpl::rpc::v1::EscrowCancel& to, STObject const& from)
1058 {
1059  populateOwner(to, from);
1060 
1061  populateOfferSequence(to, from);
1062 }
1063 
1064 void
1065 convert(org::xrpl::rpc::v1::EscrowCreate& to, STObject const& from)
1066 {
1067  populateAmount(to, from);
1068 
1069  populateDestination(to, from);
1070 
1071  populateCancelAfter(to, from);
1072 
1073  populateFinishAfter(to, from);
1074 
1075  populateCondition(to, from);
1076 
1077  populateDestinationTag(to, from);
1078 }
1079 
1080 void
1081 convert(org::xrpl::rpc::v1::EscrowFinish& to, STObject const& from)
1082 {
1083  populateOwner(to, from);
1084 
1085  populateOfferSequence(to, from);
1086 
1087  populateCondition(to, from);
1088 
1089  populateFulfillment(to, from);
1090 }
1091 
1092 void
1093 convert(org::xrpl::rpc::v1::PaymentChannelClaim& to, STObject const& from)
1094 {
1095  populateChannel(to, from);
1096 
1097  populateBalance(to, from);
1098 
1099  populateAmount(to, from);
1100 
1101  populatePaymentChannelSignature(to, from);
1102 
1103  populatePublicKey(to, from);
1104 }
1105 
1106 void
1107 convert(org::xrpl::rpc::v1::PaymentChannelCreate& to, STObject const& from)
1108 {
1109  populateAmount(to, from);
1110 
1111  populateDestination(to, from);
1112 
1113  populateSettleDelay(to, from);
1114 
1115  populatePublicKey(to, from);
1116 
1117  populateCancelAfter(to, from);
1118 
1119  populateDestinationTag(to, from);
1120 }
1121 
1122 void
1123 convert(org::xrpl::rpc::v1::PaymentChannelFund& to, STObject const& from)
1124 {
1125  populateChannel(to, from);
1126 
1127  populateAmount(to, from);
1128 
1129  populateExpiration(to, from);
1130 }
1131 
1132 void
1133 convert(org::xrpl::rpc::v1::SetRegularKey& to, STObject const& from)
1134 {
1135  populateRegularKey(to, from);
1136 }
1137 
1138 void
1139 convert(org::xrpl::rpc::v1::SignerListSet& to, STObject const& from)
1140 {
1141  populateSignerQuorum(to, from);
1142 
1143  populateSignerEntries(to, from);
1144 }
1145 
1146 void
1147 convert(org::xrpl::rpc::v1::TrustSet& to, STObject const& from)
1148 {
1149  populateLimitAmount(to, from);
1150 
1151  populateQualityIn(to, from);
1152 
1153  populateQualityOut(to, from);
1154 }
1155 
1156 void
1157 convert(org::xrpl::rpc::v1::Payment& to, STObject const& from)
1158 {
1159  populateAmount(to, from);
1160 
1161  populateDestination(to, from);
1162 
1163  populateDestinationTag(to, from);
1164 
1165  populateInvoiceID(to, from);
1166 
1167  populateSendMax(to, from);
1168 
1169  populateDeliverMin(to, from);
1170 
1171  if (from.isFieldPresent(sfPaths))
1172  {
1173  // populate path data
1174  STPathSet const& pathset = from.getFieldPathSet(sfPaths);
1175  for (auto it = pathset.begin(); it < pathset.end(); ++it)
1176  {
1177  STPath const& path = *it;
1178 
1179  org::xrpl::rpc::v1::Payment_Path* protoPath = to.add_paths();
1180 
1181  for (auto it2 = path.begin(); it2 != path.end(); ++it2)
1182  {
1183  org::xrpl::rpc::v1::Payment_PathElement* protoElement =
1184  protoPath->add_elements();
1185  STPathElement const& elt = *it2;
1186 
1187  if (elt.isOffer())
1188  {
1189  if (elt.hasCurrency())
1190  {
1191  Currency const& currency = elt.getCurrency();
1192  protoElement->mutable_currency()->set_name(
1193  to_string(currency));
1194  }
1195  if (elt.hasIssuer())
1196  {
1197  AccountID const& issuer = elt.getIssuerID();
1198  protoElement->mutable_issuer()->set_address(
1199  toBase58(issuer));
1200  }
1201  }
1202  else if (elt.isAccount())
1203  {
1204  AccountID const& pathAccount = elt.getAccountID();
1205  protoElement->mutable_account()->set_address(
1206  toBase58(pathAccount));
1207  }
1208  }
1209  }
1210  }
1211 }
1212 
1213 void
1214 convert(org::xrpl::rpc::v1::AccountRoot& to, STObject const& from)
1215 {
1216  populateAccount(to, from);
1217 
1218  populateBalance(to, from);
1219 
1220  populateSequence(to, from);
1221 
1222  populateFlags(to, from);
1223 
1224  populateOwnerCount(to, from);
1225 
1226  populatePreviousTransactionID(to, from);
1227 
1228  populatePreviousTransactionLedgerSequence(to, from);
1229 
1230  populateAccountTransactionID(to, from);
1231 
1232  populateDomain(to, from);
1233 
1234  populateEmailHash(to, from);
1235 
1236  populateMessageKey(to, from);
1237 
1238  populateRegularKey(to, from);
1239 
1240  populateTickSize(to, from);
1241 
1242  populateTransferRate(to, from);
1243 }
1244 
1245 void
1246 convert(org::xrpl::rpc::v1::Amendments& to, STObject const& from)
1247 {
1248  populateAmendments(to, from);
1249 
1250  populateMajorities(to, from);
1251 }
1252 
1253 void
1254 convert(org::xrpl::rpc::v1::Check& to, STObject const& from)
1255 {
1256  populateAccount(to, from);
1257 
1258  populateDestination(to, from);
1259 
1260  populateFlags(to, from);
1261 
1262  populateOwnerNode(to, from);
1263 
1264  populatePreviousTransactionID(to, from);
1265 
1266  populatePreviousTransactionLedgerSequence(to, from);
1267 
1268  populateSendMax(to, from);
1269 
1270  populateSequence(to, from);
1271 
1272  populateDestinationNode(to, from);
1273 
1274  populateDestinationTag(to, from);
1275 
1276  populateExpiration(to, from);
1277 
1278  populateInvoiceID(to, from);
1279 
1280  populateSourceTag(to, from);
1281 }
1282 
1283 void
1284 convert(org::xrpl::rpc::v1::DepositPreauthObject& to, STObject const& from)
1285 {
1286  populateAccount(to, from);
1287 
1288  populateAuthorize(to, from);
1289 
1290  populateFlags(to, from);
1291 
1292  populateOwnerNode(to, from);
1293 
1294  populatePreviousTransactionID(to, from);
1295 
1296  populatePreviousTransactionLedgerSequence(to, from);
1297 }
1298 
1299 void
1300 convert(org::xrpl::rpc::v1::FeeSettings& to, STObject const& from)
1301 {
1302  populateBaseFee(to, from);
1303 
1304  populateReferenceFeeUnits(to, from);
1305 
1306  populateReserveBase(to, from);
1307 
1308  populateReserveIncrement(to, from);
1309 
1310  populateFlags(to, from);
1311 }
1312 
1313 void
1314 convert(org::xrpl::rpc::v1::Escrow& to, STObject const& from)
1315 {
1316  populateAccount(to, from);
1317 
1318  populateDestination(to, from);
1319 
1320  populateAmount(to, from);
1321 
1322  populateCondition(to, from);
1323 
1324  populateCancelAfter(to, from);
1325 
1326  populateFinishAfter(to, from);
1327 
1328  populateFlags(to, from);
1329 
1330  populateSourceTag(to, from);
1331 
1332  populateDestinationTag(to, from);
1333 
1334  populateOwnerNode(to, from);
1335 
1336  populateDestinationNode(to, from);
1337 
1338  populatePreviousTransactionID(to, from);
1339 
1340  populatePreviousTransactionLedgerSequence(to, from);
1341 }
1342 
1343 void
1344 convert(org::xrpl::rpc::v1::LedgerHashes& to, STObject const& from)
1345 {
1346  populateLastLedgerSequence(to, from);
1347 
1348  populateHashes(to, from);
1349 
1350  populateFlags(to, from);
1351 }
1352 
1353 void
1354 convert(org::xrpl::rpc::v1::PayChannel& to, STObject const& from)
1355 {
1356  populateAccount(to, from);
1357 
1358  populateAmount(to, from);
1359 
1360  populateBalance(to, from);
1361 
1362  populatePublicKey(to, from);
1363 
1364  populateSettleDelay(to, from);
1365 
1366  populateOwnerNode(to, from);
1367 
1368  populatePreviousTransactionID(to, from);
1369 
1370  populatePreviousTransactionLedgerSequence(to, from);
1371 
1372  populateFlags(to, from);
1373 
1374  populateExpiration(to, from);
1375 
1376  populateCancelAfter(to, from);
1377 
1378  populateSourceTag(to, from);
1379 
1380  populateDestinationTag(to, from);
1381 }
1382 
1383 void
1384 convert(org::xrpl::rpc::v1::DirectoryNode& to, STObject const& from)
1385 {
1386  populateFlags(to, from);
1387 
1388  populateRootIndex(to, from);
1389 
1390  populateIndexes(to, from);
1391 
1392  populateIndexNext(to, from);
1393 
1394  populateIndexPrevious(to, from);
1395 
1396  populateTakerPaysIssuer(to, from);
1397 
1398  populateTakerPaysCurrency(to, from);
1399 
1400  populateTakerGetsCurrency(to, from);
1401 
1402  populateTakerGetsIssuer(to, from);
1403 }
1404 
1405 void
1406 convert(org::xrpl::rpc::v1::Offer& to, STObject const& from)
1407 {
1408  populateAccount(to, from);
1409 
1410  populateSequence(to, from);
1411 
1412  populateFlags(to, from);
1413 
1414  populateTakerPays(to, from);
1415 
1416  populateTakerGets(to, from);
1417 
1418  populateBookDirectory(to, from);
1419 
1420  populateBookNode(to, from);
1421 }
1422 
1423 void
1424 convert(org::xrpl::rpc::v1::RippleState& to, STObject const& from)
1425 {
1426  populateBalance(to, from);
1427 
1428  populateFlags(to, from);
1429 
1430  populateLowNode(to, from);
1431 
1432  populateHighNode(to, from);
1433 
1434  populateLowQualityIn(to, from);
1435 
1436  populateLowQualityOut(to, from);
1437 
1438  populateHighQualityIn(to, from);
1439 
1440  populateHighQualityOut(to, from);
1441 
1442  populatePreviousTransactionID(to, from);
1443 
1444  populatePreviousTransactionLedgerSequence(to, from);
1445 }
1446 
1447 void
1448 convert(org::xrpl::rpc::v1::SignerList& to, STObject const& from)
1449 {
1450  populateFlags(to, from);
1451 
1452  populatePreviousTransactionID(to, from);
1453 
1454  populatePreviousTransactionLedgerSequence(to, from);
1455 
1456  populateOwnerNode(to, from);
1457 
1458  populateSignerEntries(to, from);
1459 
1460  populateSignerQuorum(to, from);
1461 
1462  populateSignerListID(to, from);
1463 }
1464 
1465 void
1466 convert(org::xrpl::rpc::v1::NegativeUNL& to, STObject const& from)
1467 {
1468  populateDisabledValidators(to, from);
1469 
1470  populateValidatorToDisable(to, from);
1471 
1472  populateValidatorToReEnable(to, from);
1473 
1474  populateFlags(to, from);
1475 }
1476 
1477 void
1478 setLedgerEntryType(
1479  org::xrpl::rpc::v1::AffectedNode& proto,
1480  std::uint16_t lgrType)
1481 {
1482  switch (lgrType)
1483  {
1484  case ltACCOUNT_ROOT:
1485  proto.set_ledger_entry_type(
1486  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_ACCOUNT_ROOT);
1487  break;
1488  case ltDIR_NODE:
1489  proto.set_ledger_entry_type(
1490  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_DIRECTORY_NODE);
1491  break;
1492  case ltRIPPLE_STATE:
1493  proto.set_ledger_entry_type(
1494  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_RIPPLE_STATE);
1495  break;
1496  case ltSIGNER_LIST:
1497  proto.set_ledger_entry_type(
1498  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_SIGNER_LIST);
1499  break;
1500  case ltOFFER:
1501  proto.set_ledger_entry_type(
1502  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_OFFER);
1503  break;
1504  case ltLEDGER_HASHES:
1505  proto.set_ledger_entry_type(
1506  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_LEDGER_HASHES);
1507  break;
1508  case ltAMENDMENTS:
1509  proto.set_ledger_entry_type(
1510  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_AMENDMENTS);
1511  break;
1512  case ltFEE_SETTINGS:
1513  proto.set_ledger_entry_type(
1514  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_FEE_SETTINGS);
1515  break;
1516  case ltESCROW:
1517  proto.set_ledger_entry_type(
1518  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_ESCROW);
1519  break;
1520  case ltPAYCHAN:
1521  proto.set_ledger_entry_type(
1522  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_PAY_CHANNEL);
1523  break;
1524  case ltCHECK:
1525  proto.set_ledger_entry_type(
1526  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_CHECK);
1527  break;
1528  case ltDEPOSIT_PREAUTH:
1529  proto.set_ledger_entry_type(
1530  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_DEPOSIT_PREAUTH);
1531  break;
1532  case ltNEGATIVE_UNL:
1533  proto.set_ledger_entry_type(
1534  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_NEGATIVE_UNL);
1535  break;
1536  }
1537 }
1538 
1539 template <class T>
1540 void
1541 convert(T& to, STObject& from, std::uint16_t type)
1542 {
1543  switch (type)
1544  {
1545  case ltACCOUNT_ROOT:
1546  RPC::convert(*to.mutable_account_root(), from);
1547  break;
1548  case ltAMENDMENTS:
1549  RPC::convert(*to.mutable_amendments(), from);
1550  break;
1551  case ltDIR_NODE:
1552  RPC::convert(*to.mutable_directory_node(), from);
1553  break;
1554  case ltRIPPLE_STATE:
1555  RPC::convert(*to.mutable_ripple_state(), from);
1556  break;
1557  case ltSIGNER_LIST:
1558  RPC::convert(*to.mutable_signer_list(), from);
1559  break;
1560  case ltOFFER:
1561  RPC::convert(*to.mutable_offer(), from);
1562  break;
1563  case ltLEDGER_HASHES:
1564  RPC::convert(*to.mutable_ledger_hashes(), from);
1565  break;
1566  case ltFEE_SETTINGS:
1567  RPC::convert(*to.mutable_fee_settings(), from);
1568  break;
1569  case ltESCROW:
1570  RPC::convert(*to.mutable_escrow(), from);
1571  break;
1572  case ltPAYCHAN:
1573  RPC::convert(*to.mutable_pay_channel(), from);
1574  break;
1575  case ltCHECK:
1576  RPC::convert(*to.mutable_check(), from);
1577  break;
1578  case ltDEPOSIT_PREAUTH:
1579  RPC::convert(*to.mutable_deposit_preauth(), from);
1580  break;
1581  case ltNEGATIVE_UNL:
1582  RPC::convert(*to.mutable_negative_unl(), from);
1583  break;
1584  }
1585 }
1586 
1587 template <class T>
1588 void
1589 populateFields(
1590  T const& getProto,
1591  STObject& obj,
1592  SField const& field,
1593  uint16_t lgrType)
1594 {
1595  // final fields
1596  if (obj.isFieldPresent(field))
1597  {
1598  STObject& data = obj.getField(field).downcast<STObject>();
1599 
1600  convert(*getProto(), data, lgrType);
1601  }
1602 }
1603 
1604 template <class T>
1605 void
1606 populateFinalFields(T const& getProto, STObject& obj, uint16_t lgrType)
1607 {
1608  populateFields(getProto, obj, sfFinalFields, lgrType);
1609 }
1610 
1611 template <class T>
1612 void
1613 populatePreviousFields(T const& getProto, STObject& obj, uint16_t lgrType)
1614 {
1615  populateFields(getProto, obj, sfPreviousFields, lgrType);
1616 }
1617 
1618 template <class T>
1619 void
1620 populateNewFields(T const& getProto, STObject& obj, uint16_t lgrType)
1621 {
1622  populateFields(getProto, obj, sfNewFields, lgrType);
1623 }
1624 
1625 void
1626 convert(org::xrpl::rpc::v1::Meta& to, std::shared_ptr<TxMeta> const& from)
1627 {
1628  to.set_transaction_index(from->getIndex());
1629 
1630  convert(*to.mutable_transaction_result(), from->getResultTER());
1631  to.mutable_transaction_result()->set_result(
1632  transToken(from->getResultTER()));
1633 
1634  if (from->hasDeliveredAmount())
1635  convert(*to.mutable_delivered_amount(), from->getDeliveredAmount());
1636 
1637  STArray& nodes = from->getNodes();
1638  for (auto it = nodes.begin(); it != nodes.end(); ++it)
1639  {
1640  STObject& obj = *it;
1641  org::xrpl::rpc::v1::AffectedNode* node = to.add_affected_nodes();
1642 
1643  // ledger index
1644  uint256 ledgerIndex = obj.getFieldH256(sfLedgerIndex);
1645  node->set_ledger_index(ledgerIndex.data(), ledgerIndex.size());
1646 
1647  // ledger entry type
1648  std::uint16_t lgrType = obj.getFieldU16(sfLedgerEntryType);
1649  setLedgerEntryType(*node, lgrType);
1650 
1651  // modified node
1652  if (obj.getFName() == sfModifiedNode)
1653  {
1654  populateFinalFields(
1655  [&node]() {
1656  return node->mutable_modified_node()
1657  ->mutable_final_fields();
1658  },
1659  obj,
1660  lgrType);
1661 
1662  populatePreviousFields(
1663  [&node]() {
1664  return node->mutable_modified_node()
1665  ->mutable_previous_fields();
1666  },
1667  obj,
1668  lgrType);
1669 
1670  populatePreviousTransactionID(*node->mutable_modified_node(), obj);
1671 
1672  populatePreviousTransactionLedgerSequence(
1673  *node->mutable_modified_node(), obj);
1674  }
1675  // created node
1676  else if (obj.getFName() == sfCreatedNode)
1677  {
1678  populateNewFields(
1679  [&node]() {
1680  return node->mutable_created_node()->mutable_new_fields();
1681  },
1682  obj,
1683  lgrType);
1684  }
1685  // deleted node
1686  else if (obj.getFName() == sfDeletedNode)
1687  {
1688  populateFinalFields(
1689  [&node]() {
1690  return node->mutable_deleted_node()->mutable_final_fields();
1691  },
1692  obj,
1693  lgrType);
1694  }
1695  }
1696 }
1697 
1698 void
1699 convert(
1700  org::xrpl::rpc::v1::QueueData& to,
1701  std::map<TxSeq, TxQ::AccountTxDetails const> const& from)
1702 {
1703  if (!from.empty())
1704  {
1705  to.set_txn_count(from.size());
1706  to.set_lowest_sequence(from.begin()->first);
1707  to.set_highest_sequence(from.rbegin()->first);
1708 
1709  boost::optional<bool> anyAuthChanged(false);
1710  boost::optional<XRPAmount> totalSpend(0);
1711 
1712  for (auto const& [txSeq, txDetails] : from)
1713  {
1714  org::xrpl::rpc::v1::QueuedTransaction& qt = *to.add_transactions();
1715 
1716  qt.mutable_sequence()->set_value(txSeq);
1717  qt.set_fee_level(txDetails.feeLevel.fee());
1718  if (txDetails.lastValid)
1719  qt.mutable_last_ledger_sequence()->set_value(
1720  *txDetails.lastValid);
1721 
1722  if (txDetails.consequences)
1723  {
1724  qt.mutable_fee()->set_drops(
1725  txDetails.consequences->fee.drops());
1726  auto spend = txDetails.consequences->potentialSpend +
1727  txDetails.consequences->fee;
1728  qt.mutable_max_spend_drops()->set_drops(spend.drops());
1729  if (totalSpend)
1730  *totalSpend += spend;
1731  auto authChanged =
1732  txDetails.consequences->category == TxConsequences::blocker;
1733  if (authChanged)
1734  anyAuthChanged.emplace(authChanged);
1735  qt.set_auth_change(authChanged);
1736  }
1737  else
1738  {
1739  if (anyAuthChanged && !*anyAuthChanged)
1740  anyAuthChanged.reset();
1741  totalSpend.reset();
1742  }
1743  }
1744 
1745  if (anyAuthChanged)
1746  to.set_auth_change_queued(*anyAuthChanged);
1747  if (totalSpend)
1748  to.mutable_max_spend_drops_total()->set_drops(
1749  (*totalSpend).drops());
1750  }
1751 }
1752 
1753 void
1754 convert(
1755  org::xrpl::rpc::v1::Transaction& to,
1756  std::shared_ptr<STTx const> const& from)
1757 {
1758  STObject const& fromObj = *from;
1759 
1760  populateAccount(to, fromObj);
1761 
1762  populateFee(to, fromObj);
1763 
1764  populateSequence(to, fromObj);
1765 
1766  populateSigningPublicKey(to, fromObj);
1767 
1768  populateTransactionSignature(to, fromObj);
1769 
1770  populateFlags(to, fromObj);
1771 
1772  populateLastLedgerSequence(to, fromObj);
1773 
1774  populateSourceTag(to, fromObj);
1775 
1776  populateAccountTransactionID(to, fromObj);
1777 
1778  populateMemos(to, fromObj);
1779 
1780  populateSigners(to, fromObj);
1781 
1782  auto type = safe_cast<TxType>(fromObj.getFieldU16(sfTransactionType));
1783 
1784  switch (type)
1785  {
1786  case TxType::ttPAYMENT:
1787  convert(*to.mutable_payment(), fromObj);
1788  break;
1789  case TxType::ttESCROW_CREATE:
1790  convert(*to.mutable_escrow_create(), fromObj);
1791  break;
1792  case TxType::ttESCROW_FINISH:
1793  convert(*to.mutable_escrow_finish(), fromObj);
1794  break;
1795  case TxType::ttACCOUNT_SET:
1796  convert(*to.mutable_account_set(), fromObj);
1797  break;
1798  case TxType::ttESCROW_CANCEL:
1799  convert(*to.mutable_escrow_cancel(), fromObj);
1800  break;
1801  case TxType::ttREGULAR_KEY_SET:
1802  convert(*to.mutable_set_regular_key(), fromObj);
1803  break;
1804  case TxType::ttOFFER_CREATE:
1805  convert(*to.mutable_offer_create(), fromObj);
1806  break;
1807  case TxType::ttOFFER_CANCEL:
1808  convert(*to.mutable_offer_cancel(), fromObj);
1809  break;
1810  case TxType::ttSIGNER_LIST_SET:
1811  convert(*to.mutable_signer_list_set(), fromObj);
1812  break;
1813  case TxType::ttPAYCHAN_CREATE:
1814  convert(*to.mutable_payment_channel_create(), fromObj);
1815  break;
1816  case TxType::ttPAYCHAN_FUND:
1817  convert(*to.mutable_payment_channel_fund(), fromObj);
1818  break;
1819  case TxType::ttPAYCHAN_CLAIM:
1820  convert(*to.mutable_payment_channel_claim(), fromObj);
1821  break;
1822  case TxType::ttCHECK_CREATE:
1823  convert(*to.mutable_check_create(), fromObj);
1824  break;
1825  case TxType::ttCHECK_CASH:
1826  convert(*to.mutable_check_cash(), fromObj);
1827  break;
1828  case TxType::ttCHECK_CANCEL:
1829  convert(*to.mutable_check_cancel(), fromObj);
1830  break;
1831  case TxType::ttDEPOSIT_PREAUTH:
1832  convert(*to.mutable_deposit_preauth(), fromObj);
1833  break;
1834  case TxType::ttTRUST_SET:
1835  convert(*to.mutable_trust_set(), fromObj);
1836  break;
1837  case TxType::ttACCOUNT_DELETE:
1838  convert(*to.mutable_account_delete(), fromObj);
1839  break;
1840  default:
1841  break;
1842  }
1843 }
1844 
1845 } // namespace RPC
1846 } // namespace ripple
ripple::RPC::populateTakerPaysCurrency
void populateTakerPaysCurrency(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:780
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:764
ripple::sfHighQualityIn
const SF_U32 sfHighQualityIn(access, STI_UINT32, 16, "HighQualityIn")
Definition: SField.h:369
ripple::RPC::populateLowQualityOut
void populateLowQualityOut(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:680
ripple::RPC::populateProtoAmount
void populateProtoAmount(T const &getProto, STObject const &from, SF_Amount const &field)
Definition: GRPCHelpers.cpp:103
ripple::STObject::peekAtField
const STBase & peekAtField(SField const &field) const
Definition: STObject.cpp:346
ripple::RPC::populateDisabledValidators
void populateDisabledValidators(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:881
ripple::STObject::getFieldArray
const STArray & getFieldArray(SField const &field) const
Definition: STObject.cpp:597
ripple::sfRegularKey
const SF_Account sfRegularKey(access, STI_ACCOUNT, 8, "RegularKey")
Definition: SField.h:487
ripple::RPC::populatePublicKey
void populatePublicKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:390
ripple::RPC::populateTakerPaysIssuer
void populateTakerPaysIssuer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:790
ripple::RPC::populateBaseFee
void populateBaseFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:830
ripple::STBase::getSType
virtual SerializedTypeID getSType() const
Definition: STBase.cpp:67
ripple::sfIndexNext
const SF_U64 sfIndexNext(access, STI_UINT64, 1, "IndexNext")
Definition: SField.h:395
ripple::sfPreviousFields
const SField sfPreviousFields(access, STI_OBJECT, 6, "PreviousFields")
Definition: SField.h:503
ripple::RPC::populateReserveBase
void populateReserveBase(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:848
ripple::STBase::downcast
D & downcast()
Definition: STBase.h:94
ripple::RPC::populateProtoVLasString
void populateProtoVLasString(T const &getProto, STObject const &from, SF_Blob const &field)
Definition: GRPCHelpers.cpp:56
ripple::RPC::populateAmount
void populateAmount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:257
ripple::RPC::populateSourceTag
void populateSourceTag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:530
std::shared_ptr
STL class.
ripple::RPC::populateExpiration
void populateExpiration(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:209
ripple::STPathElement::isOffer
bool isOffer() const
Definition: STPathSet.h:139
ripple::TypedField
A field with a type known at compile time.
Definition: SField.h:281
ripple::RPC::populateSignerEntries
void populateSignerEntries(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:866
ripple::STPathSet::end
std::vector< STPath >::const_iterator end() const
Definition: STPathSet.h:375
ripple::sfPreviousTxnLgrSeq
const SF_U32 sfPreviousTxnLgrSeq(access, STI_UINT32, 5, "PreviousTxnLgrSeq", SField::sMD_DeleteFinal)
Definition: SField.h:357
ripple::sfQualityIn
const SF_U32 sfQualityIn(access, STI_UINT32, 20, "QualityIn")
Definition: SField.h:373
ripple::sfLedgerEntryType
const SF_U16 sfLedgerEntryType(access, STI_UINT16, 1, "LedgerEntryType", SField::sMD_Never)
Definition: SField.h:346
ripple::sfLedgerIndex
const SF_U256 sfLedgerIndex(access, STI_HASH256, 6, "LedgerIndex")
Definition: SField.h:422
ripple::RPC::populateSigners
void populateSigners(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:912
ripple::sfSigners
const SField sfSigners(access, STI_ARRAY, 3, "Signers", SField::sMD_Default, SField::notSigning)
Definition: SField.h:516
ripple::isTesSuccess
bool isTesSuccess(TER x)
Definition: TER.h:576
ripple::RPC::populateValidatorToDisable
void populateValidatorToDisable(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:500
ripple::STObject::getFieldV256
const STVector256 & getFieldV256(SField const &field) const
Definition: STObject.cpp:590
ripple::sfMemoType
const SF_Blob sfMemoType(access, STI_VL, 12, "MemoType")
Definition: SField.h:467
ripple::RPC::populateMemoType
void populateMemoType(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:564
ripple::XRPAmount::drops
constexpr value_type drops() const
Returns the number of drops.
Definition: XRPAmount.h:172
ripple::RPC::populateHighLimit
void populateHighLimit(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:648
ripple::sfSigningPubKey
const SF_Blob sfSigningPubKey(access, STI_VL, 3, "SigningPubKey")
Definition: SField.h:459
ripple::RPC::populateBookNode
void populateBookNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:718
ripple::RPC::populateAccount
void populateAccount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:444
ripple::sfDeliveredAmount
const SF_Amount sfDeliveredAmount(access, STI_AMOUNT, 18, "DeliveredAmount")
Definition: SField.h:454
ripple::sfSignerQuorum
const SF_U32 sfSignerQuorum(access, STI_UINT32, 35, "SignerQuorum")
Definition: SField.h:388
ripple::ltESCROW
@ ltESCROW
Definition: LedgerFormats.h:80
std::map::size
T size(T... args)
ripple::sfMessageKey
const SF_Blob sfMessageKey(access, STI_VL, 2, "MessageKey")
Definition: SField.h:458
ripple::sfSequence
const SF_U32 sfSequence(access, STI_UINT32, 4, "Sequence")
Definition: SField.h:356
ripple::sfAccount
const SF_Account sfAccount(access, STI_ACCOUNT, 1, "Account")
Definition: SField.h:480
ripple::sfFlags
const SF_U32 sfFlags(access, STI_UINT32, 2, "Flags")
Definition: SField.h:354
ripple::sfTakerPaysIssuer
const SF_U160 sfTakerPaysIssuer(access, STI_HASH160, 2, "TakerPaysIssuer")
Definition: SField.h:412
ripple::sfNewFields
const SField sfNewFields(access, STI_OBJECT, 8, "NewFields")
Definition: SField.h:505
ripple::RPC::populateMemos
void populateMemos(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:896
ripple::sfMajorities
const SField sfMajorities(access, STI_ARRAY, 16, "Majorities")
Definition: SField.h:523
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:421
ripple::RPC::populateFee
void populateFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:452
ripple::RPC::populateProtoVec256
void populateProtoVec256(T const &getProto, STObject const &from, SF_Vec256 const &field)
Definition: GRPCHelpers.cpp:71
ripple::sfTakerPays
const SF_Amount sfTakerPays(access, STI_AMOUNT, 4, "TakerPays")
Definition: SField.h:443
ripple::transToken
std::string transToken(TER code)
Definition: TER.cpp:193
ripple::RPC::populateOwner
void populateOwner(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:325
ripple::RPC::populateClearFlag
void populateClearFlag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:153
ripple::RPC::populateFields
void populateFields(T const &getProto, STObject &obj, SField const &field, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1589
ripple::RPC::populateFulfillment
void populateFulfillment(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:356
ripple::sfUnauthorize
const SF_Account sfUnauthorize(access, STI_ACCOUNT, 6, "Unauthorize")
Definition: SField.h:485
ripple::RPC::populateMajorities
void populateMajorities(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:928
ripple::ltLEDGER_HASHES
@ ltLEDGER_HASHES
Definition: LedgerFormats.h:74
ripple::RPC::populateRootIndex
void populateRootIndex(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:756
ripple::STPathElement::getCurrency
Currency const & getCurrency() const
Definition: STPathSet.h:177
ripple::ltAMENDMENTS
@ ltAMENDMENTS
Definition: LedgerFormats.h:76
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:472
ripple::RPC::populateQualityIn
void populateQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:428
ripple::to_string
std::string to_string(ListDisposition disposition)
Definition: ValidatorList.cpp:42
ripple::STObject::getFieldVL
Blob getFieldVL(SField const &field) const
Definition: STObject.cpp:568
ripple::sfOwnerNode
const SF_U64 sfOwnerNode(access, STI_UINT64, 4, "OwnerNode")
Definition: SField.h:398
ripple::sfSigner
const SField sfSigner(access, STI_OBJECT, 16, "Signer")
Definition: SField.h:509
ripple::RPC::populateMessageKey
void populateMessageKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:177
ripple::ltSIGNER_LIST
@ ltSIGNER_LIST
Definition: LedgerFormats.h:70
ripple::sfDisabledValidators
const SField sfDisabledValidators(access, STI_ARRAY, 17, "DisabledValidators")
Definition: SField.h:524
ripple::sfTakerGetsCurrency
const SF_U160 sfTakerGetsCurrency(access, STI_HASH160, 3, "TakerGetsCurrency")
Definition: SField.h:413
ripple::sfPayChannel
const SF_U256 sfPayChannel(access, STI_HASH256, 22, "Channel")
Definition: SField.h:434
ripple::RPC::populateSettleDelay
void populateSettleDelay(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:398
ripple::sfAmount
const SF_Amount sfAmount(access, STI_AMOUNT, 1, "Amount")
Definition: SField.h:440
ripple::sfSignerEntries
const SField sfSignerEntries(access, STI_ARRAY, 4, "SignerEntries")
Definition: SField.h:517
ripple::STArray::end
iterator end()
Definition: STArray.h:120
ripple::RPC::populateValidatorToReEnable
void populateValidatorToReEnable(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:510
ripple::STObject::getFieldH160
uint160 getFieldH160(SField const &field) const
Definition: STObject.cpp:550
ripple::RPC::populateLowQualityIn
void populateLowQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:672
ripple::sfOwnerCount
const SF_U32 sfOwnerCount(access, STI_UINT32, 13, "OwnerCount")
Definition: SField.h:365
ripple::RPC::populateDeliverMin
void populateDeliverMin(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:265
ripple::sfFinalFields
const SField sfFinalFields(access, STI_OBJECT, 7, "FinalFields")
Definition: SField.h:504
ripple::sfModifiedNode
const SField sfModifiedNode(access, STI_OBJECT, 5, "ModifiedNode")
Definition: SField.h:502
ripple::sfReserveBase
const SF_U32 sfReserveBase(access, STI_UINT32, 31, "ReserveBase")
Definition: SField.h:384
ripple::sfLimitAmount
const SF_Amount sfLimitAmount(access, STI_AMOUNT, 3, "LimitAmount")
Definition: SField.h:442
ripple::isTecClaim
bool isTecClaim(TER x)
Definition: TER.h:582
ripple::sfHighLimit
const SF_Amount sfHighLimit(access, STI_AMOUNT, 7, "HighLimit")
Definition: SField.h:446
ripple::RPC::populateFlags
void populateFlags(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:482
ripple::sfFinishAfter
const SF_U32 sfFinishAfter(access, STI_UINT32, 37, "FinishAfter")
Definition: SField.h:390
ripple::STPathSet
Definition: STPathSet.h:309
ripple::base_uint::data
pointer data()
Definition: base_uint.h:103
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::sfSignature
const SF_Blob sfSignature(access, STI_VL, 6, "Signature", SField::sMD_Default, SField::notSigning)
Definition: SField.h:461
ripple::RPC::populateFirstLedgerSequence
void populateFirstLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:490
ripple::STAmount::xrp
XRPAmount xrp() const
Definition: STAmount.cpp:299
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::sfAccountTxnID
const SF_U256 sfAccountTxnID(access, STI_HASH256, 9, "AccountTxnID")
Definition: SField.h:425
ripple::RPC::populatePreviousTransactionID
void populatePreviousTransactionID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:620
ripple::sfLowLimit
const SF_Amount sfLowLimit(access, STI_AMOUNT, 6, "LowLimit")
Definition: SField.h:445
ripple::ltCHECK
@ ltCHECK
Definition: LedgerFormats.h:85
ripple::sfMajority
const SField sfMajority(access, STI_OBJECT, 18, "Majority")
Definition: SField.h:510
ripple::base_uint::size
constexpr static std::size_t size()
Definition: base_uint.h:462
ripple::sfDestinationTag
const SF_U32 sfDestinationTag(access, STI_UINT32, 14, "DestinationTag")
Definition: SField.h:366
ripple::sfMemoData
const SF_Blob sfMemoData(access, STI_VL, 13, "MemoData")
Definition: SField.h:468
ripple::sfIndexPrevious
const SF_U64 sfIndexPrevious(access, STI_UINT64, 2, "IndexPrevious")
Definition: SField.h:396
ripple::isTerRetry
bool isTerRetry(TER x)
Definition: TER.h:570
ripple::sfFulfillment
const SF_Blob sfFulfillment(access, STI_VL, 16, "Fulfillment")
Definition: SField.h:472
ripple::base_uint< 256 >
ripple::sfLastLedgerSequence
const SF_U32 sfLastLedgerSequence(access, STI_UINT32, 27, "LastLedgerSequence")
Definition: SField.h:380
ripple::STArray::begin
iterator begin()
Definition: STArray.h:114
ripple::RPC::convert
void convert(org::xrpl::rpc::v1::TransactionResult &to, TER from)
Definition: GRPCHelpers.cpp:942
ripple::RPC::populateNewFields
void populateNewFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1620
ripple::RPC::populateDestinationTag
void populateDestinationTag(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:291
ripple::RPC::populateHighQualityIn
void populateHighQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:690
ripple::sfOwner
const SF_Account sfOwner(access, STI_ACCOUNT, 2, "Owner")
Definition: SField.h:481
ripple::sfHighNode
const SF_U64 sfHighNode(access, STI_UINT64, 8, "HighNode")
Definition: SField.h:402
ripple::RPC::populateSignerQuorum
void populateSignerQuorum(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:414
ripple::RPC::populateProtoPrimitive
void populateProtoPrimitive(L const &getProto, STObject const &from, TypedField< T > const &field)
Definition: GRPCHelpers.cpp:35
ripple::sfBookDirectory
const SF_U256 sfBookDirectory(access, STI_HASH256, 16, "BookDirectory")
Definition: SField.h:428
ripple::ltFEE_SETTINGS
@ ltFEE_SETTINGS
Definition: LedgerFormats.h:78
ripple::RPC::populateDeliveredAmount
void populateDeliveredAmount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:281
ripple::sfSendMax
const SF_Amount sfSendMax(access, STI_AMOUNT, 9, "SendMax")
Definition: SField.h:448
ripple::STObject::getAccountID
AccountID getAccountID(SField const &field) const
Definition: STObject.cpp:562
ripple::sfAmendment
const SF_U256 sfAmendment(access, STI_HASH256, 19, "Amendment")
Definition: SField.h:431
ripple::sfSignerListID
const SF_U32 sfSignerListID(access, STI_UINT32, 38, "SignerListID")
Definition: SField.h:391
ripple::TERSubset
Definition: TER.h:322
ripple::RPC::setLedgerEntryType
void setLedgerEntryType(org::xrpl::rpc::v1::AffectedNode &proto, std::uint16_t lgrType)
Definition: GRPCHelpers.cpp:1478
ripple::sfDestinationNode
const SF_U64 sfDestinationNode(access, STI_UINT64, 9, "DestinationNode")
Definition: SField.h:403
ripple::isTefFailure
bool isTefFailure(TER x)
Definition: TER.h:564
ripple::STArray
Definition: STArray.h:28
ripple::RPC::populateProtoCurrency
void populateProtoCurrency(T const &getProto, STObject const &from, SF_U160 const &field)
Definition: GRPCHelpers.cpp:117
ripple::STPathElement::getIssuerID
AccountID const & getIssuerID() const
Definition: STPathSet.h:183
ripple::STPathElement::getAccountID
AccountID const & getAccountID() const
Definition: STPathSet.h:171
ripple::sfTxnSignature
const SF_Blob sfTxnSignature(access, STI_VL, 4, "TxnSignature", SField::sMD_Default, SField::notSigning)
Definition: SField.h:460
ripple::sfTransactionType
const SF_U16 sfTransactionType(access, STI_UINT16, 2, "TransactionType")
Definition: SField.h:347
ripple::RPC::populatePreviousFields
void populatePreviousFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1613
ripple::RPC::populateTransferRate
void populateTransferRate(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:193
ripple::sfReferenceFeeUnits
const SF_U32 sfReferenceFeeUnits(access, STI_UINT32, 30, "ReferenceFeeUnits")
Definition: SField.h:383
ripple::RPC::populatePreviousTransactionLedgerSequence
void populatePreviousTransactionLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:630
ripple::STVector256::size
std::size_t size() const
Definition: STVector256.h:110
ripple::sfSignerEntry
const SField sfSignerEntry(access, STI_OBJECT, 11, "SignerEntry")
Definition: SField.h:508
ripple::RPC::populateReserveIncrement
void populateReserveIncrement(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:856
ripple::RPC::populateUnauthorize
void populateUnauthorize(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:317
ripple::sfLowQualityOut
const SF_U32 sfLowQualityOut(access, STI_UINT32, 19, "LowQualityOut")
Definition: SField.h:372
std::uint16_t
ripple::RPC::populateDestinationNode
void populateDestinationNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:820
ripple::RPC::populateMemoFormat
void populateMemoFormat(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:556
ripple::sfCreatedNode
const SField sfCreatedNode(access, STI_OBJECT, 3, "CreatedNode")
Definition: SField.h:500
ripple::RPC::populateCancelAfter
void populateCancelAfter(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:332
ripple::ltDEPOSIT_PREAUTH
@ ltDEPOSIT_PREAUTH
Definition: LedgerFormats.h:87
std::map
STL class.
ripple::sfSourceTag
const SF_U32 sfSourceTag(access, STI_UINT32, 3, "SourceTag")
Definition: SField.h:355
ripple::STPathElement::hasIssuer
bool hasIssuer() const
Definition: STPathSet.h:151
ripple::STPathSet::begin
std::vector< STPath >::const_iterator begin() const
Definition: STPathSet.h:369
ripple::sfIndexes
const SF_Vec256 sfIndexes(access, STI_VECTOR256, 1, "Indexes", SField::sMD_Never)
Definition: SField.h:493
ripple::STObject::getFieldU16
std::uint16_t getFieldU16(SField const &field) const
Definition: STObject.cpp:526
ripple::RPC::populateTakerPays
void populateTakerPays(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:233
ripple::sfExpiration
const SF_U32 sfExpiration(access, STI_UINT32, 10, "Expiration")
Definition: SField.h:362
ripple::sfFirstLedgerSequence
const SF_U32 sfFirstLedgerSequence(access, STI_UINT32, 26, "FirstLedgerSequence")
Definition: SField.h:379
ripple::sfFee
const SF_Amount sfFee(access, STI_AMOUNT, 8, "Fee")
Definition: SField.h:447
ripple::RPC::populateChannel
void populateChannel(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:364
ripple::sfQualityOut
const SF_U32 sfQualityOut(access, STI_UINT32, 21, "QualityOut")
Definition: SField.h:374
ripple::RPC::populateAmendment
void populateAmendment(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:580
ripple::RPC::populateProtoAccount
void populateProtoAccount(T const &getProto, STObject const &from, SF_Account const &field)
Definition: GRPCHelpers.cpp:89
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::STBase::getFName
SField const & getFName() const
Definition: STBase.cpp:135
ripple::sfValidatorToReEnable
const SF_Blob sfValidatorToReEnable(access, STI_VL, 21, "ValidatorToReEnable")
Definition: SField.h:477
ripple::STPathElement::hasCurrency
bool hasCurrency() const
Definition: STPathSet.h:157
ripple::sfMemo
const SField sfMemo(access, STI_OBJECT, 10, "Memo")
Definition: SField.h:507
ripple::sfHashes
const SF_Vec256 sfHashes(access, STI_VECTOR256, 2, "Hashes")
Definition: SField.h:494
ripple::RPC::populateCloseTime
void populateCloseTime(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:588
ripple::ltNEGATIVE_UNL
@ ltNEGATIVE_UNL
Definition: LedgerFormats.h:89
ripple::RPC::populateTakerGetsIssuer
void populateTakerGetsIssuer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:810
ripple::RPC::populateSendMax
void populateSendMax(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:273
ripple::STObject
Definition: STObject.h:51
ripple::sfPublicKey
const SF_Blob sfPublicKey(access, STI_VL, 1, "PublicKey")
Definition: SField.h:457
ripple::RPC::populateSignerWeight
void populateSignerWeight(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:596
ripple::sfSignerWeight
const SF_U16 sfSignerWeight(access, STI_UINT16, 3, "SignerWeight")
Definition: SField.h:348
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::ltRIPPLE_STATE
@ ltRIPPLE_STATE
Definition: LedgerFormats.h:66
ripple::RPC::populateLastLedgerSequence
void populateLastLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:520
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::sfLowQualityIn
const SF_U32 sfLowQualityIn(access, STI_UINT32, 18, "LowQualityIn")
Definition: SField.h:371
ripple::sfBalance
const SF_Amount sfBalance(access, STI_AMOUNT, 2, "Balance")
Definition: SField.h:441
ripple::sfTakerPaysCurrency
const SF_U160 sfTakerPaysCurrency(access, STI_HASH160, 1, "TakerPaysCurrency")
Definition: SField.h:411
ripple::sfDeliverMin
const SF_Amount sfDeliverMin(access, STI_AMOUNT, 10, "DeliverMin")
Definition: SField.h:449
ripple::sfOfferSequence
const SF_U32 sfOfferSequence(access, STI_UINT32, 25, "OfferSequence")
Definition: SField.h:378
ripple::SField
Identifies fields.
Definition: SField.h:109
ripple::STPathElement
Definition: STPathSet.h:33
ripple::RPC::populateSequence
void populateSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:572
ripple::STObject::getField
STBase & getField(SField const &field)
Definition: STObject.cpp:357
std::map::begin
T begin(T... args)
ripple::RPC::populateIndexes
void populateIndexes(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:749
ripple::sfReserveIncrement
const SF_U32 sfReserveIncrement(access, STI_UINT32, 32, "ReserveIncrement")
Definition: SField.h:385
ripple::STObject::isFieldPresent
bool isFieldPresent(SField const &field) const
Definition: STObject.cpp:401
ripple::RPC::populateSignerListID
void populateSignerListID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:734
ripple::RPC::populateHighQualityOut
void populateHighQualityOut(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:700
ripple::isTelLocal
bool isTelLocal(TER x)
Definition: TER.h:552
ripple::RPC::populateFinalFields
void populateFinalFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1606
ripple::RPC::populateIndexPrevious
void populateIndexPrevious(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:772
ripple::sfClearFlag
const SF_U32 sfClearFlag(access, STI_UINT32, 34, "ClearFlag")
Definition: SField.h:387
ripple::sfCondition
const SF_Blob sfCondition(access, STI_VL, 17, "Condition")
Definition: SField.h:473
ripple::sfPaths
const SField sfPaths(access, STI_PATHSET, 1, "Paths")
Definition: SField.h:490
ripple::sfCloseTime
const SF_U32 sfCloseTime(access, STI_UINT32, 7, "CloseTime")
Definition: SField.h:359
ripple::sfMemos
const SField sfMemos(access, STI_ARRAY, 9, "Memos")
Definition: SField.h:522
ripple::RPC::populateMemoData
void populateMemoData(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:548
ripple::STVector256
Definition: STVector256.h:29
ripple::sfSettleDelay
const SF_U32 sfSettleDelay(access, STI_UINT32, 39, "SettleDelay")
Definition: SField.h:392
ripple::RPC::populateInvoiceID
void populateInvoiceID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:301
ripple::sfTakerGets
const SF_Amount sfTakerGets(access, STI_AMOUNT, 5, "TakerGets")
Definition: SField.h:444
std::map::empty
T empty(T... args)
ripple::sfDestination
const SF_Account sfDestination(access, STI_ACCOUNT, 3, "Destination")
Definition: SField.h:482
ripple::sfCheckID
const SF_U256 sfCheckID(access, STI_HASH256, 24, "CheckID")
Definition: SField.h:436
ripple::ltPAYCHAN
@ ltPAYCHAN
Definition: LedgerFormats.h:83
ripple::sfRootIndex
const SF_U256 sfRootIndex(access, STI_HASH256, 8, "RootIndex", SField::sMD_Always)
Definition: SField.h:424
ripple::sfTransferRate
const SF_U32 sfTransferRate(access, STI_UINT32, 11, "TransferRate")
Definition: SField.h:363
ripple::sfValidatorToDisable
const SF_Blob sfValidatorToDisable(access, STI_VL, 20, "ValidatorToDisable")
Definition: SField.h:476
ripple::RPC::populateHighNode
void populateHighNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:664
ripple::sfLowNode
const SF_U64 sfLowNode(access, STI_UINT64, 7, "LowNode")
Definition: SField.h:401
ripple::RPC::populateLowNode
void populateLowNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:656
ripple::ltDIR_NODE
@ ltDIR_NODE
Directory node.
Definition: LedgerFormats.h:64
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::ltOFFER
@ ltOFFER
Definition: LedgerFormats.h:72
ripple::sfAmendments
const SF_Vec256 sfAmendments(access, STI_VECTOR256, 3, "Amendments")
Definition: SField.h:495
ripple::STPathElement::isAccount
bool isAccount() const
Definition: STPathSet.h:145
ripple::sfBookNode
const SF_U64 sfBookNode(access, STI_UINT64, 3, "BookNode")
Definition: SField.h:397
ripple::RPC::populateSigningPublicKey
void populateSigningPublicKey(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:462
ripple::RPC::populateBookDirectory
void populateBookDirectory(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:710
ripple::sfBaseFee
const SF_U64 sfBaseFee(access, STI_UINT64, 5, "BaseFee")
Definition: SField.h:399
ripple::RPC::populateAccountTransactionID
void populateAccountTransactionID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:538
ripple::sfAuthorize
const SF_Account sfAuthorize(access, STI_ACCOUNT, 5, "Authorize")
Definition: SField.h:484
ripple::sfDeletedNode
const SField sfDeletedNode(access, STI_OBJECT, 4, "DeletedNode")
Definition: SField.h:501
ripple::TxConsequences::blocker
@ blocker
Affects the ability of subsequent transactions to claim a fee.
Definition: applySteps.h:135
ripple::ltACCOUNT_ROOT
@ ltACCOUNT_ROOT
Definition: LedgerFormats.h:53
ripple::RPC::populateReferenceFeeUnits
void populateReferenceFeeUnits(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:838
ripple::RPC::populateOwnerCount
void populateOwnerCount(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:612
ripple::RPC::populateLowLimit
void populateLowLimit(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:640
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:583
ripple::RPC::populateHashes
void populateHashes(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:742
ripple::RPC::populateTakerGetsCurrency
void populateTakerGetsCurrency(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:800
ripple::STPath
Definition: STPathSet.h:212
ripple::RPC::populateAmendments
void populateAmendments(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:604
ripple::sfHighQualityOut
const SF_U32 sfHighQualityOut(access, STI_UINT32, 17, "HighQualityOut")
Definition: SField.h:370
ripple::STObject::getFieldAmount
STAmount const & getFieldAmount(SField const &field) const
Definition: STObject.cpp:576
ripple::sfPreviousTxnID
const SF_U256 sfPreviousTxnID(access, STI_HASH256, 5, "PreviousTxnID", SField::sMD_DeleteFinal)
Definition: SField.h:421
ripple::sfCancelAfter
const SF_U32 sfCancelAfter(access, STI_UINT32, 36, "CancelAfter")
Definition: SField.h:389
ripple::isTemMalformed
bool isTemMalformed(TER x)
Definition: TER.h:558
ripple::sfEmailHash
const SF_U128 sfEmailHash(access, STI_HASH128, 1, "EmailHash")
Definition: SField.h:408
ripple::sfSetFlag
const SF_U32 sfSetFlag(access, STI_UINT32, 33, "SetFlag")
Definition: SField.h:386
ripple::RPC::populateOwnerNode
void populateOwnerNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:726
ripple::sfTickSize
const SF_U8 sfTickSize(access, STI_UINT8, 16, "TickSize")
Definition: SField.h:342
std::map::rbegin
T rbegin(T... args)
ripple::sfMemoFormat
const SF_Blob sfMemoFormat(access, STI_VL, 14, "MemoFormat")
Definition: SField.h:469
ripple::sfInvoiceID
const SF_U256 sfInvoiceID(access, STI_HASH256, 17, "InvoiceID")
Definition: SField.h:429
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:556
ripple::sfDisabledValidator
const SField sfDisabledValidator(access, STI_OBJECT, 19, "DisabledValidator")
Definition: SField.h:511
ripple::sfTakerGetsIssuer
const SF_U160 sfTakerGetsIssuer(access, STI_HASH160, 4, "TakerGetsIssuer")
Definition: SField.h:414
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:436
ripple::sfDomain
const SF_Blob sfDomain(access, STI_VL, 7, "Domain")
Definition: SField.h:462
Generated by   doxygen 1.8.17