mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
7f52249e40
* Minimum factor 256*500, don't multiply by base fee
* Change autofill fee behavior to pay the open ledger fee.
** Experimental options: x-assume-tx - assume <int> more transactions in
the open queue when computing escalated fee, x-queue-okay - if true
and escalated fee is over limit, try with load fee.
* Port of 75af4ed.
341 lines
11 KiB
C++
341 lines
11 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of rippled: https://github.com/ripple/rippled
|
|
Copyright (c) 2012, 2013 Ripple Labs Inc.
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#include <BeastConfig.h>
|
|
#include <ripple/app/misc/NetworkOPs.h>
|
|
#include <ripple/core/LoadFeeTrack.h>
|
|
#include <ripple/protocol/JsonFields.h>
|
|
#include <ripple/test/WSClient.h>
|
|
#include <ripple/test/jtx.h>
|
|
#include <ripple/beast/unit_test.h>
|
|
|
|
namespace ripple {
|
|
namespace test {
|
|
|
|
class Subscribe_test : public beast::unit_test::suite
|
|
{
|
|
public:
|
|
void testServer()
|
|
{
|
|
using namespace std::chrono_literals;
|
|
using namespace jtx;
|
|
Env env(*this);
|
|
auto wsc = makeWSClient(env.app().config());
|
|
Json::Value stream;
|
|
|
|
{
|
|
// RPC subscribe to server stream
|
|
stream[jss::streams] = Json::arrayValue;
|
|
stream[jss::streams].append("server");
|
|
auto jv = wsc->invoke("subscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
{
|
|
// Raise fee to cause an update
|
|
for(int i = 0; i < 5; ++i)
|
|
env.app().getFeeTrack().raiseLocalFee();
|
|
env.app().getOPs().reportFeeChange();
|
|
|
|
// Check stream update
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::type] == "serverStatus";
|
|
}));
|
|
}
|
|
|
|
{
|
|
// RPC unsubscribe
|
|
auto jv = wsc->invoke("unsubscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
{
|
|
// Raise fee to cause an update
|
|
for (int i = 0; i < 5; ++i)
|
|
env.app().getFeeTrack().raiseLocalFee();
|
|
env.app().getOPs().reportFeeChange();
|
|
|
|
// Check stream update
|
|
expect(! wsc->getMsg(10ms));
|
|
}
|
|
}
|
|
|
|
void testLedger()
|
|
{
|
|
using namespace std::chrono_literals;
|
|
using namespace jtx;
|
|
Env env(*this);
|
|
auto wsc = makeWSClient(env.app().config());
|
|
Json::Value stream;
|
|
|
|
{
|
|
// RPC subscribe to ledger stream
|
|
stream[jss::streams] = Json::arrayValue;
|
|
stream[jss::streams].append("ledger");
|
|
auto jv = wsc->invoke("subscribe", stream);
|
|
expect(jv[jss::result][jss::ledger_index] == 2);
|
|
}
|
|
|
|
{
|
|
// Accept a ledger
|
|
env.close();
|
|
|
|
// Check stream update
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::ledger_index] == 3;
|
|
}));
|
|
}
|
|
|
|
{
|
|
// Accept another ledger
|
|
env.close();
|
|
|
|
// Check stream update
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::ledger_index] == 4;
|
|
}));
|
|
}
|
|
|
|
// RPC unsubscribe
|
|
auto jv = wsc->invoke("unsubscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
void testTransactions()
|
|
{
|
|
using namespace std::chrono_literals;
|
|
using namespace jtx;
|
|
Env env(*this);
|
|
auto wsc = makeWSClient(env.app().config());
|
|
Json::Value stream;
|
|
|
|
{
|
|
// RPC subscribe to transactions stream
|
|
stream[jss::streams] = Json::arrayValue;
|
|
stream[jss::streams].append("transactions");
|
|
auto jv = wsc->invoke("subscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
{
|
|
env.fund(XRP(10000), "alice");
|
|
env.close();
|
|
|
|
// Check stream update for payment transaction
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::meta]["AffectedNodes"][1u]
|
|
["CreatedNode"]["NewFields"][jss::Account] ==
|
|
Account("alice").human();
|
|
}));
|
|
|
|
// Check stream update for accountset transaction
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::meta]["AffectedNodes"][0u]
|
|
["ModifiedNode"]["FinalFields"][jss::Account] ==
|
|
Account("alice").human();
|
|
}));
|
|
|
|
env.fund(XRP(10000), "bob");
|
|
env.close();
|
|
|
|
// Check stream update for payment transaction
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::meta]["AffectedNodes"][1u]
|
|
["CreatedNode"]["NewFields"][jss::Account] ==
|
|
Account("bob").human();
|
|
}));
|
|
|
|
// Check stream update for accountset transaction
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::meta]["AffectedNodes"][0u]
|
|
["ModifiedNode"]["FinalFields"][jss::Account] ==
|
|
Account("bob").human();
|
|
}));
|
|
}
|
|
|
|
{
|
|
// RPC unsubscribe
|
|
auto jv = wsc->invoke("unsubscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
{
|
|
// RPC subscribe to accounts stream
|
|
stream = Json::objectValue;
|
|
stream[jss::accounts] = Json::arrayValue;
|
|
stream[jss::accounts].append(Account("alice").human());
|
|
auto jv = wsc->invoke("subscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
{
|
|
// Transaction that does not affect stream
|
|
env.fund(XRP(10000), "carol");
|
|
env.close();
|
|
expect(! wsc->getMsg(10ms));
|
|
|
|
// Transactions concerning alice
|
|
env.trust(Account("bob")["USD"](100), "alice");
|
|
env.close();
|
|
|
|
// Check stream updates
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::meta]["AffectedNodes"][1u]
|
|
["ModifiedNode"]["FinalFields"][jss::Account] ==
|
|
Account("alice").human();
|
|
}));
|
|
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::meta]["AffectedNodes"][1u]
|
|
["CreatedNode"]["NewFields"]["LowLimit"]
|
|
[jss::issuer] == Account("alice").human();
|
|
}));
|
|
}
|
|
|
|
// RPC unsubscribe
|
|
auto jv = wsc->invoke("unsubscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
void testManifests()
|
|
{
|
|
using namespace jtx;
|
|
Env env(*this);
|
|
auto wsc = makeWSClient(env.app().config());
|
|
Json::Value stream;
|
|
|
|
{
|
|
// RPC subscribe to manifests stream
|
|
stream[jss::streams] = Json::arrayValue;
|
|
stream[jss::streams].append("manifests");
|
|
auto jv = wsc->invoke("subscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
// RPC unsubscribe
|
|
auto jv = wsc->invoke("unsubscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
static
|
|
std::unique_ptr<Config>
|
|
makeValidatorConfig(
|
|
std::string const& valPrivateKey, std::string const& valPublicKey)
|
|
{
|
|
auto p = std::make_unique<Config>();
|
|
setupConfigForUnitTests(*p);
|
|
|
|
// If the config has valid validation keys then we run as a validator.
|
|
auto const sk = parseBase58<SecretKey>(
|
|
TOKEN_NODE_PRIVATE,
|
|
valPrivateKey);
|
|
if (!sk)
|
|
Throw<std::runtime_error> ("Invalid validation private key");
|
|
p->VALIDATION_PRIV = *sk;
|
|
|
|
auto const pk = parseBase58<PublicKey>(
|
|
TOKEN_NODE_PUBLIC,
|
|
valPublicKey);
|
|
if (!pk)
|
|
Throw<std::runtime_error> ("Invalid validation public key");
|
|
p->VALIDATION_PUB = *pk;
|
|
|
|
return p;
|
|
}
|
|
|
|
void testValidations()
|
|
{
|
|
using namespace jtx;
|
|
|
|
// Public key must be derived from the private key
|
|
const std::string valPrivateKey =
|
|
"paEdUCVVCNnv4aYBepid9Xh3NaAr9xWRw2vh351piFJrxQwvExd";
|
|
const std::string valPublicKey =
|
|
"n9MvFGjgv1kYkm7bLbb2QUwSqgzrQkYMYHXtrzN8W28Jfp2mVihq";
|
|
Env env(*this, makeValidatorConfig(valPrivateKey, valPublicKey));
|
|
auto wsc = makeWSClient(env.app().config());
|
|
Json::Value stream;
|
|
|
|
{
|
|
// RPC subscribe to validations stream
|
|
stream[jss::streams] = Json::arrayValue;
|
|
stream[jss::streams].append("validations");
|
|
auto jv = wsc->invoke("subscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
{
|
|
// Accept a ledger
|
|
env.close();
|
|
|
|
// Check stream update
|
|
expect(wsc->findMsg(5s,
|
|
[&](auto const& jv)
|
|
{
|
|
return jv[jss::type] == "validationReceived" &&
|
|
jv[jss::validation_public_key] == valPublicKey &&
|
|
jv[jss::ledger_hash] ==
|
|
to_string(env.closed()->info().hash) &&
|
|
jv[jss::ledger_index] ==
|
|
to_string(env.closed()->info().seq) &&
|
|
jv[jss::flags] ==
|
|
(vfFullyCanonicalSig | STValidation::kFullFlag) &&
|
|
jv[jss::full] == true &&
|
|
!jv.isMember(jss::load_fee) &&
|
|
jv[jss::signature] &&
|
|
jv[jss::signing_time];
|
|
}));
|
|
}
|
|
|
|
// RPC unsubscribe
|
|
auto jv = wsc->invoke("unsubscribe", stream);
|
|
expect(jv[jss::status] == "success");
|
|
}
|
|
|
|
void run() override
|
|
{
|
|
testServer();
|
|
testLedger();
|
|
testTransactions();
|
|
testManifests();
|
|
testValidations();
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(Subscribe,app,ripple);
|
|
|
|
} // test
|
|
} // ripple
|