ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2026-04-29 15:37:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
e0566cc22a137a4e6efd06caddd605aab8b081be
xahaud/src/test/ledger/Invariants_test.cpp

676 lines
26 KiB
C++
Raw Blame History

//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012-2017 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 <ripple/app/tx/apply.h>
#include <ripple/app/tx/impl/ApplyContext.h>
#include <ripple/app/tx/impl/Transactor.h>
#include <ripple/beast/utility/Journal.h>
#include <ripple/protocol/STLedgerEntry.h>
#include <boost/algorithm/string/predicate.hpp>
#include <regex>
#include <test/jtx.h>
#include <test/jtx/Env.h>
namespace ripple {
class Invariants_test : public beast::unit_test::suite
{
// The optional Preclose function is used to process additional transactions
// on the ledger after creating two accounts, but before closing it, and
// before the Precheck function. These should only be valid functions, and
// not direct manipulations. Preclose is not commonly used.
using Preclose = std::function<bool(
test::jtx::Account const& a,
test::jtx::Account const& b,
test::jtx::Env& env)>;
// this is common setup/method for running a failing invariant check. The
// precheck function is used to manipulate the ApplyContext with view
// changes that will cause the check to fail.
using Precheck = std::function<bool(
test::jtx::Account const& a,
test::jtx::Account const& b,
ApplyContext& ac)>;
void
doInvariantCheck(
std::vector<std::string> const& expect_logs,
Precheck const& precheck,
XRPAmount fee = XRPAmount{},
STTx tx = STTx{ttACCOUNT_SET, [](STObject&) {}},
std::initializer_list<TER> ters =
{tecINVARIANT_FAILED, tefINVARIANT_FAILED},
Preclose const& preclose = {})
{
using namespace test::jtx;
Env env{*this};
Account const A1{"A1"};
Account const A2{"A2"};
env.fund(XRP(1000), A1, A2);
if (preclose)
BEAST_EXPECT(preclose(A1, A2, env));
env.close();
OpenView ov{*env.current()};
test::StreamSink sink{beast::severities::kWarning};
beast::Journal jlog{sink};
ApplyContext ac{
env.app(),
ov,
tx,
tesSUCCESS,
env.current()->fees().base,
tapNONE,
jlog};
BEAST_EXPECT(precheck(A1, A2, ac));
// invoke check twice to cover tec and tef cases
if (!BEAST_EXPECT(ters.size() == 2))
return;
TER terActual = tesSUCCESS;
for (TER const& terExpect : ters)
{
terActual = ac.checkInvariants(terActual, fee);
BEAST_EXPECT(terExpect == terActual);
// Handle both with and without BEAST_ENHANCED_LOGGING
auto const msg = sink.messages().str();
bool hasExpectedPrefix = false;
#ifdef BEAST_ENHANCED_LOGGING
// When BEAST_ENHANCED_LOGGING is enabled, messages may include ANSI
// color codes and start with [file:line]. Just search for the
// message content.
hasExpectedPrefix =
msg.find("Invariant failed:") != std::string::npos ||
msg.find("Transaction caused an exception") !=
std::string::npos;
#else
// Without BEAST_ENHANCED_LOGGING, messages start directly with the
// text
hasExpectedPrefix = msg.starts_with("Invariant failed:") ||
msg.starts_with("Transaction caused an exception");
#endif
BEAST_EXPECT(hasExpectedPrefix);
for (auto const& m : expect_logs)
{
if (sink.messages().str().find(m) == std::string::npos)
{
// uncomment if you want to log the invariant failure
// message log << " --> " << m << std::endl;
fail();
}
}
}
}
void
testXRPNotCreated()
{
using namespace test::jtx;
testcase << "XRP created";
doInvariantCheck(
{{"XRP net change was positive: 500"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// put a single account in the view and "manufacture" some XRP
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto amt = sle->getFieldAmount(sfBalance);
sle->setFieldAmount(sfBalance, amt + STAmount{500});
ac.view().update(sle);
return true;
});
}
void
testAccountRootsNotRemoved()
{
using namespace test::jtx;
testcase << "account root removed";
// An account was deleted, but not by an AccountDelete transaction.
doInvariantCheck(
{{"an account root was deleted"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// remove an account from the view
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
ac.view().erase(sle);
return true;
});
// Successful AccountDelete transaction that didn't delete an account.
//
// Note that this is a case where a second invocation of the invariant
// checker returns a tecINVARIANT_FAILED, not a tefINVARIANT_FAILED.
// After a discussion with the team, we believe that's okay.
doInvariantCheck(
{{"account deletion succeeded without deleting an account"}},
[](Account const&, Account const&, ApplyContext& ac) {
return true;
},
XRPAmount{},
STTx{ttACCOUNT_DELETE, [](STObject& tx) {}},
{tecINVARIANT_FAILED, tecINVARIANT_FAILED});
// Successful AccountDelete that deleted more than one account.
doInvariantCheck(
{{"account deletion succeeded but deleted multiple accounts"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
// remove two accounts from the view
auto const sleA1 = ac.view().peek(keylet::account(A1.id()));
auto const sleA2 = ac.view().peek(keylet::account(A2.id()));
if (!sleA1 || !sleA2)
return false;
ac.view().erase(sleA1);
ac.view().erase(sleA2);
return true;
},
XRPAmount{},
STTx{ttACCOUNT_DELETE, [](STObject& tx) {}});
}
void
testTypesMatch()
{
using namespace test::jtx;
testcase << "ledger entry types don't match";
doInvariantCheck(
{{"ledger entry type mismatch"},
{"XRP net change of -1000000000 doesn't match fee 0"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// replace an entry in the table with an SLE of a different type
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto sleNew = std::make_shared<SLE>(ltTICKET, sle->key());
ac.rawView().rawReplace(sleNew);
return true;
});
doInvariantCheck(
{{"invalid ledger entry type added"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// add an entry in the table with an SLE of an invalid type
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
// make a dummy escrow ledger entry, then change the type to an
// unsupported value so that the valid type invariant check
// will fail.
auto sleNew = std::make_shared<SLE>(
keylet::escrow(A1, (*sle)[sfSequence] + 2));
// We don't use ltNICKNAME directly since it's marked deprecated
// to prevent accidental use elsewhere.
sleNew->type_ = static_cast<LedgerEntryType>('n');
ac.view().insert(sleNew);
return true;
});
}
void
testNoXRPTrustLine()
{
using namespace test::jtx;
testcase << "trust lines with XRP not allowed";
doInvariantCheck(
{{"an XRP trust line was created"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
// create simple trust SLE with xrp currency
auto const sleNew = std::make_shared<SLE>(
keylet::line(A1, A2, xrpIssue().currency));
ac.view().insert(sleNew);
return true;
});
}
void
testNoDeepFreezeTrustLinesWithoutFreeze()
{
using namespace test::jtx;
testcase << "trust lines with deep freeze flag without freeze "
"not allowed";
doInvariantCheck(
{{"a trust line with deep freeze flag without normal freeze was "
"created"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
auto const sleNew = std::make_shared<SLE>(
keylet::line(A1, A2, A1["USD"].currency));
sleNew->setFieldAmount(sfLowLimit, A1["USD"](0));
sleNew->setFieldAmount(sfHighLimit, A1["USD"](0));
std::uint32_t uFlags = 0u;
uFlags |= lsfLowDeepFreeze;
sleNew->setFieldU32(sfFlags, uFlags);
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"a trust line with deep freeze flag without normal freeze was "
"created"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
auto const sleNew = std::make_shared<SLE>(
keylet::line(A1, A2, A1["USD"].currency));
sleNew->setFieldAmount(sfLowLimit, A1["USD"](0));
sleNew->setFieldAmount(sfHighLimit, A1["USD"](0));
std::uint32_t uFlags = 0u;
uFlags |= lsfHighDeepFreeze;
sleNew->setFieldU32(sfFlags, uFlags);
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"a trust line with deep freeze flag without normal freeze was "
"created"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
auto const sleNew = std::make_shared<SLE>(
keylet::line(A1, A2, A1["USD"].currency));
sleNew->setFieldAmount(sfLowLimit, A1["USD"](0));
sleNew->setFieldAmount(sfHighLimit, A1["USD"](0));
std::uint32_t uFlags = 0u;
uFlags |= lsfLowDeepFreeze | lsfHighDeepFreeze;
sleNew->setFieldU32(sfFlags, uFlags);
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"a trust line with deep freeze flag without normal freeze was "
"created"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
auto const sleNew = std::make_shared<SLE>(
keylet::line(A1, A2, A1["USD"].currency));
sleNew->setFieldAmount(sfLowLimit, A1["USD"](0));
sleNew->setFieldAmount(sfHighLimit, A1["USD"](0));
std::uint32_t uFlags = 0u;
uFlags |= lsfLowDeepFreeze | lsfHighFreeze;
sleNew->setFieldU32(sfFlags, uFlags);
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"a trust line with deep freeze flag without normal freeze was "
"created"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
auto const sleNew = std::make_shared<SLE>(
keylet::line(A1, A2, A1["USD"].currency));
sleNew->setFieldAmount(sfLowLimit, A1["USD"](0));
sleNew->setFieldAmount(sfHighLimit, A1["USD"](0));
std::uint32_t uFlags = 0u;
uFlags |= lsfLowFreeze | lsfHighDeepFreeze;
sleNew->setFieldU32(sfFlags, uFlags);
ac.view().insert(sleNew);
return true;
});
}
void
testTransfersNotFrozen()
{
using namespace test::jtx;
testcase << "transfers when frozen";
Account G1{"G1"};
// Helper function to establish the trustlines
auto const createTrustlines =
[&](Account const& A1, Account const& A2, Env& env) {
// Preclose callback to establish trust lines with gateway
env.fund(XRP(1000), G1);
env.trust(G1["USD"](10000), A1);
env.trust(G1["USD"](10000), A2);
env.close();
env(pay(G1, A1, G1["USD"](1000)));
env(pay(G1, A2, G1["USD"](1000)));
env.close();
return true;
};
auto const A1FrozenByIssuer =
[&](Account const& A1, Account const& A2, Env& env) {
createTrustlines(A1, A2, env);
env(trust(G1, A1["USD"](10000), tfSetFreeze));
env.close();
return true;
};
auto const A1DeepFrozenByIssuer =
[&](Account const& A1, Account const& A2, Env& env) {
A1FrozenByIssuer(A1, A2, env);
env(trust(G1, A1["USD"](10000), tfSetDeepFreeze));
env.close();
return true;
};
auto const changeBalances = [&](Account const& A1,
Account const& A2,
ApplyContext& ac,
int A1Balance,
int A2Balance) {
auto const sleA1 = ac.view().peek(keylet::line(A1, G1["USD"]));
auto const sleA2 = ac.view().peek(keylet::line(A2, G1["USD"]));
sleA1->setFieldAmount(sfBalance, G1["USD"](A1Balance));
sleA2->setFieldAmount(sfBalance, G1["USD"](A2Balance));
ac.view().update(sleA1);
ac.view().update(sleA2);
};
// test: imitating frozen A1 making a payment to A2.
doInvariantCheck(
{{"Attempting to move frozen funds"}},
[&](Account const& A1, Account const& A2, ApplyContext& ac) {
changeBalances(A1, A2, ac, -900, -1100);
return true;
},
XRPAmount{},
STTx{ttPAYMENT, [](STObject& tx) {}},
{tecINVARIANT_FAILED, tefINVARIANT_FAILED},
A1FrozenByIssuer);
// test: imitating deep frozen A1 making a payment to A2.
doInvariantCheck(
{{"Attempting to move frozen funds"}},
[&](Account const& A1, Account const& A2, ApplyContext& ac) {
changeBalances(A1, A2, ac, -900, -1100);
return true;
},
XRPAmount{},
STTx{ttPAYMENT, [](STObject& tx) {}},
{tecINVARIANT_FAILED, tefINVARIANT_FAILED},
A1DeepFrozenByIssuer);
// test: imitating A2 making a payment to deep frozen A1.
doInvariantCheck(
{{"Attempting to move frozen funds"}},
[&](Account const& A1, Account const& A2, ApplyContext& ac) {
changeBalances(A1, A2, ac, -1100, -900);
return true;
},
XRPAmount{},
STTx{ttPAYMENT, [](STObject& tx) {}},
{tecINVARIANT_FAILED, tefINVARIANT_FAILED},
A1DeepFrozenByIssuer);
}
void
testXRPBalanceCheck()
{
using namespace test::jtx;
testcase << "XRP balance checks";
doInvariantCheck(
{{"Cannot return non-native STAmount as XRPAmount"}},
[](Account const& A1, Account const& A2, ApplyContext& ac) {
// non-native balance
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
STAmount nonNative(A2["USD"](51));
sle->setFieldAmount(sfBalance, nonNative);
ac.view().update(sle);
return true;
});
doInvariantCheck(
{{"incorrect account XRP balance"},
{"XRP net change was positive: 99999999000000001"}},
[this](Account const& A1, Account const&, ApplyContext& ac) {
// balance exceeds genesis amount
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
// Use `drops(1)` to bypass a call to STAmount::canonicalize
// with an invalid value
sle->setFieldAmount(sfBalance, INITIAL_XRP + drops(1));
BEAST_EXPECT(!sle->getFieldAmount(sfBalance).negative());
ac.view().update(sle);
return true;
});
doInvariantCheck(
{{"incorrect account XRP balance"},
{"XRP net change of -1000000001 doesn't match fee 0"}},
[this](Account const& A1, Account const&, ApplyContext& ac) {
// balance is negative
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
sle->setFieldAmount(sfBalance, STAmount{1, true});
BEAST_EXPECT(sle->getFieldAmount(sfBalance).negative());
ac.view().update(sle);
return true;
});
}
void
testTransactionFeeCheck()
{
using namespace test::jtx;
using namespace std::string_literals;
testcase << "Transaction fee checks";
doInvariantCheck(
{{"fee paid was negative: -1"},
{"XRP net change of 0 doesn't match fee -1"}},
[](Account const&, Account const&, ApplyContext&) { return true; },
XRPAmount{-1});
doInvariantCheck(
{{"fee paid exceeds system limit: "s + to_string(INITIAL_XRP)},
{"XRP net change of 0 doesn't match fee "s +
to_string(INITIAL_XRP)}},
[](Account const&, Account const&, ApplyContext&) { return true; },
XRPAmount{INITIAL_XRP});
doInvariantCheck(
{{"fee paid is 20 exceeds fee specified in transaction."},
{"XRP net change of 0 doesn't match fee 20"}},
[](Account const&, Account const&, ApplyContext&) { return true; },
XRPAmount{20},
STTx{ttACCOUNT_SET, [](STObject& tx) {
tx.setFieldAmount(sfFee, XRPAmount{10});
}});
}
void
testNoBadOffers()
{
using namespace test::jtx;
testcase << "no bad offers";
doInvariantCheck(
{{"offer with a bad amount"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// offer with negative takerpays
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto sleNew = std::make_shared<SLE>(
keylet::offer(A1.id(), (*sle)[sfSequence]));
sleNew->setAccountID(sfAccount, A1.id());
sleNew->setFieldU32(sfSequence, (*sle)[sfSequence]);
sleNew->setFieldAmount(sfTakerPays, XRP(-1));
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"offer with a bad amount"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// offer with negative takergets
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto sleNew = std::make_shared<SLE>(
keylet::offer(A1.id(), (*sle)[sfSequence]));
sleNew->setAccountID(sfAccount, A1.id());
sleNew->setFieldU32(sfSequence, (*sle)[sfSequence]);
sleNew->setFieldAmount(sfTakerPays, A1["USD"](10));
sleNew->setFieldAmount(sfTakerGets, XRP(-1));
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"offer with a bad amount"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// offer XRP to XRP
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto sleNew = std::make_shared<SLE>(
keylet::offer(A1.id(), (*sle)[sfSequence]));
sleNew->setAccountID(sfAccount, A1.id());
sleNew->setFieldU32(sfSequence, (*sle)[sfSequence]);
sleNew->setFieldAmount(sfTakerPays, XRP(10));
sleNew->setFieldAmount(sfTakerGets, XRP(11));
ac.view().insert(sleNew);
return true;
});
}
void
testNoZeroEscrow()
{
using namespace test::jtx;
testcase << "no zero escrow";
doInvariantCheck(
{{"XRP net change of -1000000 doesn't match fee 0"},
{"escrow specifies invalid amount"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// escrow with negative amount
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto sleNew = std::make_shared<SLE>(
keylet::escrow(A1, (*sle)[sfSequence] + 2));
sleNew->setFieldAmount(sfAmount, XRP(-1));
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"XRP net change was positive: 100000000000000001"},
{"escrow specifies invalid amount"}},
[](Account const& A1, Account const&, ApplyContext& ac) {
// escrow with too-large amount
auto const sle = ac.view().peek(keylet::account(A1.id()));
if (!sle)
return false;
auto sleNew = std::make_shared<SLE>(
keylet::escrow(A1, (*sle)[sfSequence] + 2));
// Use `drops(1)` to bypass a call to STAmount::canonicalize
// with an invalid value
sleNew->setFieldAmount(sfAmount, INITIAL_XRP + drops(1));
ac.view().insert(sleNew);
return true;
});
}
void
testValidNewAccountRoot()
{
using namespace test::jtx;
testcase << "valid new account root";
doInvariantCheck(
{{"account root created by a non-Payment"}},
[](Account const&, Account const&, ApplyContext& ac) {
// Insert a new account root created by a non-payment into
// the view.
const Account A3{"A3"};
Keylet const acctKeylet = keylet::account(A3);
auto const sleNew = std::make_shared<SLE>(acctKeylet);
ac.view().insert(sleNew);
return true;
});
doInvariantCheck(
{{"multiple accounts created in a single transaction"}},
[](Account const&, Account const&, ApplyContext& ac) {
// Insert two new account roots into the view.
{
const Account A3{"A3"};
Keylet const acctKeylet = keylet::account(A3);
auto const sleA3 = std::make_shared<SLE>(acctKeylet);
ac.view().insert(sleA3);
}
{
const Account A4{"A4"};
Keylet const acctKeylet = keylet::account(A4);
auto const sleA4 = std::make_shared<SLE>(acctKeylet);
ac.view().insert(sleA4);
}
return true;
});
doInvariantCheck(
{{"account created with wrong starting sequence number"}},
[](Account const&, Account const&, ApplyContext& ac) {
// Insert a new account root with the wrong starting sequence.
const Account A3{"A3"};
Keylet const acctKeylet = keylet::account(A3);
auto const sleNew = std::make_shared<SLE>(acctKeylet);
sleNew->setFieldU32(sfSequence, ac.view().seq() + 1);
ac.view().insert(sleNew);
return true;
},
XRPAmount{},
STTx{ttPAYMENT, [](STObject& tx) {}});
}
public:
void
run() override
{
testXRPNotCreated();
testAccountRootsNotRemoved();
testTypesMatch();
testNoXRPTrustLine();
testNoDeepFreezeTrustLinesWithoutFreeze();
testTransfersNotFrozen();
testXRPBalanceCheck();
testTransactionFeeCheck();
testNoBadOffers();
testNoZeroEscrow();
testValidNewAccountRoot();
}
};
BEAST_DEFINE_TESTSUITE(Invariants, ledger, ripple);
} // namespace ripple
Reference in New Issue View Git Blame Copy Permalink