rippled
AccountSet_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2016 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/basics/StringUtilities.h>
21 #include <ripple/protocol/AmountConversions.h>
22 #include <ripple/protocol/Feature.h>
23 #include <ripple/protocol/Quality.h>
24 #include <ripple/protocol/Rate.h>
25 #include <ripple/protocol/jss.h>
26 #include <test/jtx.h>
27 
28 namespace ripple {
29 
30 class AccountSet_test : public beast::unit_test::suite
31 {
32 public:
33  void
34  testNullAccountSet()
35  {
36  testcase("No AccountSet");
37 
38  using namespace test::jtx;
39  Env env(*this);
40  Account const alice("alice");
41  env.fund(XRP(10000), noripple(alice));
42  // ask for the ledger entry - account root, to check its flags
43  auto const jrr = env.le(alice);
44  BEAST_EXPECT((*env.le(alice))[sfFlags] == 0u);
45  }
46 
47  void
48  testMostFlags()
49  {
50  testcase("Most Flags");
51 
52  using namespace test::jtx;
53  Account const alice("alice");
54 
55  // Test without DepositAuth enabled initially.
56  Env env(*this, supported_amendments() - featureDepositAuth);
57  env.fund(XRP(10000), noripple(alice));
58 
59  // Give alice a regular key so she can legally set and clear
60  // her asfDisableMaster flag.
61  Account const alie{"alie", KeyType::secp256k1};
62  env(regkey(alice, alie));
63  env.close();
64 
65  auto testFlags = [this, &alice, &alie, &env](
66  std::initializer_list<std::uint32_t> goodFlags) {
67  std::uint32_t const orig_flags = (*env.le(alice))[sfFlags];
68  for (std::uint32_t flag{1u};
69  flag < std::numeric_limits<std::uint32_t>::digits;
70  ++flag)
71  {
72  if (flag == asfNoFreeze)
73  {
74  // The asfNoFreeze flag can't be cleared. It is tested
75  // elsewhere.
76  continue;
77  }
78  if (flag == asfAuthorizedNFTokenMinter)
79  {
80  // The asfAuthorizedNFTokenMinter flag requires the
81  // presence or absence of the sfNFTokenMinter field in
82  // the transaction. It is tested elsewhere.
83  continue;
84  }
85  else if (
86  std::find(goodFlags.begin(), goodFlags.end(), flag) !=
87  goodFlags.end())
88  {
89  // Good flag
90  env.require(nflags(alice, flag));
91  env(fset(alice, flag), sig(alice));
92  env.close();
93  env.require(flags(alice, flag));
94  env(fclear(alice, flag), sig(alie));
95  env.close();
96  env.require(nflags(alice, flag));
97  std::uint32_t const now_flags = (*env.le(alice))[sfFlags];
98  BEAST_EXPECT(now_flags == orig_flags);
99  }
100  else
101  {
102  // Bad flag
103  BEAST_EXPECT((*env.le(alice))[sfFlags] == orig_flags);
104  env(fset(alice, flag), sig(alice));
105  env.close();
106  BEAST_EXPECT((*env.le(alice))[sfFlags] == orig_flags);
107  env(fclear(alice, flag), sig(alie));
108  env.close();
109  BEAST_EXPECT((*env.le(alice))[sfFlags] == orig_flags);
110  }
111  }
112  };
113 
114  // Test with featureDepositAuth disabled.
115  testFlags(
116  {asfRequireDest,
117  asfRequireAuth,
118  asfDisallowXRP,
119  asfGlobalFreeze,
120  asfDisableMaster,
121  asfDefaultRipple});
122 
123  // Enable featureDepositAuth and retest.
124  env.enableFeature(featureDepositAuth);
125  env.close();
126  testFlags(
127  {asfRequireDest,
128  asfRequireAuth,
129  asfDisallowXRP,
130  asfGlobalFreeze,
131  asfDisableMaster,
132  asfDefaultRipple,
133  asfDepositAuth});
134  }
135 
136  void
137  testSetAndResetAccountTxnID()
138  {
139  testcase("Set and reset AccountTxnID");
140 
141  using namespace test::jtx;
142  Env env(*this);
143  Account const alice("alice");
144  env.fund(XRP(10000), noripple(alice));
145 
146  std::uint32_t const orig_flags = (*env.le(alice))[sfFlags];
147 
148  // asfAccountTxnID is special and not actually set as a flag,
149  // so we check the field presence instead
150  BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfAccountTxnID));
151  env(fset(alice, asfAccountTxnID), sig(alice));
152  BEAST_EXPECT(env.le(alice)->isFieldPresent(sfAccountTxnID));
153  env(fclear(alice, asfAccountTxnID));
154  BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfAccountTxnID));
155  std::uint32_t const now_flags = (*env.le(alice))[sfFlags];
156  BEAST_EXPECT(now_flags == orig_flags);
157  }
158 
159  void
160  testSetNoFreeze()
161  {
162  testcase("Set NoFreeze");
163 
164  using namespace test::jtx;
165  Env env(*this);
166  Account const alice("alice");
167  env.fund(XRP(10000), noripple(alice));
168  env.memoize("eric");
169  env(regkey(alice, "eric"));
170 
171  env.require(nflags(alice, asfNoFreeze));
172  env(fset(alice, asfNoFreeze), sig("eric"), ter(tecNEED_MASTER_KEY));
173  env(fset(alice, asfNoFreeze), sig(alice));
174  env.require(flags(alice, asfNoFreeze));
175  env(fclear(alice, asfNoFreeze), sig(alice));
176  // verify flag is still set (clear does not clear in this case)
177  env.require(flags(alice, asfNoFreeze));
178  }
179 
180  void
181  testDomain()
182  {
183  testcase("Domain");
184 
185  using namespace test::jtx;
186  Env env(*this);
187  Account const alice("alice");
188  env.fund(XRP(10000), alice);
189  auto jt = noop(alice);
190  // The Domain field is represented as the hex string of the lowercase
191  // ASCII of the domain. For example, the domain example.com would be
192  // represented as "6578616d706c652e636f6d".
193  //
194  // To remove the Domain field from an account, send an AccountSet with
195  // the Domain set to an empty string.
196  std::string const domain = "example.com";
197  jt[sfDomain.fieldName] = strHex(domain);
198  env(jt);
199  BEAST_EXPECT((*env.le(alice))[sfDomain] == makeSlice(domain));
200 
201  jt[sfDomain.fieldName] = "";
202  env(jt);
203  BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfDomain));
204 
205  // The upper limit on the length is 256 bytes
206  // (defined as DOMAIN_BYTES_MAX in SetAccount)
207  // test the edge cases: 255, 256, 257.
208  std::size_t const maxLength = 256;
209  for (std::size_t len = maxLength - 1; len <= maxLength + 1; ++len)
210  {
211  std::string domain2 =
212  std::string(len - domain.length() - 1, 'a') + "." + domain;
213 
214  BEAST_EXPECT(domain2.length() == len);
215 
216  jt[sfDomain.fieldName] = strHex(domain2);
217 
218  if (len <= maxLength)
219  {
220  env(jt);
221  BEAST_EXPECT((*env.le(alice))[sfDomain] == makeSlice(domain2));
222  }
223  else
224  {
225  env(jt, ter(telBAD_DOMAIN));
226  }
227  }
228  }
229 
230  void
231  testMessageKey()
232  {
233  testcase("MessageKey");
234 
235  using namespace test::jtx;
236  Env env(*this);
237  Account const alice("alice");
238  env.fund(XRP(10000), alice);
239  auto jt = noop(alice);
240 
241  auto const rkp = randomKeyPair(KeyType::ed25519);
242  jt[sfMessageKey.fieldName] = strHex(rkp.first.slice());
243  env(jt);
244  BEAST_EXPECT(
245  strHex((*env.le(alice))[sfMessageKey]) ==
246  strHex(rkp.first.slice()));
247 
248  jt[sfMessageKey.fieldName] = "";
249  env(jt);
250  BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfMessageKey));
251 
252  using namespace std::string_literals;
253  jt[sfMessageKey.fieldName] = strHex("NOT_REALLY_A_PUBKEY"s);
254  env(jt, ter(telBAD_PUBLIC_KEY));
255  }
256 
257  void
258  testWalletID()
259  {
260  testcase("WalletID");
261 
262  using namespace test::jtx;
263  Env env(*this);
264  Account const alice("alice");
265  env.fund(XRP(10000), alice);
266  auto jt = noop(alice);
267 
268  std::string const locator =
269  "9633EC8AF54F16B5286DB1D7B519EF49EEFC050C0C8AC4384F1D88ACD1BFDF05";
270  jt[sfWalletLocator.fieldName] = locator;
271  env(jt);
272  BEAST_EXPECT(to_string((*env.le(alice))[sfWalletLocator]) == locator);
273 
274  jt[sfWalletLocator.fieldName] = "";
275  env(jt);
276  BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfWalletLocator));
277  }
278 
279  void
280  testEmailHash()
281  {
282  testcase("EmailHash");
283 
284  using namespace test::jtx;
285  Env env(*this);
286  Account const alice("alice");
287  env.fund(XRP(10000), alice);
288  auto jt = noop(alice);
289 
290  std::string const mh("5F31A79367DC3137FADA860C05742EE6");
291  jt[sfEmailHash.fieldName] = mh;
292  env(jt);
293  BEAST_EXPECT(to_string((*env.le(alice))[sfEmailHash]) == mh);
294 
295  jt[sfEmailHash.fieldName] = "";
296  env(jt);
297  BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfEmailHash));
298  }
299 
300  void
301  testTransferRate()
302  {
303  struct test_results
304  {
305  double set;
306  TER code;
307  double get;
308  };
309 
310  testcase("TransferRate");
311 
312  using namespace test::jtx;
313  auto doTests = [this](
314  FeatureBitset const& features,
315  std::initializer_list<test_results> testData) {
316  Env env(*this, features);
317 
318  Account const alice("alice");
319  env.fund(XRP(10000), alice);
320 
321  for (auto const& r : testData)
322  {
323  env(rate(alice, r.set), ter(r.code));
324  env.close();
325 
326  // If the field is not present expect the default value
327  if (!(*env.le(alice))[~sfTransferRate])
328  BEAST_EXPECT(r.get == 1.0);
329  else
330  BEAST_EXPECT(
331  *(*env.le(alice))[~sfTransferRate] ==
332  r.get * QUALITY_ONE);
333  }
334  };
335 
336  doTests(
337  supported_amendments(),
338  {{1.0, tesSUCCESS, 1.0},
339  {1.1, tesSUCCESS, 1.1},
340  {2.0, tesSUCCESS, 2.0},
341  {2.1, temBAD_TRANSFER_RATE, 2.0},
342  {0.0, tesSUCCESS, 1.0},
343  {2.0, tesSUCCESS, 2.0},
344  {0.9, temBAD_TRANSFER_RATE, 2.0}});
345  }
346 
347  void
348  testGateway()
349  {
350  testcase("Gateway");
351 
352  using namespace test::jtx;
353 
354  Account const alice("alice");
355  Account const bob("bob");
356  Account const gw("gateway");
357  auto const USD = gw["USD"];
358 
359  // Test gateway with a variety of allowed transfer rates
360  for (double transferRate = 1.0; transferRate <= 2.0;
361  transferRate += 0.03125)
362  {
363  Env env(*this);
364  env.fund(XRP(10000), gw, alice, bob);
365  env.close();
366  env.trust(USD(10), alice, bob);
367  env.close();
368  env(rate(gw, transferRate));
369  env.close();
370 
371  auto const amount = USD(1);
372  Rate const rate(transferRate * QUALITY_ONE);
373  auto const amountWithRate =
374  toAmount<STAmount>(multiply(amount.value(), rate));
375 
376  env(pay(gw, alice, USD(10)));
377  env.close();
378  env(pay(alice, bob, USD(1)), sendmax(USD(10)));
379  env.close();
380 
381  env.require(balance(alice, USD(10) - amountWithRate));
382  env.require(balance(bob, USD(1)));
383  }
384 
385  // Since fix1201 was enabled on Nov 14 2017 a rate in excess of
386  // 2.0 has been blocked by the transactor. But there are a few
387  // accounts on the MainNet that have larger-than-currently-allowed
388  // TransferRates. We'll bypass the transactor so we can check
389  // operation of these legacy TransferRates.
390  //
391  // Two out-of-bound values are currently in the ledger (March 2020)
392  // They are 4.0 and 4.294967295. So those are the values we test.
393  for (double transferRate : {4.0, 4.294967295})
394  {
395  Env env(*this);
396  env.fund(XRP(10000), gw, alice, bob);
397  env.close();
398  env.trust(USD(10), alice, bob);
399  env.close();
400 
401  // We'd like to use transferRate here, but the transactor
402  // blocks transfer rates that large. So we use an acceptable
403  // transfer rate here and later hack the ledger to replace
404  // the acceptable value with an out-of-bounds value.
405  env(rate(gw, 2.0));
406  env.close();
407 
408  // Because we're hacking the ledger we need the account to have
409  // non-zero sfMintedNFTokens and sfBurnedNFTokens fields. This
410  // prevents an exception when the AccountRoot template is applied.
411  {
412  uint256 const nftId0{token::getNextID(env, gw, 0u)};
413  env(token::mint(gw, 0u));
414  env.close();
415 
416  env(token::burn(gw, nftId0));
417  env.close();
418  }
419 
420  // Note that we're bypassing almost all of the ledger's safety
421  // checks with this modify() call. If you call close() between
422  // here and the end of the test all the effort will be lost.
423  env.app().openLedger().modify(
424  [&gw, transferRate](OpenView& view, beast::Journal j) {
425  // Get the account root we want to hijack.
426  auto const sle = view.read(keylet::account(gw.id()));
427  if (!sle)
428  return false; // This would be really surprising!
429 
430  // We'll insert a replacement for the account root
431  // with the higher (currently invalid) transfer rate.
432  auto replacement = std::make_shared<SLE>(*sle, sle->key());
433  (*replacement)[sfTransferRate] =
434  static_cast<std::uint32_t>(transferRate * QUALITY_ONE);
435  view.rawReplace(replacement);
436  return true;
437  });
438 
439  auto const amount = USD(1);
440  auto const amountWithRate = toAmount<STAmount>(
441  multiply(amount.value(), Rate(transferRate * QUALITY_ONE)));
442 
443  env(pay(gw, alice, USD(10)));
444  env(pay(alice, bob, amount), sendmax(USD(10)));
445 
446  env.require(balance(alice, USD(10) - amountWithRate));
447  env.require(balance(bob, amount));
448  }
449  }
450 
451  void
452  testBadInputs()
453  {
454  testcase("Bad inputs");
455 
456  using namespace test::jtx;
457  Env env(*this);
458  Account const alice("alice");
459  env.fund(XRP(10000), alice);
460 
461  auto jt = fset(alice, asfDisallowXRP);
462  jt[jss::ClearFlag] = asfDisallowXRP;
463  env(jt, ter(temINVALID_FLAG));
464 
465  jt = fset(alice, asfRequireAuth);
466  jt[jss::ClearFlag] = asfRequireAuth;
467  env(jt, ter(temINVALID_FLAG));
468 
469  jt = fset(alice, asfRequireDest);
470  jt[jss::ClearFlag] = asfRequireDest;
471  env(jt, ter(temINVALID_FLAG));
472 
473  jt = fset(alice, asfDisallowXRP);
474  jt[sfFlags.fieldName] = tfAllowXRP;
475  env(jt, ter(temINVALID_FLAG));
476 
477  jt = fset(alice, asfRequireAuth);
478  jt[sfFlags.fieldName] = tfOptionalAuth;
479  env(jt, ter(temINVALID_FLAG));
480 
481  jt = fset(alice, asfRequireDest);
482  jt[sfFlags.fieldName] = tfOptionalDestTag;
483  env(jt, ter(temINVALID_FLAG));
484 
485  jt = fset(alice, asfRequireDest);
486  jt[sfFlags.fieldName] = tfAccountSetMask;
487  env(jt, ter(temINVALID_FLAG));
488 
489  env(fset(alice, asfDisableMaster),
490  sig(alice),
491  ter(tecNO_ALTERNATIVE_KEY));
492  }
493 
494  void
495  testRequireAuthWithDir()
496  {
497  testcase("Require auth");
498 
499  using namespace test::jtx;
500  Env env(*this);
501  Account const alice("alice");
502  Account const bob("bob");
503 
504  env.fund(XRP(10000), alice);
505  env.close();
506 
507  // alice should have an empty directory.
508  BEAST_EXPECT(dirIsEmpty(*env.closed(), keylet::ownerDir(alice)));
509 
510  // Give alice a signer list, then there will be stuff in the directory.
511  env(signers(alice, 1, {{bob, 1}}));
512  env.close();
513  BEAST_EXPECT(!dirIsEmpty(*env.closed(), keylet::ownerDir(alice)));
514 
515  env(fset(alice, asfRequireAuth), ter(tecOWNERS));
516 
517  // Remove the signer list. After that asfRequireAuth should succeed.
518  env(signers(alice, test::jtx::none));
519  env.close();
520  BEAST_EXPECT(dirIsEmpty(*env.closed(), keylet::ownerDir(alice)));
521 
522  env(fset(alice, asfRequireAuth));
523  }
524 
525  void
526  testTicket()
527  {
528  using namespace test::jtx;
529  Env env(*this);
530  Account const alice("alice");
531 
532  env.fund(XRP(10000), alice);
533  env.close();
534 
535  std::uint32_t const ticketSeq{env.seq(alice) + 1};
536  env(ticket::create(alice, 1));
537  env.close();
538  env.require(owners(alice, 1), tickets(alice, 1));
539 
540  // Try using a ticket that alice doesn't have.
541  env(noop(alice), ticket::use(ticketSeq + 1), ter(terPRE_TICKET));
542  env.close();
543  env.require(owners(alice, 1), tickets(alice, 1));
544 
545  // Actually use alice's ticket. Note that if a transaction consumes
546  // a ticket then the account's sequence number does not advance.
547  std::uint32_t const aliceSeq{env.seq(alice)};
548  env(noop(alice), ticket::use(ticketSeq));
549  env.close();
550  env.require(owners(alice, 0), tickets(alice, 0));
551  BEAST_EXPECT(aliceSeq == env.seq(alice));
552 
553  // Try re-using a ticket that alice already used.
554  env(noop(alice), ticket::use(ticketSeq), ter(tefNO_TICKET));
555  env.close();
556  }
557 
558  void
559  run() override
560  {
561  testNullAccountSet();
562  testMostFlags();
563  testSetAndResetAccountTxnID();
564  testSetNoFreeze();
565  testDomain();
566  testGateway();
567  testMessageKey();
568  testWalletID();
569  testEmailHash();
570  testBadInputs();
571  testRequireAuthWithDir();
572  testTransferRate();
573  testTicket();
574  }
575 };
576 
577 BEAST_DEFINE_TESTSUITE_PRIO(AccountSet, app, ripple, 1);
578 
579 } // namespace ripple
ripple::keylet::ownerDir
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Definition: Indexes.cpp:303
ripple::tefNO_TICKET
@ tefNO_TICKET
Definition: TER.h:164
ripple::transferRate
Rate transferRate(ReadView const &view, AccountID const &issuer)
Definition: View.cpp:471
ripple::terPRE_TICKET
@ terPRE_TICKET
Definition: TER.h:204
ripple::makeSlice
std::enable_if_t< std::is_same< T, char >::value||std::is_same< T, unsigned char >::value, Slice > makeSlice(std::array< T, N > const &a)
Definition: Slice.h:241
ripple::AccountSet_test::testTicket
void testTicket()
Definition: AccountSet_test.cpp:526
ripple::asfDisallowXRP
constexpr std::uint32_t asfDisallowXRP
Definition: TxFlags.h:74
ripple::asfDepositAuth
constexpr std::uint32_t asfDepositAuth
Definition: TxFlags.h:80
std::string
STL class.
ripple::test::jtx::none
static const none_t none
Definition: tags.h:34
ripple::Rate
Represents a transfer rate.
Definition: Rate.h:37
ripple::tecOWNERS
@ tecOWNERS
Definition: TER.h:262
ripple::AccountSet_test::testNullAccountSet
void testNullAccountSet()
Definition: AccountSet_test.cpp:34
ripple::OpenView
Writable ledger view that accumulates state and tx changes.
Definition: OpenView.h:55
ripple::asfNoFreeze
constexpr std::uint32_t asfNoFreeze
Definition: TxFlags.h:77
std::find
T find(T... args)
std::string::length
T length(T... args)
ripple::SField::fieldName
const std::string fieldName
Definition: SField.h:132
ripple::telBAD_DOMAIN
@ telBAD_DOMAIN
Definition: TER.h:52
ripple::featureDepositAuth
const uint256 featureDepositAuth
ripple::tfAllowXRP
constexpr std::uint32_t tfAllowXRP
Definition: TxFlags.h:66
ripple::BEAST_DEFINE_TESTSUITE_PRIO
BEAST_DEFINE_TESTSUITE_PRIO(NFToken, tx, ripple, 2)
ripple::temBAD_TRANSFER_RATE
@ temBAD_TRANSFER_RATE
Definition: TER.h:102
ripple::AccountSet_test::testGateway
void testGateway()
Definition: AccountSet_test.cpp:348
ripple::tfAccountSetMask
constexpr std::uint32_t tfAccountSetMask
Definition: TxFlags.h:67
ripple::KeyType::ed25519
@ ed25519
ripple::base_uint< 256 >
ripple::temINVALID_FLAG
@ temINVALID_FLAG
Definition: TER.h:106
ripple::AccountSet_test::testRequireAuthWithDir
void testRequireAuthWithDir()
Definition: AccountSet_test.cpp:495
ripple::asfDisableMaster
constexpr std::uint32_t asfDisableMaster
Definition: TxFlags.h:75
ripple::tecNO_ALTERNATIVE_KEY
@ tecNO_ALTERNATIVE_KEY
Definition: TER.h:260
ripple::AccountSet_test::testEmailHash
void testEmailHash()
Definition: AccountSet_test.cpp:280
ripple::keylet::account
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition: Indexes.cpp:133
ripple::AccountSet_test::run
void run() override
Definition: AccountSet_test.cpp:559
ripple::OpenView::rawReplace
void rawReplace(std::shared_ptr< SLE > const &sle) override
Unconditionally replace a state item.
Definition: OpenView.cpp:245
ripple::TERSubset< CanCvtToTER >
ripple::AccountSet_test::testTransferRate
void testTransferRate()
Definition: AccountSet_test.cpp:301
ripple::set
bool set(T &target, std::string const &name, Section const &section)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
Definition: BasicConfig.h:313
ripple::sfAccountTxnID
const SF_UINT256 sfAccountTxnID
ripple::sfTransferRate
const SF_UINT32 sfTransferRate
beast::Journal
A generic endpoint for log messages.
Definition: Journal.h:58
std::uint32_t
ripple::AccountSet_test::testDomain
void testDomain()
Definition: AccountSet_test.cpp:181
ripple::tecNEED_MASTER_KEY
@ tecNEED_MASTER_KEY
Definition: TER.h:272
ripple::tfOptionalAuth
constexpr std::uint32_t tfOptionalAuth
Definition: TxFlags.h:64
ripple::AccountSet_test::testMostFlags
void testMostFlags()
Definition: AccountSet_test.cpp:48
ripple::KeyType::secp256k1
@ secp256k1
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:47
ripple::sfEmailHash
const SF_UINT128 sfEmailHash
ripple::randomKeyPair
std::pair< PublicKey, SecretKey > randomKeyPair(KeyType type)
Create a key pair using secure random numbers.
Definition: SecretKey.cpp:368
ripple::dirIsEmpty
bool dirIsEmpty(ReadView const &view, Keylet const &k)
Returns true if the directory is empty.
Definition: View.cpp:590
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::AccountSet_test::testBadInputs
void testBadInputs()
Definition: AccountSet_test.cpp:452
ripple::sfWalletLocator
const SF_UINT256 sfWalletLocator
ripple::AccountSet_test::testSetNoFreeze
void testSetNoFreeze()
Definition: AccountSet_test.cpp:160
ripple::sfFlags
const SF_UINT32 sfFlags
ripple::asfRequireAuth
constexpr std::uint32_t asfRequireAuth
Definition: TxFlags.h:73
ripple::asfDefaultRipple
constexpr std::uint32_t asfDefaultRipple
Definition: TxFlags.h:79
ripple::asfRequireDest
constexpr std::uint32_t asfRequireDest
Definition: TxFlags.h:72
ripple::FeatureBitset
Definition: Feature.h:113
ripple::telBAD_PUBLIC_KEY
@ telBAD_PUBLIC_KEY
Definition: TER.h:54
ripple::sfMessageKey
const SF_VL sfMessageKey
ripple::asfGlobalFreeze
constexpr std::uint32_t asfGlobalFreeze
Definition: TxFlags.h:78
ripple::OpenView::read
std::shared_ptr< SLE const > read(Keylet const &k) const override
Return the state item associated with a key.
Definition: OpenView.cpp:171
std::size_t
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:41
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:30
ripple::AccountSet_test::testMessageKey
void testMessageKey()
Definition: AccountSet_test.cpp:231
ripple::tfOptionalDestTag
constexpr std::uint32_t tfOptionalDestTag
Definition: TxFlags.h:62
ripple::sfDomain
const SF_VL sfDomain
ripple::AccountSet_test::testSetAndResetAccountTxnID
void testSetAndResetAccountTxnID()
Definition: AccountSet_test.cpp:137
ripple::AccountSet_test::testWalletID
void testWalletID()
Definition: AccountSet_test.cpp:258
ripple::tesSUCCESS
@ tesSUCCESS
Definition: TER.h:219
ripple::asfAccountTxnID
constexpr std::uint32_t asfAccountTxnID
Definition: TxFlags.h:76
ripple::toAmount< STAmount >
STAmount toAmount< STAmount >(STAmount const &amt)
Definition: AmountConversions.h:70
ripple::get
T & get(EitherAmount &amt)
Definition: AmountSpec.h:118
ripple::AccountSet_test
Definition: AccountSet_test.cpp:30
std::initializer_list
ripple::asfAuthorizedNFTokenMinter
constexpr std::uint32_t asfAuthorizedNFTokenMinter
Definition: TxFlags.h:81
Generated by   doxygen 1.8.17