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  return Change ::preflight(ctx);
90  default:
91  assert(false);
92  return temUNKNOWN;
93  }
94 }
95 
96 /* invoke_preclaim<T> uses name hiding to accomplish
97  compile-time polymorphism of (presumably) static
98  class functions for Transactor and derived classes.
99 */
100 template <class T>
101 static TER
102 invoke_preclaim(PreclaimContext const& ctx)
103 {
104  // If the transactor requires a valid account and the transaction doesn't
105  // list one, preflight will have already a flagged a failure.
106  auto const id = ctx.tx.getAccountID(sfAccount);
107 
108  if (id != beast::zero)
109  {
110  TER result = T::checkSeq(ctx);
111 
112  if (result != tesSUCCESS)
113  return result;
114 
115  result = T::checkFee(ctx, calculateBaseFee(ctx.view, ctx.tx));
116 
117  if (result != tesSUCCESS)
118  return result;
119 
120  result = T::checkSign(ctx);
121 
122  if (result != tesSUCCESS)
123  return result;
124  }
125 
126  return T::preclaim(ctx);
127 }
128 
129 static TER
130 invoke_preclaim(PreclaimContext const& ctx)
131 {
132  switch (ctx.tx.getTxnType())
133  {
134  case ttACCOUNT_SET:
135  return invoke_preclaim<SetAccount>(ctx);
136  case ttCHECK_CANCEL:
137  return invoke_preclaim<CancelCheck>(ctx);
138  case ttCHECK_CASH:
139  return invoke_preclaim<CashCheck>(ctx);
140  case ttCHECK_CREATE:
141  return invoke_preclaim<CreateCheck>(ctx);
142  case ttDEPOSIT_PREAUTH:
143  return invoke_preclaim<DepositPreauth>(ctx);
144  case ttOFFER_CANCEL:
145  return invoke_preclaim<CancelOffer>(ctx);
146  case ttOFFER_CREATE:
147  return invoke_preclaim<CreateOffer>(ctx);
148  case ttESCROW_CREATE:
149  return invoke_preclaim<EscrowCreate>(ctx);
150  case ttESCROW_FINISH:
151  return invoke_preclaim<EscrowFinish>(ctx);
152  case ttESCROW_CANCEL:
153  return invoke_preclaim<EscrowCancel>(ctx);
154  case ttPAYCHAN_CLAIM:
155  return invoke_preclaim<PayChanClaim>(ctx);
156  case ttPAYCHAN_CREATE:
157  return invoke_preclaim<PayChanCreate>(ctx);
158  case ttPAYCHAN_FUND:
159  return invoke_preclaim<PayChanFund>(ctx);
160  case ttPAYMENT:
161  return invoke_preclaim<Payment>(ctx);
162  case ttREGULAR_KEY_SET:
163  return invoke_preclaim<SetRegularKey>(ctx);
164  case ttSIGNER_LIST_SET:
165  return invoke_preclaim<SetSignerList>(ctx);
166  case ttTICKET_CANCEL:
167  return invoke_preclaim<CancelTicket>(ctx);
168  case ttTICKET_CREATE:
169  return invoke_preclaim<CreateTicket>(ctx);
170  case ttTRUST_SET:
171  return invoke_preclaim<SetTrust>(ctx);
172  case ttACCOUNT_DELETE:
173  return invoke_preclaim<DeleteAccount>(ctx);
174  case ttAMENDMENT:
175  case ttFEE:
176  return invoke_preclaim<Change>(ctx);
177  default:
178  assert(false);
179  return temUNKNOWN;
180  }
181 }
182 
183 static FeeUnit64
184 invoke_calculateBaseFee(ReadView const& view, STTx const& tx)
185 {
186  switch (tx.getTxnType())
187  {
188  case ttACCOUNT_SET:
189  return SetAccount::calculateBaseFee(view, tx);
190  case ttCHECK_CANCEL:
191  return CancelCheck::calculateBaseFee(view, tx);
192  case ttCHECK_CASH:
193  return CashCheck::calculateBaseFee(view, tx);
194  case ttCHECK_CREATE:
195  return CreateCheck::calculateBaseFee(view, tx);
196  case ttDEPOSIT_PREAUTH:
197  return DepositPreauth::calculateBaseFee(view, tx);
198  case ttOFFER_CANCEL:
199  return CancelOffer::calculateBaseFee(view, tx);
200  case ttOFFER_CREATE:
201  return CreateOffer::calculateBaseFee(view, tx);
202  case ttESCROW_CREATE:
203  return EscrowCreate::calculateBaseFee(view, tx);
204  case ttESCROW_FINISH:
205  return EscrowFinish::calculateBaseFee(view, tx);
206  case ttESCROW_CANCEL:
207  return EscrowCancel::calculateBaseFee(view, tx);
208  case ttPAYCHAN_CLAIM:
209  return PayChanClaim::calculateBaseFee(view, tx);
210  case ttPAYCHAN_CREATE:
211  return PayChanCreate::calculateBaseFee(view, tx);
212  case ttPAYCHAN_FUND:
213  return PayChanFund::calculateBaseFee(view, tx);
214  case ttPAYMENT:
215  return Payment::calculateBaseFee(view, tx);
216  case ttREGULAR_KEY_SET:
217  return SetRegularKey::calculateBaseFee(view, tx);
218  case ttSIGNER_LIST_SET:
219  return SetSignerList::calculateBaseFee(view, tx);
220  case ttTICKET_CANCEL:
221  return CancelTicket::calculateBaseFee(view, tx);
222  case ttTICKET_CREATE:
223  return CreateTicket::calculateBaseFee(view, tx);
224  case ttTRUST_SET:
225  return SetTrust::calculateBaseFee(view, tx);
226  case ttACCOUNT_DELETE:
227  return DeleteAccount::calculateBaseFee(view, tx);
228  case ttAMENDMENT:
229  case ttFEE:
230  return Change::calculateBaseFee(view, tx);
231  default:
232  assert(false);
233  return FeeUnit64{0};
234  }
235 }
236 
237 template <class T>
238 static TxConsequences
239 invoke_calculateConsequences(STTx const& tx)
240 {
241  auto const category = T::affectsSubsequentTransactionAuth(tx)
242  ? TxConsequences::blocker
243  : TxConsequences::normal;
244  auto const feePaid = T::calculateFeePaid(tx);
245  auto const maxSpend = T::calculateMaxSpend(tx);
246 
247  return {category, feePaid, maxSpend};
248 }
249 
250 static TxConsequences
251 invoke_calculateConsequences(STTx const& tx)
252 {
253  switch (tx.getTxnType())
254  {
255  case ttACCOUNT_SET:
256  return invoke_calculateConsequences<SetAccount>(tx);
257  case ttCHECK_CANCEL:
258  return invoke_calculateConsequences<CancelCheck>(tx);
259  case ttCHECK_CASH:
260  return invoke_calculateConsequences<CashCheck>(tx);
261  case ttCHECK_CREATE:
262  return invoke_calculateConsequences<CreateCheck>(tx);
263  case ttDEPOSIT_PREAUTH:
264  return invoke_calculateConsequences<DepositPreauth>(tx);
265  case ttOFFER_CANCEL:
266  return invoke_calculateConsequences<CancelOffer>(tx);
267  case ttOFFER_CREATE:
268  return invoke_calculateConsequences<CreateOffer>(tx);
269  case ttESCROW_CREATE:
270  return invoke_calculateConsequences<EscrowCreate>(tx);
271  case ttESCROW_FINISH:
272  return invoke_calculateConsequences<EscrowFinish>(tx);
273  case ttESCROW_CANCEL:
274  return invoke_calculateConsequences<EscrowCancel>(tx);
275  case ttPAYCHAN_CLAIM:
276  return invoke_calculateConsequences<PayChanClaim>(tx);
277  case ttPAYCHAN_CREATE:
278  return invoke_calculateConsequences<PayChanCreate>(tx);
279  case ttPAYCHAN_FUND:
280  return invoke_calculateConsequences<PayChanFund>(tx);
281  case ttPAYMENT:
282  return invoke_calculateConsequences<Payment>(tx);
283  case ttREGULAR_KEY_SET:
284  return invoke_calculateConsequences<SetRegularKey>(tx);
285  case ttSIGNER_LIST_SET:
286  return invoke_calculateConsequences<SetSignerList>(tx);
287  case ttTICKET_CANCEL:
288  return invoke_calculateConsequences<CancelTicket>(tx);
289  case ttTICKET_CREATE:
290  return invoke_calculateConsequences<CreateTicket>(tx);
291  case ttTRUST_SET:
292  return invoke_calculateConsequences<SetTrust>(tx);
293  case ttACCOUNT_DELETE:
294  return invoke_calculateConsequences<DeleteAccount>(tx);
295  case ttAMENDMENT:
296  case ttFEE:
297  [[fallthrough]];
298  default:
299  assert(false);
300  return {
301  TxConsequences::blocker,
302  Transactor::calculateFeePaid(tx),
303  beast::zero};
304  }
305 }
306 
307 static std::pair<TER, bool>
308 invoke_apply(ApplyContext& ctx)
309 {
310  switch (ctx.tx.getTxnType())
311  {
312  case ttACCOUNT_SET: {
313  SetAccount p(ctx);
314  return p();
315  }
316  case ttCHECK_CANCEL: {
317  CancelCheck p(ctx);
318  return p();
319  }
320  case ttCHECK_CASH: {
321  CashCheck p(ctx);
322  return p();
323  }
324  case ttCHECK_CREATE: {
325  CreateCheck p(ctx);
326  return p();
327  }
328  case ttDEPOSIT_PREAUTH: {
329  DepositPreauth p(ctx);
330  return p();
331  }
332  case ttOFFER_CANCEL: {
333  CancelOffer p(ctx);
334  return p();
335  }
336  case ttOFFER_CREATE: {
337  CreateOffer p(ctx);
338  return p();
339  }
340  case ttESCROW_CREATE: {
341  EscrowCreate p(ctx);
342  return p();
343  }
344  case ttESCROW_FINISH: {
345  EscrowFinish p(ctx);
346  return p();
347  }
348  case ttESCROW_CANCEL: {
349  EscrowCancel p(ctx);
350  return p();
351  }
352  case ttPAYCHAN_CLAIM: {
353  PayChanClaim p(ctx);
354  return p();
355  }
356  case ttPAYCHAN_CREATE: {
357  PayChanCreate p(ctx);
358  return p();
359  }
360  case ttPAYCHAN_FUND: {
361  PayChanFund p(ctx);
362  return p();
363  }
364  case ttPAYMENT: {
365  Payment p(ctx);
366  return p();
367  }
368  case ttREGULAR_KEY_SET: {
369  SetRegularKey p(ctx);
370  return p();
371  }
372  case ttSIGNER_LIST_SET: {
373  SetSignerList p(ctx);
374  return p();
375  }
376  case ttTICKET_CANCEL: {
377  CancelTicket p(ctx);
378  return p();
379  }
380  case ttTICKET_CREATE: {
381  CreateTicket p(ctx);
382  return p();
383  }
384  case ttTRUST_SET: {
385  SetTrust p(ctx);
386  return p();
387  }
388  case ttACCOUNT_DELETE: {
389  DeleteAccount p(ctx);
390  return p();
391  }
392  case ttAMENDMENT:
393  case ttFEE: {
394  Change p(ctx);
395  return p();
396  }
397  default:
398  assert(false);
399  return {temUNKNOWN, false};
400  }
401 }
402 
403 PreflightResult
404 preflight(
405  Application& app,
406  Rules const& rules,
407  STTx const& tx,
408  ApplyFlags flags,
409  beast::Journal j)
410 {
411  PreflightContext const pfctx(app, tx, rules, flags, j);
412  try
413  {
414  return {pfctx, invoke_preflight(pfctx)};
415  }
416  catch (std::exception const& e)
417  {
418  JLOG(j.fatal()) << "apply: " << e.what();
419  return {pfctx, tefEXCEPTION};
420  }
421 }
422 
423 PreclaimResult
424 preclaim(
425  PreflightResult const& preflightResult,
426  Application& app,
427  OpenView const& view)
428 {
429  boost::optional<PreclaimContext const> ctx;
430  if (preflightResult.rules != view.rules())
431  {
432  auto secondFlight = preflight(
433  app,
434  view.rules(),
435  preflightResult.tx,
436  preflightResult.flags,
437  preflightResult.j);
438  ctx.emplace(
439  app,
440  view,
441  secondFlight.ter,
442  secondFlight.tx,
443  secondFlight.flags,
444  secondFlight.j);
445  }
446  else
447  {
448  ctx.emplace(
449  app,
450  view,
451  preflightResult.ter,
452  preflightResult.tx,
453  preflightResult.flags,
454  preflightResult.j);
455  }
456  try
457  {
458  if (ctx->preflightResult != tesSUCCESS)
459  return {*ctx, ctx->preflightResult};
460  return {*ctx, invoke_preclaim(*ctx)};
461  }
462  catch (std::exception const& e)
463  {
464  JLOG(ctx->j.fatal()) << "apply: " << e.what();
465  return {*ctx, tefEXCEPTION};
466  }
467 }
468 
469 FeeUnit64
470 calculateBaseFee(ReadView const& view, STTx const& tx)
471 {
472  return invoke_calculateBaseFee(view, tx);
473 }
474 
475 TxConsequences
476 calculateConsequences(PreflightResult const& preflightResult)
477 {
478  assert(preflightResult.ter == tesSUCCESS);
479  if (preflightResult.ter != tesSUCCESS)
480  return {
481  TxConsequences::blocker,
482  Transactor::calculateFeePaid(preflightResult.tx),
483  beast::zero};
484  return invoke_calculateConsequences(preflightResult.tx);
485 }
486 
487 std::pair<TER, bool>
488 doApply(PreclaimResult const& preclaimResult, Application& app, OpenView& view)
489 {
490  if (preclaimResult.view.seq() != view.seq())
491  {
492  // Logic error from the caller. Don't have enough
493  // info to recover.
494  return {tefEXCEPTION, false};
495  }
496  try
497  {
498  if (!preclaimResult.likelyToClaimFee)
499  return {preclaimResult.ter, false};
500  ApplyContext ctx(
501  app,
502  view,
503  preclaimResult.tx,
504  preclaimResult.ter,
505  calculateBaseFee(view, preclaimResult.tx),
506  preclaimResult.flags,
507  preclaimResult.j);
508  return invoke_apply(ctx);
509  }
510  catch (std::exception const& e)
511  {
512  JLOG(preclaimResult.j.fatal()) << "apply: " << e.what();
513  return {tefEXCEPTION, false};
514  }
515 }
516 
517 } // 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:94
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:470
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:476
ripple::ApplyFlags
ApplyFlags
Definition: ApplyView.h:30
ripple::invoke_calculateBaseFee
static FeeUnit64 invoke_calculateBaseFee(ReadView const &view, STTx const &tx)
Definition: applySteps.cpp:184
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:404
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:488
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:239
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:308
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:424
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:31
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:102
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:476
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::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