rippled
applySteps.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2012, 2013 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/app/tx/applySteps.h>
21 #include <ripple/app/tx/impl/ApplyContext.h>
22 #include <ripple/app/tx/impl/CancelCheck.h>
23 #include <ripple/app/tx/impl/CancelOffer.h>
24 #include <ripple/app/tx/impl/CancelTicket.h>
25 #include <ripple/app/tx/impl/CashCheck.h>
26 #include <ripple/app/tx/impl/Change.h>
27 #include <ripple/app/tx/impl/CreateCheck.h>
28 #include <ripple/app/tx/impl/CreateOffer.h>
29 #include <ripple/app/tx/impl/CreateTicket.h>
30 #include <ripple/app/tx/impl/DeleteAccount.h>
31 #include <ripple/app/tx/impl/DepositPreauth.h>
32 #include <ripple/app/tx/impl/Escrow.h>
33 #include <ripple/app/tx/impl/PayChan.h>
34 #include <ripple/app/tx/impl/Payment.h>
35 #include <ripple/app/tx/impl/SetAccount.h>
36 #include <ripple/app/tx/impl/SetRegularKey.h>
37 #include <ripple/app/tx/impl/SetSignerList.h>
38 #include <ripple/app/tx/impl/SetTrust.h>
39 
40 namespace ripple {
41 
42 static NotTEC
43 invoke_preflight(PreflightContext const& ctx)
44 {
45  switch (ctx.tx.getTxnType())
46  {
47  case ttACCOUNT_SET:
48  return SetAccount ::preflight(ctx);
49  case ttCHECK_CANCEL:
50  return CancelCheck ::preflight(ctx);
51  case ttCHECK_CASH:
52  return CashCheck ::preflight(ctx);
53  case ttCHECK_CREATE:
54  return CreateCheck ::preflight(ctx);
55  case ttDEPOSIT_PREAUTH:
56  return DepositPreauth ::preflight(ctx);
57  case ttOFFER_CANCEL:
58  return CancelOffer ::preflight(ctx);
59  case ttOFFER_CREATE:
60  return CreateOffer ::preflight(ctx);
61  case ttESCROW_CREATE:
62  return EscrowCreate ::preflight(ctx);
63  case ttESCROW_FINISH:
64  return EscrowFinish ::preflight(ctx);
65  case ttESCROW_CANCEL:
66  return EscrowCancel ::preflight(ctx);
67  case ttPAYCHAN_CLAIM:
68  return PayChanClaim ::preflight(ctx);
69  case ttPAYCHAN_CREATE:
70  return PayChanCreate ::preflight(ctx);
71  case ttPAYCHAN_FUND:
72  return PayChanFund ::preflight(ctx);
73  case ttPAYMENT:
74  return Payment ::preflight(ctx);
75  case ttREGULAR_KEY_SET:
76  return SetRegularKey ::preflight(ctx);
77  case ttSIGNER_LIST_SET:
78  return SetSignerList ::preflight(ctx);
79  case ttTICKET_CANCEL:
80  return CancelTicket ::preflight(ctx);
81  case ttTICKET_CREATE:
82  return CreateTicket ::preflight(ctx);
83  case ttTRUST_SET:
84  return SetTrust ::preflight(ctx);
85  case ttACCOUNT_DELETE:
86  return DeleteAccount ::preflight(ctx);
87  case ttAMENDMENT:
88  case ttFEE:
89  case ttUNL_MODIFY:
90  return Change ::preflight(ctx);
91  default:
92  assert(false);
93  return temUNKNOWN;
94  }
95 }
96 
97 /* invoke_preclaim<T> uses name hiding to accomplish
98  compile-time polymorphism of (presumably) static
99  class functions for Transactor and derived classes.
100 */
101 template <class T>
102 static TER
103 invoke_preclaim(PreclaimContext const& ctx)
104 {
105  // If the transactor requires a valid account and the transaction doesn't
106  // list one, preflight will have already a flagged a failure.
107  auto const id = ctx.tx.getAccountID(sfAccount);
108 
109  if (id != beast::zero)
110  {
111  TER result = T::checkSeq(ctx);
112 
113  if (result != tesSUCCESS)
114  return result;
115 
116  result = T::checkFee(ctx, calculateBaseFee(ctx.view, ctx.tx));
117 
118  if (result != tesSUCCESS)
119  return result;
120 
121  result = T::checkSign(ctx);
122 
123  if (result != tesSUCCESS)
124  return result;
125  }
126 
127  return T::preclaim(ctx);
128 }
129 
130 static TER
131 invoke_preclaim(PreclaimContext const& ctx)
132 {
133  switch (ctx.tx.getTxnType())
134  {
135  case ttACCOUNT_SET:
136  return invoke_preclaim<SetAccount>(ctx);
137  case ttCHECK_CANCEL:
138  return invoke_preclaim<CancelCheck>(ctx);
139  case ttCHECK_CASH:
140  return invoke_preclaim<CashCheck>(ctx);
141  case ttCHECK_CREATE:
142  return invoke_preclaim<CreateCheck>(ctx);
143  case ttDEPOSIT_PREAUTH:
144  return invoke_preclaim<DepositPreauth>(ctx);
145  case ttOFFER_CANCEL:
146  return invoke_preclaim<CancelOffer>(ctx);
147  case ttOFFER_CREATE:
148  return invoke_preclaim<CreateOffer>(ctx);
149  case ttESCROW_CREATE:
150  return invoke_preclaim<EscrowCreate>(ctx);
151  case ttESCROW_FINISH:
152  return invoke_preclaim<EscrowFinish>(ctx);
153  case ttESCROW_CANCEL:
154  return invoke_preclaim<EscrowCancel>(ctx);
155  case ttPAYCHAN_CLAIM:
156  return invoke_preclaim<PayChanClaim>(ctx);
157  case ttPAYCHAN_CREATE:
158  return invoke_preclaim<PayChanCreate>(ctx);
159  case ttPAYCHAN_FUND:
160  return invoke_preclaim<PayChanFund>(ctx);
161  case ttPAYMENT:
162  return invoke_preclaim<Payment>(ctx);
163  case ttREGULAR_KEY_SET:
164  return invoke_preclaim<SetRegularKey>(ctx);
165  case ttSIGNER_LIST_SET:
166  return invoke_preclaim<SetSignerList>(ctx);
167  case ttTICKET_CANCEL:
168  return invoke_preclaim<CancelTicket>(ctx);
169  case ttTICKET_CREATE:
170  return invoke_preclaim<CreateTicket>(ctx);
171  case ttTRUST_SET:
172  return invoke_preclaim<SetTrust>(ctx);
173  case ttACCOUNT_DELETE:
174  return invoke_preclaim<DeleteAccount>(ctx);
175  case ttAMENDMENT:
176  case ttFEE:
177  case ttUNL_MODIFY:
178  return invoke_preclaim<Change>(ctx);
179  default:
180  assert(false);
181  return temUNKNOWN;
182  }
183 }
184 
185 static FeeUnit64
186 invoke_calculateBaseFee(ReadView const& view, STTx const& tx)
187 {
188  switch (tx.getTxnType())
189  {
190  case ttACCOUNT_SET:
191  return SetAccount::calculateBaseFee(view, tx);
192  case ttCHECK_CANCEL:
193  return CancelCheck::calculateBaseFee(view, tx);
194  case ttCHECK_CASH:
195  return CashCheck::calculateBaseFee(view, tx);
196  case ttCHECK_CREATE:
197  return CreateCheck::calculateBaseFee(view, tx);
198  case ttDEPOSIT_PREAUTH:
199  return DepositPreauth::calculateBaseFee(view, tx);
200  case ttOFFER_CANCEL:
201  return CancelOffer::calculateBaseFee(view, tx);
202  case ttOFFER_CREATE:
203  return CreateOffer::calculateBaseFee(view, tx);
204  case ttESCROW_CREATE:
205  return EscrowCreate::calculateBaseFee(view, tx);
206  case ttESCROW_FINISH:
207  return EscrowFinish::calculateBaseFee(view, tx);
208  case ttESCROW_CANCEL:
209  return EscrowCancel::calculateBaseFee(view, tx);
210  case ttPAYCHAN_CLAIM:
211  return PayChanClaim::calculateBaseFee(view, tx);
212  case ttPAYCHAN_CREATE:
213  return PayChanCreate::calculateBaseFee(view, tx);
214  case ttPAYCHAN_FUND:
215  return PayChanFund::calculateBaseFee(view, tx);
216  case ttPAYMENT:
217  return Payment::calculateBaseFee(view, tx);
218  case ttREGULAR_KEY_SET:
219  return SetRegularKey::calculateBaseFee(view, tx);
220  case ttSIGNER_LIST_SET:
221  return SetSignerList::calculateBaseFee(view, tx);
222  case ttTICKET_CANCEL:
223  return CancelTicket::calculateBaseFee(view, tx);
224  case ttTICKET_CREATE:
225  return CreateTicket::calculateBaseFee(view, tx);
226  case ttTRUST_SET:
227  return SetTrust::calculateBaseFee(view, tx);
228  case ttACCOUNT_DELETE:
229  return DeleteAccount::calculateBaseFee(view, tx);
230  case ttAMENDMENT:
231  case ttFEE:
232  case ttUNL_MODIFY:
233  return Change::calculateBaseFee(view, tx);
234  default:
235  assert(false);
236  return FeeUnit64{0};
237  }
238 }
239 
240 template <class T>
241 static TxConsequences
242 invoke_calculateConsequences(STTx const& tx)
243 {
244  auto const category = T::affectsSubsequentTransactionAuth(tx)
245  ? TxConsequences::blocker
246  : TxConsequences::normal;
247  auto const feePaid = T::calculateFeePaid(tx);
248  auto const maxSpend = T::calculateMaxSpend(tx);
249 
250  return {category, feePaid, maxSpend};
251 }
252 
253 static TxConsequences
254 invoke_calculateConsequences(STTx const& tx)
255 {
256  switch (tx.getTxnType())
257  {
258  case ttACCOUNT_SET:
259  return invoke_calculateConsequences<SetAccount>(tx);
260  case ttCHECK_CANCEL:
261  return invoke_calculateConsequences<CancelCheck>(tx);
262  case ttCHECK_CASH:
263  return invoke_calculateConsequences<CashCheck>(tx);
264  case ttCHECK_CREATE:
265  return invoke_calculateConsequences<CreateCheck>(tx);
266  case ttDEPOSIT_PREAUTH:
267  return invoke_calculateConsequences<DepositPreauth>(tx);
268  case ttOFFER_CANCEL:
269  return invoke_calculateConsequences<CancelOffer>(tx);
270  case ttOFFER_CREATE:
271  return invoke_calculateConsequences<CreateOffer>(tx);
272  case ttESCROW_CREATE:
273  return invoke_calculateConsequences<EscrowCreate>(tx);
274  case ttESCROW_FINISH:
275  return invoke_calculateConsequences<EscrowFinish>(tx);
276  case ttESCROW_CANCEL:
277  return invoke_calculateConsequences<EscrowCancel>(tx);
278  case ttPAYCHAN_CLAIM:
279  return invoke_calculateConsequences<PayChanClaim>(tx);
280  case ttPAYCHAN_CREATE:
281  return invoke_calculateConsequences<PayChanCreate>(tx);
282  case ttPAYCHAN_FUND:
283  return invoke_calculateConsequences<PayChanFund>(tx);
284  case ttPAYMENT:
285  return invoke_calculateConsequences<Payment>(tx);
286  case ttREGULAR_KEY_SET:
287  return invoke_calculateConsequences<SetRegularKey>(tx);
288  case ttSIGNER_LIST_SET:
289  return invoke_calculateConsequences<SetSignerList>(tx);
290  case ttTICKET_CANCEL:
291  return invoke_calculateConsequences<CancelTicket>(tx);
292  case ttTICKET_CREATE:
293  return invoke_calculateConsequences<CreateTicket>(tx);
294  case ttTRUST_SET:
295  return invoke_calculateConsequences<SetTrust>(tx);
296  case ttACCOUNT_DELETE:
297  return invoke_calculateConsequences<DeleteAccount>(tx);
298  case ttAMENDMENT:
299  case ttFEE:
300  case ttUNL_MODIFY:
301  [[fallthrough]];
302  default:
303  assert(false);
304  return {
305  TxConsequences::blocker,
306  Transactor::calculateFeePaid(tx),
307  beast::zero};
308  }
309 }
310 
311 static std::pair<TER, bool>
312 invoke_apply(ApplyContext& ctx)
313 {
314  switch (ctx.tx.getTxnType())
315  {
316  case ttACCOUNT_SET: {
317  SetAccount p(ctx);
318  return p();
319  }
320  case ttCHECK_CANCEL: {
321  CancelCheck p(ctx);
322  return p();
323  }
324  case ttCHECK_CASH: {
325  CashCheck p(ctx);
326  return p();
327  }
328  case ttCHECK_CREATE: {
329  CreateCheck p(ctx);
330  return p();
331  }
332  case ttDEPOSIT_PREAUTH: {
333  DepositPreauth p(ctx);
334  return p();
335  }
336  case ttOFFER_CANCEL: {
337  CancelOffer p(ctx);
338  return p();
339  }
340  case ttOFFER_CREATE: {
341  CreateOffer p(ctx);
342  return p();
343  }
344  case ttESCROW_CREATE: {
345  EscrowCreate p(ctx);
346  return p();
347  }
348  case ttESCROW_FINISH: {
349  EscrowFinish p(ctx);
350  return p();
351  }
352  case ttESCROW_CANCEL: {
353  EscrowCancel p(ctx);
354  return p();
355  }
356  case ttPAYCHAN_CLAIM: {
357  PayChanClaim p(ctx);
358  return p();
359  }
360  case ttPAYCHAN_CREATE: {
361  PayChanCreate p(ctx);
362  return p();
363  }
364  case ttPAYCHAN_FUND: {
365  PayChanFund p(ctx);
366  return p();
367  }
368  case ttPAYMENT: {
369  Payment p(ctx);
370  return p();
371  }
372  case ttREGULAR_KEY_SET: {
373  SetRegularKey p(ctx);
374  return p();
375  }
376  case ttSIGNER_LIST_SET: {
377  SetSignerList p(ctx);
378  return p();
379  }
380  case ttTICKET_CANCEL: {
381  CancelTicket p(ctx);
382  return p();
383  }
384  case ttTICKET_CREATE: {
385  CreateTicket p(ctx);
386  return p();
387  }
388  case ttTRUST_SET: {
389  SetTrust p(ctx);
390  return p();
391  }
392  case ttACCOUNT_DELETE: {
393  DeleteAccount p(ctx);
394  return p();
395  }
396  case ttAMENDMENT:
397  case ttFEE:
398  case ttUNL_MODIFY: {
399  Change p(ctx);
400  return p();
401  }
402  default:
403  assert(false);
404  return {temUNKNOWN, false};
405  }
406 }
407 
408 PreflightResult
409 preflight(
410  Application& app,
411  Rules const& rules,
412  STTx const& tx,
413  ApplyFlags flags,
414  beast::Journal j)
415 {
416  PreflightContext const pfctx(app, tx, rules, flags, j);
417  try
418  {
419  return {pfctx, invoke_preflight(pfctx)};
420  }
421  catch (std::exception const& e)
422  {
423  JLOG(j.fatal()) << "apply: " << e.what();
424  return {pfctx, tefEXCEPTION};
425  }
426 }
427 
428 PreclaimResult
429 preclaim(
430  PreflightResult const& preflightResult,
431  Application& app,
432  OpenView const& view)
433 {
434  boost::optional<PreclaimContext const> ctx;
435  if (preflightResult.rules != view.rules())
436  {
437  auto secondFlight = preflight(
438  app,
439  view.rules(),
440  preflightResult.tx,
441  preflightResult.flags,
442  preflightResult.j);
443  ctx.emplace(
444  app,
445  view,
446  secondFlight.ter,
447  secondFlight.tx,
448  secondFlight.flags,
449  secondFlight.j);
450  }
451  else
452  {
453  ctx.emplace(
454  app,
455  view,
456  preflightResult.ter,
457  preflightResult.tx,
458  preflightResult.flags,
459  preflightResult.j);
460  }
461  try
462  {
463  if (ctx->preflightResult != tesSUCCESS)
464  return {*ctx, ctx->preflightResult};
465  return {*ctx, invoke_preclaim(*ctx)};
466  }
467  catch (std::exception const& e)
468  {
469  JLOG(ctx->j.fatal()) << "apply: " << e.what();
470  return {*ctx, tefEXCEPTION};
471  }
472 }
473 
474 FeeUnit64
475 calculateBaseFee(ReadView const& view, STTx const& tx)
476 {
477  return invoke_calculateBaseFee(view, tx);
478 }
479 
480 TxConsequences
481 calculateConsequences(PreflightResult const& preflightResult)
482 {
483  assert(preflightResult.ter == tesSUCCESS);
484  if (preflightResult.ter != tesSUCCESS)
485  return {
486  TxConsequences::blocker,
487  Transactor::calculateFeePaid(preflightResult.tx),
488  beast::zero};
489  return invoke_calculateConsequences(preflightResult.tx);
490 }
491 
492 std::pair<TER, bool>
493 doApply(PreclaimResult const& preclaimResult, Application& app, OpenView& view)
494 {
495  if (preclaimResult.view.seq() != view.seq())
496  {
497  // Logic error from the caller. Don't have enough
498  // info to recover.
499  return {tefEXCEPTION, false};
500  }
501  try
502  {
503  if (!preclaimResult.likelyToClaimFee)
504  return {preclaimResult.ter, false};
505  ApplyContext ctx(
506  app,
507  view,
508  preclaimResult.tx,
509  preclaimResult.ter,
510  calculateBaseFee(view, preclaimResult.tx),
511  preclaimResult.flags,
512  preclaimResult.j);
513  return invoke_apply(ctx);
514  }
515  catch (std::exception const& e)
516  {
517  JLOG(preclaimResult.j.fatal()) << "apply: " << e.what();
518  return {tefEXCEPTION, false};
519  }
520 }
521 
522 } // namespace ripple
ripple::ttPAYCHAN_CLAIM
@ ttPAYCHAN_CLAIM
Definition: TxFormats.h:51
ripple::ttCHECK_CANCEL
@ ttCHECK_CANCEL
Definition: TxFormats.h:54
beast::Journal::fatal
Stream fatal() const
Definition: Journal.h:339
ripple::STTx::getTxnType
TxType getTxnType() const
Definition: STTx.h:105
ripple::SetTrust::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: SetTrust.cpp:31
ripple::PayChanClaim
Definition: app/tx/impl/PayChan.h:62
ripple::Application
Definition: Application.h:97
ripple::SetRegularKey::calculateBaseFee
static FeeUnit64 calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: SetRegularKey.cpp:28
ripple::PreclaimResult::view
ReadView const & view
From the input - the ledger view.
Definition: applySteps.h:88
ripple::ttACCOUNT_DELETE
@ ttACCOUNT_DELETE
Definition: TxFormats.h:57
ripple::PreclaimResult::j
const beast::Journal j
From the input - the journal.
Definition: applySteps.h:94
ripple::PreclaimContext::view
ReadView const & view
Definition: Transactor.h:57
ripple::calculateBaseFee
FeeUnit64 calculateBaseFee(ReadView const &view, STTx const &tx)
Compute only the expected base fee for a transaction.
Definition: applySteps.cpp:475
std::exception
STL class.
ripple::EscrowFinish::calculateBaseFee
static FeeUnit64 calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: Escrow.cpp:354
ripple::CashCheck::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: CashCheck.cpp:35
std::pair
ripple::invoke_preflight
static NotTEC invoke_preflight(PreflightContext const &ctx)
Definition: applySteps.cpp:43
ripple::ttOFFER_CREATE
@ ttOFFER_CREATE
Definition: TxFormats.h:43
ripple::Payment
Definition: Payment.h:32
ripple::OpenView
Writable ledger view that accumulates state and tx changes.
Definition: OpenView.h:52
ripple::CreateCheck
Definition: CreateCheck.h:27
ripple::CancelOffer
Definition: CancelOffer.h:30
ripple::PayChanClaim::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: PayChan.cpp:387
ripple::sfAccount
const SF_Account sfAccount(access, STI_ACCOUNT, 1, "Account")
Definition: SField.h:480
ripple::ApplyFlags
ApplyFlags
Definition: ApplyView.h:30
ripple::invoke_calculateBaseFee
static FeeUnit64 invoke_calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: applySteps.cpp:186
ripple::TxConsequences::normal
@ normal
Moves currency around, creates offers, etc.
Definition: applySteps.h:132
ripple::SetAccount
Definition: SetAccount.h:32
ripple::DepositPreauth
Definition: DepositPreauth.h:27
ripple::EscrowCreate
Definition: Escrow.h:27
ripple::EscrowFinish::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: Escrow.cpp:304
ripple::DeleteAccount::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: DeleteAccount.cpp:35
ripple::PreflightResult::tx
STTx const & tx
From the input - the transaction.
Definition: applySteps.h:50
ripple::CreateOffer::preflight
static NotTEC preflight(PreflightContext const &ctx)
Enforce constraints beyond those of the Transactor base class.
Definition: CreateOffer.cpp:41
ripple::preflight
PreflightResult preflight(Application &app, Rules const &rules, STTx const &tx, ApplyFlags flags, beast::Journal j)
Gate a transaction based on static information.
Definition: applySteps.cpp:409
ripple::DeleteAccount
Definition: DeleteAccount.h:29
ripple::Payment::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: Payment.cpp:48
ripple::PreclaimResult::likelyToClaimFee
const bool likelyToClaimFee
Success flag - whether the transaction is likely to claim a fee.
Definition: applySteps.h:100
ripple::PreclaimResult::ter
const TER ter
Intermediate transaction result.
Definition: applySteps.h:97
ripple::SetSignerList
See the README.md for an overview of the SetSignerList transaction that this class implements.
Definition: SetSignerList.h:41
ripple::ttESCROW_FINISH
@ ttESCROW_FINISH
Definition: TxFormats.h:38
ripple::ttPAYMENT
@ ttPAYMENT
Definition: TxFormats.h:36
ripple::DeleteAccount::calculateBaseFee
static FeeUnit64 calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: DeleteAccount.cpp:56
ripple::ttFEE
@ ttFEE
Definition: TxFormats.h:60
ripple::doApply
std::pair< TER, bool > doApply(PreclaimResult const &preclaimResult, Application &app, OpenView &view)
Apply a prechecked transaction to an OpenView.
Definition: applySteps.cpp:493
ripple::PreflightResult
Describes the results of the preflight check.
Definition: applySteps.h:46
ripple::PreflightResult::rules
const Rules rules
From the input - the rules.
Definition: applySteps.h:52
ripple::ttTRUST_SET
@ ttTRUST_SET
Definition: TxFormats.h:56
ripple::STObject::getAccountID
AccountID getAccountID(SField const &field) const
Definition: STObject.cpp:562
ripple::PreflightResult::ter
const NotTEC ter
Intermediate transaction result.
Definition: applySteps.h:59
ripple::TERSubset< CanCvtToTER >
ripple::Change
Definition: Change.h:32
ripple::SetTrust
Definition: SetTrust.h:31
ripple::TER
TERSubset< CanCvtToTER > TER
Definition: TER.h:547
ripple::STTx
Definition: STTx.h:42
ripple::Transactor::calculateBaseFee
static FeeUnit64 calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: Transactor.cpp:121
ripple::ApplyContext
State information when applying a tx.
Definition: ApplyContext.h:35
ripple::PayChanFund::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: PayChan.cpp:296
beast::Journal
A generic endpoint for log messages.
Definition: Journal.h:58
ripple::CreateOffer
Transactor specialized for creating offers in the ledger.
Definition: CreateOffer.h:34
ripple::ttCHECK_CASH
@ ttCHECK_CASH
Definition: TxFormats.h:53
ripple::temUNKNOWN
@ temUNKNOWN
Definition: TER.h:119
ripple::ttTICKET_CREATE
@ ttTICKET_CREATE
Definition: TxFormats.h:46
ripple::ttAMENDMENT
@ ttAMENDMENT
Definition: TxFormats.h:59
ripple::feeunit::TaggedFee
Definition: FeeUnits.h:70
ripple::invoke_calculateConsequences
static TxConsequences invoke_calculateConsequences(STTx const &tx)
Definition: applySteps.cpp:242
ripple::CancelOffer::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: CancelOffer.cpp:28
ripple::ttPAYCHAN_CREATE
@ ttPAYCHAN_CREATE
Definition: TxFormats.h:49
ripple::PreclaimContext::tx
STTx const & tx
Definition: Transactor.h:59
ripple::PayChanCreate::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: PayChan.cpp:166
ripple::invoke_apply
static std::pair< TER, bool > invoke_apply(ApplyContext &ctx)
Definition: applySteps.cpp:312
ripple::PreclaimContext
State information when determining if a tx is likely to claim a fee.
Definition: Transactor.h:53
ripple::ttESCROW_CREATE
@ ttESCROW_CREATE
Definition: TxFormats.h:37
ripple::preclaim
PreclaimResult preclaim(PreflightResult const &preflightResult, Application &app, OpenView const &view)
Gate a transaction based on static ledger information.
Definition: applySteps.cpp:429
ripple::ttCHECK_CREATE
@ ttCHECK_CREATE
Definition: TxFormats.h:52
ripple::CancelTicket::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: CancelTicket.cpp:30
ripple::CancelCheck
Definition: CancelCheck.h:27
ripple::Change::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: Change.cpp:33
ripple::EscrowCancel
Definition: Escrow.h:65
ripple::ReadView
A view into a ledger.
Definition: ReadView.h:188
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::invoke_preclaim
static TER invoke_preclaim(PreclaimContext const &ctx)
Definition: applySteps.cpp:103
ripple::ttTICKET_CANCEL
@ ttTICKET_CANCEL
Definition: TxFormats.h:47
ripple::SetRegularKey
Definition: SetRegularKey.h:30
ripple::EscrowCreate::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: Escrow.cpp:100
ripple::calculateConsequences
TxConsequences calculateConsequences(PreflightResult const &preflightResult)
Determine the XRP balance consequences if a transaction consumes the maximum XRP allowed.
Definition: applySteps.cpp:481
ripple::SetRegularKey::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: SetRegularKey.cpp:51
ripple::PayChanFund
Definition: app/tx/impl/PayChan.h:46
ripple::ttESCROW_CANCEL
@ ttESCROW_CANCEL
Definition: TxFormats.h:40
ripple::ttACCOUNT_SET
@ ttACCOUNT_SET
Definition: TxFormats.h:39
ripple::ReadView::seq
LedgerIndex seq() const
Returns the sequence number of the base ledger.
Definition: ReadView.h:256
ripple::FeeUnit64
FeeUnit< std::uint64_t > FeeUnit64
Definition: FeeUnits.h:460
ripple::SetAccount::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: SetAccount.cpp:52
ripple::ttOFFER_CANCEL
@ ttOFFER_CANCEL
Definition: TxFormats.h:44
ripple::Change::calculateBaseFee
static FeeUnit64 calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: Change.h:48
ripple::PreclaimResult
Describes the results of the preclaim check.
Definition: applySteps.h:84
ripple::Rules
Rules controlling protocol behavior.
Definition: ReadView.h:127
ripple::EscrowCancel::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: Escrow.cpp:515
ripple::ttUNL_MODIFY
@ ttUNL_MODIFY
Definition: TxFormats.h:61
ripple::PreclaimResult::flags
const ApplyFlags flags
From the input - the flags.
Definition: applySteps.h:92
ripple::PreflightResult::flags
const ApplyFlags flags
From the input - the flags.
Definition: applySteps.h:54
ripple::CreateTicket::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: CreateTicket.cpp:30
ripple::CreateTicket
Definition: CreateTicket.h:30
ripple::tefEXCEPTION
@ tefEXCEPTION
Definition: TER.h:148
ripple::PreflightContext::tx
STTx const & tx
Definition: Transactor.h:36
ripple::PreflightContext
State information when preflighting a tx.
Definition: Transactor.h:32
ripple::Transactor::calculateFeePaid
static XRPAmount calculateFeePaid(STTx const &tx)
Definition: Transactor.cpp:139
ripple::CashCheck
Definition: CashCheck.h:27
ripple::PayChanCreate
Definition: app/tx/impl/PayChan.h:27
ripple::CreateCheck::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: CreateCheck.cpp:32
ripple::DepositPreauth::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: DepositPreauth.cpp:31
ripple::ttPAYCHAN_FUND
@ ttPAYCHAN_FUND
Definition: TxFormats.h:50
ripple::TxConsequences::blocker
@ blocker
Affects the ability of subsequent transactions to claim a fee.
Definition: applySteps.h:135
ripple::CancelTicket
Definition: CancelTicket.h:29
ripple::EscrowFinish
Definition: Escrow.h:46
ripple::tesSUCCESS
@ tesSUCCESS
Definition: TER.h:213
ripple::OpenView::rules
Rules const & rules() const override
Returns the tx processing rules.
Definition: OpenView.cpp:129
ripple::ttREGULAR_KEY_SET
@ ttREGULAR_KEY_SET
Definition: TxFormats.h:41
ripple::ttDEPOSIT_PREAUTH
@ ttDEPOSIT_PREAUTH
Definition: TxFormats.h:55
ripple::ApplyContext::tx
STTx const & tx
Definition: ApplyContext.h:48
std::exception::what
T what(T... args)
ripple::CancelCheck::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: CancelCheck.cpp:34
ripple::SetSignerList::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: SetSignerList.cpp:79
ripple::PreclaimResult::tx
STTx const & tx
From the input - the transaction.
Definition: applySteps.h:90
ripple::ttSIGNER_LIST_SET
@ ttSIGNER_LIST_SET
Definition: TxFormats.h:48
ripple::PreflightResult::j
const beast::Journal j
From the input - the journal.
Definition: applySteps.h:56
ripple::NotTEC
TERSubset< CanCvtToNotTEC > NotTEC
Definition: TER.h:507
Generated by   doxygen 1.8.17