rippled
xchain_bridge.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2022 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 <test/jtx/xchain_bridge.h>
21 
22 #include <ripple/json/json_value.h>
23 #include <ripple/protocol/Issue.h>
24 #include <ripple/protocol/SField.h>
25 #include <ripple/protocol/STBase.h>
26 #include <ripple/protocol/STInteger.h>
27 #include <ripple/protocol/STObject.h>
28 #include <ripple/protocol/TxFlags.h>
29 #include <ripple/protocol/XChainAttestations.h>
30 #include <ripple/protocol/jss.h>
31 #include <test/jtx/Env.h>
32 #include <test/jtx/attester.h>
33 
34 namespace ripple {
35 namespace test {
36 namespace jtx {
37 
38 // use this for creating a bridge for a transaction
39 Json::Value
40 bridge(
41  Account const& lockingChainDoor,
42  Issue const& lockingChainIssue,
43  Account const& issuingChainDoor,
44  Issue const& issuingChainIssue)
45 {
46  Json::Value jv;
47  jv[sfLockingChainDoor.getJsonName()] = lockingChainDoor.human();
48  jv[sfLockingChainIssue.getJsonName()] = to_json(lockingChainIssue);
49  jv[sfIssuingChainDoor.getJsonName()] = issuingChainDoor.human();
50  jv[sfIssuingChainIssue.getJsonName()] = to_json(issuingChainIssue);
51  return jv;
52 }
53 
54 // use this for creating a bridge for a rpc query
55 Json::Value
56 bridge_rpc(
57  Account const& lockingChainDoor,
58  Issue const& lockingChainIssue,
59  Account const& issuingChainDoor,
60  Issue const& issuingChainIssue)
61 {
62  Json::Value jv;
63  jv[sfLockingChainDoor.getJsonName()] = lockingChainDoor.human();
64  jv[sfLockingChainIssue.getJsonName()] = to_json(lockingChainIssue);
65  jv[sfIssuingChainDoor.getJsonName()] = issuingChainDoor.human();
66  jv[sfIssuingChainIssue.getJsonName()] = to_json(issuingChainIssue);
67  return jv;
68 }
69 
70 Json::Value
71 bridge_create(
72  Account const& acc,
73  Json::Value const& bridge,
74  STAmount const& reward,
75  std::optional<STAmount> const& minAccountCreate)
76 {
77  Json::Value jv;
78 
79  jv[jss::Account] = acc.human();
80  jv[sfXChainBridge.getJsonName()] = bridge;
81  jv[sfSignatureReward.getJsonName()] = reward.getJson(JsonOptions::none);
82  if (minAccountCreate)
83  jv[sfMinAccountCreateAmount.getJsonName()] =
84  minAccountCreate->getJson(JsonOptions::none);
85 
86  jv[jss::TransactionType] = jss::XChainCreateBridge;
87  jv[jss::Flags] = tfUniversal;
88  return jv;
89 }
90 
91 Json::Value
92 bridge_modify(
93  Account const& acc,
94  Json::Value const& bridge,
95  std::optional<STAmount> const& reward,
96  std::optional<STAmount> const& minAccountCreate)
97 {
98  Json::Value jv;
99 
100  jv[jss::Account] = acc.human();
101  jv[sfXChainBridge.getJsonName()] = bridge;
102  if (reward)
103  jv[sfSignatureReward.getJsonName()] =
104  reward->getJson(JsonOptions::none);
105  if (minAccountCreate)
106  jv[sfMinAccountCreateAmount.getJsonName()] =
107  minAccountCreate->getJson(JsonOptions::none);
108 
109  jv[jss::TransactionType] = jss::XChainModifyBridge;
110  jv[jss::Flags] = tfUniversal;
111  return jv;
112 }
113 
114 Json::Value
115 xchain_create_claim_id(
116  Account const& acc,
117  Json::Value const& bridge,
118  STAmount const& reward,
119  Account const& otherChainSource)
120 {
121  Json::Value jv;
122 
123  jv[jss::Account] = acc.human();
124  jv[sfXChainBridge.getJsonName()] = bridge;
125  jv[sfSignatureReward.getJsonName()] = reward.getJson(JsonOptions::none);
126  jv[sfOtherChainSource.getJsonName()] = otherChainSource.human();
127 
128  jv[jss::TransactionType] = jss::XChainCreateClaimID;
129  jv[jss::Flags] = tfUniversal;
130  return jv;
131 }
132 
133 Json::Value
134 xchain_commit(
135  Account const& acc,
136  Json::Value const& bridge,
137  std::uint32_t claimID,
138  AnyAmount const& amt,
139  std::optional<Account> const& dst)
140 {
141  Json::Value jv;
142 
143  jv[jss::Account] = acc.human();
144  jv[sfXChainBridge.getJsonName()] = bridge;
145  jv[sfXChainClaimID.getJsonName()] = claimID;
146  jv[jss::Amount] = amt.value.getJson(JsonOptions::none);
147  if (dst)
148  jv[sfOtherChainDestination.getJsonName()] = dst->human();
149 
150  jv[jss::TransactionType] = jss::XChainCommit;
151  jv[jss::Flags] = tfUniversal;
152  return jv;
153 }
154 
155 Json::Value
156 xchain_claim(
157  Account const& acc,
158  Json::Value const& bridge,
159  std::uint32_t claimID,
160  AnyAmount const& amt,
161  Account const& dst)
162 {
163  Json::Value jv;
164 
165  jv[sfAccount.getJsonName()] = acc.human();
166  jv[sfXChainBridge.getJsonName()] = bridge;
167  jv[sfXChainClaimID.getJsonName()] = claimID;
168  jv[sfDestination.getJsonName()] = dst.human();
169  jv[sfAmount.getJsonName()] = amt.value.getJson(JsonOptions::none);
170 
171  jv[jss::TransactionType] = jss::XChainClaim;
172  jv[jss::Flags] = tfUniversal;
173  return jv;
174 }
175 
176 Json::Value
177 sidechain_xchain_account_create(
178  Account const& acc,
179  Json::Value const& bridge,
180  Account const& dst,
181  AnyAmount const& amt,
182  AnyAmount const& reward)
183 {
184  Json::Value jv;
185 
186  jv[sfAccount.getJsonName()] = acc.human();
187  jv[sfXChainBridge.getJsonName()] = bridge;
188  jv[sfDestination.getJsonName()] = dst.human();
189  jv[sfAmount.getJsonName()] = amt.value.getJson(JsonOptions::none);
190  jv[sfSignatureReward.getJsonName()] =
191  reward.value.getJson(JsonOptions::none);
192 
193  jv[jss::TransactionType] = jss::XChainAccountCreateCommit;
194  jv[jss::Flags] = tfUniversal;
195  return jv;
196 }
197 
198 Json::Value
199 claim_attestation(
200  jtx::Account const& submittingAccount,
201  Json::Value const& jvBridge,
202  jtx::Account const& sendingAccount,
203  jtx::AnyAmount const& sendingAmount,
204  jtx::Account const& rewardAccount,
205  bool wasLockingChainSend,
206  std::uint64_t claimID,
207  std::optional<jtx::Account> const& dst,
208  jtx::signer const& signer)
209 {
210  STXChainBridge const stBridge(jvBridge);
211 
212  auto const& pk = signer.account.pk();
213  auto const& sk = signer.account.sk();
214  auto const sig = sign_claim_attestation(
215  pk,
216  sk,
217  stBridge,
218  sendingAccount,
219  sendingAmount.value,
220  rewardAccount,
221  wasLockingChainSend,
222  claimID,
223  dst);
224 
225  Json::Value result;
226 
227  result[sfAccount.getJsonName()] = submittingAccount.human();
228  result[sfXChainBridge.getJsonName()] = jvBridge;
229 
230  result[sfAttestationSignerAccount.getJsonName()] = signer.account.human();
231  result[sfPublicKey.getJsonName()] = strHex(pk.slice());
232  result[sfSignature.getJsonName()] = strHex(sig);
233  result[sfOtherChainSource.getJsonName()] = toBase58(sendingAccount);
234  result[sfAmount.getJsonName()] =
235  sendingAmount.value.getJson(JsonOptions::none);
236  result[sfAttestationRewardAccount.getJsonName()] = toBase58(rewardAccount);
237  result[sfWasLockingChainSend.getJsonName()] = wasLockingChainSend ? 1 : 0;
238 
239  result[sfXChainClaimID.getJsonName()] =
240  STUInt64{claimID}.getJson(JsonOptions::none);
241  if (dst)
242  result[sfDestination.getJsonName()] = toBase58(*dst);
243 
244  result[jss::TransactionType] = jss::XChainAddClaimAttestation;
245  result[jss::Flags] = tfUniversal;
246 
247  return result;
248 }
249 
250 Json::Value
251 create_account_attestation(
252  jtx::Account const& submittingAccount,
253  Json::Value const& jvBridge,
254  jtx::Account const& sendingAccount,
255  jtx::AnyAmount const& sendingAmount,
256  jtx::AnyAmount const& rewardAmount,
257  jtx::Account const& rewardAccount,
258  bool wasLockingChainSend,
259  std::uint64_t createCount,
260  jtx::Account const& dst,
261  jtx::signer const& signer)
262 {
263  STXChainBridge const stBridge(jvBridge);
264 
265  auto const& pk = signer.account.pk();
266  auto const& sk = signer.account.sk();
267  auto const sig = jtx::sign_create_account_attestation(
268  pk,
269  sk,
270  stBridge,
271  sendingAccount,
272  sendingAmount.value,
273  rewardAmount.value,
274  rewardAccount,
275  wasLockingChainSend,
276  createCount,
277  dst);
278 
279  Json::Value result;
280 
281  result[sfAccount.getJsonName()] = submittingAccount.human();
282  result[sfXChainBridge.getJsonName()] = jvBridge;
283 
284  result[sfAttestationSignerAccount.getJsonName()] = signer.account.human();
285  result[sfPublicKey.getJsonName()] = strHex(pk.slice());
286  result[sfSignature.getJsonName()] = strHex(sig);
287  result[sfOtherChainSource.getJsonName()] = toBase58(sendingAccount);
288  result[sfAmount.getJsonName()] =
289  sendingAmount.value.getJson(JsonOptions::none);
290  result[sfAttestationRewardAccount.getJsonName()] = toBase58(rewardAccount);
291  result[sfWasLockingChainSend.getJsonName()] = wasLockingChainSend ? 1 : 0;
292 
293  result[sfXChainAccountCreateCount.getJsonName()] =
294  STUInt64{createCount}.getJson(JsonOptions::none);
295  result[sfDestination.getJsonName()] = toBase58(dst);
296  result[sfSignatureReward.getJsonName()] =
297  rewardAmount.value.getJson(JsonOptions::none);
298 
299  result[jss::TransactionType] = jss::XChainAddAccountCreateAttestation;
300  result[jss::Flags] = tfUniversal;
301 
302  return result;
303 }
304 
305 JValueVec
306 claim_attestations(
307  jtx::Account const& submittingAccount,
308  Json::Value const& jvBridge,
309  jtx::Account const& sendingAccount,
310  jtx::AnyAmount const& sendingAmount,
311  std::vector<jtx::Account> const& rewardAccounts,
312  bool wasLockingChainSend,
313  std::uint64_t claimID,
314  std::optional<jtx::Account> const& dst,
315  std::vector<jtx::signer> const& signers,
316  std::size_t const numAtts,
317  std::size_t const fromIdx)
318 {
319  assert(fromIdx + numAtts <= rewardAccounts.size());
320  assert(fromIdx + numAtts <= signers.size());
321  JValueVec vec;
322  vec.reserve(numAtts);
323  for (auto i = fromIdx; i < fromIdx + numAtts; ++i)
324  vec.emplace_back(claim_attestation(
325  submittingAccount,
326  jvBridge,
327  sendingAccount,
328  sendingAmount,
329  rewardAccounts[i],
330  wasLockingChainSend,
331  claimID,
332  dst,
333  signers[i]));
334  return vec;
335 }
336 
337 JValueVec
338 create_account_attestations(
339  jtx::Account const& submittingAccount,
340  Json::Value const& jvBridge,
341  jtx::Account const& sendingAccount,
342  jtx::AnyAmount const& sendingAmount,
343  jtx::AnyAmount const& rewardAmount,
344  std::vector<jtx::Account> const& rewardAccounts,
345  bool wasLockingChainSend,
346  std::uint64_t createCount,
347  jtx::Account const& dst,
348  std::vector<jtx::signer> const& signers,
349  std::size_t const numAtts,
350  std::size_t const fromIdx)
351 {
352  assert(fromIdx + numAtts <= rewardAccounts.size());
353  assert(fromIdx + numAtts <= signers.size());
354  JValueVec vec;
355  vec.reserve(numAtts);
356  for (auto i = fromIdx; i < fromIdx + numAtts; ++i)
357  vec.emplace_back(create_account_attestation(
358  submittingAccount,
359  jvBridge,
360  sendingAccount,
361  sendingAmount,
362  rewardAmount,
363  rewardAccounts[i],
364  wasLockingChainSend,
365  createCount,
366  dst,
367  signers[i]));
368  return vec;
369 }
370 
371 XChainBridgeObjects::XChainBridgeObjects()
372  : mcDoor("mcDoor")
373  , mcAlice("mcAlice")
374  , mcBob("mcBob")
375  , mcCarol("mcCarol")
376  , mcGw("mcGw")
377  , scDoor("scDoor")
378  , scAlice("scAlice")
379  , scBob("scBob")
380  , scCarol("scCarol")
381  , scGw("scGw")
382  , scAttester("scAttester")
383  , scReward("scReward")
384  , mcuDoor("mcuDoor")
385  , mcuAlice("mcuAlice")
386  , mcuBob("mcuBob")
387  , mcuCarol("mcuCarol")
388  , mcuGw("mcuGw")
389  , scuDoor("scuDoor")
390  , scuAlice("scuAlice")
391  , scuBob("scuBob")
392  , scuCarol("scuCarol")
393  , scuGw("scuGw")
394  , mcUSD(mcGw["USD"])
395  , scUSD(scGw["USD"])
396  , jvXRPBridgeRPC(
397  bridge_rpc(mcDoor, xrpIssue(), Account::master, xrpIssue()))
398  , jvb(bridge(mcDoor, xrpIssue(), Account::master, xrpIssue()))
399  , jvub(bridge(mcuDoor, xrpIssue(), Account::master, xrpIssue()))
400  , features(supported_amendments() | FeatureBitset{featureXChainBridge})
401  , signers([] {
402  constexpr int numSigners = UT_XCHAIN_DEFAULT_NUM_SIGNERS;
403  std::vector<signer> result;
404  result.reserve(numSigners);
405  for (int i = 0; i < numSigners; ++i)
406  {
407  using namespace std::literals;
408  auto const a = Account(
409  "signer_"s + std::to_string(i),
410  (i % 2) ? KeyType::ed25519 : KeyType::secp256k1);
411  result.emplace_back(a);
412  }
413  return result;
414  }())
415  , alt_signers([] {
416  constexpr int numSigners = UT_XCHAIN_DEFAULT_NUM_SIGNERS;
417  std::vector<signer> result;
418  result.reserve(numSigners);
419  for (int i = 0; i < numSigners; ++i)
420  {
421  using namespace std::literals;
422  auto const a = Account(
423  "alt_signer_"s + std::to_string(i),
424  (i % 2) ? KeyType::ed25519 : KeyType::secp256k1);
425  result.emplace_back(a);
426  }
427  return result;
428  }())
429  , payee([&] {
430  std::vector<Account> r;
431  r.reserve(signers.size());
432  for (int i = 0, e = signers.size(); i != e; ++i)
433  {
434  r.push_back(scReward);
435  }
436  return r;
437  }())
438  , payees([&] {
439  std::vector<Account> r;
440  r.reserve(signers.size());
441  for (int i = 0, e = signers.size(); i != e; ++i)
442  {
443  using namespace std::literals;
444  auto const a = Account("reward_"s + std::to_string(i));
445  r.push_back(a);
446  }
447  return r;
448  }())
449  , quorum(UT_XCHAIN_DEFAULT_QUORUM)
450  , reward(XRP(1))
451  , split_reward_quorum(
452  divide(reward, STAmount(UT_XCHAIN_DEFAULT_QUORUM), reward.issue()))
453  , split_reward_everyone(divide(
454  reward,
455  STAmount(UT_XCHAIN_DEFAULT_NUM_SIGNERS),
456  reward.issue()))
457  , tiny_reward(drops(37))
458  , tiny_reward_split((divide(
459  tiny_reward,
460  STAmount(UT_XCHAIN_DEFAULT_QUORUM),
461  tiny_reward.issue())))
462  , tiny_reward_remainder(
463  tiny_reward -
464  multiply(
465  tiny_reward_split,
466  STAmount(UT_XCHAIN_DEFAULT_QUORUM),
467  tiny_reward.issue()))
468  , one_xrp(XRP(1))
469  , xrp_dust(divide(one_xrp, STAmount(10000), one_xrp.issue()))
470 {
471 }
472 
473 void
474 XChainBridgeObjects::createMcBridgeObjects(Env& mcEnv)
475 {
476  STAmount xrp_funds{XRP(10000)};
477  mcEnv.fund(xrp_funds, mcDoor, mcAlice, mcBob, mcCarol, mcGw);
478 
479  // Signer's list must match the attestation signers
480  mcEnv(jtx::signers(mcDoor, signers.size(), signers));
481 
482  // create XRP bridges in both direction
483  auto const reward = XRP(1);
484  STAmount const minCreate = XRP(20);
485 
486  mcEnv(bridge_create(mcDoor, jvb, reward, minCreate));
487  mcEnv.close();
488 }
489 
490 void
491 XChainBridgeObjects::createScBridgeObjects(Env& scEnv)
492 {
493  STAmount xrp_funds{XRP(10000)};
494  scEnv.fund(
495  xrp_funds, scDoor, scAlice, scBob, scCarol, scGw, scAttester, scReward);
496 
497  // Signer's list must match the attestation signers
498  scEnv(jtx::signers(Account::master, signers.size(), signers));
499 
500  // create XRP bridges in both direction
501  auto const reward = XRP(1);
502  STAmount const minCreate = XRP(20);
503 
504  scEnv(bridge_create(Account::master, jvb, reward, minCreate));
505  scEnv.close();
506 }
507 
508 void
509 XChainBridgeObjects::createBridgeObjects(Env& mcEnv, Env& scEnv)
510 {
511  createMcBridgeObjects(mcEnv);
512  createScBridgeObjects(scEnv);
513 }
514 } // namespace jtx
515 } // namespace test
516 } // namespace ripple
ripple::test::jtx::XChainBridgeObjects::createBridgeObjects
void createBridgeObjects(Env &mcEnv, Env &scEnv)
Definition: xchain_bridge.cpp:509
ripple::test::jtx::XRP
const XRP_t XRP
Converts to XRP Issue or STAmount.
Definition: amount.cpp:105
ripple::test::jtx::XChainBridgeObjects::createScBridgeObjects
void createScBridgeObjects(Env &scEnv)
Definition: xchain_bridge.cpp:491
ripple::test::jtx::xchain_commit
Json::Value xchain_commit(Account const &acc, Json::Value const &bridge, std::uint32_t claimID, AnyAmount const &amt, std::optional< Account > const &dst)
Definition: xchain_bridge.cpp:134
ripple::Issue
A currency issued by an account.
Definition: Issue.h:35
ripple::test::jtx::drops
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
Definition: amount.h:241
ripple::sfDestination
const SF_ACCOUNT sfDestination
ripple::sfAmount
const SF_AMOUNT sfAmount
ripple::sfLockingChainDoor
const SF_ACCOUNT sfLockingChainDoor
ripple::test::jtx::bridge_rpc
Json::Value bridge_rpc(Account const &lockingChainDoor, Issue const &lockingChainIssue, Account const &issuingChainDoor, Issue const &issuingChainIssue)
Definition: xchain_bridge.cpp:56
ripple::test::jtx::claim_attestations
JValueVec claim_attestations(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, std::vector< jtx::Account > const &rewardAccounts, bool wasLockingChainSend, std::uint64_t claimID, std::optional< jtx::Account > const &dst, std::vector< jtx::signer > const &signers, std::size_t const numAtts, std::size_t const fromIdx)
Definition: xchain_bridge.cpp:306
std::vector::reserve
T reserve(T... args)
ripple::test::jtx::sign_create_account_attestation
Buffer sign_create_account_attestation(PublicKey const &pk, SecretKey const &sk, STXChainBridge const &bridge, AccountID const &sendingAccount, STAmount const &sendingAmount, STAmount const &rewardAmount, AccountID const &rewardAccount, bool wasLockingChainSend, std::uint64_t createCount, AccountID const &dst)
Definition: attester.cpp:56
ripple::test::jtx::XChainBridgeObjects::XChainBridgeObjects
XChainBridgeObjects()
Definition: xchain_bridge.cpp:371
std::vector
STL class.
ripple::STAmount::getJson
Json::Value getJson(JsonOptions) const override
Definition: STAmount.cpp:653
ripple::test::jtx::XChainBridgeObjects::jvb
Json::Value jvb
Definition: xchain_bridge.h:184
ripple::test::jtx::AnyAmount
Amount specifier with an option for any issuer.
Definition: amount.h:361
ripple::test::jtx::signer::account
Account account
Definition: multisign.h:38
ripple::toBase58
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition: AccountID.cpp:104
ripple::sfOtherChainSource
const SF_ACCOUNT sfOtherChainSource
ripple::test::jtx::Account::human
std::string const & human() const
Returns the human readable public key.
Definition: Account.h:113
ripple::test::jtx::XChainBridgeObjects::scGw
const Account scGw
Definition: xchain_bridge.h:164
ripple::test::jtx::UT_XCHAIN_DEFAULT_QUORUM
constexpr std::size_t UT_XCHAIN_DEFAULT_QUORUM
Definition: xchain_bridge.h:37
ripple::test::jtx::claim_attestation
Json::Value claim_attestation(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, jtx::Account const &rewardAccount, bool wasLockingChainSend, std::uint64_t claimID, std::optional< jtx::Account > const &dst, jtx::signer const &signer)
Definition: xchain_bridge.cpp:199
ripple::test::jtx::bridge_modify
Json::Value bridge_modify(Account const &acc, Json::Value const &bridge, std::optional< STAmount > const &reward, std::optional< STAmount > const &minAccountCreate)
Definition: xchain_bridge.cpp:92
ripple::sfWasLockingChainSend
const SF_UINT8 sfWasLockingChainSend
ripple::test::jtx::XChainBridgeObjects::mcCarol
const Account mcCarol
Definition: xchain_bridge.h:158
ripple::SField::getJsonName
Json::StaticString const & getJsonName() const
Definition: SField.h:214
ripple::test::jtx::create_account_attestation
Json::Value create_account_attestation(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, jtx::AnyAmount const &rewardAmount, jtx::Account const &rewardAccount, bool wasLockingChainSend, std::uint64_t createCount, jtx::Account const &dst, jtx::signer const &signer)
Definition: xchain_bridge.cpp:251
ripple::test::jtx::signer
A signer in a SignerList.
Definition: multisign.h:35
ripple::test::jtx::bridge
Json::Value bridge(Account const &lockingChainDoor, Issue const &lockingChainIssue, Account const &issuingChainDoor, Issue const &issuingChainIssue)
Definition: xchain_bridge.cpp:40
ripple::sfXChainClaimID
const SF_UINT64 sfXChainClaimID
ripple::test::jtx::sign_claim_attestation
Buffer sign_claim_attestation(PublicKey const &pk, SecretKey const &sk, STXChainBridge const &bridge, AccountID const &sendingAccount, STAmount const &sendingAmount, AccountID const &rewardAccount, bool wasLockingChainSend, std::uint64_t claimID, std::optional< AccountID > const &dst)
Definition: attester.cpp:33
ripple::test::jtx::xchain_claim
Json::Value xchain_claim(Account const &acc, Json::Value const &bridge, std::uint32_t claimID, AnyAmount const &amt, Account const &dst)
Definition: xchain_bridge.cpp:156
ripple::divide
STAmount divide(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:86
ripple::KeyType::ed25519
@ ed25519
ripple::test::jtx::XChainBridgeObjects::reward
const STAmount reward
Definition: xchain_bridge.h:194
ripple::test::jtx::XChainBridgeObjects::scCarol
const Account scCarol
Definition: xchain_bridge.h:163
ripple::test::jtx::XChainBridgeObjects::scDoor
const Account scDoor
Definition: xchain_bridge.h:160
ripple::sfSignatureReward
const SF_AMOUNT sfSignatureReward
ripple::test::jtx::signers
Json::Value signers(Account const &account, std::uint32_t quorum, std::vector< signer > const &v)
Definition: multisign.cpp:35
ripple::test::jtx::XChainBridgeObjects::mcGw
const Account mcGw
Definition: xchain_bridge.h:159
ripple::sfLockingChainIssue
const SF_ISSUE sfLockingChainIssue
ripple::JsonOptions::none
@ none
ripple::test::jtx::XChainBridgeObjects::scReward
const Account scReward
Definition: xchain_bridge.h:166
std::to_string
T to_string(T... args)
ripple::test::jtx::Env::close
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition: Env.cpp:121
ripple::STAmount
Definition: STAmount.h:46
Json::Value::size
UInt size() const
Number of values in array or object.
Definition: json_value.cpp:706
ripple::sfAttestationSignerAccount
const SF_ACCOUNT sfAttestationSignerAccount
ripple::test::jtx::supported_amendments
FeatureBitset supported_amendments()
Definition: Env.h:71
std::uint32_t
ripple::test::jtx::sig
Set the regular signature on a JTx.
Definition: sig.h:34
ripple::test::jtx::XChainBridgeObjects::scAttester
const Account scAttester
Definition: xchain_bridge.h:165
ripple::test::jtx::Account::master
static const Account master
The master account.
Definition: Account.h:47
ripple::featureXChainBridge
const uint256 featureXChainBridge
ripple::test::jtx::UT_XCHAIN_DEFAULT_NUM_SIGNERS
constexpr std::size_t UT_XCHAIN_DEFAULT_NUM_SIGNERS
Definition: xchain_bridge.h:36
ripple::STInteger
Definition: SField.h:51
ripple::STXChainBridge
Definition: STXChainBridge.h:32
ripple::KeyType::secp256k1
@ secp256k1
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:47
ripple::sfMinAccountCreateAmount
const SF_AMOUNT sfMinAccountCreateAmount
std::vector::emplace_back
T emplace_back(T... args)
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test::jtx::xchain_create_claim_id
Json::Value xchain_create_claim_id(Account const &acc, Json::Value const &bridge, STAmount const &reward, Account const &otherChainSource)
Definition: xchain_bridge.cpp:115
ripple::to_json
Json::Value to_json(Issue const &is)
Definition: Issue.cpp:68
ripple::test::jtx::sidechain_xchain_account_create
Json::Value sidechain_xchain_account_create(Account const &acc, Json::Value const &bridge, Account const &dst, AnyAmount const &amt, AnyAmount const &reward)
Definition: xchain_bridge.cpp:177
ripple::test::jtx::XChainBridgeObjects::mcDoor
const Account mcDoor
Definition: xchain_bridge.h:155
ripple::test::jtx::Env::fund
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition: Env.cpp:228
ripple::sfOtherChainDestination
const SF_ACCOUNT sfOtherChainDestination
ripple::test::jtx::XChainBridgeObjects::scBob
const Account scBob
Definition: xchain_bridge.h:162
ripple::sfXChainAccountCreateCount
const SF_UINT64 sfXChainAccountCreateCount
ripple::sfSignature
const SF_VL sfSignature
ripple::test::jtx::XChainBridgeObjects::scAlice
const Account scAlice
Definition: xchain_bridge.h:161
ripple::FeatureBitset
Definition: Feature.h:113
ripple::xrpIssue
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition: Issue.h:105
std::optional< STAmount >
ripple::test::jtx::create_account_attestations
JValueVec create_account_attestations(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, jtx::AnyAmount const &rewardAmount, std::vector< jtx::Account > const &rewardAccounts, bool wasLockingChainSend, std::uint64_t createCount, jtx::Account const &dst, std::vector< jtx::signer > const &signers, std::size_t const numAtts, std::size_t const fromIdx)
Definition: xchain_bridge.cpp:338
std::size_t
ripple::test::jtx::Account
Immutable cryptographic account descriptor.
Definition: Account.h:37
ripple::sfAccount
const SF_ACCOUNT sfAccount
ripple::sfIssuingChainDoor
const SF_ACCOUNT sfIssuingChainDoor
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:30
ripple::sfAttestationRewardAccount
const SF_ACCOUNT sfAttestationRewardAccount
ripple::test::jtx::Account::sk
SecretKey const & sk() const
Return the secret key.
Definition: Account.h:96
ripple::test::jtx::XChainBridgeObjects::mcBob
const Account mcBob
Definition: xchain_bridge.h:157
ripple::test::jtx::AnyAmount::value
STAmount value
Definition: amount.h:364
ripple::tfUniversal
constexpr std::uint32_t tfUniversal
Definition: TxFlags.h:59
ripple::sfIssuingChainIssue
const SF_ISSUE sfIssuingChainIssue
ripple::test::jtx::XChainBridgeObjects::createMcBridgeObjects
void createMcBridgeObjects(Env &mcEnv)
Definition: xchain_bridge.cpp:474
ripple::test::jtx::bridge_create
Json::Value bridge_create(Account const &acc, Json::Value const &bridge, STAmount const &reward, std::optional< STAmount > const &minAccountCreate)
Definition: xchain_bridge.cpp:71
ripple::test::jtx::XChainBridgeObjects::mcAlice
const Account mcAlice
Definition: xchain_bridge.h:156
ripple::sfXChainBridge
const SF_XCHAIN_BRIDGE sfXChainBridge
ripple::sfPublicKey
const SF_VL sfPublicKey
ripple::test::jtx::Account::pk
PublicKey const & pk() const
Return the public key.
Definition: Account.h:89
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:117
ripple::test::jtx::XChainBridgeObjects::signers
const std::vector< signer > signers
Definition: xchain_bridge.h:188
Json::Value
Represents a JSON value.
Definition: json_value.h:145
Generated by   doxygen 1.8.17