rippled
compression_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright 2020 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #include <ripple/app/misc/Manifest.h>
21 #include <ripple/app/ledger/Ledger.h>
22 #include <ripple/app/ledger/LedgerMaster.h>
23 #include <ripple/beast/unit_test.h>
24 #include <ripple/beast/utility/Journal.h>
25 #include <ripple/core/TimeKeeper.h>
26 #include <ripple/overlay/Compression.h>
27 #include <ripple/overlay/impl/ZeroCopyStream.h>
28 #include <ripple/overlay/impl/ProtocolMessage.h>
29 #include <ripple/overlay/Message.h>
30 #include <ripple/protocol/digest.h>
31 #include <ripple/protocol/HashPrefix.h>
32 #include <ripple/protocol/jss.h>
33 #include <ripple/protocol/PublicKey.h>
34 #include <ripple/protocol/SecretKey.h>
35 #include <ripple/protocol/Sign.h>
36 #include <ripple/shamap/SHAMapNodeID.h>
37 #include <ripple.pb.h>
38 #include <boost/asio/ip/address_v4.hpp>
39 #include <boost/beast/core/multi_buffer.hpp>
40 #include <boost/endian/conversion.hpp>
41 #include <test/jtx/Account.h>
42 #include <test/jtx/amount.h>
43 #include <test/jtx/Env.h>
44 #include <test/jtx/pay.h>
45 #include <test/jtx/WSClient.h>
46 #include <algorithm>
47 
48 namespace ripple {
49 
50 namespace test {
51 
52 using namespace ripple::test;
53 using namespace ripple::test::jtx;
54 
55 static
56 uint256
57 ledgerHash (LedgerInfo const& info)
58 {
59 return ripple::sha512Half(
60  HashPrefix::ledgerMaster,
61  std::uint32_t(info.seq),
62  std::uint64_t(info.drops.drops ()),
63  info.parentHash,
64  info.txHash,
65  info.accountHash,
66  std::uint32_t(info.parentCloseTime.time_since_epoch().count()),
67  std::uint32_t(info.closeTime.time_since_epoch().count()),
68  std::uint8_t(info.closeTimeResolution.count()),
69  std::uint8_t(info.closeFlags));
70 }
71 
72 class compression_test : public beast::unit_test::suite {
73  using Compressed = compression::Compressed;
74  using Algorithm = compression::Algorithm;
75 public:
76  compression_test() {}
77 
78  template<typename T>
79  void
80  doTest(std::shared_ptr<T> proto, protocol::MessageType mt, uint16_t nbuffers, const char *msg,
81  bool log = false) {
82 
83  if (log)
84  printf("=== compress/decompress %s ===\n", msg);
85  Message m(*proto, mt);
86 
87  auto &buffer = m.getBuffer(Compressed::On);
88 
89  if (log)
90  printf("==> compressed, original %d bytes, compressed %d bytes\n",
91  (int)m.getBuffer(Compressed::Off).size(),
92  (int)m.getBuffer(Compressed::On).size());
93 
94  boost::beast::multi_buffer buffers;
95 
96 
97  // simulate multi-buffer
98  auto sz = buffer.size() / nbuffers;
99  for (int i = 0; i < nbuffers; i++) {
100  auto start = buffer.begin() + sz * i;
101  auto end = i < nbuffers - 1 ? (buffer.begin() + sz * (i + 1)) : buffer.end();
102  std::vector<std::uint8_t> slice(start, end);
103  buffers.commit(
104  boost::asio::buffer_copy(buffers.prepare(slice.size()), boost::asio::buffer(slice)));
105  }
106  auto header = ripple::detail::parseMessageHeader(buffers.data(), buffer.size());
107 
108  if (log)
109  printf("==> parsed header: buffers size %d, compressed %d, algorithm %d, header size %d, payload size %d, buffer size %d\n",
110  (int)buffers.size(), header->algorithm != Algorithm::None, (int)header->algorithm,
111  (int)header->header_size, (int)header->payload_wire_size, (int)buffer.size());
112 
113  if (header->algorithm == Algorithm::None) {
114  if (log)
115  printf("==> NOT COMPRESSED\n");
116  return;
117  }
118 
119  std::vector<std::uint8_t> decompressed;
120  decompressed.resize(header->uncompressed_size);
121 
122  BEAST_EXPECT(header->payload_wire_size == buffer.size() - header->header_size);
123 
124  ZeroCopyInputStream stream(buffers.data());
125  stream.Skip(header->header_size);
126 
127  auto decompressedSize = ripple::compression::decompress(stream, header->payload_wire_size,
128  decompressed.data(), header->uncompressed_size);
129  BEAST_EXPECT(decompressedSize == header->uncompressed_size);
130  auto const proto1 = std::make_shared<T>();
131 
132  BEAST_EXPECT(proto1->ParseFromArray(decompressed.data(), decompressedSize));
133  auto uncompressed = m.getBuffer(Compressed::Off);
134  BEAST_EXPECT(std::equal(uncompressed.begin() + ripple::compression::headerBytes,
135  uncompressed.end(),
136  decompressed.begin()));
137  if (log)
138  printf("\n");
139  }
140 
141  std::shared_ptr<protocol::TMManifests>
142  buildManifests(int n) {
143  auto manifests = std::make_shared<protocol::TMManifests>();
144  manifests->mutable_list()->Reserve(n);
145  for (int i = 0; i < n; i++) {
146  auto master = randomKeyPair(KeyType::ed25519);
147  auto signing = randomKeyPair(KeyType::ed25519);
148  STObject st(sfGeneric);
149  st[sfSequence] = i;
150  st[sfPublicKey] = std::get<0>(master);
151  st[sfSigningPubKey] = std::get<0>(signing);
152  st[sfDomain] = makeSlice(std::string("example") + std::to_string(i) + std::string(".com"));
153  sign(st, HashPrefix::manifest, KeyType::ed25519, std::get<1>(master), sfMasterSignature);
154  sign(st, HashPrefix::manifest, KeyType::ed25519, std::get<1>(signing));
155  Serializer s;
156  st.add(s);
157  auto *manifest = manifests->add_list();
158  manifest->set_stobject(s.data(), s.size());
159  }
160  return manifests;
161  }
162 
163  std::shared_ptr<protocol::TMEndpoints>
164  buildEndpoints(int n) {
165  auto endpoints = std::make_shared<protocol::TMEndpoints>();
166  endpoints->mutable_endpoints()->Reserve(n);
167  for (int i = 0; i < n; i++) {
168  auto *endpoint = endpoints->add_endpoints();
169  endpoint->set_hops(i);
170  std::string addr = std::string("10.0.1.") + std::to_string(i);
171  endpoint->mutable_ipv4()->set_ipv4(
172  boost::endian::native_to_big(boost::asio::ip::address_v4::from_string(addr).to_uint()));
173  endpoint->mutable_ipv4()->set_ipv4port(i);
174  }
175  endpoints->set_version(2);
176 
177  return endpoints;
178  }
179 
180  std::shared_ptr<protocol::TMTransaction>
181  buildTransaction(Logs &logs) {
182  Env env(*this, envconfig());
183  int fund = 10000;
184  auto const alice = Account("alice");
185  auto const bob = Account("bob");
186  env.fund(XRP(fund), "alice", "bob");
187  env.trust(bob["USD"](fund), alice);
188  env.close();
189 
190  auto toBinary = [](std::string const &text) {
191  std::string binary;
192  for (size_t i = 0; i < text.size(); ++i) {
193  unsigned int c = charUnHex(text[i]);
194  c = c << 4;
195  ++i;
196  c = c | charUnHex(text[i]);
197  binary.push_back(c);
198  }
199 
200  return binary;
201  };
202 
203  std::string usdTxBlob = "";
204  auto wsc = makeWSClient(env.app().config());
205  {
206  Json::Value jrequestUsd;
207  jrequestUsd[jss::secret] = toBase58(generateSeed("bob"));
208  jrequestUsd[jss::tx_json] =
209  pay("bob", "alice", bob["USD"](fund / 2));
210  Json::Value jreply_usd = wsc->invoke("sign", jrequestUsd);
211 
212  usdTxBlob =
213  toBinary(jreply_usd[jss::result][jss::tx_blob].asString());
214  }
215 
216  auto transaction = std::make_shared<protocol::TMTransaction>();
217  transaction->set_rawtransaction(usdTxBlob);
218  transaction->set_status(protocol::tsNEW);
219  auto tk = make_TimeKeeper(logs.journal("TimeKeeper"));
220  transaction->set_receivetimestamp(tk->now().time_since_epoch().count());
221  transaction->set_deferred(true);
222 
223  return transaction;
224  }
225 
226  std::shared_ptr<protocol::TMGetLedger>
227  buildGetLedger() {
228  auto getLedger = std::make_shared<protocol::TMGetLedger>();
229  getLedger->set_itype(protocol::liTS_CANDIDATE);
230  getLedger->set_ltype(protocol::TMLedgerType::ltACCEPTED);
231  uint256 const hash(ripple::sha512Half(123456789));
232  getLedger->set_ledgerhash(hash.begin(), hash.size());
233  getLedger->set_ledgerseq(123456789);
234  ripple::SHAMapNodeID sha(hash.data(), hash.size());
235  getLedger->add_nodeids(sha.getRawString());
236  getLedger->set_requestcookie(123456789);
237  getLedger->set_querytype(protocol::qtINDIRECT);
238  getLedger->set_querydepth(3);
239  return getLedger;
240  }
241 
242  std::shared_ptr<protocol::TMLedgerData>
243  buildLedgerData(uint32_t n, Logs &logs) {
244  auto ledgerData = std::make_shared<protocol::TMLedgerData>();
245  uint256 const hash(ripple::sha512Half(12356789));
246  ledgerData->set_ledgerhash(hash.data(), hash.size());
247  ledgerData->set_ledgerseq(123456789);
248  ledgerData->set_type(protocol::TMLedgerInfoType::liAS_NODE);
249  ledgerData->set_requestcookie(123456789);
250  ledgerData->set_error(protocol::TMReplyError::reNO_LEDGER);
251  ledgerData->mutable_nodes()->Reserve(n);
252  uint256 parentHash(0);
253  for (int i = 0; i < n; i++) {
254  LedgerInfo info;
255  auto tk = make_TimeKeeper(logs.journal("TimeKeeper"));
256  info.seq = i;
257  info.parentCloseTime = tk->now();
258  info.hash = ripple::sha512Half(i);
259  info.txHash = ripple::sha512Half(i + 1);
260  info.accountHash = ripple::sha512Half(i + 2);
261  info.parentHash = parentHash;
262  info.drops = XRPAmount(10);
263  info.closeTimeResolution = tk->now().time_since_epoch();
264  info.closeTime = tk->now();
265  parentHash = ledgerHash(info);
266  Serializer nData;
267  ripple::addRaw(info, nData);
268  ledgerData->add_nodes()->set_nodedata(nData.getDataPtr(), nData.getLength());
269  }
270 
271  return ledgerData;
272  }
273 
274  std::shared_ptr<protocol::TMGetObjectByHash>
275  buildGetObjectByHash() {
276  auto getObject = std::make_shared<protocol::TMGetObjectByHash>();
277 
278  getObject->set_type(protocol::TMGetObjectByHash_ObjectType::TMGetObjectByHash_ObjectType_otTRANSACTION);
279  getObject->set_query(true);
280  getObject->set_seq(123456789);
281  uint256 hash(ripple::sha512Half(123456789));
282  getObject->set_ledgerhash(hash.data(), hash.size());
283  getObject->set_fat(true);
284  for (int i = 0; i < 100; i++) {
285  uint256 hash(ripple::sha512Half(i));
286  auto object = getObject->add_objects();
287  object->set_hash(hash.data(), hash.size());
288  ripple::SHAMapNodeID sha(hash.data(), hash.size());
289  object->set_nodeid(sha.getRawString());
290  object->set_index("");
291  object->set_data("");
292  object->set_ledgerseq(i);
293  }
294  return getObject;
295  }
296 
297  std::shared_ptr<protocol::TMValidatorList>
298  buildValidatorList()
299  {
300  auto list = std::make_shared<protocol::TMValidatorList>();
301 
302  auto master = randomKeyPair(KeyType::ed25519);
303  auto signing = randomKeyPair(KeyType::ed25519);
304  STObject st(sfGeneric);
305  st[sfSequence] = 0;
306  st[sfPublicKey] = std::get<0>(master);
307  st[sfSigningPubKey] = std::get<0>(signing);
308  st[sfDomain] = makeSlice(std::string("example.com"));
309  sign(st, HashPrefix::manifest, KeyType::ed25519, std::get<1>(master), sfMasterSignature);
310  sign(st, HashPrefix::manifest, KeyType::ed25519, std::get<1>(signing));
311  Serializer s;
312  st.add(s);
313  list->set_manifest(s.data(), s.size());
314  list->set_version(3);
315  STObject signature(sfSignature);
316  ripple::sign(st, HashPrefix::manifest,KeyType::ed25519, std::get<1>(signing));
317  Serializer s1;
318  st.add(s1);
319  list->set_signature(s1.data(), s1.size());
320  list->set_blob(strHex(s.getString()));
321  return list;
322  }
323 
324  void
325  testProtocol() {
326  testcase("Message Compression");
327 
328  auto thresh = beast::severities::Severity::kInfo;
329  auto logs = std::make_unique<Logs>(thresh);
330 
331  protocol::TMManifests manifests;
332  protocol::TMEndpoints endpoints;
333  protocol::TMTransaction transaction;
334  protocol::TMGetLedger get_ledger;
335  protocol::TMLedgerData ledger_data;
336  protocol::TMGetObjectByHash get_object;
337  protocol::TMValidatorList validator_list;
338 
339  // 4.5KB
340  doTest(buildManifests(20), protocol::mtMANIFESTS, 4, "TMManifests20");
341  // 22KB
342  doTest(buildManifests(100), protocol::mtMANIFESTS, 4, "TMManifests100");
343  // 131B
344  doTest(buildEndpoints(10), protocol::mtENDPOINTS, 4, "TMEndpoints10");
345  // 1.3KB
346  doTest(buildEndpoints(100), protocol::mtENDPOINTS, 4, "TMEndpoints100");
347  // 242B
348  doTest(buildTransaction(*logs), protocol::mtTRANSACTION, 1, "TMTransaction");
349  // 87B
350  doTest(buildGetLedger(), protocol::mtGET_LEDGER, 1, "TMGetLedger");
351  // 61KB
352  doTest(buildLedgerData(500, *logs), protocol::mtLEDGER_DATA, 10, "TMLedgerData500");
353  // 122 KB
354  doTest(buildLedgerData(1000, *logs), protocol::mtLEDGER_DATA, 20, "TMLedgerData1000");
355  // 1.2MB
356  doTest(buildLedgerData(10000, *logs), protocol::mtLEDGER_DATA, 50, "TMLedgerData10000");
357  // 12MB
358  doTest(buildLedgerData(100000, *logs), protocol::mtLEDGER_DATA, 100, "TMLedgerData100000");
359  // 61MB
360  doTest(buildLedgerData(500000, *logs), protocol::mtLEDGER_DATA, 100, "TMLedgerData500000");
361  // 7.7KB
362  doTest(buildGetObjectByHash(), protocol::mtGET_OBJECTS, 4, "TMGetObjectByHash");
363  // 895B
364  doTest(buildValidatorList(), protocol::mtVALIDATORLIST, 4, "TMValidatorList");
365  }
366 
367  void run() override {
368  testProtocol();
369  }
370 
371 };
372 
373 BEAST_DEFINE_TESTSUITE_MANUAL_PRIO(compression, ripple_data, ripple, 20);
374 
375 }
376 }
ripple::test::ledgerHash
static uint256 ledgerHash(LedgerInfo const &info)
Definition: compression_test.cpp:57
std::vector::resize
T resize(T... args)
ripple::HashPrefix::ledgerMaster
@ ledgerMaster
ledger master data for signing
ripple::test::jtx::XRP
const XRP_t XRP
Converts to XRP Issue or STAmount.
Definition: amount.cpp:109
ripple::Message::getBuffer
std::vector< uint8_t > const & getBuffer(Compressed tryCompressed)
Retrieve the packed message data.
Definition: Message.cpp:144
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:199
std::string
STL class.
std::equal
T equal(T... args)
std::shared_ptr
STL class.
ripple::LedgerInfo::parentHash
uint256 parentHash
Definition: ReadView.h:98
ripple::Logs
Manages partitions for logging.
Definition: Log.h:49
ripple::test::compression_test::buildEndpoints
std::shared_ptr< protocol::TMEndpoints > buildEndpoints(int n)
Definition: compression_test.cpp:164
ripple::charUnHex
int charUnHex(unsigned char c)
Converts a hex digit to the corresponding integer.
Definition: strHex.cpp:26
ripple::sfGeneric
const SField sfGeneric(access, 0)
Definition: SField.h:317
ripple::test::compression_test::testProtocol
void testProtocol()
Definition: compression_test.cpp:325
ripple::test::compression_test::buildLedgerData
std::shared_ptr< protocol::TMLedgerData > buildLedgerData(uint32_t n, Logs &logs)
Definition: compression_test.cpp:243
ripple::LedgerInfo::hash
uint256 hash
Definition: ReadView.h:95
ripple::XRPAmount::drops
constexpr value_type drops() const
Returns the number of drops.
Definition: XRPAmount.h:185
ripple::HashPrefix::manifest
@ manifest
Manifest.
ripple::sfSigningPubKey
const SF_Blob sfSigningPubKey(access, STI_VL, 3, "SigningPubKey")
Definition: SField.h:442
std::vector
STL class.
std::vector::size
T size(T... args)
ripple::Serializer::getString
std::string getString() const
Definition: Serializer.h:202
ripple::sfSequence
const SF_U32 sfSequence(access, STI_UINT32, 4, "Sequence")
Definition: SField.h:340
ripple::compression::headerBytes
constexpr std::size_t headerBytes
Definition: Compression.h:31
ripple::sfMasterSignature
const SF_Blob sfMasterSignature(access, STI_VL, 18, "MasterSignature", SField::sMD_Default, SField::notSigning)
Definition: SField.h:457
ripple::toBase58
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition: AccountID.cpp:29
ripple::test::compression_test::buildValidatorList
std::shared_ptr< protocol::TMValidatorList > buildValidatorList()
Definition: compression_test.cpp:298
ripple::test::compression_test::compression_test
compression_test()
Definition: compression_test.cpp:76
ripple::addRaw
void addRaw(LedgerInfo const &info, Serializer &s)
Definition: View.cpp:42
ripple::ZeroCopyInputStream
Implements ZeroCopyInputStream around a buffer sequence.
Definition: ZeroCopyStream.h:34
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:237
ripple::LedgerInfo::seq
LedgerIndex seq
Definition: ReadView.h:87
ripple::test::compression_test::buildGetObjectByHash
std::shared_ptr< protocol::TMGetObjectByHash > buildGetObjectByHash()
Definition: compression_test.cpp:275
ripple::SHAMapNodeID
Definition: SHAMapNodeID.h:33
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:52
ripple::test::jtx::sign
void sign(Json::Value &jv, Account const &account)
Sign automatically.
Definition: utility.cpp:45
ripple::test::compression_test
Definition: compression_test.cpp:72
ripple::LedgerInfo::txHash
uint256 txHash
Definition: ReadView.h:96
ripple::base_uint::data
pointer data()
Definition: base_uint.h:102
ripple::test::jtx::Env::trust
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
Definition: Env.cpp:245
ripple::sfSignature
const SF_Blob sfSignature(access, STI_VL, 6, "Signature", SField::sMD_Default, SField::notSigning)
Definition: SField.h:444
algorithm
ripple::base_uint::size
constexpr static std::size_t size()
Definition: base_uint.h:417
ripple::Serializer::data
void const * data() const noexcept
Definition: Serializer.h:79
ripple::uint256
base_uint< 256 > uint256
Definition: base_uint.h:436
std::string::push_back
T push_back(T... args)
ripple::LedgerInfo::closeTime
NetClock::time_point closeTime
Definition: ReadView.h:118
ripple::KeyType::ed25519
@ ed25519
ripple::base_uint< 256 >
ripple::test::compression_test::run
void run() override
Definition: compression_test.cpp:367
std::chrono::time_point::time_since_epoch
T time_since_epoch(T... args)
ripple::test::BEAST_DEFINE_TESTSUITE_MANUAL_PRIO
BEAST_DEFINE_TESTSUITE_MANUAL_PRIO(CrossingLimits, tx, ripple, 10)
ripple::Serializer::getDataPtr
const void * getDataPtr() const
Definition: Serializer.h:190
ripple::Application::config
virtual Config & config()=0
ripple::SHAMapNodeID::getRawString
std::string getRawString() const
Definition: SHAMapNodeID.cpp:93
ripple::LedgerInfo::closeFlags
int closeFlags
Definition: ReadView.h:109
std::to_string
T to_string(T... args)
ripple::compression::Compressed
Compressed
Definition: Compression.h:39
std::uint32_t
ripple::detail::parseMessageHeader
boost::optional< MessageHeader > parseMessageHeader(BufferSequence const &bufs, std::size_t size)
Definition: ProtocolMessage.h:105
ripple::compression::Algorithm
Algorithm
Definition: Compression.h:34
ripple::test::compression_test::buildTransaction
std::shared_ptr< protocol::TMTransaction > buildTransaction(Logs &logs)
Definition: compression_test.cpp:181
ripple::LedgerInfo::drops
XRPAmount drops
Definition: ReadView.h:100
ripple::Serializer
Definition: Serializer.h:43
ripple::Message
Definition: overlay/Message.h:49
ripple::randomKeyPair
std::pair< PublicKey, SecretKey > randomKeyPair(KeyType type)
Create a key pair using secure random numbers.
Definition: SecretKey.cpp:286
ripple::generateSeed
Seed generateSeed(std::string const &passPhrase)
Generate a seed deterministically.
Definition: Seed.cpp:74
ripple::test::compression_test::buildGetLedger
std::shared_ptr< protocol::TMGetLedger > buildGetLedger()
Definition: compression_test.cpp:227
ripple::STObject
Definition: STObject.h:51
ripple::sfPublicKey
const SF_Blob sfPublicKey(access, STI_VL, 1, "PublicKey")
Definition: SField.h:440
ripple::compression::decompress
std::size_t decompress(InputStream &in, std::size_t inSize, std::uint8_t *decompressed, std::size_t decompressedSize, Algorithm algorithm=Algorithm::LZ4)
Decompress input stream.
Definition: Compression.h:54
ripple::test::jtx
Definition: Check_test.cpp:26
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test
Definition: BookStep.cpp:1040
ripple::Serializer::size
std::size_t size() const noexcept
Definition: Serializer.h:73
ripple::Logs::journal
beast::Journal journal(std::string const &name)
Definition: Log.cpp:140
ripple::STObject::add
virtual void add(Serializer &s) const override
Definition: STObject.h:343
ripple::base_uint::begin
iterator begin()
Definition: base_uint.h:106
ripple::test::jtx::pay
Json::Value pay(Account const &account, Account const &to, AnyAmount amount)
Create a payment.
Definition: pay.cpp:29
ripple::sign
Buffer sign(PublicKey const &pk, SecretKey const &sk, Slice const &m)
Generate a signature for a message.
Definition: SecretKey.cpp:132
std::vector::begin
T begin(T... args)
ripple::test::jtx::Env::close
void close(NetClock::time_point closeTime, boost::optional< std::chrono::milliseconds > consensusDelay=boost::none)
Close and advance the ledger.
Definition: Env.cpp:114
ripple::LedgerInfo::closeTimeResolution
NetClock::duration closeTimeResolution
Definition: ReadView.h:112
ripple::sha512Half
sha512_half_hasher::result_type sha512Half(Args const &... args)
Returns the SHA512-Half of a series of objects.
Definition: digest.h:268
ripple::test::jtx::Env::fund
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition: Env.cpp:214
ripple::test::compression_test::doTest
void doTest(std::shared_ptr< T > proto, protocol::MessageType mt, uint16_t nbuffers, const char *msg, bool log=false)
Definition: compression_test.cpp:80
ripple::make_TimeKeeper
std::unique_ptr< TimeKeeper > make_TimeKeeper(beast::Journal j)
Definition: TimeKeeper.cpp:129
std::chrono::duration::count
T count(T... args)
ripple::test::compression_test::buildManifests
std::shared_ptr< protocol::TMManifests > buildManifests(int n)
Definition: compression_test.cpp:142
ripple::test::makeWSClient
std::unique_ptr< WSClient > makeWSClient(Config const &cfg, bool v2, unsigned rpc_version, std::unordered_map< std::string, std::string > const &headers)
Returns a client operating through WebSockets/S.
Definition: WSClient.cpp:307
ripple::test::jtx::Account
Immutable cryptographic account descriptor.
Definition: Account.h:37
ripple::LedgerInfo
Information about the notional ledger backing the view.
Definition: ReadView.h:79
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:70
ripple::Serializer::getLength
int getLength() const
Definition: Serializer.h:198
std::vector::data
T data(T... args)
ripple::LedgerInfo::accountHash
uint256 accountHash
Definition: ReadView.h:97
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:117
Json::Value
Represents a JSON value.
Definition: json_value.h:141
ripple::XRPAmount
Definition: XRPAmount.h:46
ripple::LedgerInfo::parentCloseTime
NetClock::time_point parentCloseTime
Definition: ReadView.h:88
ripple::sfDomain
const SF_Blob sfDomain(access, STI_VL, 7, "Domain")
Definition: SField.h:445
Generated by   doxygen 1.8.17