ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-11-20 10:35:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
6e49f7d1b14982bf54bde431c1fd897a217e8e23
xahaud/src/ripple/app/hook/impl/HookAPI.cpp
tequ 6e49f7d1b1 add float APIs
2025-09-06 02:42:34 +09:00

1181 lines
31 KiB
C++
Raw Blame History

// Implementation of decoupled Hook APIs for emit and related helpers.
#include <ripple/app/hook/HookAPI.h>
#include <ripple/app/hook/applyHook.h>
#include <ripple/app/ledger/OpenLedger.h>
#include <ripple/app/misc/Transaction.h>
#include <ripple/app/tx/apply.h>
#include <ripple/app/tx/impl/ApplyContext.h>
#include <ripple/app/tx/impl/Transactor.h>
#include <ripple/basics/Log.h>
#include <ripple/protocol/STObject.h>
#include <ripple/protocol/TxFlags.h>
#include <ripple/protocol/tokens.h>
#include <cfenv>
namespace hook {
namespace hook_float {
// power of 10 LUT for fast integer math
static int64_t power_of_ten[19] = {
1LL,
10LL,
100LL,
1000LL,
10000LL,
100000LL,
1000000LL,
10000000LL,
100000000LL,
1000000000LL,
10000000000LL,
100000000000LL,
1000000000000LL,
10000000000000LL,
100000000000000LL,
1000000000000000LL, // 15
10000000000000000LL,
100000000000000000LL,
1000000000000000000LL,
};
using namespace hook_api;
static int64_t const minMantissa = 1000000000000000ull;
static int64_t const maxMantissa = 9999999999999999ull;
static int32_t const minExponent = -96;
static int32_t const maxExponent = 80;
inline Expected<int32_t, HookReturnCode>
get_exponent(int64_t float1)
{
if (float1 < 0)
return Unexpected(INVALID_FLOAT);
if (float1 == 0)
return 0;
uint64_t float_in = (uint64_t)float1;
float_in >>= 54U;
float_in &= 0xFFU;
return ((int32_t)float_in) - 97;
}
inline Expected<uint64_t, HookReturnCode>
get_mantissa(int64_t float1)
{
if (float1 < 0)
return Unexpected(INVALID_FLOAT);
if (float1 == 0)
return 0;
float1 -= ((((uint64_t)float1) >> 54U) << 54U);
return float1;
}
inline bool
is_negative(int64_t float1)
{
return ((float1 >> 62U) & 1ULL) == 0;
}
inline int64_t
invert_sign(int64_t float1)
{
int64_t r = (int64_t)(((uint64_t)float1) ^ (1ULL << 62U));
return r;
}
inline int64_t
set_sign(int64_t float1, bool set_negative)
{
bool neg = is_negative(float1);
if ((neg && set_negative) || (!neg && !set_negative))
return float1;
return invert_sign(float1);
}
inline Expected<uint64_t, HookReturnCode>
set_mantissa(int64_t float1, uint64_t mantissa)
{
if (mantissa > maxMantissa)
return Unexpected(MANTISSA_OVERSIZED);
if (mantissa < minMantissa)
return Unexpected(MANTISSA_UNDERSIZED);
return float1 - get_mantissa(float1).value() + mantissa;
}
inline Expected<uint64_t, HookReturnCode>
set_exponent(int64_t float1, int32_t exponent)
{
if (exponent > maxExponent)
return Unexpected(EXPONENT_OVERSIZED);
if (exponent < minExponent)
return Unexpected(EXPONENT_UNDERSIZED);
uint64_t exp = (exponent + 97);
exp <<= 54U;
float1 &= ~(0xFFLL << 54);
float1 += (int64_t)exp;
return float1;
}
inline Expected<uint64_t, HookReturnCode>
make_float(ripple::IOUAmount& amt)
{
int64_t man_out = amt.mantissa();
int64_t float_out = 0;
bool neg = man_out < 0;
if (neg)
man_out *= -1;
float_out = set_sign(float_out, neg);
auto const mantissa = set_mantissa(float_out, (uint64_t)man_out);
if (!mantissa)
// TODO: This change requires the amendment.
// return Unexpected(mantissa.error());
float_out = mantissa.error();
else
float_out = mantissa.value();
auto const exponent = set_exponent(float_out, amt.exponent());
if (!exponent)
return Unexpected(exponent.error());
float_out = exponent.value();
return float_out;
}
inline Expected<uint64_t, HookReturnCode>
make_float(uint64_t mantissa, int32_t exponent, bool neg)
{
if (mantissa == 0)
return 0;
if (mantissa > maxMantissa)
return Unexpected(MANTISSA_OVERSIZED);
if (mantissa < minMantissa)
return Unexpected(MANTISSA_UNDERSIZED);
if (exponent > maxExponent)
return Unexpected(EXPONENT_OVERSIZED);
if (exponent < minExponent)
return Unexpected(EXPONENT_UNDERSIZED);
int64_t out = 0;
auto const m = set_mantissa(out, mantissa);
if (!m)
return m.error();
out = m.value();
auto const e = set_exponent(out, exponent);
if (!e)
return e.error();
out = e.value();
out = set_sign(out, neg);
return out;
}
/**
* This function normalizes the mantissa and exponent passed, if it can.
* It returns the XFL and mutates the supplied manitssa and exponent.
* If a negative mantissa is provided then the returned XFL has the negative
* flag set. If there is an overflow error return XFL_OVERFLOW. On underflow
* returns canonical 0
*/
template <typename T>
inline Expected<uint64_t, HookReturnCode>
normalize_xfl(T& man, int32_t& exp, bool neg = false)
{
if (man == 0)
return 0;
if (man == std::numeric_limits<int64_t>::min())
man++;
constexpr bool sman = std::is_same<T, int64_t>::value;
static_assert(sman || std::is_same<T, uint64_t>());
if constexpr (sman)
{
if (man < 0)
{
man *= -1LL;
neg = true;
}
}
// mantissa order
std::feclearexcept(FE_ALL_EXCEPT);
int32_t mo = log10(man);
// defensively ensure log10 produces a sane result; we'll borrow the
// overflow error code if it didn't
if (std::fetestexcept(FE_INVALID))
return Unexpected(XFL_OVERFLOW);
int32_t adjust = 15 - mo;
if (adjust > 0)
{
// defensive check
if (adjust > 18)
return 0;
man *= power_of_ten[adjust];
exp -= adjust;
}
else if (adjust < 0)
{
// defensive check
if (-adjust > 18)
return Unexpected(XFL_OVERFLOW);
man /= power_of_ten[-adjust];
exp -= adjust;
}
if (man == 0)
{
exp = 0;
return 0;
}
// even after adjustment the mantissa can be outside the range by one place
// improving the math above would probably alleviate the need for these
// branches
if (man < minMantissa)
{
if (man == minMantissa - 1LL)
man += 1LL;
else
{
man *= 10LL;
exp--;
}
}
if (man > maxMantissa)
{
if (man == maxMantissa + 1LL)
man -= 1LL;
else
{
man /= 10LL;
exp++;
}
}
if (exp < minExponent)
{
man = 0;
exp = 0;
return 0;
}
if (man == 0)
{
exp = 0;
return 0;
}
if (exp > maxExponent)
return Unexpected(XFL_OVERFLOW);
auto const ret = make_float((uint64_t)man, exp, neg);
if constexpr (sman)
{
if (neg)
man *= -1LL;
}
if (!ret)
return ret.error();
return ret;
}
const int64_t float_one_internal =
make_float(1000000000000000ull, -15, false).value();
} // namespace hook_float
using namespace ripple;
using namespace hook_float;
Expected<std::shared_ptr<Transaction>, HookReturnCode>
HookAPI::emit(Slice txBlob)
{
auto& applyCtx = hookCtx.applyCtx;
auto j = applyCtx.app.journal("View");
auto& view = applyCtx.view();
if (hookCtx.expected_etxn_count < 0)
return Unexpected(PREREQUISITE_NOT_MET);
if (hookCtx.result.emittedTxn.size() >= hookCtx.expected_etxn_count)
return Unexpected(TOO_MANY_EMITTED_TXN);
std::shared_ptr<STTx const> stpTrans;
try
{
SerialIter sit(txBlob);
stpTrans = std::make_shared<STTx const>(sit);
}
catch (std::exception const& e)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC() << "]: Failed " << e.what();
return Unexpected(EMISSION_FAILURE);
}
if (isPseudoTx(*stpTrans))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: Attempted to emit pseudo txn.";
return Unexpected(EMISSION_FAILURE);
}
ripple::TxType txType = stpTrans->getTxnType();
ripple::uint256 const& hookCanEmit = hookCtx.result.hookCanEmit;
if (!hook::canEmit(txType, hookCanEmit))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: Hook cannot emit this txn.";
return Unexpected(EMISSION_FAILURE);
}
// check the emitted txn is valid
/* Emitted TXN rules
* 0. Account must match the hook account
* 1. Sequence: 0
* 2. PubSigningKey: 000000000000000
* 3. sfEmitDetails present and valid
* 4. No sfTxnSignature
* 5. LastLedgerSeq > current ledger, > firstledgerseq & LastLedgerSeq < seq
* + 5
* 6. FirstLedgerSeq > current ledger
* 7. Fee must be correctly high
* 8. The generation cannot be higher than 10
*/
// rule 0: account must match the hook account
if (!stpTrans->isFieldPresent(sfAccount) ||
stpTrans->getAccountID(sfAccount) != hookCtx.result.account)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfAccount does not match hook account";
return Unexpected(EMISSION_FAILURE);
}
// rule 1: sfSequence must be present and 0
if (!stpTrans->isFieldPresent(sfSequence) ||
stpTrans->getFieldU32(sfSequence) != 0)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfSequence missing or non-zero";
return Unexpected(EMISSION_FAILURE);
}
// rule 2: sfSigningPubKey must be present and 00...00
if (!stpTrans->isFieldPresent(sfSigningPubKey))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfSigningPubKey missing";
return Unexpected(EMISSION_FAILURE);
}
auto const pk = stpTrans->getSigningPubKey();
if (pk.size() != 33 && pk.size() != 0)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfSigningPubKey present but wrong size";
return Unexpected(EMISSION_FAILURE);
}
for (int i = 0; i < pk.size(); ++i)
if (pk[i] != 0)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfSigningPubKey present but non-zero.";
return Unexpected(EMISSION_FAILURE);
}
// rule 2.a: no signers
if (stpTrans->isFieldPresent(sfSigners))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfSigners not allowed in emitted txns.";
return Unexpected(EMISSION_FAILURE);
}
// rule 2.b: ticketseq cannot be used
if (stpTrans->isFieldPresent(sfTicketSequence))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfTicketSequence not allowed in emitted txns.";
return Unexpected(EMISSION_FAILURE);
}
// rule 2.c sfAccountTxnID not allowed
if (stpTrans->isFieldPresent(sfAccountTxnID))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfAccountTxnID not allowed in emitted txns.";
return Unexpected(EMISSION_FAILURE);
}
// rule 3: sfEmitDetails must be present and valid
if (!stpTrans->isFieldPresent(sfEmitDetails))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitDetails missing.";
return Unexpected(EMISSION_FAILURE);
}
auto const& emitDetails = const_cast<ripple::STTx&>(*stpTrans)
.getField(sfEmitDetails)
.downcast<STObject>();
if (!emitDetails.isFieldPresent(sfEmitGeneration) ||
!emitDetails.isFieldPresent(sfEmitBurden) ||
!emitDetails.isFieldPresent(sfEmitParentTxnID) ||
!emitDetails.isFieldPresent(sfEmitNonce) ||
!emitDetails.isFieldPresent(sfEmitHookHash))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitDetails malformed.";
return Unexpected(EMISSION_FAILURE);
}
// rule 8: emit generation cannot exceed 10
if (emitDetails.getFieldU32(sfEmitGeneration) >= 10)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitGeneration was 10 or more.";
return Unexpected(EMISSION_FAILURE);
}
auto const gen = emitDetails.getFieldU32(sfEmitGeneration);
auto const bur = emitDetails.getFieldU64(sfEmitBurden);
auto const pTxnID = emitDetails.getFieldH256(sfEmitParentTxnID);
auto const nonce = emitDetails.getFieldH256(sfEmitNonce);
std::optional<ripple::AccountID> callback;
if (emitDetails.isFieldPresent(sfEmitCallback))
callback = emitDetails.getAccountID(sfEmitCallback);
auto const& hash = emitDetails.getFieldH256(sfEmitHookHash);
uint32_t gen_proper = static_cast<uint32_t>(etxn_generation());
if (gen != gen_proper)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitGeneration provided in EmitDetails "
<< "not correct (" << gen << ") "
<< "should be " << gen_proper;
return Unexpected(EMISSION_FAILURE);
}
uint64_t bur_proper = static_cast<uint64_t>(etxn_burden().value());
if (bur != bur_proper)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitBurden provided in EmitDetails "
<< "was not correct (" << bur << ") "
<< "should be " << bur_proper;
return Unexpected(EMISSION_FAILURE);
}
if (pTxnID != applyCtx.tx.getTransactionID())
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitParentTxnID provided in EmitDetails"
<< "was not correct";
return Unexpected(EMISSION_FAILURE);
}
if (hookCtx.nonce_used.find(nonce) == hookCtx.nonce_used.end())
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitNonce provided in EmitDetails was not "
"generated by nonce api";
return Unexpected(EMISSION_FAILURE);
}
if (callback && *callback != hookCtx.result.account)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfEmitCallback account must be the account of "
"the emitting hook";
return Unexpected(EMISSION_FAILURE);
}
if (hash != hookCtx.result.hookHash)
{
JLOG(j.trace())
<< "HookEmit[" << HC_ACC()
<< "]: sfEmitHookHash must be the hash of the emitting hook";
return Unexpected(EMISSION_FAILURE);
}
// rule 4: sfTxnSignature must be absent
if (stpTrans->isFieldPresent(sfTxnSignature))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfTxnSignature is present but should not be";
return Unexpected(EMISSION_FAILURE);
}
// rule 5: LastLedgerSeq must be present and after current ledger
if (!stpTrans->isFieldPresent(sfLastLedgerSequence))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfLastLedgerSequence missing";
return Unexpected(EMISSION_FAILURE);
}
uint32_t tx_lls = stpTrans->getFieldU32(sfLastLedgerSequence);
uint32_t ledgerSeq = view.info().seq;
if (tx_lls < ledgerSeq + 1)
{
JLOG(j.trace())
<< "HookEmit[" << HC_ACC()
<< "]: sfLastLedgerSequence invalid (less than next ledger)";
return Unexpected(EMISSION_FAILURE);
}
if (tx_lls > ledgerSeq + 5)
{
JLOG(j.trace())
<< "HookEmit[" << HC_ACC()
<< "]: sfLastLedgerSequence cannot be greater than current seq + 5";
return Unexpected(EMISSION_FAILURE);
}
// rule 6
if (!stpTrans->isFieldPresent(sfFirstLedgerSequence) ||
stpTrans->getFieldU32(sfFirstLedgerSequence) > tx_lls)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: sfFirstLedgerSequence must be present and <= "
"LastLedgerSequence";
return Unexpected(EMISSION_FAILURE);
}
// rule 7 check the emitted txn pays the appropriate fee
int64_t minfee = etxn_fee_base(txBlob).value();
if (minfee < 0)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: Fee could not be calculated";
return Unexpected(EMISSION_FAILURE);
}
if (!stpTrans->isFieldPresent(sfFee))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: Fee missing from emitted tx";
return Unexpected(EMISSION_FAILURE);
}
int64_t fee = stpTrans->getFieldAmount(sfFee).xrp().drops();
if (fee < minfee)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: Fee less than minimum required";
return Unexpected(EMISSION_FAILURE);
}
std::string reason;
auto tpTrans =
std::make_shared<Transaction>(stpTrans, reason, applyCtx.app);
if (tpTrans->getStatus() != NEW)
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: tpTrans->getStatus() != NEW";
return Unexpected(EMISSION_FAILURE);
}
// preflight the transaction
auto preflightResult = ripple::preflight(
applyCtx.app,
view.rules(),
*stpTrans,
ripple::ApplyFlags::tapPREFLIGHT_EMIT,
j);
if (!isTesSuccess(preflightResult.ter))
{
JLOG(j.trace()) << "HookEmit[" << HC_ACC()
<< "]: Transaction preflight failure: "
<< preflightResult.ter;
return Unexpected(EMISSION_FAILURE);
}
return tpTrans;
}
Expected<uint64_t, HookReturnCode>
HookAPI::etxn_burden() const
{
if (hookCtx.expected_etxn_count <= -1)
return Unexpected(PREREQUISITE_NOT_MET);
uint64_t last_burden = static_cast<uint64_t>(otxn_burden());
uint64_t burden =
last_burden * static_cast<uint64_t>(hookCtx.expected_etxn_count);
if (burden < last_burden)
return Unexpected(FEE_TOO_LARGE);
return burden;
}
Expected<uint64_t, HookReturnCode>
HookAPI::etxn_fee_base(ripple::Slice txBlob) const
{
auto& applyCtx = hookCtx.applyCtx;
auto j = applyCtx.app.journal("View");
if (hookCtx.expected_etxn_count <= -1)
return Unexpected(PREREQUISITE_NOT_MET);
try
{
SerialIter sitTrans(txBlob);
std::unique_ptr<STTx const> stpTrans =
std::make_unique<STTx const>(std::ref(sitTrans));
return Transactor::calculateBaseFee(
*(applyCtx.app.openLedger().current()), *stpTrans)
.drops();
}
catch (std::exception const& e)
{
JLOG(j.trace()) << "HookInfo[" << HC_ACC()
<< "]: etxn_fee_base exception: " << e.what();
return Unexpected(INVALID_TXN);
}
}
uint32_t
HookAPI::etxn_generation() const
{
return otxn_generation() + 1;
}
using namespace hook_float;
Expected<uint64_t, HookReturnCode>
HookAPI::float_set(int32_t exponent, int64_t mantissa) const
{
if (mantissa == 0)
return 0;
auto normalized = hook_float::normalize_xfl(mantissa, exponent);
// the above function will underflow into a canonical 0
// but this api must report that underflow
if (!normalized)
{
if (normalized.error() == XFL_OVERFLOW)
return Unexpected(INVALID_FLOAT);
return normalized.error();
}
if (normalized.value() == 0)
return Unexpected(INVALID_FLOAT);
return normalized;
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_multiply(uint64_t float1, uint64_t float2) const
{
if (float1 == 0 || float2 == 0)
return 0;
uint64_t man1 = get_mantissa(float1).value();
int32_t exp1 = get_exponent(float1).value();
bool neg1 = is_negative(float1);
uint64_t man2 = get_mantissa(float2).value();
int32_t exp2 = get_exponent(float2).value();
bool neg2 = is_negative(float2);
auto const result =
float_multiply_internal_parts(man1, exp1, neg1, man2, exp2, neg2);
if (!result)
return result.error();
return result;
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_mulratio(
uint64_t float1,
uint32_t round_up,
uint32_t numerator,
uint32_t denominator) const
{
if (float1 == 0)
return 0;
if (denominator == 0)
return Unexpected(DIVISION_BY_ZERO);
int64_t man1 = get_mantissa(float1).value();
int32_t exp1 = get_exponent(float1).value();
if (!mulratio_internal(man1, exp1, round_up > 0, numerator, denominator))
return Unexpected(XFL_OVERFLOW);
// defensive check
if (man1 < 0)
man1 *= -1LL;
auto const result = make_float((uint64_t)man1, exp1, is_negative(float1));
if (!result)
return result.error();
return result;
}
uint64_t
HookAPI::float_negate(uint64_t float1) const
{
if (float1 == 0)
return 0;
return invert_sign(float1);
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_compare(uint64_t float1, uint64_t float2, uint32_t mode) const
{
bool equal_flag = mode & compare_mode::EQUAL;
bool less_flag = mode & compare_mode::LESS;
bool greater_flag = mode & compare_mode::GREATER;
bool not_equal = less_flag && greater_flag;
if ((equal_flag && less_flag && greater_flag) || mode == 0)
return Unexpected(INVALID_ARGUMENT);
if (mode & (~0b111UL))
return Unexpected(INVALID_ARGUMENT);
try
{
int64_t man1 =
(get_mantissa(float1)).value() * (is_negative(float1) ? -1LL : 1LL);
int32_t exp1 = get_exponent(float1).value();
ripple::IOUAmount amt1{man1, exp1};
int64_t man2 =
get_mantissa(float2).value() * (is_negative(float2) ? -1LL : 1LL);
int32_t exp2 = get_exponent(float2).value();
ripple::IOUAmount amt2{man2, exp2};
if (not_equal && amt1 != amt2)
return 1;
if (equal_flag && amt1 == amt2)
return 1;
if (greater_flag && amt1 > amt2)
return 1;
if (less_flag && amt1 < amt2)
return 1;
return 0;
}
catch (std::overflow_error& e)
{
return Unexpected(XFL_OVERFLOW);
}
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_sum(uint64_t float1, uint64_t float2) const
{
if (float1 == 0)
return float2;
if (float2 == 0)
return float1;
int64_t man1 =
get_mantissa(float1).value() * (is_negative(float1) ? -1LL : 1LL);
int32_t exp1 = get_exponent(float1).value();
int64_t man2 =
get_mantissa(float2).value() * (is_negative(float2) ? -1LL : 1LL);
int32_t exp2 = get_exponent(float2).value();
try
{
ripple::IOUAmount amt1{man1, exp1};
ripple::IOUAmount amt2{man2, exp2};
amt1 += amt2;
auto const result = make_float(amt1);
if (!result)
{
// TODO: Should be (EXPONENT_UNDERSIZED || MANTISSA_UNDERSIZED)
if (result.error() == EXPONENT_UNDERSIZED)
{
// this is an underflow e.g. as a result of subtracting an xfl
// from itself and thus not an error, just return canonical 0
return 0;
}
return Unexpected(result.error());
}
return result;
}
catch (std::overflow_error& e)
{
return Unexpected(XFL_OVERFLOW);
}
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_invert(uint64_t float1) const
{
if (float1 == 0)
return Unexpected(DIVISION_BY_ZERO);
if (float1 == float_one_internal)
return float_one_internal;
return float_divide_internal(float_one_internal, float1);
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_divide(uint64_t float1, uint64_t float2) const
{
return float_divide_internal(float1, float2);
}
uint64_t
HookAPI::float_one() const
{
return float_one_internal;
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_mantissa(uint64_t float1) const
{
if (float1 == 0)
return 0;
return get_mantissa(float1);
}
uint64_t
HookAPI::float_sign(uint64_t float1) const
{
if (float1 == 0)
return 0;
return is_negative(float1);
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_int(uint64_t float1, uint32_t decimal_places, uint32_t absolute)
const
{
if (float1 == 0)
return 0;
uint64_t man1 = get_mantissa(float1).value();
int32_t exp1 = get_exponent(float1).value();
bool neg1 = is_negative(float1);
if (decimal_places > 15)
return Unexpected(INVALID_ARGUMENT);
if (neg1)
{
if (!absolute)
return Unexpected(CANT_RETURN_NEGATIVE);
}
int32_t shift = -(exp1 + decimal_places);
if (shift > 15)
return 0;
if (shift < 0)
return Unexpected(TOO_BIG);
if (shift > 0)
man1 /= power_of_ten[shift];
return man1;
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_log(uint64_t float1) const
{
if (float1 == 0)
return Unexpected(INVALID_ARGUMENT);
uint64_t man1 = get_mantissa(float1).value();
int32_t exp1 = get_exponent(float1).value();
if (is_negative(float1))
return Unexpected(COMPLEX_NOT_SUPPORTED);
double inp = (double)(man1);
double result = log10(inp) + exp1;
return double_to_xfl(result);
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_root(uint64_t float1, uint32_t n) const
{
if (float1 == 0)
return 0;
if (n < 2)
return Unexpected(INVALID_ARGUMENT);
uint64_t man1 = get_mantissa(float1).value();
int32_t exp1 = get_exponent(float1).value();
if (is_negative(float1))
return Unexpected(COMPLEX_NOT_SUPPORTED);
double inp = (double)(man1)*pow(10, exp1);
double result = pow(inp, ((double)1.0f) / ((double)(n)));
return double_to_xfl(result);
}
uint64_t
HookAPI::otxn_burden() const
{
auto& applyCtx = hookCtx.applyCtx;
auto j = applyCtx.app.journal("View");
if (hookCtx.burden)
return hookCtx.burden;
auto const& tx = applyCtx.tx;
if (!tx.isFieldPresent(sfEmitDetails))
return 1;
auto const& pd = const_cast<ripple::STTx&>(tx)
.getField(sfEmitDetails)
.downcast<STObject>();
if (!pd.isFieldPresent(sfEmitBurden))
{
JLOG(j.warn())
<< "HookError[" << HC_ACC()
<< "]: found sfEmitDetails but sfEmitBurden was not present";
return 1;
}
uint64_t burden = pd.getFieldU64(sfEmitBurden);
burden &= ((1ULL << 63) - 1);
hookCtx.burden = burden;
return static_cast<int64_t>(burden);
}
uint32_t
HookAPI::otxn_generation() const
{
auto& applyCtx = hookCtx.applyCtx;
auto j = applyCtx.app.journal("View");
if (hookCtx.generation)
return hookCtx.generation;
auto const& tx = applyCtx.tx;
if (!tx.isFieldPresent(sfEmitDetails))
return 0;
auto const& pd = const_cast<ripple::STTx&>(tx)
.getField(sfEmitDetails)
.downcast<STObject>();
if (!pd.isFieldPresent(sfEmitGeneration))
{
JLOG(j.warn())
<< "HookError[" << HC_ACC()
<< "]: found sfEmitDetails but sfEmitGeneration was not present";
return 0;
}
hookCtx.generation = pd.getFieldU32(sfEmitGeneration);
return hookCtx.generation;
}
// private
inline Expected<uint64_t, HookReturnCode>
HookAPI::float_multiply_internal_parts(
uint64_t man1,
int32_t exp1,
bool neg1,
uint64_t man2,
int32_t exp2,
bool neg2) const
{
using namespace boost::multiprecision;
cpp_int mult = cpp_int(man1) * cpp_int(man2);
mult /= power_of_ten[15];
uint64_t man_out = static_cast<uint64_t>(mult);
if (mult > man_out)
return Unexpected(XFL_OVERFLOW);
int32_t exp_out = exp1 + exp2 + 15;
bool neg_out = (neg1 && !neg2) || (!neg1 && neg2);
auto const ret = normalize_xfl(man_out, exp_out, neg_out);
if (!ret)
{
if (ret.error() == EXPONENT_UNDERSIZED)
return 0;
if (ret.error() == EXPONENT_OVERSIZED)
return Unexpected(XFL_OVERFLOW);
return ret.error();
}
return ret;
}
inline Expected<uint64_t, HookReturnCode>
HookAPI::mulratio_internal(
int64_t& man1,
int32_t& exp1,
bool round_up,
uint32_t numerator,
uint32_t denominator) const
{
try
{
ripple::IOUAmount amt{man1, exp1};
ripple::IOUAmount out = ripple::mulRatio(
amt, numerator, denominator, round_up != 0); // already normalized
man1 = out.mantissa();
exp1 = out.exponent();
return 1;
}
catch (std::overflow_error& e)
{
return Unexpected(XFL_OVERFLOW);
}
}
inline Expected<uint64_t, HookReturnCode>
HookAPI::float_divide_internal(uint64_t float1, uint64_t float2) const
{
bool const hasFix = hookCtx.applyCtx.view().rules().enabled(fixFloatDivide);
if (float2 == 0)
return DIVISION_BY_ZERO;
if (float1 == 0)
return 0;
// special case: division by 1
// RH TODO: add more special cases (division by power of 10)
if (float2 == float_one_internal)
return float1;
uint64_t man1 = get_mantissa(float1).value();
int32_t exp1 = get_exponent(float1).value();
bool neg1 = is_negative(float1);
uint64_t man2 = get_mantissa(float2).value();
int32_t exp2 = get_exponent(float2).value();
bool neg2 = is_negative(float2);
auto tmp1 = normalize_xfl(man1, exp1);
auto tmp2 = normalize_xfl(man2, exp2);
if (!tmp1 || !tmp2)
return Unexpected(INVALID_FLOAT);
if (tmp1.value() == 0)
return 0;
while (man2 > man1)
{
man2 /= 10;
exp2++;
}
if (man2 == 0)
return Unexpected(DIVISION_BY_ZERO);
while (man2 < man1)
{
if (man2 * 10 > man1)
break;
man2 *= 10;
exp2--;
}
uint64_t man3 = 0;
int32_t exp3 = exp1 - exp2;
while (man2 > 0)
{
int i = 0;
if (hasFix)
{
for (; man1 >= man2; man1 -= man2, ++i)
;
}
else
{
for (; man1 > man2; man1 -= man2, ++i)
;
}
man3 *= 10;
man3 += i;
man2 /= 10;
if (man2 == 0)
break;
exp3--;
}
bool neg3 = !((neg1 && neg2) || (!neg1 && !neg2));
return normalize_xfl(man3, exp3, neg3);
}
inline Expected<uint64_t, HookReturnCode>
HookAPI::double_to_xfl(double x) const
{
if ((x) == 0)
return 0;
bool neg = x < 0;
double absresult = neg ? -x : x;
// first compute the base 10 order of the float
int32_t exp_out = (int32_t)log10(absresult);
// next adjust it into the valid mantissa range (this means dividing by its
// order and multiplying by 10**15)
absresult *= pow(10, -exp_out + 15);
// after adjustment the value may still fall below the minMantissa
int64_t result = (int64_t)absresult;
if (result < minMantissa)
{
if (result == minMantissa - 1LL)
result += 1LL;
else
{
result *= 10LL;
exp_out--;
}
}
// likewise the value can fall above the maxMantissa
if (result > maxMantissa)
{
if (result == maxMantissa + 1LL)
result -= 1LL;
else
{
result /= 10LL;
exp_out++;
}
}
exp_out -= 15;
auto const ret = make_float(result, exp_out, neg);
if (!ret)
{
// TODO: Should be (EXPONENT_UNDERSIZED || MANTISSA_UNDERSIZED)
if (ret.error() == EXPONENT_UNDERSIZED)
return 0;
return Unexpected(ret.error());
}
return ret;
}
} // namespace hook
Reference in New Issue View Git Blame Copy Permalink