ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-11-04 18:55:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

remit compiling, not tested

Browse Source
This commit is contained in:
Richard Holland
2023-12-02 18:00:23 +00:00
parent 5168b2684a
commit 16553b3778
15 changed files with 141 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Builds/CMake/RippledCore.cmake
View File

@@ -455,6 +455,7 @@ target_sources (rippled PRIVATE
src/ripple/app/tx/impl/GenesisMint.cpp
src/ripple/app/tx/impl/Import.cpp
src/ripple/app/tx/impl/Invoke.cpp
src/ripple/app/tx/impl/Remit.cpp
src/ripple/app/tx/impl/SetSignerList.cpp
src/ripple/app/tx/impl/SetTrust.cpp
src/ripple/app/tx/impl/SignerEntries.cpp

2
src/ripple/app/tx/impl/InvariantCheck.cpp
View File

@@ -597,7 +597,7 @@ ValidNewAccountRoot::finalize(
return false;
}
if ((tt == ttPAYMENT || tt == ttIMPORT || tt == ttGENESIS_MINT) &&
if ((tt == ttPAYMENT || tt == ttIMPORT || tt == ttGENESIS_MINT || tt == ttREMIT) &&
result == tesSUCCESS)
{
std::uint32_t const startingSeq{

77
src/ripple/app/tx/impl/Remit.cpp
View File

@@ -23,7 +23,6 @@
#include <ripple/protocol/Feature.h>
#include <ripple/protocol/Indexes.h>
#include <ripple/app/tx/impl/URIToken.h>
namespace ripple {
TxConsequences
@@ -60,14 +59,14 @@ Remit::preflight(PreflightContext const& ctx)
std::map<Currency, std::set<AccountID>> already;
bool nativeAlready = false;
STArray const& sEntries(obj.getFieldArray(sfAmounts));
STArray const& sEntries(ctx.tx.getFieldArray(sfAmounts));
for (STObject const& sEntry : sEntries)
{
// Validate the AmountEntry.
if (sEntry.getFName() != sfAmountEntry)
{
JLOG(ctx.j.warn())
<< "Malformed " << annotation << ": Expected AmountEntry.";
<< "Malformed: Expected AmountEntry.";
return temMALFORMED;
}
@@ -97,27 +96,27 @@ Remit::preflight(PreflightContext const& ctx)
continue;
}
auto& found = already.find(amount.getCurrency());
auto found = already.find(amount.getCurrency());
if (found == already.end())
{
already.emplace(amount.getCurrency(), {issuerAccID});
already.emplace(amount.getCurrency(), std::set<AccountID>{amount.getIssuer()});
continue;
}
if (found->second.find(issuerAccID))
if (found->second.find(amount.getIssuer()) != found->second.end())
{
JLOG(ctx.j.warn()) << "Malformed transaction: Issued Currency appears more than once.";
return temMALFORMED;
}
found->second.emplace(issuerAccID);
found->second.emplace(amount.getIssuer());
}
}
// sanity check minturitoken
if (ctx.tx.isFieldPresent(sfMintURIToken))
{
STObject const& mint = const_cast<ripple::STTx&>(tx)
STObject const& mint = const_cast<ripple::STTx&>(ctx.tx)
.getField(sfMintURIToken)
.downcast<STObject>();
// RH TODO: iterate mint fields detect any that shouldnt be there
@@ -130,7 +129,7 @@ Remit::preflight(PreflightContext const& ctx)
return temMALFORMED;
}
if (!URToken::validateUTF(mint.getFieldVL(sfURI)))
if (!URIToken::validateUTF8(mint.getFieldVL(sfURI)))
{
JLOG(ctx.j.warn())
<< "Malformed transaction: Invalid UTF8 inside MintURIToken.";
@@ -160,14 +159,15 @@ Remit::preflight(PreflightContext const& ctx)
return preflight2(ctx);
}
TER
Remit::doApply()
{
if (!sb.rules().enabled(featureRemit))
if (!view().rules().enabled(featureRemit))
return temDISABLED;
Sandbox sb(&ctx_.view());
beast::Journal& j = journal;
beast::Journal const& j = ctx_.journal;
auto const srcAccID = ctx_.tx[sfAccount];
@@ -218,19 +218,23 @@ Remit::doApply()
sleDstAcc->setFieldU32(sfSequence, seqno);
sleDstAcc->setFieldU32(sfOwnerCount, 0);
if (sleDstAccFees && view().rules().enabled(featureXahauGenesis))
auto sleFees = view().peek(keylet::fees());
if (sleFees && view().rules().enabled(featureXahauGenesis))
{
uint64_t accIdx = sleDstAccFees->isFieldPresent(sfAccountCount)
? sleDstAccFees->getFieldU64(sfAccountCount)
uint64_t accIdx = sleFees->isFieldPresent(sfAccountCount)
? sleFees->getFieldU64(sfAccountCount)
: 0;
sleDstAcc->setFieldU64(sfAccountIndex, accIdx);
sleDstAccFees->setFieldU64(sfAccountCount, accIdx + 1);
sleFees->setFieldU64(sfAccountCount, accIdx + 1);
sb.update(sleFees);
}
// we'll fix this up at the end
sleDstAcc->setFieldAmount(sfBalance, 0);
sleDstAcc->setFieldAmount(sfBalance, STAmount{XRPAmount{0}});
sb.insert(sleDstAcc);
sleDstAcc = sb.peek(sleDstAcc);
// pull a new shrptr so we can update as we go
sleDstAcc = sb.peek(keylet::account(dstAccID));
}
@@ -238,7 +242,7 @@ Remit::doApply()
if (ctx_.tx.isFieldPresent(sfMintURIToken))
{
nativeRemit += objectReserve;
STObject const& mint = const_cast<ripple::STTx&>(tx)
STObject const& mint = const_cast<ripple::STTx&>(ctx_.tx)
.getField(sfMintURIToken)
.downcast<STObject>();
@@ -260,7 +264,7 @@ Remit::doApply()
}
sleMint = std::make_shared<SLE>(kl);
auto sleMint = std::make_shared<SLE>(kl);
sleMint->setAccountID(sfOwner, dstAccID);
sleMint->setAccountID(sfIssuer, srcAccID);
@@ -274,20 +278,20 @@ Remit::doApply()
auto const page = view().dirInsert(
keylet::ownerDir(sleDstAcc), kl, describeOwnerDir(sleDstAcc));
keylet::ownerDir(dstAccID), kl, describeOwnerDir(dstAccID));
JLOG(j_.trace())
<< "Adding URIToken to owner directory " << to_string(kl->key)
<< "Adding URIToken to owner directory " << to_string(kl.key)
<< ": " << (page ? "success" : "failure");
if (!page)
return tecDIR_FULL;
sleMint->setFieldU64(sfOwnerNode, *page);
sb.insert(sleU);
sb.insert(sleMint);
// ensure there is a deletion blocker against the issuer now
sleSrcAcc->setFieldU32(sfFlags, sle->getFlags() | lsfURITokenIssuer);
sleSrcAcc->setFieldU32(sfFlags, sleSrcAcc->getFlags() | lsfURITokenIssuer);
adjustOwnerCount(sb, sleSrcAcc, 1, j);
}
@@ -297,8 +301,9 @@ Remit::doApply()
if (ctx_.tx.isFieldPresent(sfURITokenIDs))
{
STVector256 ids = ctx_.tx.getFieldV256(sfURITokenIDs);
for (uint256 const kl : ids)
for (uint256 const klRaw : ids)
{
Keylet kl = keylet::unchecked(klRaw);
auto sleU = sb.peek(kl);
// does it exist
@@ -318,7 +323,7 @@ Remit::doApply()
}
// is it our uritoken?
if (sleU->getAccounntID(sfOwner) != srcAccID)
if (sleU->getAccountID(sfOwner) != srcAccID)
{
JLOG(j.warn())
<< "Remit: one or more supplied URITokenIDs was not owned by sender.";
@@ -337,7 +342,7 @@ Remit::doApply()
// remove from sender dir
{
auto const page = (*sleU)[sfOwnerNode];
if (!sb.dirRemove(keylet::ownerDir(srcAccID), page, kl->key, true))
if (!sb.dirRemove(keylet::ownerDir(srcAccID), page, kl.key, true))
{
JLOG(j.fatal())
<< "Could not remove URIToken from owner directory";
@@ -353,7 +358,7 @@ Remit::doApply()
sb.dirInsert(keylet::ownerDir(dstAccID), kl, describeOwnerDir(dstAccID));
JLOG(j_.trace())
<< "Adding URIToken to owner directory " << to_string(kl->key)
<< "Adding URIToken to owner directory " << to_string(kl.key)
<< ": " << (page ? "success" : "failure");
if (!page)
@@ -365,7 +370,7 @@ Remit::doApply()
}
// change the owner
sleU->setAccountID(sfOwner, sleDstAcc);
sleU->setAccountID(sfOwner, dstAccID);
}
}
@@ -375,7 +380,7 @@ Remit::doApply()
{
// process trustline remits
STArray const& sEntries(obj.getFieldArray(sfAmounts));
STArray const& sEntries(ctx_.tx.getFieldArray(sfAmounts));
for (STObject const& sEntry : sEntries)
{
STAmount const amount = sEntry.getFieldAmount(sfAmount);
@@ -391,7 +396,8 @@ Remit::doApply()
if (TER canXfer =
trustTransferAllowed(
sb,
{srcAccID, dstID},
std::vector<AccountID>{srcAccID, dstAccID},
amount.issue(),
j); canXfer != tesSUCCESS)
return canXfer;
@@ -402,7 +408,7 @@ Remit::doApply()
// the destination can always be assured they got the exact amount specified.
// therefore we need to compute the amount + transfer fee
auto const srcAmt =
issuerAccID != srcAccID && issuerAccID != dstAccID && xferRate != parityRate
issuerAccID != srcAccID && issuerAccID != dstAccID
? multiply(amount, transferRate(sb, issuerAccID))
: amount;
@@ -447,17 +453,17 @@ Remit::doApply()
bal -= nativeRemit;
if (bal < beast::zero || bal > mSourceBalance)
return tecINTERNAL;
sleSrcAcc.setFieldAmount(sfBalance, bal);
sleSrcAcc->setFieldAmount(sfBalance, bal);
}
// add the balance to the destination
{
STAmount bal = sleDstAcc.getFieldAmount(sfBalance);
STAmount bal = sleDstAcc->getFieldAmount(sfBalance);
STAmount prior = bal;
bal += nativeRemit;
if (bal < beast::zero || bal < prior)
return tecINTERNAL;
sleDstAcc.setField(sfBalance, bal);
sleDstAcc->setFieldAmount(sfBalance, bal);
}
}
@@ -467,9 +473,6 @@ Remit::doApply()
return tesSUCCESS;
}
{
}
XRPAmount
Remit::calculateBaseFee(ReadView const& view, STTx const& tx)
{

3
src/ripple/app/tx/impl/Remit.h
View File

@@ -45,9 +45,6 @@ public:
static NotTEC
preflight(PreflightContext const& ctx);
static TER
preclaim(PreclaimContext const& ctx);
TER
doApply() override;
};

2
src/ripple/app/tx/impl/URIToken.cpp
View File

@@ -103,7 +103,7 @@ URIToken::preflight(PreflightContext const& ctx)
return temMALFORMED;
}
if (!validUTF8(uri))
if (!validateUTF8(uri))
{
JLOG(ctx.j.warn()) << "Malformed transaction. URI must be a "
"valid utf-8 string.";

22
src/ripple/ledger/View.h
View File

@@ -27,6 +27,7 @@
#include <ripple/ledger/OpenView.h>
#include <ripple/ledger/RawView.h>
#include <ripple/ledger/ReadView.h>
#include <ripple/ledger/Sandbox.h>
#include <ripple/protocol/Feature.h>
#include <ripple/protocol/Protocol.h>
#include <ripple/protocol/Rate.h>
@@ -388,6 +389,18 @@ rippleCredit(
bool bCheckIssuer,
beast::Journal j);
// Send regardless of limits.
// --> saAmount: Amount/currency/issuer to deliver to receiver.
// <-- saActual: Amount actually cost. Sender pays fees.
TER
rippleSend(
ApplyView& view,
AccountID const& uSenderID,
AccountID const& uReceiverID,
STAmount const& saAmount,
STAmount& saActual,
beast::Journal j);
[[nodiscard]] TER
accountSend(
ApplyView& view,
@@ -627,12 +640,13 @@ trustTransferAllowed(
{
static_assert(
std::is_same<V, ReadView const>::value ||
std::is_same<V, ApplyView>::value);
std::is_same<V, ApplyView>::value ||
std::is_same<V, Sandbox>::value);
typedef typename std::conditional<
std::is_same<V, ApplyView>::value,
std::shared_ptr<SLE>,
std::shared_ptr<SLE const>>::type SLEPtr;
std::is_same<V, ReadView const>::value,
std::shared_ptr<SLE const>,
std::shared_ptr<SLE>>::type SLEPtr;
if (isBadCurrency(issue.currency))
return tecNO_PERMISSION;

2
src/ripple/ledger/impl/View.cpp
View File

@@ -1150,7 +1150,7 @@ rippleCredit(
// Send regardless of limits.
// --> saAmount: Amount/currency/issuer to deliver to receiver.
// <-- saActual: Amount actually cost. Sender pays fees.
static TER
TER
rippleSend(
ApplyView& view,
AccountID const& uSenderID,

3
src/ripple/protocol/SField.h
View File

@@ -552,6 +552,7 @@ extern SF_ACCOUNT const sfEmitCallback;
// account (uncommon)
extern SF_ACCOUNT const sfHookAccount;
extern SF_ACCOUNT const sfNFTokenMinter;
extern SF_ACCOUNT const sfInform;
// path set
extern SField const sfPaths;
@@ -562,6 +563,7 @@ extern SF_VECTOR256 const sfHashes;
extern SF_VECTOR256 const sfAmendments;
extern SF_VECTOR256 const sfNFTokenOffers;
extern SF_VECTOR256 const sfHookNamespaces;
extern SF_VECTOR256 const sfURITokenIDs;
// inner object
// OBJECT/1 is reserved for end of object
@@ -620,7 +622,6 @@ extern SField const sfActiveValidators;
extern SField const sfImportVLKeys;
extern SField const sfHookEmissions;
extern SField const sfAmounts;
extern SField const sfURITokenIDs;
//------------------------------------------------------------------------------

1
src/ripple/protocol/TER.h
View File

@@ -337,7 +337,6 @@ enum TECcodes : TERUnderlyingType {
tecXCHAIN_PAYMENT_FAILED = 184, // RESERVED - XCHAIN
tecXCHAIN_SELF_COMMIT = 185, // RESERVED - XCHAIN
tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR = 186, // RESERVED - XCHAIN
tecBAD_LINE_DIRECTIONALITY = 187,
tecLAST_POSSIBLE_ENTRY = 255,
};

2
src/ripple/protocol/TxFormats.h
View File

@@ -148,7 +148,7 @@ enum TxType : std::uint16_t
/* A payment transactor that delivers only the exact amounts specified, creating accounts and TLs as needed
* that the sender pays for. */
ttREMIT = 95;
ttREMIT = 95,
/** This transaction can only be used by the genesis account, which is controlled exclusively by
* rewards/governance hooks, to print new XRP to be delivered directly to an array of destinations,

1
src/ripple/protocol/impl/SField.cpp
View File

@@ -305,6 +305,7 @@ CONSTRUCT_TYPED_SFIELD(sfEmitCallback, "EmitCallback", ACCOUNT,
// account (uncommon)
CONSTRUCT_TYPED_SFIELD(sfHookAccount, "HookAccount", ACCOUNT, 16);
CONSTRUCT_TYPED_SFIELD(sfInform, "Inform", ACCOUNT, 99);
// vector of 256-bit
CONSTRUCT_TYPED_SFIELD(sfIndexes, "Indexes", VECTOR256, 1, SField::sMD_Never);

1
src/ripple/protocol/jss.h
View File

@@ -117,6 +117,7 @@ JSS(Payment); // transaction type.
JSS(PaymentChannelClaim); // transaction type.
JSS(PaymentChannelCreate); // transaction type.
JSS(PaymentChannelFund); // transaction type.
JSS(Remit); // transaction type.
JSS(RippleState); // ledger type.
JSS(SLE_hit_rate); // out: GetCounts.
JSS(SetFee); // transaction type.

47
src/test/consensus/NegativeUNL_test.cpp
View File

@@ -53,12 +53,21 @@ namespace test {
* @return true if meet all three expectation
*/
bool
inline
negUnlSizeTest(
std::shared_ptr<Ledger const> const& l,
std::shared_ptr<ripple::Ledger const> const& l,
size_t size,
bool hasToDisable,
bool hasToReEnable);
bool hasToReEnable)
{
bool sameSize = l->negativeUNL().size() == size;
bool sameToDisable =
(l->validatorToDisable() != std::nullopt) == hasToDisable;
bool sameToReEnable =
(l->validatorToReEnable() != std::nullopt) == hasToReEnable;
return sameSize && sameToDisable && sameToReEnable;
}
/**
* Try to apply a ttUNL_MODIFY Tx, and test the apply result
*
@@ -69,7 +78,15 @@ negUnlSizeTest(
* @return true if meet the expectation of apply result
*/
bool
applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass);
inline
applyAndTestResult(jtx::Env& env, ripple::OpenView& view, ripple::STTx const& tx, bool pass)
{
auto res = apply(env.app(), view, tx, ApplyFlags::tapNONE, env.journal);
if (pass)
return res.first == tesSUCCESS;
else
return res.first == tefFAILURE || res.first == temDISABLED;
}
/**
* Verify the content of negative UNL entries (public key and ledger sequence)
@@ -1912,31 +1929,7 @@ BEAST_DEFINE_TESTSUITE(NegativeUNLVoteFilterValidations, consensus, ripple);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
bool
negUnlSizeTest(
std::shared_ptr<Ledger const> const& l,
size_t size,
bool hasToDisable,
bool hasToReEnable)
{
bool sameSize = l->negativeUNL().size() == size;
bool sameToDisable =
(l->validatorToDisable() != std::nullopt) == hasToDisable;
bool sameToReEnable =
(l->validatorToReEnable() != std::nullopt) == hasToReEnable;
return sameSize && sameToDisable && sameToReEnable;
}
bool
applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
{
auto res = apply(env.app(), view, tx, ApplyFlags::tapNONE, env.journal);
if (pass)
return res.first == tesSUCCESS;
else
return res.first == tefFAILURE || res.first == temDISABLED;
}
bool
VerifyPubKeyAndSeq(

114
src/test/consensus/UNLReport_test.cpp
View File

@@ -61,28 +61,57 @@ namespace test {
// * @param hasToReEnable if expect ToDisable in ledger
// * @return true if meet all three expectation
// */
inline bool
/*
bool
inline
negUnlSizeTest(
std::shared_ptr<Ledger const> const& l,
std::shared_ptr<ripple::Ledger const> const& l,
size_t size,
bool hasToDisable,
bool hasToReEnable);
bool hasToReEnable)
{
bool sameSize = l->negativeUNL().size() == size;
bool sameToDisable =
(l->validatorToDisable() != std::nullopt) == hasToDisable;
bool sameToReEnable =
(l->validatorToReEnable() != std::nullopt) == hasToReEnable;
// /**
// * Try to apply a ttUNL_MODIFY Tx, and test the apply result
// *
// * @param env the test environment
// * @param view the OpenView of the ledger
// * @param tx the ttUNL_MODIFY Tx
// * @param pass if the Tx should be applied successfully
// * @return true if meet the expectation of apply result
// */
return sameSize && sameToDisable && sameToReEnable;
}
*/
/**
* Try to apply a ttUNL_MODIFY Tx, and test the apply result
*
* @param env the test environment
* @param view the OpenView of the ledger
* @param tx the ttUNL_MODIFY Tx
* @param pass if the Tx should be applied successfully
* @return true if meet the expectation of apply result
*/
/*
bool
applyAndTestUNLRResult(
jtx::Env& env,
OpenView& view,
STTx const& tx,
bool pass);
inline
applyAndTestResult(jtx::Env& env, ripple::OpenView& view, ripple::STTx const&
tx, bool pass)
{
auto res = apply(env.app(), view, tx, ApplyFlags::tapNONE, env.journal);
if (pass)
return res.first == tesSUCCESS;
else
return res.first == tefFAILURE || res.first == temDISABLED;
}
*/
inline bool
applyAndTestUNLRResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
{
auto res = apply(env.app(), view, tx, ApplyFlags::tapNONE, env.journal);
if (pass)
return res.first == tesSUCCESS;
else
return res.first == tefFAILURE || res.first == temDISABLED ||
res.first == temMALFORMED ||
res.first == telIMPORT_VL_KEY_NOT_RECOGNISED;
}
/**
* Verify the content of UNL Report entries (public key and ledger sequence)
@@ -1235,34 +1264,6 @@ BEAST_DEFINE_TESTSUITE(UNLReportVoteNewValidator, consensus, ripple);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
inline bool
negUnlSizeTest(
std::shared_ptr<Ledger const> const& l,
size_t size,
bool hasToDisable,
bool hasToReEnable)
{
bool sameSize = l->negativeUNL().size() == size;
bool sameToDisable =
(l->validatorToDisable() != std::nullopt) == hasToDisable;
bool sameToReEnable =
(l->validatorToReEnable() != std::nullopt) == hasToReEnable;
return sameSize && sameToDisable && sameToReEnable;
}
bool
applyAndTestUNLRResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
{
auto res = apply(env.app(), view, tx, ApplyFlags::tapNONE, env.journal);
if (pass)
return res.first == tesSUCCESS;
else
return res.first == tefFAILURE || res.first == temDISABLED ||
res.first == temMALFORMED ||
res.first == telIMPORT_VL_KEY_NOT_RECOGNISED;
}
bool
VerifyUNLRPubKeyAndSeq(
std::shared_ptr<Ledger const> const& l,
@@ -1412,6 +1413,7 @@ createUNLRTx(
return STTx(ttUNL_REPORT, fill);
}
/*
inline STTx
createTx(bool disabling, LedgerIndex seq, PublicKey const& txKey)
{
@@ -1422,35 +1424,24 @@ createTx(bool disabling, LedgerIndex seq, PublicKey const& txKey)
};
return STTx(ttUNL_MODIFY, fill);
}
*/
/*
inline std::size_t
countTx(std::shared_ptr<SHAMap> const& txSet)
{
/*uint64_t counter = 0;
if (txSet)
for (auto const& item : *txSet)
{
SerialIter sit(item.slice());
auto tx = std::make_shared<STTx
const>(SerialIter{sit.getSlice(sit.getVLDataLength())});
if (tx->getFieldU16(sfTransactionType) == ttUNL_MODIFY)
counter++;
}
*/
std::size_t count = 0;
for (auto i = txSet->begin(); i != txSet->end(); ++i)
{
// RH TODO: why does the above parse??
auto raw = i->slice();
if (raw[0] == 0x12U && raw[1] == 0 && raw[2] == 0x66U)
count++;
}
return count;
};
*/
/*
inline bool
applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
{
@@ -1460,6 +1451,7 @@ applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
else
return res.first == tefFAILURE || res.first == temDISABLED;
}
*/
} // namespace test
} // namespace ripple
} // namespace ripple

1
src/test/jtx/utility.h
View File

@@ -65,4 +65,5 @@ fill_seq(Json::Value& jv, ReadView const& view);
} // namespace test
} // namespace ripple
#endif