xrpld
Loading...
Searching...
No Matches
libxrpl/tx/transactors/account/AccountSet.cpp
1#include <xrpl/tx/transactors/account/AccountSet.h>
2
3#include <xrpl/basics/Blob.h>
4#include <xrpl/basics/Log.h>
5#include <xrpl/basics/Slice.h>
6#include <xrpl/basics/base_uint.h>
7#include <xrpl/ledger/ApplyView.h>
8#include <xrpl/ledger/ReadView.h>
9#include <xrpl/ledger/helpers/DirectoryHelpers.h>
10#include <xrpl/protocol/Feature.h>
11#include <xrpl/protocol/Indexes.h>
12#include <xrpl/protocol/LedgerFormats.h>
13#include <xrpl/protocol/Permissions.h>
14#include <xrpl/protocol/Protocol.h>
15#include <xrpl/protocol/PublicKey.h>
16#include <xrpl/protocol/Quality.h>
17#include <xrpl/protocol/SField.h>
18#include <xrpl/protocol/STLedgerEntry.h>
19#include <xrpl/protocol/STTx.h>
20#include <xrpl/protocol/TER.h>
21#include <xrpl/protocol/TxFlags.h>
22#include <xrpl/protocol/XRPAmount.h>
23#include <xrpl/tx/Transactor.h>
24#include <xrpl/tx/applySteps.h>
25
26#include <cstdint>
27
28namespace xrpl {
29
32{
33 // The AccountSet may be a blocker, but only if it sets or clears
34 // specific account flags.
35 auto const getTxConsequencesCategory = [](STTx const& tx) {
36 if (std::uint32_t const uTxFlags = tx.getFlags();
37 uTxFlags & (tfRequireAuth | tfOptionalAuth))
39
40 if (auto const uSetFlag = tx[~sfSetFlag]; uSetFlag &&
41 (*uSetFlag == asfRequireAuth || *uSetFlag == asfDisableMaster ||
42 *uSetFlag == asfAccountTxnID))
44
45 if (auto const uClearFlag = tx[~sfClearFlag]; uClearFlag &&
46 (*uClearFlag == asfRequireAuth || *uClearFlag == asfDisableMaster ||
47 *uClearFlag == asfAccountTxnID))
49
51 };
52
53 return TxConsequences{ctx.tx, getTxConsequencesCategory(ctx.tx)};
54}
55
58{
59 return tfAccountSetMask;
60}
61
64{
65 auto& tx = ctx.tx;
66 auto& j = ctx.j;
67
68 std::uint32_t const uSetFlag = tx.getFieldU32(sfSetFlag);
69 std::uint32_t const uClearFlag = tx.getFieldU32(sfClearFlag);
70
71 if ((uSetFlag != 0) && (uSetFlag == uClearFlag))
72 {
73 JLOG(j.trace()) << "Malformed transaction: Set and clear same flag.";
74 return temINVALID_FLAG;
75 }
76
77 //
78 // RequireAuth
79 //
80 bool const bSetRequireAuth = tx.isFlag(tfRequireAuth) || (uSetFlag == asfRequireAuth);
81 bool const bClearRequireAuth = tx.isFlag(tfOptionalAuth) || (uClearFlag == asfRequireAuth);
82
83 if (bSetRequireAuth && bClearRequireAuth)
84 {
85 JLOG(j.trace()) << "Malformed transaction: Contradictory flags set.";
86 return temINVALID_FLAG;
87 }
88
89 //
90 // RequireDestTag
91 //
92 bool const bSetRequireDest = tx.isFlag(tfRequireDestTag) || (uSetFlag == asfRequireDest);
93 bool const bClearRequireDest = tx.isFlag(tfOptionalDestTag) || (uClearFlag == asfRequireDest);
94
95 if (bSetRequireDest && bClearRequireDest)
96 {
97 JLOG(j.trace()) << "Malformed transaction: Contradictory flags set.";
98 return temINVALID_FLAG;
99 }
100
101 //
102 // DisallowXRP
103 //
104 bool const bSetDisallowXRP = tx.isFlag(tfDisallowXRP) || (uSetFlag == asfDisallowXRP);
105 bool const bClearDisallowXRP = tx.isFlag(tfAllowXRP) || (uClearFlag == asfDisallowXRP);
106
107 if (bSetDisallowXRP && bClearDisallowXRP)
108 {
109 JLOG(j.trace()) << "Malformed transaction: Contradictory flags set.";
110 return temINVALID_FLAG;
111 }
112
113 // TransferRate
114 if (tx.isFieldPresent(sfTransferRate))
115 {
116 std::uint32_t const uRate = tx.getFieldU32(sfTransferRate);
117
118 if ((uRate != 0u) && (uRate < QUALITY_ONE))
119 {
120 JLOG(j.trace()) << "Malformed transaction: Transfer rate too small.";
122 }
123
124 if (uRate > 2 * QUALITY_ONE)
125 {
126 JLOG(j.trace()) << "Malformed transaction: Transfer rate too large.";
128 }
129 }
130
131 // TickSize
132 if (tx.isFieldPresent(sfTickSize))
133 {
134 auto const uTickSize = tx[sfTickSize];
135 if ((uTickSize != 0u) &&
136 ((uTickSize < Quality::kMinTickSize) || (uTickSize > Quality::kMaxTickSize)))
137 {
138 JLOG(j.trace()) << "Malformed transaction: Bad tick size.";
139 return temBAD_TICK_SIZE;
140 }
141 }
142
143 if (auto const mk = tx[~sfMessageKey])
144 {
145 if (!mk->empty() && !publicKeyType({mk->data(), mk->size()}))
146 {
147 JLOG(j.trace()) << "Invalid message key specified.";
148 return telBAD_PUBLIC_KEY;
149 }
150 }
151
152 if (auto const domain = tx[~sfDomain]; domain && domain->size() > kMaxDomainLength)
153 {
154 JLOG(j.trace()) << "domain too long";
155 return telBAD_DOMAIN;
156 }
157
158 // Configure authorized minting account:
159 if (uSetFlag == asfAuthorizedNFTokenMinter && !tx.isFieldPresent(sfNFTokenMinter))
160 return temMALFORMED;
161
162 if (uClearFlag == asfAuthorizedNFTokenMinter && tx.isFieldPresent(sfNFTokenMinter))
163 return temMALFORMED;
164
165 return tesSUCCESS;
166}
167
168TER
170{
171 auto const id = ctx.tx[sfAccount];
172
173 auto const sle = ctx.view.read(keylet::account(id));
174 if (!sle)
175 return terNO_ACCOUNT;
176
177 std::uint32_t const uSetFlag = ctx.tx.getFieldU32(sfSetFlag);
178
179 // legacy AccountSet flags
180 bool const bSetRequireAuth = ctx.tx.isFlag(tfRequireAuth) || (uSetFlag == asfRequireAuth);
181
182 //
183 // RequireAuth
184 //
185 if (bSetRequireAuth && !sle->isFlag(lsfRequireAuth))
186 {
187 if (!dirIsEmpty(ctx.view, keylet::ownerDir(id)))
188 {
189 JLOG(ctx.j.trace()) << "Retry: Owner directory not empty.";
190 return ((ctx.flags & TapRetry) != 0u) ? TER{terOWNERS} : TER{tecOWNERS};
191 }
192 }
193
194 //
195 // Clawback
196 //
197 if (uSetFlag == asfAllowTrustLineClawback)
198 {
199 if (sle->isFlag(lsfNoFreeze))
200 {
201 JLOG(ctx.j.trace()) << "Can't set Clawback if NoFreeze is set";
202 return tecNO_PERMISSION;
203 }
204
205 if (!dirIsEmpty(ctx.view, keylet::ownerDir(id)))
206 {
207 JLOG(ctx.j.trace()) << "Owner directory not empty.";
208 return tecOWNERS;
209 }
210 }
211 else if (uSetFlag == asfNoFreeze)
212 {
213 // Cannot set NoFreeze if clawback is enabled
214 if (sle->isFlag(lsfAllowTrustLineClawback))
215 {
216 JLOG(ctx.j.trace()) << "Can't set NoFreeze if clawback is enabled";
217 return tecNO_PERMISSION;
218 }
219 }
220
221 return tesSUCCESS;
222}
223
224TER
226{
227 auto const sle = view().peek(keylet::account(accountID_));
228 if (!sle)
229 return tefINTERNAL; // LCOV_EXCL_LINE
230
231 std::uint32_t const uFlagsIn = sle->getFieldU32(sfFlags);
232 std::uint32_t uFlagsOut = uFlagsIn;
233
234 STTx const& tx{ctx_.tx};
235 std::uint32_t const uSetFlag{tx.getFieldU32(sfSetFlag)};
236 std::uint32_t const uClearFlag{tx.getFieldU32(sfClearFlag)};
237
238 // legacy AccountSet flags
239 bool const bSetRequireDest{tx.isFlag(tfRequireDestTag) || (uSetFlag == asfRequireDest)};
240 bool const bClearRequireDest{tx.isFlag(tfOptionalDestTag) || (uClearFlag == asfRequireDest)};
241 bool const bSetRequireAuth{tx.isFlag(tfRequireAuth) || (uSetFlag == asfRequireAuth)};
242 bool const bClearRequireAuth{tx.isFlag(tfOptionalAuth) || (uClearFlag == asfRequireAuth)};
243 bool const bSetDisallowXRP{tx.isFlag(tfDisallowXRP) || (uSetFlag == asfDisallowXRP)};
244 bool const bClearDisallowXRP{tx.isFlag(tfAllowXRP) || (uClearFlag == asfDisallowXRP)};
245
246 bool const sigWithMaster{
247 [&tx, &acct = accountID_] {
248 auto const spk = tx.getSigningPubKey();
249
250 if (publicKeyType(makeSlice(spk)))
251 {
252 PublicKey const signingPubKey(makeSlice(spk));
253
254 if (calcAccountID(signingPubKey) == acct)
255 return true;
256 }
257 return false;
258 }(),
259 };
260
261 //
262 // RequireAuth
263 //
264 if (bSetRequireAuth && !sle->isFlag(lsfRequireAuth))
265 {
266 JLOG(j_.trace()) << "Set RequireAuth.";
267 uFlagsOut |= lsfRequireAuth;
268 }
269
270 if (bClearRequireAuth && sle->isFlag(lsfRequireAuth))
271 {
272 JLOG(j_.trace()) << "Clear RequireAuth.";
273 uFlagsOut &= ~lsfRequireAuth;
274 }
275
276 //
277 // RequireDestTag
278 //
279 if (bSetRequireDest && !sle->isFlag(lsfRequireDestTag))
280 {
281 JLOG(j_.trace()) << "Set lsfRequireDestTag.";
282 uFlagsOut |= lsfRequireDestTag;
283 }
284
285 if (bClearRequireDest && sle->isFlag(lsfRequireDestTag))
286 {
287 JLOG(j_.trace()) << "Clear lsfRequireDestTag.";
288 uFlagsOut &= ~lsfRequireDestTag;
289 }
290
291 //
292 // DisallowXRP
293 //
294 if (bSetDisallowXRP && !sle->isFlag(lsfDisallowXRP))
295 {
296 JLOG(j_.trace()) << "Set lsfDisallowXRP.";
297 uFlagsOut |= lsfDisallowXRP;
298 }
299
300 if (bClearDisallowXRP && sle->isFlag(lsfDisallowXRP))
301 {
302 JLOG(j_.trace()) << "Clear lsfDisallowXRP.";
303 uFlagsOut &= ~lsfDisallowXRP;
304 }
305
306 //
307 // DisableMaster
308 //
309 if ((uSetFlag == asfDisableMaster) && !sle->isFlag(lsfDisableMaster))
310 {
311 if (!sigWithMaster)
312 {
313 JLOG(j_.trace()) << "Must use master key to disable master key.";
314 return tecNEED_MASTER_KEY;
315 }
316
317 if ((!sle->isFieldPresent(sfRegularKey)) && (!view().peek(keylet::signerList(accountID_))))
318 {
319 // Account has no regular key or multi-signer signer list.
321 }
322
323 JLOG(j_.trace()) << "Set lsfDisableMaster.";
324 uFlagsOut |= lsfDisableMaster;
325 }
326
327 if ((uClearFlag == asfDisableMaster) && sle->isFlag(lsfDisableMaster))
328 {
329 JLOG(j_.trace()) << "Clear lsfDisableMaster.";
330 uFlagsOut &= ~lsfDisableMaster;
331 }
332
333 //
334 // DefaultRipple
335 //
336 if (uSetFlag == asfDefaultRipple)
337 {
338 JLOG(j_.trace()) << "Set lsfDefaultRipple.";
339 uFlagsOut |= lsfDefaultRipple;
340 }
341 else if (uClearFlag == asfDefaultRipple)
342 {
343 JLOG(j_.trace()) << "Clear lsfDefaultRipple.";
344 uFlagsOut &= ~lsfDefaultRipple;
345 }
346
347 //
348 // NoFreeze
349 //
350 if (uSetFlag == asfNoFreeze)
351 {
352 if (!sigWithMaster && !sle->isFlag(lsfDisableMaster))
353 {
354 JLOG(j_.trace()) << "Must use master key to set NoFreeze.";
355 return tecNEED_MASTER_KEY;
356 }
357
358 JLOG(j_.trace()) << "Set NoFreeze flag";
359 uFlagsOut |= lsfNoFreeze;
360 }
361
362 // Anyone may set global freeze
363 if (uSetFlag == asfGlobalFreeze)
364 {
365 JLOG(j_.trace()) << "Set GlobalFreeze flag";
366 uFlagsOut |= lsfGlobalFreeze;
367 }
368
369 // If you have set NoFreeze, you may not clear GlobalFreeze
370 // This prevents those who have set NoFreeze from using
371 // GlobalFreeze strategically.
372 if ((uSetFlag != asfGlobalFreeze) && (uClearFlag == asfGlobalFreeze) &&
373 ((uFlagsOut & lsfNoFreeze) == 0))
374 {
375 JLOG(j_.trace()) << "Clear GlobalFreeze flag";
376 uFlagsOut &= ~lsfGlobalFreeze;
377 }
378
379 //
380 // Track transaction IDs signed by this account in its root
381 //
382 if ((uSetFlag == asfAccountTxnID) && !sle->isFieldPresent(sfAccountTxnID))
383 {
384 JLOG(j_.trace()) << "Set AccountTxnID.";
385 sle->makeFieldPresent(sfAccountTxnID);
386 }
387
388 if ((uClearFlag == asfAccountTxnID) && sle->isFieldPresent(sfAccountTxnID))
389 {
390 JLOG(j_.trace()) << "Clear AccountTxnID.";
391 sle->makeFieldAbsent(sfAccountTxnID);
392 }
393
394 //
395 // DepositAuth
396 //
397 if (uSetFlag == asfDepositAuth)
398 {
399 JLOG(j_.trace()) << "Set lsfDepositAuth.";
400 uFlagsOut |= lsfDepositAuth;
401 }
402 else if (uClearFlag == asfDepositAuth)
403 {
404 JLOG(j_.trace()) << "Clear lsfDepositAuth.";
405 uFlagsOut &= ~lsfDepositAuth;
406 }
407
408 //
409 // EmailHash
410 //
411 if (tx.isFieldPresent(sfEmailHash))
412 {
413 UInt128 const uHash = tx.getFieldH128(sfEmailHash);
414
415 if (!uHash)
416 {
417 JLOG(j_.trace()) << "unset email hash";
418 sle->makeFieldAbsent(sfEmailHash);
419 }
420 else
421 {
422 JLOG(j_.trace()) << "set email hash";
423 sle->setFieldH128(sfEmailHash, uHash);
424 }
425 }
426
427 //
428 // WalletLocator
429 //
430 if (tx.isFieldPresent(sfWalletLocator))
431 {
432 UInt256 const uHash = tx.getFieldH256(sfWalletLocator);
433
434 if (!uHash)
435 {
436 JLOG(j_.trace()) << "unset wallet locator";
437 sle->makeFieldAbsent(sfWalletLocator);
438 }
439 else
440 {
441 JLOG(j_.trace()) << "set wallet locator";
442 sle->setFieldH256(sfWalletLocator, uHash);
443 }
444 }
445
446 //
447 // MessageKey
448 //
449 if (tx.isFieldPresent(sfMessageKey))
450 {
451 Blob const messageKey = tx.getFieldVL(sfMessageKey);
452
453 if (messageKey.empty())
454 {
455 JLOG(j_.debug()) << "clear message key";
456 sle->makeFieldAbsent(sfMessageKey);
457 }
458 else
459 {
460 JLOG(j_.debug()) << "set message key";
461 sle->setFieldVL(sfMessageKey, messageKey);
462 }
463 }
464
465 //
466 // Domain
467 //
468 if (tx.isFieldPresent(sfDomain))
469 {
470 Blob const domain = tx.getFieldVL(sfDomain);
471
472 if (domain.empty())
473 {
474 JLOG(j_.trace()) << "unset domain";
475 sle->makeFieldAbsent(sfDomain);
476 }
477 else
478 {
479 JLOG(j_.trace()) << "set domain";
480 sle->setFieldVL(sfDomain, domain);
481 }
482 }
483
484 //
485 // TransferRate
486 //
487 if (tx.isFieldPresent(sfTransferRate))
488 {
489 std::uint32_t const uRate = tx.getFieldU32(sfTransferRate);
490
491 if (uRate == 0 || uRate == QUALITY_ONE)
492 {
493 JLOG(j_.trace()) << "unset transfer rate";
494 sle->makeFieldAbsent(sfTransferRate);
495 }
496 else
497 {
498 JLOG(j_.trace()) << "set transfer rate";
499 sle->setFieldU32(sfTransferRate, uRate);
500 }
501 }
502
503 //
504 // TickSize
505 //
506 if (tx.isFieldPresent(sfTickSize))
507 {
508 auto const uTickSize = tx[sfTickSize];
509 if ((uTickSize == 0) || (uTickSize == Quality::kMaxTickSize))
510 {
511 JLOG(j_.trace()) << "unset tick size";
512 sle->makeFieldAbsent(sfTickSize);
513 }
514 else
515 {
516 JLOG(j_.trace()) << "set tick size";
517 sle->setFieldU8(sfTickSize, uTickSize);
518 }
519 }
520
521 // Configure authorized minting account:
522 if (uSetFlag == asfAuthorizedNFTokenMinter)
523 sle->setAccountID(sfNFTokenMinter, ctx_.tx[sfNFTokenMinter]);
524
525 if (uClearFlag == asfAuthorizedNFTokenMinter && sle->isFieldPresent(sfNFTokenMinter))
526 sle->makeFieldAbsent(sfNFTokenMinter);
527
528 if (uSetFlag == asfDisallowIncomingNFTokenOffer)
529 {
530 uFlagsOut |= lsfDisallowIncomingNFTokenOffer;
531 }
532 else if (uClearFlag == asfDisallowIncomingNFTokenOffer)
533 {
534 uFlagsOut &= ~lsfDisallowIncomingNFTokenOffer;
535 }
536
537 if (uSetFlag == asfDisallowIncomingCheck)
538 {
539 uFlagsOut |= lsfDisallowIncomingCheck;
540 }
541 else if (uClearFlag == asfDisallowIncomingCheck)
542 {
543 uFlagsOut &= ~lsfDisallowIncomingCheck;
544 }
545
546 if (uSetFlag == asfDisallowIncomingPayChan)
547 {
548 uFlagsOut |= lsfDisallowIncomingPayChan;
549 }
550 else if (uClearFlag == asfDisallowIncomingPayChan)
551 {
552 uFlagsOut &= ~lsfDisallowIncomingPayChan;
553 }
554
555 if (uSetFlag == asfDisallowIncomingTrustline)
556 {
557 uFlagsOut |= lsfDisallowIncomingTrustline;
558 }
559 else if (uClearFlag == asfDisallowIncomingTrustline)
560 {
561 uFlagsOut &= ~lsfDisallowIncomingTrustline;
562 }
563
564 // Set or clear flags for disallowing escrow
565 if (ctx_.view().rules().enabled(featureTokenEscrow))
566 {
567 if (uSetFlag == asfAllowTrustLineLocking)
568 {
569 uFlagsOut |= lsfAllowTrustLineLocking;
570 }
571 else if (uClearFlag == asfAllowTrustLineLocking)
572 {
573 uFlagsOut &= ~lsfAllowTrustLineLocking;
574 }
575 }
576
577 // Set flag for clawback
578 if (uSetFlag == asfAllowTrustLineClawback)
579 {
580 JLOG(j_.trace()) << "set allow clawback";
581 uFlagsOut |= lsfAllowTrustLineClawback;
582 }
583
584 if (uFlagsIn != uFlagsOut)
585 sle->setFieldU32(sfFlags, uFlagsOut);
586
587 ctx_.view().update(sle);
588
589 return tesSUCCESS;
590}
591
592void
594{
595 // No transaction-specific invariants yet (future work).
596}
597
598bool
600{
601 // No transaction-specific invariants yet (future work).
602 return true;
603}
604
605} // namespace xrpl
A generic endpoint for log messages.
Definition Journal.h:44
Stream trace() const
Severity stream access functions.
Definition Journal.h:338
void visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override
Inspect a single ledger entry modified by this transaction.
bool finalizeInvariants(STTx const &tx, TER result, XRPAmount fee, ReadView const &view, beast::Journal const &j) override
Check transaction-specific post-conditions after all entries have been visited.
static NotTEC preflight(PreflightContext const &ctx)
static std::uint32_t getFlagsMask(PreflightContext const &ctx)
static TER preclaim(PreclaimContext const &ctx)
static TxConsequences makeTxConsequences(PreflightContext const &ctx)
virtual SLE::pointer peek(Keylet const &k)=0
Prepare to modify the SLE associated with key.
A public key.
Definition PublicKey.h:53
static int const kMaxTickSize
Definition Quality.h:97
static int const kMinTickSize
Definition Quality.h:96
A view into a ledger.
Definition ReadView.h:41
virtual SLE::const_pointer read(Keylet const &k) const =0
Return the state item associated with a key.
std::shared_ptr< STLedgerEntry const > const & ConstRef
Blob getFieldVL(SField const &field) const
Definition STObject.cpp:649
UInt256 getFieldH256(SField const &field) const
Definition STObject.cpp:631
std::uint32_t getFieldU32(SField const &field) const
Definition STObject.cpp:601
bool isFlag(std::uint32_t) const
Definition STObject.cpp:511
bool isFieldPresent(SField const &field) const
Definition STObject.cpp:464
UInt128 getFieldH128(SField const &field) const
Definition STObject.cpp:613
Blob getSigningPubKey() const
Definition STTx.h:256
beast::Journal const j_
Definition Transactor.h:164
ApplyView & view()
Definition Transactor.h:184
AccountID const accountID_
Definition Transactor.h:166
ApplyContext & ctx_
Definition Transactor.h:162
Class describing the consequences to the account of applying a transaction if the transaction consume...
Definition applySteps.h:53
@ Normal
Moves currency around, creates offers, etc.
Definition applySteps.h:63
@ Blocker
Affects the ability of subsequent transactions to claim a fee.
Definition applySteps.h:68
T empty(T... args)
Keylet signerList(AccountID const &account) noexcept
A SignerList.
Definition Indexes.cpp:360
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Definition Indexes.cpp:415
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ telBAD_DOMAIN
Definition TER.h:39
@ telBAD_PUBLIC_KEY
Definition TER.h:41
@ terOWNERS
Definition TER.h:222
@ terNO_ACCOUNT
Definition TER.h:219
bool dirIsEmpty(ReadView const &view, Keylet const &k)
Returns true if the directory is empty.
BaseUInt< 128 > UInt128
Definition base_uint.h:579
@ tefINTERNAL
Definition TER.h:167
std::optional< KeyType > publicKeyType(Slice const &slice)
Returns the type of public key.
Slice makeSlice(std::array< T, N > const &a)
Definition Slice.h:228
BaseUInt< 256 > UInt256
Definition base_uint.h:581
TERSubset< CanCvtToNotTEC > NotTEC
Definition TER.h:617
AccountID calcAccountID(PublicKey const &pk)
@ TapRetry
Definition ApplyView.h:36
@ temINVALID_FLAG
Definition TER.h:99
@ temMALFORMED
Definition TER.h:75
@ temBAD_TRANSFER_RATE
Definition TER.h:95
@ temBAD_TICK_SIZE
Definition TER.h:106
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecNEED_MASTER_KEY
Definition TER.h:319
@ tecNO_ALTERNATIVE_KEY
Definition TER.h:307
@ tecOWNERS
Definition TER.h:309
@ tecNO_PERMISSION
Definition TER.h:316
std::vector< unsigned char > Blob
Storage for linear binary data.
Definition Blob.h:11
@ tesSUCCESS
Definition TER.h:253
constexpr std::size_t kMaxDomainLength
The maximum length of a domain.
Definition Protocol.h:266
State information when determining if a tx is likely to claim a fee.
Definition Transactor.h:92
ReadView const & view
Definition Transactor.h:95
beast::Journal const j
Definition Transactor.h:100
State information when preflighting a tx.
Definition Transactor.h:39
beast::Journal const j
Definition Transactor.h:46