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