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 
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 populateTicketSequence(T& to, STObject const& from)
752 {
753  populateProtoPrimitive(
754  [&to]() { return to.mutable_ticket_sequence(); },
755  from,
756  sfTicketSequence);
757 }
758 
759 template <class T>
760 void
761 populateHashes(T& to, STObject const& from)
762 {
763  populateProtoVec256([&to]() { return to.add_hashes(); }, from, sfHashes);
764 }
765 
766 template <class T>
767 void
768 populateIndexes(T& to, STObject const& from)
769 {
770  populateProtoVec256([&to]() { return to.add_indexes(); }, from, sfIndexes);
771 }
772 
773 template <class T>
774 void
775 populateRootIndex(T& to, STObject const& from)
776 {
777  populateProtoPrimitive(
778  [&to]() { return to.mutable_root_index(); }, from, sfRootIndex);
779 }
780 
781 template <class T>
782 void
783 populateIndexNext(T& to, STObject const& from)
784 {
785  populateProtoPrimitive(
786  [&to]() { return to.mutable_index_next(); }, from, sfIndexNext);
787 }
788 
789 template <class T>
790 void
791 populateIndexPrevious(T& to, STObject const& from)
792 {
793  populateProtoPrimitive(
794  [&to]() { return to.mutable_index_previous(); }, from, sfIndexPrevious);
795 }
796 
797 template <class T>
798 void
799 populateTakerPaysCurrency(T& to, STObject const& from)
800 {
801  populateProtoCurrency(
802  [&to]() { return to.mutable_taker_pays_currency(); },
803  from,
804  sfTakerPaysCurrency);
805 }
806 
807 template <class T>
808 void
809 populateTakerPaysIssuer(T& to, STObject const& from)
810 {
811  populateProtoPrimitive(
812  [&to]() { return to.mutable_taker_pays_issuer(); },
813  from,
814  sfTakerPaysIssuer);
815 }
816 
817 template <class T>
818 void
819 populateTakerGetsCurrency(T& to, STObject const& from)
820 {
821  populateProtoCurrency(
822  [&to]() { return to.mutable_taker_gets_currency(); },
823  from,
824  sfTakerGetsCurrency);
825 }
826 
827 template <class T>
828 void
829 populateTakerGetsIssuer(T& to, STObject const& from)
830 {
831  populateProtoPrimitive(
832  [&to]() { return to.mutable_taker_gets_issuer(); },
833  from,
834  sfTakerGetsIssuer);
835 }
836 
837 template <class T>
838 void
839 populateDestinationNode(T& to, STObject const& from)
840 {
841  populateProtoPrimitive(
842  [&to]() { return to.mutable_destination_node(); },
843  from,
844  sfDestinationNode);
845 }
846 
847 template <class T>
848 void
849 populateBaseFee(T& to, STObject const& from)
850 {
851  populateProtoPrimitive(
852  [&to]() { return to.mutable_base_fee(); }, from, sfBaseFee);
853 }
854 
855 template <class T>
856 void
857 populateReferenceFeeUnits(T& to, STObject const& from)
858 {
859  populateProtoPrimitive(
860  [&to]() { return to.mutable_reference_fee_units(); },
861  from,
862  sfReferenceFeeUnits);
863 }
864 
865 template <class T>
866 void
867 populateReserveBase(T& to, STObject const& from)
868 {
869  populateProtoPrimitive(
870  [&to]() { return to.mutable_reserve_base(); }, from, sfReserveBase);
871 }
872 
873 template <class T>
874 void
875 populateReserveIncrement(T& to, STObject const& from)
876 {
877  populateProtoPrimitive(
878  [&to]() { return to.mutable_reserve_increment(); },
879  from,
880  sfReserveIncrement);
881 }
882 
883 template <class T>
884 void
885 populateSignerEntries(T& to, STObject const& from)
886 {
887  populateProtoArray(
888  [&to]() { return to.add_signer_entries(); },
889  [](auto& innerObj, auto& innerProto) {
890  populateAccount(innerProto, innerObj);
891  populateSignerWeight(innerProto, innerObj);
892  },
893  from,
894  sfSignerEntries,
895  sfSignerEntry);
896 }
897 
898 template <class T>
899 void
900 populateDisabledValidators(T& to, STObject const& from)
901 {
902  populateProtoArray(
903  [&to]() { return to.add_disabled_validators(); },
904  [](auto& innerObj, auto& innerProto) {
905  populatePublicKey(innerProto, innerObj);
906  populateFirstLedgerSequence(innerProto, innerObj);
907  },
908  from,
909  sfDisabledValidators,
910  sfDisabledValidator);
911 }
912 
913 template <class T>
914 void
915 populateMemos(T& to, STObject const& from)
916 {
917  populateProtoArray(
918  [&to]() { return to.add_memos(); },
919  [](auto& innerObj, auto& innerProto) {
920  populateMemoData(innerProto, innerObj);
921  populateMemoType(innerProto, innerObj);
922  populateMemoFormat(innerProto, innerObj);
923  },
924  from,
925  sfMemos,
926  sfMemo);
927 }
928 
929 template <class T>
930 void
931 populateSigners(T& to, STObject const& from)
932 {
933  populateProtoArray(
934  [&to]() { return to.add_signers(); },
935  [](auto& innerObj, auto& innerProto) {
936  populateAccount(innerProto, innerObj);
937  populateTransactionSignature(innerProto, innerObj);
938  populateSigningPublicKey(innerProto, innerObj);
939  },
940  from,
941  sfSigners,
942  sfSigner);
943 }
944 
945 template <class T>
946 void
947 populateMajorities(T& to, STObject const& from)
948 {
949  populateProtoArray(
950  [&to]() { return to.add_majorities(); },
951  [](auto innerObj, auto innerProto) {
952  populateAmendment(innerProto, innerObj);
953  populateCloseTime(innerProto, innerObj);
954  },
955  from,
956  sfMajorities,
957  sfMajority);
958 }
959 
960 void
961 convert(org::xrpl::rpc::v1::TransactionResult& to, TER from)
962 {
963  if (isTecClaim(from))
964  {
965  to.set_result_type(
966  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEC);
967  }
968  if (isTefFailure(from))
969  {
970  to.set_result_type(
971  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEF);
972  }
973  if (isTelLocal(from))
974  {
975  to.set_result_type(
976  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEL);
977  }
978  if (isTemMalformed(from))
979  {
980  to.set_result_type(
981  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TEM);
982  }
983  if (isTerRetry(from))
984  {
985  to.set_result_type(
986  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TER);
987  }
988  if (isTesSuccess(from))
989  {
990  to.set_result_type(
991  org::xrpl::rpc::v1::TransactionResult::RESULT_TYPE_TES);
992  }
993 }
994 
995 void
996 convert(org::xrpl::rpc::v1::AccountSet& to, STObject const& from)
997 {
998  populateClearFlag(to, from);
999 
1000  populateDomain(to, from);
1001 
1002  populateEmailHash(to, from);
1003 
1004  populateMessageKey(to, from);
1005 
1006  populateSetFlag(to, from);
1007 
1008  populateTransferRate(to, from);
1009 
1010  populateTickSize(to, from);
1011 }
1012 
1013 void
1014 convert(org::xrpl::rpc::v1::OfferCreate& to, STObject const& from)
1015 {
1016  populateExpiration(to, from);
1017 
1018  populateOfferSequence(to, from);
1019 
1020  populateTakerGets(to, from);
1021 
1022  populateTakerPays(to, from);
1023 }
1024 
1025 void
1026 convert(org::xrpl::rpc::v1::OfferCancel& to, STObject const& from)
1027 {
1028  populateOfferSequence(to, from);
1029 }
1030 
1031 void
1032 convert(org::xrpl::rpc::v1::AccountDelete& to, STObject const& from)
1033 {
1034  populateDestination(to, from);
1035 }
1036 
1037 void
1038 convert(org::xrpl::rpc::v1::CheckCancel& to, STObject const& from)
1039 {
1040  populateCheckID(to, from);
1041 }
1042 
1043 void
1044 convert(org::xrpl::rpc::v1::CheckCash& to, STObject const& from)
1045 {
1046  populateCheckID(to, from);
1047 
1048  populateAmount(to, from);
1049 
1050  populateDeliverMin(to, from);
1051 }
1052 
1053 void
1054 convert(org::xrpl::rpc::v1::CheckCreate& to, STObject const& from)
1055 {
1056  populateDestination(to, from);
1057 
1058  populateSendMax(to, from);
1059 
1060  populateDestinationTag(to, from);
1061 
1062  populateExpiration(to, from);
1063 
1064  populateInvoiceID(to, from);
1065 }
1066 
1067 void
1068 convert(org::xrpl::rpc::v1::DepositPreauth& to, STObject const& from)
1069 {
1070  populateAuthorize(to, from);
1071 
1072  populateUnauthorize(to, from);
1073 }
1074 
1075 void
1076 convert(org::xrpl::rpc::v1::EscrowCancel& to, STObject const& from)
1077 {
1078  populateOwner(to, from);
1079 
1080  populateOfferSequence(to, from);
1081 }
1082 
1083 void
1084 convert(org::xrpl::rpc::v1::EscrowCreate& to, STObject const& from)
1085 {
1086  populateAmount(to, from);
1087 
1088  populateDestination(to, from);
1089 
1090  populateCancelAfter(to, from);
1091 
1092  populateFinishAfter(to, from);
1093 
1094  populateCondition(to, from);
1095 
1096  populateDestinationTag(to, from);
1097 }
1098 
1099 void
1100 convert(org::xrpl::rpc::v1::EscrowFinish& to, STObject const& from)
1101 {
1102  populateOwner(to, from);
1103 
1104  populateOfferSequence(to, from);
1105 
1106  populateCondition(to, from);
1107 
1108  populateFulfillment(to, from);
1109 }
1110 
1111 void
1112 convert(org::xrpl::rpc::v1::PaymentChannelClaim& to, STObject const& from)
1113 {
1114  populateChannel(to, from);
1115 
1116  populateBalance(to, from);
1117 
1118  populateAmount(to, from);
1119 
1120  populatePaymentChannelSignature(to, from);
1121 
1122  populatePublicKey(to, from);
1123 }
1124 
1125 void
1126 convert(org::xrpl::rpc::v1::PaymentChannelCreate& to, STObject const& from)
1127 {
1128  populateAmount(to, from);
1129 
1130  populateDestination(to, from);
1131 
1132  populateSettleDelay(to, from);
1133 
1134  populatePublicKey(to, from);
1135 
1136  populateCancelAfter(to, from);
1137 
1138  populateDestinationTag(to, from);
1139 }
1140 
1141 void
1142 convert(org::xrpl::rpc::v1::PaymentChannelFund& to, STObject const& from)
1143 {
1144  populateChannel(to, from);
1145 
1146  populateAmount(to, from);
1147 
1148  populateExpiration(to, from);
1149 }
1150 
1151 void
1152 convert(org::xrpl::rpc::v1::SetRegularKey& to, STObject const& from)
1153 {
1154  populateRegularKey(to, from);
1155 }
1156 
1157 void
1158 convert(org::xrpl::rpc::v1::SignerListSet& to, STObject const& from)
1159 {
1160  populateSignerQuorum(to, from);
1161 
1162  populateSignerEntries(to, from);
1163 }
1164 
1165 void
1166 convert(org::xrpl::rpc::v1::TicketCreate& to, STObject const& from)
1167 {
1168  populateTicketCount(to, from);
1169 }
1170 
1171 void
1172 convert(org::xrpl::rpc::v1::TrustSet& to, STObject const& from)
1173 {
1174  populateLimitAmount(to, from);
1175 
1176  populateQualityIn(to, from);
1177 
1178  populateQualityOut(to, from);
1179 }
1180 
1181 void
1182 convert(org::xrpl::rpc::v1::Payment& to, STObject const& from)
1183 {
1184  populateAmount(to, from);
1185 
1186  populateDestination(to, from);
1187 
1188  populateDestinationTag(to, from);
1189 
1190  populateInvoiceID(to, from);
1191 
1192  populateSendMax(to, from);
1193 
1194  populateDeliverMin(to, from);
1195 
1196  if (from.isFieldPresent(sfPaths))
1197  {
1198  // populate path data
1199  STPathSet const& pathset = from.getFieldPathSet(sfPaths);
1200  for (auto it = pathset.begin(); it < pathset.end(); ++it)
1201  {
1202  STPath const& path = *it;
1203 
1204  org::xrpl::rpc::v1::Payment_Path* protoPath = to.add_paths();
1205 
1206  for (auto it2 = path.begin(); it2 != path.end(); ++it2)
1207  {
1208  org::xrpl::rpc::v1::Payment_PathElement* protoElement =
1209  protoPath->add_elements();
1210  STPathElement const& elt = *it2;
1211 
1212  if (elt.isOffer())
1213  {
1214  if (elt.hasCurrency())
1215  {
1216  Currency const& currency = elt.getCurrency();
1217  protoElement->mutable_currency()->set_name(
1218  to_string(currency));
1219  }
1220  if (elt.hasIssuer())
1221  {
1222  AccountID const& issuer = elt.getIssuerID();
1223  protoElement->mutable_issuer()->set_address(
1224  toBase58(issuer));
1225  }
1226  }
1227  else if (elt.isAccount())
1228  {
1229  AccountID const& pathAccount = elt.getAccountID();
1230  protoElement->mutable_account()->set_address(
1231  toBase58(pathAccount));
1232  }
1233  }
1234  }
1235  }
1236 }
1237 
1238 void
1239 convert(org::xrpl::rpc::v1::AccountRoot& to, STObject const& from)
1240 {
1241  populateAccount(to, from);
1242 
1243  populateBalance(to, from);
1244 
1245  populateSequence(to, from);
1246 
1247  populateFlags(to, from);
1248 
1249  populateOwnerCount(to, from);
1250 
1251  populatePreviousTransactionID(to, from);
1252 
1253  populatePreviousTransactionLedgerSequence(to, from);
1254 
1255  populateAccountTransactionID(to, from);
1256 
1257  populateDomain(to, from);
1258 
1259  populateEmailHash(to, from);
1260 
1261  populateMessageKey(to, from);
1262 
1263  populateRegularKey(to, from);
1264 
1265  populateTickSize(to, from);
1266 
1267  populateTransferRate(to, from);
1268 }
1269 
1270 void
1271 convert(org::xrpl::rpc::v1::Amendments& to, STObject const& from)
1272 {
1273  populateAmendments(to, from);
1274 
1275  populateMajorities(to, from);
1276 }
1277 
1278 void
1279 convert(org::xrpl::rpc::v1::Check& to, STObject const& from)
1280 {
1281  populateAccount(to, from);
1282 
1283  populateDestination(to, from);
1284 
1285  populateFlags(to, from);
1286 
1287  populateOwnerNode(to, from);
1288 
1289  populatePreviousTransactionID(to, from);
1290 
1291  populatePreviousTransactionLedgerSequence(to, from);
1292 
1293  populateSendMax(to, from);
1294 
1295  populateSequence(to, from);
1296 
1297  populateDestinationNode(to, from);
1298 
1299  populateDestinationTag(to, from);
1300 
1301  populateExpiration(to, from);
1302 
1303  populateInvoiceID(to, from);
1304 
1305  populateSourceTag(to, from);
1306 }
1307 
1308 void
1309 convert(org::xrpl::rpc::v1::DepositPreauthObject& to, STObject const& from)
1310 {
1311  populateAccount(to, from);
1312 
1313  populateAuthorize(to, from);
1314 
1315  populateFlags(to, from);
1316 
1317  populateOwnerNode(to, from);
1318 
1319  populatePreviousTransactionID(to, from);
1320 
1321  populatePreviousTransactionLedgerSequence(to, from);
1322 }
1323 
1324 void
1325 convert(org::xrpl::rpc::v1::FeeSettings& to, STObject const& from)
1326 {
1327  populateBaseFee(to, from);
1328 
1329  populateReferenceFeeUnits(to, from);
1330 
1331  populateReserveBase(to, from);
1332 
1333  populateReserveIncrement(to, from);
1334 
1335  populateFlags(to, from);
1336 }
1337 
1338 void
1339 convert(org::xrpl::rpc::v1::Escrow& to, STObject const& from)
1340 {
1341  populateAccount(to, from);
1342 
1343  populateDestination(to, from);
1344 
1345  populateAmount(to, from);
1346 
1347  populateCondition(to, from);
1348 
1349  populateCancelAfter(to, from);
1350 
1351  populateFinishAfter(to, from);
1352 
1353  populateFlags(to, from);
1354 
1355  populateSourceTag(to, from);
1356 
1357  populateDestinationTag(to, from);
1358 
1359  populateOwnerNode(to, from);
1360 
1361  populateDestinationNode(to, from);
1362 
1363  populatePreviousTransactionID(to, from);
1364 
1365  populatePreviousTransactionLedgerSequence(to, from);
1366 }
1367 
1368 void
1369 convert(org::xrpl::rpc::v1::LedgerHashes& to, STObject const& from)
1370 {
1371  populateLastLedgerSequence(to, from);
1372 
1373  populateHashes(to, from);
1374 
1375  populateFlags(to, from);
1376 }
1377 
1378 void
1379 convert(org::xrpl::rpc::v1::PayChannel& to, STObject const& from)
1380 {
1381  populateAccount(to, from);
1382 
1383  populateAmount(to, from);
1384 
1385  populateBalance(to, from);
1386 
1387  populatePublicKey(to, from);
1388 
1389  populateSettleDelay(to, from);
1390 
1391  populateOwnerNode(to, from);
1392 
1393  populatePreviousTransactionID(to, from);
1394 
1395  populatePreviousTransactionLedgerSequence(to, from);
1396 
1397  populateFlags(to, from);
1398 
1399  populateExpiration(to, from);
1400 
1401  populateCancelAfter(to, from);
1402 
1403  populateSourceTag(to, from);
1404 
1405  populateDestinationTag(to, from);
1406 
1407  populateDestinationNode(to, from);
1408 }
1409 
1410 void
1411 convert(org::xrpl::rpc::v1::DirectoryNode& to, STObject const& from)
1412 {
1413  populateFlags(to, from);
1414 
1415  populateRootIndex(to, from);
1416 
1417  populateIndexes(to, from);
1418 
1419  populateIndexNext(to, from);
1420 
1421  populateIndexPrevious(to, from);
1422 
1423  populateTakerPaysIssuer(to, from);
1424 
1425  populateTakerPaysCurrency(to, from);
1426 
1427  populateTakerGetsCurrency(to, from);
1428 
1429  populateTakerGetsIssuer(to, from);
1430 }
1431 
1432 void
1433 convert(org::xrpl::rpc::v1::Offer& to, STObject const& from)
1434 {
1435  populateAccount(to, from);
1436 
1437  populateSequence(to, from);
1438 
1439  populateFlags(to, from);
1440 
1441  populateTakerPays(to, from);
1442 
1443  populateTakerGets(to, from);
1444 
1445  populateBookDirectory(to, from);
1446 
1447  populateBookNode(to, from);
1448 }
1449 
1450 void
1451 convert(org::xrpl::rpc::v1::RippleState& to, STObject const& from)
1452 {
1453  populateBalance(to, from);
1454 
1455  populateFlags(to, from);
1456 
1457  populateLowNode(to, from);
1458 
1459  populateHighNode(to, from);
1460 
1461  populateLowQualityIn(to, from);
1462 
1463  populateLowQualityOut(to, from);
1464 
1465  populateHighQualityIn(to, from);
1466 
1467  populateHighQualityOut(to, from);
1468 
1469  populatePreviousTransactionID(to, from);
1470 
1471  populatePreviousTransactionLedgerSequence(to, from);
1472 }
1473 
1474 void
1475 convert(org::xrpl::rpc::v1::SignerList& to, STObject const& from)
1476 {
1477  populateFlags(to, from);
1478 
1479  populatePreviousTransactionID(to, from);
1480 
1481  populatePreviousTransactionLedgerSequence(to, from);
1482 
1483  populateOwnerNode(to, from);
1484 
1485  populateSignerEntries(to, from);
1486 
1487  populateSignerQuorum(to, from);
1488 
1489  populateSignerListID(to, from);
1490 }
1491 
1492 void
1493 convert(org::xrpl::rpc::v1::NegativeUNL& to, STObject const& from)
1494 {
1495  populateDisabledValidators(to, from);
1496 
1497  populateValidatorToDisable(to, from);
1498 
1499  populateValidatorToReEnable(to, from);
1500 
1501  populateFlags(to, from);
1502 }
1503 
1504 void
1505 convert(org::xrpl::rpc::v1::TicketObject& to, STObject const& from)
1506 {
1507  populateAccount(to, from);
1508 
1509  populateFlags(to, from);
1510 
1511  populateOwnerNode(to, from);
1512 
1513  populatePreviousTransactionID(to, from);
1514 
1515  populatePreviousTransactionLedgerSequence(to, from);
1516 
1517  populateTicketSequence(to, from);
1518 }
1519 
1520 void
1521 setLedgerEntryType(
1522  org::xrpl::rpc::v1::AffectedNode& proto,
1523  std::uint16_t lgrType)
1524 {
1525  switch (lgrType)
1526  {
1527  case ltACCOUNT_ROOT:
1528  proto.set_ledger_entry_type(
1529  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_ACCOUNT_ROOT);
1530  break;
1531  case ltDIR_NODE:
1532  proto.set_ledger_entry_type(
1533  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_DIRECTORY_NODE);
1534  break;
1535  case ltRIPPLE_STATE:
1536  proto.set_ledger_entry_type(
1537  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_RIPPLE_STATE);
1538  break;
1539  case ltSIGNER_LIST:
1540  proto.set_ledger_entry_type(
1541  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_SIGNER_LIST);
1542  break;
1543  case ltOFFER:
1544  proto.set_ledger_entry_type(
1545  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_OFFER);
1546  break;
1547  case ltLEDGER_HASHES:
1548  proto.set_ledger_entry_type(
1549  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_LEDGER_HASHES);
1550  break;
1551  case ltAMENDMENTS:
1552  proto.set_ledger_entry_type(
1553  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_AMENDMENTS);
1554  break;
1555  case ltFEE_SETTINGS:
1556  proto.set_ledger_entry_type(
1557  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_FEE_SETTINGS);
1558  break;
1559  case ltESCROW:
1560  proto.set_ledger_entry_type(
1561  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_ESCROW);
1562  break;
1563  case ltPAYCHAN:
1564  proto.set_ledger_entry_type(
1565  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_PAY_CHANNEL);
1566  break;
1567  case ltCHECK:
1568  proto.set_ledger_entry_type(
1569  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_CHECK);
1570  break;
1571  case ltDEPOSIT_PREAUTH:
1572  proto.set_ledger_entry_type(
1573  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_DEPOSIT_PREAUTH);
1574  break;
1575  case ltNEGATIVE_UNL:
1576  proto.set_ledger_entry_type(
1577  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_NEGATIVE_UNL);
1578  break;
1579  case ltTICKET:
1580  proto.set_ledger_entry_type(
1581  org::xrpl::rpc::v1::LEDGER_ENTRY_TYPE_TICKET);
1582  break;
1583  }
1584 }
1585 
1586 template <class T>
1587 void
1588 convert(T& to, STObject& from, std::uint16_t type)
1589 {
1590  switch (type)
1591  {
1592  case ltACCOUNT_ROOT:
1593  RPC::convert(*to.mutable_account_root(), from);
1594  break;
1595  case ltAMENDMENTS:
1596  RPC::convert(*to.mutable_amendments(), from);
1597  break;
1598  case ltDIR_NODE:
1599  RPC::convert(*to.mutable_directory_node(), from);
1600  break;
1601  case ltRIPPLE_STATE:
1602  RPC::convert(*to.mutable_ripple_state(), from);
1603  break;
1604  case ltSIGNER_LIST:
1605  RPC::convert(*to.mutable_signer_list(), from);
1606  break;
1607  case ltOFFER:
1608  RPC::convert(*to.mutable_offer(), from);
1609  break;
1610  case ltLEDGER_HASHES:
1611  RPC::convert(*to.mutable_ledger_hashes(), from);
1612  break;
1613  case ltFEE_SETTINGS:
1614  RPC::convert(*to.mutable_fee_settings(), from);
1615  break;
1616  case ltESCROW:
1617  RPC::convert(*to.mutable_escrow(), from);
1618  break;
1619  case ltPAYCHAN:
1620  RPC::convert(*to.mutable_pay_channel(), from);
1621  break;
1622  case ltCHECK:
1623  RPC::convert(*to.mutable_check(), from);
1624  break;
1625  case ltDEPOSIT_PREAUTH:
1626  RPC::convert(*to.mutable_deposit_preauth(), from);
1627  break;
1628  case ltNEGATIVE_UNL:
1629  RPC::convert(*to.mutable_negative_unl(), from);
1630  break;
1631  case ltTICKET:
1632  RPC::convert(*to.mutable_ticket(), from);
1633  break;
1634  }
1635 }
1636 
1637 template <class T>
1638 void
1639 populateFields(
1640  T const& getProto,
1641  STObject& obj,
1642  SField const& field,
1643  uint16_t lgrType)
1644 {
1645  // final fields
1646  if (obj.isFieldPresent(field))
1647  {
1648  STObject& data = obj.getField(field).downcast<STObject>();
1649 
1650  convert(*getProto(), data, lgrType);
1651  }
1652 }
1653 
1654 template <class T>
1655 void
1656 populateFinalFields(T const& getProto, STObject& obj, uint16_t lgrType)
1657 {
1658  populateFields(getProto, obj, sfFinalFields, lgrType);
1659 }
1660 
1661 template <class T>
1662 void
1663 populatePreviousFields(T const& getProto, STObject& obj, uint16_t lgrType)
1664 {
1665  populateFields(getProto, obj, sfPreviousFields, lgrType);
1666 }
1667 
1668 template <class T>
1669 void
1670 populateNewFields(T const& getProto, STObject& obj, uint16_t lgrType)
1671 {
1672  populateFields(getProto, obj, sfNewFields, lgrType);
1673 }
1674 
1675 void
1676 convert(org::xrpl::rpc::v1::Meta& to, std::shared_ptr<TxMeta> const& from)
1677 {
1678  to.set_transaction_index(from->getIndex());
1679 
1680  convert(*to.mutable_transaction_result(), from->getResultTER());
1681  to.mutable_transaction_result()->set_result(
1682  transToken(from->getResultTER()));
1683 
1684  if (from->hasDeliveredAmount())
1685  convert(*to.mutable_delivered_amount(), from->getDeliveredAmount());
1686 
1687  STArray& nodes = from->getNodes();
1688  for (auto it = nodes.begin(); it != nodes.end(); ++it)
1689  {
1690  STObject& obj = *it;
1691  org::xrpl::rpc::v1::AffectedNode* node = to.add_affected_nodes();
1692 
1693  // ledger index
1694  uint256 ledgerIndex = obj.getFieldH256(sfLedgerIndex);
1695  node->set_ledger_index(ledgerIndex.data(), ledgerIndex.size());
1696 
1697  // ledger entry type
1698  std::uint16_t lgrType = obj.getFieldU16(sfLedgerEntryType);
1699  setLedgerEntryType(*node, lgrType);
1700 
1701  // modified node
1702  if (obj.getFName() == sfModifiedNode)
1703  {
1704  populateFinalFields(
1705  [&node]() {
1706  return node->mutable_modified_node()
1707  ->mutable_final_fields();
1708  },
1709  obj,
1710  lgrType);
1711 
1712  populatePreviousFields(
1713  [&node]() {
1714  return node->mutable_modified_node()
1715  ->mutable_previous_fields();
1716  },
1717  obj,
1718  lgrType);
1719 
1720  populatePreviousTransactionID(*node->mutable_modified_node(), obj);
1721 
1722  populatePreviousTransactionLedgerSequence(
1723  *node->mutable_modified_node(), obj);
1724  }
1725  // created node
1726  else if (obj.getFName() == sfCreatedNode)
1727  {
1728  populateNewFields(
1729  [&node]() {
1730  return node->mutable_created_node()->mutable_new_fields();
1731  },
1732  obj,
1733  lgrType);
1734  }
1735  // deleted node
1736  else if (obj.getFName() == sfDeletedNode)
1737  {
1738  populateFinalFields(
1739  [&node]() {
1740  return node->mutable_deleted_node()->mutable_final_fields();
1741  },
1742  obj,
1743  lgrType);
1744  }
1745  }
1746 }
1747 
1748 void
1749 convert(
1750  org::xrpl::rpc::v1::QueueData& to,
1751  std::vector<TxQ::TxDetails> const& from)
1752 {
1753  if (!from.empty())
1754  {
1755  to.set_txn_count(from.size());
1756 
1757  std::uint32_t seqCount = 0;
1758  std::uint32_t ticketCount = 0;
1759  boost::optional<std::uint32_t> lowestSeq;
1760  boost::optional<std::uint32_t> highestSeq;
1761  boost::optional<std::uint32_t> lowestTicket;
1762  boost::optional<std::uint32_t> highestTicket;
1763  bool anyAuthChanged = false;
1764  XRPAmount totalSpend(0);
1765 
1766  for (auto const& tx : from)
1767  {
1768  org::xrpl::rpc::v1::QueuedTransaction& qt = *to.add_transactions();
1769 
1770  if (tx.seqProxy.isSeq())
1771  {
1772  qt.mutable_sequence()->set_value(tx.seqProxy.value());
1773  ++seqCount;
1774  if (!lowestSeq)
1775  lowestSeq = tx.seqProxy.value();
1776  highestSeq = tx.seqProxy.value();
1777  }
1778  else
1779  {
1780  qt.mutable_ticket()->set_value(tx.seqProxy.value());
1781  ++ticketCount;
1782  if (!lowestTicket)
1783  lowestTicket = tx.seqProxy.value();
1784  highestTicket = tx.seqProxy.value();
1785  }
1786 
1787  qt.set_fee_level(tx.feeLevel.fee());
1788  if (tx.lastValid)
1789  qt.mutable_last_ledger_sequence()->set_value(*tx.lastValid);
1790 
1791  qt.mutable_fee()->set_drops(tx.consequences.fee().drops());
1792  auto const spend =
1793  tx.consequences.potentialSpend() + tx.consequences.fee();
1794  qt.mutable_max_spend_drops()->set_drops(spend.drops());
1795  totalSpend += spend;
1796  bool const authChanged = tx.consequences.isBlocker();
1797  if (authChanged)
1798  anyAuthChanged = true;
1799  qt.set_auth_change(authChanged);
1800  }
1801 
1802  if (seqCount)
1803  to.set_sequence_count(seqCount);
1804  if (ticketCount)
1805  to.set_ticket_count(ticketCount);
1806  if (lowestSeq)
1807  to.set_lowest_sequence(*lowestSeq);
1808  if (highestSeq)
1809  to.set_highest_sequence(*highestSeq);
1810  if (lowestTicket)
1811  to.set_lowest_ticket(*lowestTicket);
1812  if (highestTicket)
1813  to.set_highest_ticket(*highestTicket);
1814 
1815  to.set_auth_change_queued(anyAuthChanged);
1816  to.mutable_max_spend_drops_total()->set_drops(totalSpend.drops());
1817  }
1818 }
1819 
1820 void
1821 convert(
1822  org::xrpl::rpc::v1::Transaction& to,
1823  std::shared_ptr<STTx const> const& from)
1824 {
1825  STObject const& fromObj = *from;
1826 
1827  populateAccount(to, fromObj);
1828 
1829  populateFee(to, fromObj);
1830 
1831  populateSequence(to, fromObj);
1832 
1833  populateSigningPublicKey(to, fromObj);
1834 
1835  populateTransactionSignature(to, fromObj);
1836 
1837  populateFlags(to, fromObj);
1838 
1839  populateLastLedgerSequence(to, fromObj);
1840 
1841  populateSourceTag(to, fromObj);
1842 
1843  populateAccountTransactionID(to, fromObj);
1844 
1845  populateMemos(to, fromObj);
1846 
1847  populateSigners(to, fromObj);
1848 
1849  populateTicketSequence(to, fromObj);
1850 
1851  auto type = safe_cast<TxType>(fromObj.getFieldU16(sfTransactionType));
1852 
1853  switch (type)
1854  {
1855  case TxType::ttPAYMENT:
1856  convert(*to.mutable_payment(), fromObj);
1857  break;
1858  case TxType::ttESCROW_CREATE:
1859  convert(*to.mutable_escrow_create(), fromObj);
1860  break;
1861  case TxType::ttESCROW_FINISH:
1862  convert(*to.mutable_escrow_finish(), fromObj);
1863  break;
1864  case TxType::ttACCOUNT_SET:
1865  convert(*to.mutable_account_set(), fromObj);
1866  break;
1867  case TxType::ttESCROW_CANCEL:
1868  convert(*to.mutable_escrow_cancel(), fromObj);
1869  break;
1870  case TxType::ttREGULAR_KEY_SET:
1871  convert(*to.mutable_set_regular_key(), fromObj);
1872  break;
1873  case TxType::ttOFFER_CREATE:
1874  convert(*to.mutable_offer_create(), fromObj);
1875  break;
1876  case TxType::ttOFFER_CANCEL:
1877  convert(*to.mutable_offer_cancel(), fromObj);
1878  break;
1879  case TxType::ttSIGNER_LIST_SET:
1880  convert(*to.mutable_signer_list_set(), fromObj);
1881  break;
1882  case TxType::ttPAYCHAN_CREATE:
1883  convert(*to.mutable_payment_channel_create(), fromObj);
1884  break;
1885  case TxType::ttPAYCHAN_FUND:
1886  convert(*to.mutable_payment_channel_fund(), fromObj);
1887  break;
1888  case TxType::ttPAYCHAN_CLAIM:
1889  convert(*to.mutable_payment_channel_claim(), fromObj);
1890  break;
1891  case TxType::ttCHECK_CREATE:
1892  convert(*to.mutable_check_create(), fromObj);
1893  break;
1894  case TxType::ttCHECK_CASH:
1895  convert(*to.mutable_check_cash(), fromObj);
1896  break;
1897  case TxType::ttCHECK_CANCEL:
1898  convert(*to.mutable_check_cancel(), fromObj);
1899  break;
1900  case TxType::ttDEPOSIT_PREAUTH:
1901  convert(*to.mutable_deposit_preauth(), fromObj);
1902  break;
1903  case TxType::ttTRUST_SET:
1904  convert(*to.mutable_trust_set(), fromObj);
1905  break;
1906  case TxType::ttACCOUNT_DELETE:
1907  convert(*to.mutable_account_delete(), fromObj);
1908  break;
1909  case TxType::ttTICKET_CREATE:
1910  convert(*to.mutable_ticket_create(), fromObj);
1911  break;
1912  default:
1913  break;
1914  }
1915 }
1916 
1917 } // namespace RPC
1918 } // namespace ripple
ripple::RPC::populateTakerPaysCurrency
void populateTakerPaysCurrency(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:799
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:783
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:689
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:900
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:488
ripple::sfTicketCount
const SF_U32 sfTicketCount(access, STI_UINT32, 40, "TicketCount")
Definition: SField.h:393
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:809
ripple::RPC::populateBaseFee
void populateBaseFee(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:849
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:397
ripple::sfPreviousFields
const SField sfPreviousFields(access, STI_OBJECT, 6, "PreviousFields")
Definition: SField.h:504
ripple::RPC::populateReserveBase
void populateReserveBase(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:867
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:539
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:885
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:424
ripple::RPC::populateSigners
void populateSigners(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:931
ripple::sfSigners
const SField sfSigners(access, STI_ARRAY, 3, "Signers", SField::sMD_Default, SField::notSigning)
Definition: SField.h:517
ripple::isTesSuccess
bool isTesSuccess(TER x)
Definition: TER.h:580
ripple::RPC::populateTicketSequence
void populateTicketSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:751
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:590
ripple::sfMemoType
const SF_Blob sfMemoType(access, STI_VL, 12, "MemoType")
Definition: SField.h:468
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::RPC::populateHighLimit
void populateHighLimit(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:657
ripple::sfSigningPubKey
const SF_Blob sfSigningPubKey(access, STI_VL, 3, "SigningPubKey")
Definition: SField.h:460
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
ripple::sfDeliveredAmount
const SF_Amount sfDeliveredAmount(access, STI_AMOUNT, 18, "DeliveredAmount")
Definition: SField.h:455
ripple::sfSignerQuorum
const SF_U32 sfSignerQuorum(access, STI_UINT32, 35, "SignerQuorum")
Definition: SField.h:388
ripple::ltESCROW
@ ltESCROW
Definition: LedgerFormats.h:80
std::vector
STL class.
std::vector::size
T size(T... args)
ripple::sfMessageKey
const SF_Blob sfMessageKey(access, STI_VL, 2, "MessageKey")
Definition: SField.h:459
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:481
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:414
ripple::sfNewFields
const SField sfNewFields(access, STI_OBJECT, 8, "NewFields")
Definition: SField.h:506
ripple::RPC::populateMemos
void populateMemos(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:915
ripple::sfMajorities
const SField sfMajorities(access, STI_ARRAY, 16, "Majorities")
Definition: SField.h:524
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::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:444
ripple::transToken
std::string transToken(TER code)
Definition: TER.cpp:196
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:1639
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:486
ripple::RPC::populateMajorities
void populateMajorities(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:947
ripple::ltLEDGER_HASHES
@ ltLEDGER_HASHES
Definition: LedgerFormats.h:74
ripple::RPC::populateRootIndex
void populateRootIndex(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:775
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:481
ripple::RPC::populateQualityIn
void populateQualityIn(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:437
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:400
ripple::sfSigner
const SField sfSigner(access, STI_OBJECT, 16, "Signer")
Definition: SField.h:510
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:525
ripple::sfTakerGetsCurrency
const SF_U160 sfTakerGetsCurrency(access, STI_HASH160, 3, "TakerGetsCurrency")
Definition: SField.h:415
ripple::sfPayChannel
const SF_U256 sfPayChannel(access, STI_HASH256, 22, "Channel")
Definition: SField.h:435
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:441
ripple::sfSignerEntries
const SField sfSignerEntries(access, STI_ARRAY, 4, "SignerEntries")
Definition: SField.h:518
ripple::STArray::end
iterator end()
Definition: STArray.h:120
ripple::RPC::populateValidatorToReEnable
void populateValidatorToReEnable(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:519
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:681
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:505
ripple::sfModifiedNode
const SField sfModifiedNode(access, STI_OBJECT, 5, "ModifiedNode")
Definition: SField.h:503
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:443
ripple::isTecClaim
bool isTecClaim(TER x)
Definition: TER.h:586
ripple::sfHighLimit
const SF_Amount sfHighLimit(access, STI_AMOUNT, 7, "HighLimit")
Definition: SField.h:447
ripple::RPC::populateFlags
void populateFlags(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:491
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:462
ripple::RPC::populateFirstLedgerSequence
void populateFirstLedgerSequence(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:499
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::ltTICKET
@ ltTICKET
Definition: LedgerFormats.h:68
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:427
ripple::RPC::populatePreviousTransactionID
void populatePreviousTransactionID(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:629
ripple::sfLowLimit
const SF_Amount sfLowLimit(access, STI_AMOUNT, 6, "LowLimit")
Definition: SField.h:446
ripple::ltCHECK
@ ltCHECK
Definition: LedgerFormats.h:85
ripple::sfMajority
const SField sfMajority(access, STI_OBJECT, 18, "Majority")
Definition: SField.h:511
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:469
ripple::sfIndexPrevious
const SF_U64 sfIndexPrevious(access, STI_UINT64, 2, "IndexPrevious")
Definition: SField.h:398
ripple::isTerRetry
bool isTerRetry(TER x)
Definition: TER.h:574
ripple::sfFulfillment
const SF_Blob sfFulfillment(access, STI_VL, 16, "Fulfillment")
Definition: SField.h:473
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:961
ripple::RPC::populateNewFields
void populateNewFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1670
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:699
ripple::sfOwner
const SF_Account sfOwner(access, STI_ACCOUNT, 2, "Owner")
Definition: SField.h:482
ripple::sfHighNode
const SF_U64 sfHighNode(access, STI_UINT64, 8, "HighNode")
Definition: SField.h:404
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:430
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:449
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:433
ripple::sfSignerListID
const SF_U32 sfSignerListID(access, STI_UINT32, 38, "SignerListID")
Definition: SField.h:391
ripple::TERSubset
Definition: TER.h:326
ripple::RPC::setLedgerEntryType
void setLedgerEntryType(org::xrpl::rpc::v1::AffectedNode &proto, std::uint16_t lgrType)
Definition: GRPCHelpers.cpp:1521
ripple::sfDestinationNode
const SF_U64 sfDestinationNode(access, STI_UINT64, 9, "DestinationNode")
Definition: SField.h:405
ripple::isTefFailure
bool isTefFailure(TER x)
Definition: TER.h:568
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:461
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:1663
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:639
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:509
ripple::RPC::populateReserveIncrement
void populateReserveIncrement(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:875
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:839
ripple::RPC::populateMemoFormat
void populateMemoFormat(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:565
ripple::sfCreatedNode
const SField sfCreatedNode(access, STI_OBJECT, 3, "CreatedNode")
Definition: SField.h:501
ripple::RPC::populateCancelAfter
void populateCancelAfter(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:332
ripple::ltDEPOSIT_PREAUTH
@ ltDEPOSIT_PREAUTH
Definition: LedgerFormats.h:87
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:494
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:448
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:589
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:478
ripple::STPathElement::hasCurrency
bool hasCurrency() const
Definition: STPathSet.h:157
ripple::sfTicketSequence
const SF_U32 sfTicketSequence(access, STI_UINT32, 41, "TicketSequence")
Definition: SField.h:394
ripple::sfMemo
const SField sfMemo(access, STI_OBJECT, 10, "Memo")
Definition: SField.h:508
ripple::sfHashes
const SF_Vec256 sfHashes(access, STI_VECTOR256, 2, "Hashes")
Definition: SField.h:495
ripple::RPC::populateCloseTime
void populateCloseTime(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:597
ripple::ltNEGATIVE_UNL
@ ltNEGATIVE_UNL
Definition: LedgerFormats.h:89
ripple::RPC::populateTakerGetsIssuer
void populateTakerGetsIssuer(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:829
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:458
ripple::RPC::populateSignerWeight
void populateSignerWeight(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:605
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:529
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:442
ripple::sfTakerPaysCurrency
const SF_U160 sfTakerPaysCurrency(access, STI_HASH160, 1, "TakerPaysCurrency")
Definition: SField.h:413
ripple::sfDeliverMin
const SF_Amount sfDeliverMin(access, STI_AMOUNT, 10, "DeliverMin")
Definition: SField.h:450
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:581
ripple::STObject::getField
STBase & getField(SField const &field)
Definition: STObject.cpp:357
ripple::RPC::populateIndexes
void populateIndexes(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:768
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:743
ripple::RPC::populateHighQualityOut
void populateHighQualityOut(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:709
ripple::isTelLocal
bool isTelLocal(TER x)
Definition: TER.h:556
ripple::RPC::populateFinalFields
void populateFinalFields(T const &getProto, STObject &obj, uint16_t lgrType)
Definition: GRPCHelpers.cpp:1656
ripple::RPC::populateIndexPrevious
void populateIndexPrevious(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:791
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:474
ripple::sfPaths
const SField sfPaths(access, STI_PATHSET, 1, "Paths")
Definition: SField.h:491
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:523
ripple::RPC::populateMemoData
void populateMemoData(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:557
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:445
std::vector::empty
T empty(T... args)
ripple::sfDestination
const SF_Account sfDestination(access, STI_ACCOUNT, 3, "Destination")
Definition: SField.h:483
ripple::sfCheckID
const SF_U256 sfCheckID(access, STI_HASH256, 24, "CheckID")
Definition: SField.h:437
ripple::ltPAYCHAN
@ ltPAYCHAN
Definition: LedgerFormats.h:83
ripple::sfRootIndex
const SF_U256 sfRootIndex(access, STI_HASH256, 8, "RootIndex", SField::sMD_Always)
Definition: SField.h:426
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:477
ripple::RPC::populateHighNode
void populateHighNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:673
ripple::sfLowNode
const SF_U64 sfLowNode(access, STI_UINT64, 7, "LowNode")
Definition: SField.h:403
ripple::RPC::populateLowNode
void populateLowNode(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:665
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:496
ripple::STPathElement::isAccount
bool isAccount() const
Definition: STPathSet.h:145
ripple::sfBookNode
const SF_U64 sfBookNode(access, STI_UINT64, 3, "BookNode")
Definition: SField.h:399
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::sfBaseFee
const SF_U64 sfBaseFee(access, STI_UINT64, 5, "BaseFee")
Definition: SField.h:401
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::sfAuthorize
const SF_Account sfAuthorize(access, STI_ACCOUNT, 5, "Authorize")
Definition: SField.h:485
ripple::sfDeletedNode
const SField sfDeletedNode(access, STI_OBJECT, 4, "DeletedNode")
Definition: SField.h:502
ripple::ltACCOUNT_ROOT
@ ltACCOUNT_ROOT
Definition: LedgerFormats.h:53
ripple::RPC::populateReferenceFeeUnits
void populateReferenceFeeUnits(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:857
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:583
ripple::RPC::populateHashes
void populateHashes(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:761
ripple::RPC::populateTakerGetsCurrency
void populateTakerGetsCurrency(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:819
ripple::STPath
Definition: STPathSet.h:212
ripple::RPC::populateAmendments
void populateAmendments(T &to, STObject const &from)
Definition: GRPCHelpers.cpp:613
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:423
ripple::sfCancelAfter
const SF_U32 sfCancelAfter(access, STI_UINT32, 36, "CancelAfter")
Definition: SField.h:389
ripple::isTemMalformed
bool isTemMalformed(TER x)
Definition: TER.h:562
ripple::sfEmailHash
const SF_U128 sfEmailHash(access, STI_HASH128, 1, "EmailHash")
Definition: SField.h:410
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:735
ripple::sfTickSize
const SF_U8 sfTickSize(access, STI_UINT8, 16, "TickSize")
Definition: SField.h:342
ripple::sfMemoFormat
const SF_Blob sfMemoFormat(access, STI_VL, 14, "MemoFormat")
Definition: SField.h:470
ripple::sfInvoiceID
const SF_U256 sfInvoiceID(access, STI_HASH256, 17, "InvoiceID")
Definition: SField.h:431
ripple::XRPAmount
Definition: XRPAmount.h:46
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:512
ripple::sfTakerGetsIssuer
const SF_U160 sfTakerGetsIssuer(access, STI_HASH160, 4, "TakerGetsIssuer")
Definition: SField.h:416
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::sfDomain
const SF_Blob sfDomain(access, STI_VL, 7, "Domain")
Definition: SField.h:463
Generated by   doxygen 1.8.17