1#include <test/jtx/Account.h>
2#include <test/jtx/Env.h>
3#include <test/jtx/TestHelpers.h>
4#include <test/jtx/WSClient.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/escrow.h>
7#include <test/jtx/mpt.h>
8#include <test/jtx/pay.h>
9#include <test/jtx/trust.h>
11#include <xrpl/beast/unit_test/suite.h>
12#include <xrpl/json/json_value.h>
13#include <xrpl/protocol/ApiVersion.h>
14#include <xrpl/protocol/ErrorCodes.h>
15#include <xrpl/protocol/Feature.h>
16#include <xrpl/protocol/STAmount.h>
17#include <xrpl/protocol/TxFlags.h>
18#include <xrpl/protocol/jss.h>
28 using namespace std::chrono_literals;
30 Env env(*
this, features);
36 auto const usd = alice[
"USD"];
37 auto const cny = alice[
"CNY"];
38 auto const jpy = alice[
"JPY"];
44 env(
trust(hw, usd(10000)));
45 env(
trust(hw, jpy(10000)));
46 env(
pay(alice, hw, usd(5000)));
47 env(
pay(alice, hw, jpy(5000)));
53 env(
trust(bob, usd(100)));
54 env(
trust(bob, cny(100)));
55 env(
pay(alice, bob, usd(50)));
57 Account const charley{
"charley"};
58 env.
fund(
XRP(10000),
"charley");
60 env(
trust(charley, cny(500)));
61 env(
trust(charley, jpy(500)));
62 env(
pay(alice, charley, cny(250)));
63 env(
pay(alice, charley, jpy(250)));
68 env(
trust(dave, cny(100)));
69 env(
pay(alice, dave, cny(30)));
72 env(
trust(alice, charley[
"USD"](50)));
73 env(
pay(charley, alice, usd(10)));
76 env(
trust(alice, dave[
"CNY"](0), dave, tfSetFreeze));
83 qry[jss::account] = alice.
human();
84 qry[jss::hotwallet] = hw.
human();
86 auto jv = wsc->invoke(
"gateway_balances", qry);
87 expect(jv[jss::status] ==
"success");
88 if (wsc->version() == 2)
91 expect(jv.isMember(jss::id) && jv[jss::id] == 5);
94 auto const& result = jv[jss::result];
96 expect(result[jss::status] ==
"success");
99 auto const& balances = result[jss::balances];
100 expect(balances.isObject(),
"balances is not an object");
101 expect(balances.size() == 1,
"balances size is not 1");
103 auto const& hwBalance = balances[hw.
human()];
104 expect(hwBalance.isArray(),
"hwBalance is not an array");
105 expect(hwBalance.size() == 2);
106 auto const c1 = hwBalance[0u][jss::currency];
107 auto const c2 = hwBalance[1u][jss::currency];
108 expect(c1 ==
"USD" || c2 ==
"USD");
109 expect(c1 ==
"JPY" || c2 ==
"JPY");
110 expect(hwBalance[0u][jss::value] ==
"5000" && hwBalance[1u][jss::value] ==
"5000");
114 auto const& fBalances = result[jss::frozen_balances];
115 expect(fBalances.isObject());
116 expect(fBalances.size() == 1);
118 auto const& fBal = fBalances[dave.
human()];
121 expect(fBal[0u].isObject());
122 expect(fBal[0u][jss::currency] ==
"CNY");
123 expect(fBal[0u][jss::value] ==
"30");
127 auto const& assets = result[jss::assets];
128 expect(assets.isObject(),
"assets it not an object");
129 expect(assets.size() == 1,
"assets size is not 1");
131 auto const& cAssets = assets[charley.
human()];
132 expect(cAssets.isArray());
133 expect(cAssets.size() == 1);
134 expect(cAssets[0u][jss::currency] ==
"USD");
135 expect(cAssets[0u][jss::value] ==
"10");
139 auto const& obligations = result[jss::obligations];
140 expect(obligations.isObject(),
"obligations is not an object");
141 expect(obligations.size() == 3);
142 expect(obligations[
"CNY"] ==
"250");
143 expect(obligations[
"JPY"] ==
"250");
144 expect(obligations[
"USD"] ==
"50");
152 using namespace std::chrono_literals;
154 Env env(*
this, features);
166 qry2[jss::account] = alice.
human();
167 qry2[jss::hotwallet] =
"asdf";
170 qry2[jss::api_version] = apiVersion;
171 auto jv = wsc->invoke(
"gateway_balances", qry2);
172 expect(jv[jss::status] ==
"error");
174 auto response = jv[jss::result];
175 auto const error = apiVersion < 2u ?
"invalidHotWallet" :
"invalidParams";
177 auto const errorMessage =
178 apiVersion < 2u ?
"Invalid hotwallet." :
"Invalid parameters.";
179 BEAST_EXPECT(response[jss::error] == error);
180 BEAST_EXPECT(response[jss::error_code] == errorCode);
181 BEAST_EXPECT(response[jss::error_message] == errorMessage);
188 testcase(
"Gateway Balances with non-string account/ident");
189 using namespace std::chrono_literals;
191 Env env(*
this, features);
202 qry[jss::account] = 42;
203 qry[jss::hotwallet] = alice.
human();
206 qry[jss::api_version] = apiVersion;
207 auto jv = wsc->invoke(
"gateway_balances", qry);
208 expect(jv[jss::status] ==
"error");
209 BEAST_EXPECT(jv[jss::result][jss::error] ==
"invalidParams");
211 BEAST_EXPECT(jv[jss::result][jss::error_message] ==
"Invalid field 'account'.");
216 qry2[jss::ident] = 42;
219 qry2[jss::api_version] = apiVersion;
220 auto jv = wsc->invoke(
"gateway_balances", qry2);
221 expect(jv[jss::status] ==
"error");
222 BEAST_EXPECT(jv[jss::result][jss::error] ==
"invalidParams");
224 BEAST_EXPECT(jv[jss::result][jss::error_message] ==
"Invalid field 'ident'.");
231 using namespace std::chrono_literals;
239 auto const usd = alice[
"USD"];
248 env(
trust(hw, maxUSD));
250 env(
pay(alice, hw, maxUSD));
256 env(
trust(bob, maxUSD));
258 env(
pay(alice, bob, maxUSD));
260 Account const charley{
"charley"};
263 env(
trust(charley, maxUSD));
265 env(
pay(alice, charley, maxUSD));
272 query[jss::account] = alice.
human();
273 query[jss::hotwallet] = hw.
human();
279 auto jv = wsc->invoke(
"gateway_balances", query);
280 expect(jv[jss::status] ==
"success");
281 expect(jv[jss::result][jss::obligations][
"USD"] == maxUSD.
getText());
287 testcase(
"Gateway Balances with MPT Escrow");
288 using namespace std::chrono_literals;
293 Env env(*
this, features);
298 env.
fund(
XRP(10000), alice, bob);
302 MPTTester mpt(env, alice, {.holders = {bob}, .fund =
false});
303 mpt.
create({.flags = tfMPTCanEscrow});
306 mpt.authorize({.account = bob, .holderCount = 1});
307 mpt.pay(alice, bob, 1000);
310 auto const MPT = mpt[
"MPT"];
317 qry[jss::account] = bob.
human();
319 auto jv = wsc->invoke(
"gateway_balances", qry);
320 expect(jv[jss::status] ==
"success");
328 for (
auto const feature : {sa - featurePermissionedDEX, sa})
bool expect(Condition const &shouldBeTrue)
Evaluate a test condition.
TestcaseT testcase
Memberspace for declaring test cases.
virtual Config & config()=0
std::string getText() const override
static constexpr std::uint64_t kMaxValue
static constexpr int kMaxOffset
void testGWB(FeatureBitset features)
void run() override
Runs the suite.
void testGWBApiVersions(FeatureBitset features)
void testGWBInvalidAccount(FeatureBitset features)
Immutable cryptographic account descriptor.
std::string const & human() const
Returns the human readable public key.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
NetClock::time_point now()
Returns the current network time.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Converts to MPT Issue or STAmount.
The api_version numbers this server serves.
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount)
auto const kFinishTime
Set the "FinishAfter" time tag on a JTx.
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
XrpT const XRP
Converts to XRP Issue or STAmount.
bool hasEnvelope2(json::Value const &reply)
Reports whether reply carries the version 2 envelope: jsonrpc equal to rpc::kJsonRpcVersion and rippl...
FeatureBitset testableAmendments()
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
std::unique_ptr< WSClient > makeWSClient(Config const &cfg, bool v2, unsigned rpcVersion, std::unordered_map< std::string, std::string > const &headers)
Returns a client operating through WebSockets/S.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
void forAllApiVersions(Fn const &fn, Args &&... args)