ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-12-06 17:27:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
59e565052159ca723d5e0d781d9218b7b4ca7b9a
xahaud/src/ripple/app/hook/impl/HookAPI.cpp
tequ 59e5650521 add sto_erase tests
2025-12-02 22:10:32 +09:00

3198 lines
87 KiB
C++
Raw Blame History

// Implementation of decoupled Hook APIs for emit and related helpers.
#include <ripple/app/hook/HookAPI.h>
#include <ripple/app/ledger/OpenLedger.h>
#include <ripple/app/ledger/TransactionMaster.h>
#include <ripple/app/tx/impl/Import.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;
/// control APIs
// _g
// accept
// rollback
/// util APIs
Expected<std::string, HookReturnCode>
HookAPI::util_raddr(Bytes const& accountID) const
{
if (accountID.size() != 20)
return Unexpected(INVALID_ARGUMENT);
return encodeBase58Token(
TokenType::AccountID, accountID.data(), accountID.size());
}
Expected<Bytes, HookReturnCode>
HookAPI::util_accid(std::string raddress) const
{
auto const result = decodeBase58Token(raddress, TokenType::AccountID);
if (result.empty())
return Unexpected(INVALID_ARGUMENT);
return Bytes(result.data(), result.data() + result.size());
}
Expected<bool, HookReturnCode>
HookAPI::util_verify(Slice const& data, Slice const& sig, Slice const& key)
const
{
if (key.size() != 33)
return Unexpected(INVALID_KEY);
if (data.size() == 0)
return Unexpected(TOO_SMALL);
if (sig.size() < 30)
return Unexpected(TOO_SMALL);
if (!publicKeyType(key))
return Unexpected(INVALID_KEY);
ripple::PublicKey pubkey{key};
return ripple::verify(pubkey, data, sig, false);
}
uint256
HookAPI::util_sha512h(Slice const& data) const
{
return ripple::sha512Half(data);
}
// util_keylet
/// sto APIs
Expected<bool, HookReturnCode>
HookAPI::sto_validate(Bytes const& data) const
{
if (data.size() < 2)
return Unexpected(TOO_SMALL);
unsigned char* start = const_cast<unsigned char*>(data.data());
unsigned char* upto = start;
unsigned char* end = start + data.size();
for (int i = 0; i < 1024 && upto < end; ++i)
{
int type = -1, field = -1, payload_start = -1, payload_length = -1;
auto const length = get_stobject_length(
upto, end, type, field, payload_start, payload_length, 0);
if (!length)
return 0;
upto += length.value();
}
return upto == end ? 1 : 0;
}
Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
HookAPI::sto_subfield(Bytes const& data, uint32_t field_id) const
{
if (data.size() < 2)
return Unexpected(TOO_SMALL);
unsigned char* start = const_cast<unsigned char*>(data.data());
unsigned char* upto = start;
unsigned char* end = start + data.size();
DBG_PRINTF(
"sto_subfield called, looking for field %u type %u\n",
field_id & 0xFFFF,
(field_id >> 16));
for (int j = -5; j < 5; ++j)
DBG_PRINTF((j == 0 ? " >%02X< " : " %02X "), *(start + j));
DBG_PRINTF("\n");
// if ((*upto & 0xF0) == 0xE0)
// upto++;
for (int i = 0; i < 1024 && upto < end; ++i)
{
int type = -1, field = -1, payload_start = -1, payload_length = -1;
auto const length = get_stobject_length(
upto, end, type, field, payload_start, payload_length, 0);
if (!length)
return Unexpected(PARSE_ERROR);
if ((type << 16) + field == field_id)
{
DBG_PRINTF(
"sto_subfield returned for field %u type %u\n",
field_id & 0xFFFF,
(field_id >> 16));
for (int j = -5; j < 5; ++j)
DBG_PRINTF((j == 0 ? " [%02X] " : " %02X "), *(upto + j));
DBG_PRINTF("\n");
if (type == 0xF) // we return arrays fully formed
return std::make_pair(upto - start, length.value());
// return pointers to all other objects as payloads
return std::make_pair(upto - start + payload_start, payload_length);
}
upto += length.value();
}
if (upto != end)
return Unexpected(PARSE_ERROR);
return Unexpected(DOESNT_EXIST);
}
Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
HookAPI::sto_subarray(Bytes const& data, uint32_t index_id) const
{
if (data.size() < 2)
return Unexpected(TOO_SMALL);
unsigned char* start = const_cast<unsigned char*>(data.data());
unsigned char* upto = start;
unsigned char* end = start + data.size();
// unwrap the array if it is wrapped,
// by removing a byte from the start and end
// why here 0xF0?
// STI_ARRAY = 0xF0
// eg) Signers field value = 0x03 => 0xF3
// eg) Amounts field value = 0x5C => 0xF0, 0x5C
if ((*upto & 0xF0U) == 0xF0U)
{
if (hookCtx.applyCtx.view().rules().enabled(fixHookAPI20251128) &&
*upto == 0xF0U)
{
// field value > 15
upto++;
upto++;
end--;
}
else
{
// field value <= 15
upto++;
end--;
}
}
if (upto >= end)
return Unexpected(PARSE_ERROR);
/*
DBG_PRINTF("sto_subarray called, looking for index %u\n", index_id);
for (int j = -5; j < 5; ++j)
printf(( j == 0 ? " >%02X< " : " %02X "), *(start + j));
DBG_PRINTF("\n");
*/
for (int i = 0; i < 1024 && upto < end; ++i)
{
int type = -1, field = -1, payload_start = -1, payload_length = -1;
auto const length = get_stobject_length(
upto, end, type, field, payload_start, payload_length, 0);
if (!length)
return Unexpected(PARSE_ERROR);
if (i == index_id)
{
DBG_PRINTF("sto_subarray returned for index %u\n", index_id);
for (int j = -5; j < 5; ++j)
DBG_PRINTF(
(j == 0 ? " [%02X] " : " %02X "),
*(upto + j + length.value()));
DBG_PRINTF("\n");
return std::make_pair(upto - start, length.value());
}
upto += length.value();
}
if (upto != end)
return Unexpected(PARSE_ERROR);
return Unexpected(DOESNT_EXIST);
}
Expected<Bytes, HookReturnCode>
HookAPI::sto_emplace(
Bytes const& source_object,
std::optional<Bytes> const& field_object,
uint32_t field_id) const
{
// RH TODO: put these constants somewhere (votable?)
if (source_object.size() > 1024 * 16)
return Unexpected(TOO_BIG);
if (source_object.size() < 2)
return Unexpected(TOO_SMALL);
if (!field_object.has_value())
{
// this is a delete operation
}
else
{
if (field_object->size() > 4096)
return Unexpected(TOO_BIG);
if (field_object->size() < 2)
return Unexpected(TOO_SMALL);
}
if (field_object.has_value() &&
hookCtx.applyCtx.view().rules().enabled(fixHookAPI20251128))
{
// inject field should be valid sto object and it's field id should
// match the field_id
unsigned char* inject_start = (unsigned char*)(field_object->data());
unsigned char* inject_end =
(unsigned char*)(field_object->data() + field_object->size());
int type = -1, field = -1, payload_start = -1, payload_length = -1;
auto const length = get_stobject_length(
inject_start,
inject_end,
type,
field,
payload_start,
payload_length,
0);
if (!length)
return Unexpected(PARSE_ERROR);
if ((type << 16) + field != field_id)
{
return Unexpected(PARSE_ERROR);
}
}
std::vector<uint8_t> out(
(size_t)(
source_object.size() + (field_object ? field_object->size() : 0)),
(uint8_t)0);
uint8_t* write_ptr = out.data();
// we must inject the field at the canonical location....
// so find that location
unsigned char* start = (unsigned char*)(source_object.data());
unsigned char* upto = start;
unsigned char* end = start + source_object.size();
unsigned char* inject_start = end;
unsigned char* inject_end = end;
DBG_PRINTF(
"sto_emplace called, looking for field %u type %u\n",
field_id & 0xFFFF,
(field_id >> 16));
for (int j = -5; j < 5; ++j)
DBG_PRINTF((j == 0 ? " >%02X< " : " %02X "), *(start + j));
DBG_PRINTF("\n");
for (int i = 0; i < 1024 && upto < end; ++i)
{
int type = -1, field = -1, payload_start = -1, payload_length = -1;
auto const length = get_stobject_length(
upto, end, type, field, payload_start, payload_length, 0);
if (!length)
return Unexpected(PARSE_ERROR);
if ((type << 16) + field == field_id)
{
inject_start = upto;
inject_end = upto + length.value();
break;
}
else if ((type << 16) + field > field_id)
{
inject_start = upto;
inject_end = upto;
break;
}
upto += length.value();
}
// if the scan loop ends past the end of the source object
// then the source object is invalid/corrupt, so we must
// return an error
if (upto > end)
return Unexpected(PARSE_ERROR);
// upto is injection point
int64_t bytes_written = 0;
// part 1
if (inject_start - start > 0)
{
size_t len = inject_start - start;
memcpy(write_ptr, start, len);
bytes_written += len;
}
if (field_object && field_object->size() > 0)
{
// write the field (or don't if it's a delete operation)
memcpy(
write_ptr + bytes_written,
field_object->data(),
field_object->size());
bytes_written += field_object->size();
}
// part 2
if (end - inject_end > 0)
{
size_t len = end - inject_end;
memcpy(write_ptr + bytes_written, inject_end, len);
bytes_written += len;
}
out.resize(bytes_written);
return out;
}
// sto_erase
/// etxn APIs
Expected<std::shared_ptr<Transaction>, HookReturnCode>
HookAPI::emit(Slice const& txBlob) const
{
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: "
<< transHuman(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 const& 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));
if (!hookCtx.applyCtx.view().rules().enabled(fixHookAPI20251128))
return Transactor::calculateBaseFee(
*(applyCtx.app.openLedger().current()), *stpTrans)
.drops();
return invoke_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);
}
}
Expected<uint64_t, HookReturnCode>
HookAPI::etxn_details(uint8_t* out_ptr) const
{
if (hookCtx.expected_etxn_count <= -1)
return Unexpected(PREREQUISITE_NOT_MET);
uint32_t generation = etxn_generation();
auto const burden_result = etxn_burden();
if (!burden_result)
return Unexpected(FEE_TOO_LARGE);
int64_t burden = burden_result.value();
uint8_t* out = out_ptr;
*out++ = 0xEDU; // begin sfEmitDetails /* upto =
// 0 | size = 1 */
*out++ = 0x20U; // sfEmitGeneration preamble /* upto =
// 1 | size = 6 */
*out++ = 0x2EU; // preamble cont
*out++ = (generation >> 24U) & 0xFFU;
*out++ = (generation >> 16U) & 0xFFU;
*out++ = (generation >> 8U) & 0xFFU;
*out++ = (generation >> 0U) & 0xFFU;
*out++ = 0x3DU; // sfEmitBurden preamble /* upto
// = 7 | size = 9 */
*out++ = (burden >> 56U) & 0xFFU;
*out++ = (burden >> 48U) & 0xFFU;
*out++ = (burden >> 40U) & 0xFFU;
*out++ = (burden >> 32U) & 0xFFU;
*out++ = (burden >> 24U) & 0xFFU;
*out++ = (burden >> 16U) & 0xFFU;
*out++ = (burden >> 8U) & 0xFFU;
*out++ = (burden >> 0U) & 0xFFU;
*out++ = 0x5BU; // sfEmitParentTxnID preamble /* upto
// = 16 | size = 33 */
auto const& txID = hookCtx.applyCtx.tx.getTransactionID();
memcpy(out, txID.data(), 32);
out += 32;
*out++ = 0x5CU; // sfEmitNonce /* upto
// = 49 | size = 33 */
auto hash = etxn_nonce();
if (!hash.has_value())
return INTERNAL_ERROR;
memcpy(out, hash->data(), 32);
out += 32;
*out++ = 0x5DU; // sfEmitHookHash preamble /* upto
// = 82 | size = 33 */
for (int i = 0; i < 32; ++i)
*out++ = hookCtx.result.hookHash.data()[i];
if (hookCtx.result.hasCallback)
{
*out++ = 0x8AU; // sfEmitCallback preamble /*
// upto = 115 | size = 22 */
*out++ = 0x14U; // preamble cont
memcpy(out, hookCtx.result.account.data(), 20);
out += 20;
}
*out++ = 0xE1U; // end object (sfEmitDetails) /* upto =
// 137 | size = 1 */
/* upto = 138 | --------- */
int64_t outlen = out - out_ptr;
return outlen;
}
Expected<uint64_t, HookReturnCode>
HookAPI::etxn_reserve(uint64_t count) const
{
if (hookCtx.expected_etxn_count > -1)
return Unexpected(ALREADY_SET);
if (count < 1)
return Unexpected(TOO_SMALL);
if (count > hook_api::max_emit)
return Unexpected(TOO_BIG);
hookCtx.expected_etxn_count = count;
return count;
}
uint32_t
HookAPI::etxn_generation() const
{
return otxn_generation() + 1;
}
Expected<uint256, HookReturnCode>
HookAPI::etxn_nonce() const
{
if (hookCtx.emit_nonce_counter > hook_api::max_nonce)
return Unexpected(TOO_MANY_NONCES);
// in some cases the same hook might execute multiple times
// on one txn, therefore we need to pass this information to the nonce
uint32_t flags = 0;
flags |= hookCtx.result.isStrong ? 0b10U : 0;
flags |= hookCtx.result.isCallback ? 0b01U : 0;
flags |= (hookCtx.result.hookChainPosition << 2U);
auto hash = ripple::sha512Half(
ripple::HashPrefix::emitTxnNonce,
hookCtx.applyCtx.tx.getTransactionID(),
hookCtx.emit_nonce_counter++,
hookCtx.result.account,
hookCtx.result.hookHash,
flags);
hookCtx.nonce_used[hash] = true;
return hash;
}
/// float APIs
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);
return float_multiply_internal_parts(man1, exp1, neg1, man2, exp2, neg2);
}
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<Bytes, HookReturnCode>
HookAPI::float_sto(
std::optional<Currency> currency,
std::optional<AccountID> issuer,
uint64_t float1,
uint32_t field_code,
uint32_t write_len) const
{
uint16_t field = field_code & 0xFFFFU;
uint16_t type = field_code >> 16U;
bool is_xrp = field_code == 0;
bool is_short =
field_code == 0xFFFFFFFFU; // non-xrp value but do not output header or
// tail, just amount
int bytes_needed = 8 +
(field == 0 && type == 0
? 0
: (field == 0xFFFFU && type == 0xFFFFU
? 0
: (field < 16 && type < 16
? 1
: (field >= 16 && type < 16
? 2
: (field < 16 && type >= 16 ? 2 : 3)))));
if (issuer && !currency)
return Unexpected(INVALID_ARGUMENT);
if (!issuer && currency)
return Unexpected(INVALID_ARGUMENT);
if (issuer)
{
if (is_xrp)
return Unexpected(INVALID_ARGUMENT);
if (is_short)
return Unexpected(INVALID_ARGUMENT);
bytes_needed += 40;
}
else if (!is_xrp && !is_short)
return Unexpected(INVALID_ARGUMENT);
if (bytes_needed > write_len)
return Unexpected(TOO_SMALL);
Bytes vec(bytes_needed);
uint8_t* write_ptr = vec.data();
if (is_xrp || is_short)
{
// do nothing
}
else if (field < 16 && type < 16)
{
*write_ptr++ = (((uint8_t)type) << 4U) + ((uint8_t)field);
}
else if (field >= 16 && type < 16)
{
*write_ptr++ = (((uint8_t)type) << 4U);
*write_ptr++ = ((uint8_t)field);
}
else if (field < 16 && type >= 16)
{
*write_ptr++ = (((uint8_t)field) << 4U);
*write_ptr++ = ((uint8_t)type);
}
else
{
*write_ptr++ = 0;
*write_ptr++ = ((uint8_t)type);
*write_ptr++ = ((uint8_t)field);
}
uint64_t man = get_mantissa(float1).value();
int32_t exp = get_exponent(float1).value();
bool neg = is_negative(float1);
uint8_t out[8];
if (is_xrp)
{
int32_t shift = -(exp);
if (shift > 15)
// https://github.com/Xahau/xahaud/issues/586
return Unexpected(XFL_OVERFLOW);
if (shift < 0)
return Unexpected(XFL_OVERFLOW);
if (shift > 0)
man /= power_of_ten[shift];
out[0] = (neg ? 0b00000000U : 0b01000000U);
out[0] += (uint8_t)((man >> 56U) & 0b111111U);
out[1] = (uint8_t)((man >> 48U) & 0xFF);
out[2] = (uint8_t)((man >> 40U) & 0xFF);
out[3] = (uint8_t)((man >> 32U) & 0xFF);
out[4] = (uint8_t)((man >> 24U) & 0xFF);
out[5] = (uint8_t)((man >> 16U) & 0xFF);
out[6] = (uint8_t)((man >> 8U) & 0xFF);
out[7] = (uint8_t)((man >> 0U) & 0xFF);
}
else if (man == 0)
{
out[0] = 0b10000000U;
for (int i = 1; i < 8; ++i)
out[i] = 0;
}
else
{
exp += 97;
/// encode the rippled floating point sto format
out[0] = (neg ? 0b10000000U : 0b11000000U);
out[0] += (uint8_t)(exp >> 2U);
out[1] = ((uint8_t)(exp & 0b11U)) << 6U;
out[1] += (((uint8_t)(man >> 48U)) & 0b111111U);
out[2] = (uint8_t)((man >> 40U) & 0xFFU);
out[3] = (uint8_t)((man >> 32U) & 0xFFU);
out[4] = (uint8_t)((man >> 24U) & 0xFFU);
out[5] = (uint8_t)((man >> 16U) & 0xFFU);
out[6] = (uint8_t)((man >> 8U) & 0xFFU);
out[7] = (uint8_t)((man >> 0U) & 0xFFU);
}
std::memcpy(write_ptr, out, 8);
write_ptr += 8;
if (!is_xrp && !is_short)
{
std::memcpy(write_ptr, currency->data(), 20);
write_ptr += 20;
std::memcpy(write_ptr, issuer->data(), 20);
}
return vec;
}
Expected<uint64_t, HookReturnCode>
HookAPI::float_sto_set(Bytes const& data) const
{
uint8_t* upto = const_cast<uint8_t*>(data.data());
uint8_t length = data.size();
if (length > 8)
{
uint8_t hi = upto[0] >> 4U;
uint8_t lo = upto[0] & 0xFU;
if (hi == 0 && lo == 0)
{
// typecode >= 16 && fieldcode >= 16
if (length < 11)
return Unexpected(NOT_AN_OBJECT);
upto += 3;
length -= 3;
}
else if (hi == 0 || lo == 0)
{
// typecode >= 16 && fieldcode < 16
if (length < 10)
return Unexpected(NOT_AN_OBJECT);
upto += 2;
length -= 2;
}
else
{
// typecode < 16 && fieldcode < 16
upto++;
length--;
}
}
if (length < 8)
return Unexpected(NOT_AN_OBJECT);
bool is_xrp = (((*upto) & 0b10000000U) == 0);
bool is_negative = (((*upto) & 0b01000000U) == 0);
int32_t exponent = 0;
if (is_xrp)
{
// exponent remains 0
upto++;
}
else
{
exponent = (((*upto++) & 0b00111111U)) << 2U;
exponent += ((*upto) >> 6U);
exponent -= 97;
}
uint64_t mantissa = (((uint64_t)(*upto++)) & 0b00111111U) << 48U;
mantissa += ((uint64_t)*upto++) << 40U;
mantissa += ((uint64_t)*upto++) << 32U;
mantissa += ((uint64_t)*upto++) << 24U;
mantissa += ((uint64_t)*upto++) << 16U;
mantissa += ((uint64_t)*upto++) << 8U;
mantissa += ((uint64_t)*upto++);
if (mantissa == 0)
return 0;
return hook_float::normalize_xfl(mantissa, exponent, is_negative);
}
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);
}
/// otxn APIs
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;
}
Expected<const STBase*, HookReturnCode>
HookAPI::otxn_field(uint32_t field_id) const
{
SField const& fieldType = ripple::SField::getField(field_id);
if (fieldType == sfInvalid)
return Unexpected(INVALID_FIELD);
if (!hookCtx.applyCtx.tx.isFieldPresent(fieldType))
return Unexpected(DOESNT_EXIST);
auto const& field = hookCtx.emitFailure
? hookCtx.emitFailure->getField(fieldType)
: const_cast<ripple::STTx&>(hookCtx.applyCtx.tx).getField(fieldType);
return &field;
}
Expected<uint256, HookReturnCode>
HookAPI::otxn_id(uint32_t flags) const
{
auto const& txID =
(hookCtx.emitFailure && !flags
? hookCtx.applyCtx.tx.getFieldH256(sfTransactionHash)
: hookCtx.applyCtx.tx.getTransactionID());
return txID;
}
TxType
HookAPI::otxn_type() const
{
if (hookCtx.emitFailure)
return safe_cast<TxType>(
hookCtx.emitFailure->getFieldU16(sfTransactionType));
return hookCtx.applyCtx.tx.getTxnType();
}
Expected<uint32_t, HookReturnCode>
HookAPI::otxn_slot(uint32_t slot_into) const
{
if (slot_into > hook_api::max_slots)
return Unexpected(INVALID_ARGUMENT);
// check if we can emplace the object to a slot
if (slot_into == 0 && no_free_slots())
return Unexpected(NO_FREE_SLOTS);
if (slot_into == 0)
{
if (auto found = get_free_slot(); found)
slot_into = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
auto const& st_tx = std::make_shared<ripple::STObject>(
hookCtx.emitFailure ? *(hookCtx.emitFailure)
: const_cast<ripple::STTx&>(hookCtx.applyCtx.tx)
.downcast<ripple::STObject>());
hookCtx.slot[slot_into] = hook::SlotEntry{.storage = st_tx, .entry = 0};
hookCtx.slot[slot_into].entry = &(*hookCtx.slot[slot_into].storage);
return slot_into;
}
Expected<Blob, HookReturnCode>
HookAPI::otxn_param(Bytes const& param_name) const
{
if (param_name.size() < 1)
return Unexpected(TOO_SMALL);
if (param_name.size() > 32)
return Unexpected(TOO_BIG);
if (!hookCtx.applyCtx.tx.isFieldPresent(sfHookParameters))
return Unexpected(DOESNT_EXIST);
auto const& params = hookCtx.applyCtx.tx.getFieldArray(sfHookParameters);
for (auto const& param : params)
{
if (!param.isFieldPresent(sfHookParameterName) ||
param.getFieldVL(sfHookParameterName) != param_name)
continue;
if (!param.isFieldPresent(sfHookParameterValue))
return Unexpected(DOESNT_EXIST);
auto const& val = param.getFieldVL(sfHookParameterValue);
if (val.empty())
return Unexpected(DOESNT_EXIST);
return val;
}
return Unexpected(DOESNT_EXIST);
}
/// hook APIs
AccountID
HookAPI::hook_account() const
{
return hookCtx.result.account;
}
Expected<ripple::uint256, HookReturnCode>
HookAPI::hook_hash(int32_t hook_no) const
{
if (hook_no == -1)
return hookCtx.result.hookHash;
std::shared_ptr<SLE> hookSLE =
hookCtx.applyCtx.view().peek(hookCtx.result.hookKeylet);
if (!hookSLE || !hookSLE->isFieldPresent(sfHooks))
return Unexpected(INTERNAL_ERROR);
ripple::STArray const& hooks = hookSLE->getFieldArray(sfHooks);
if (hook_no >= hooks.size())
return Unexpected(DOESNT_EXIST);
auto const& hook = hooks[hook_no];
if (!hook.isFieldPresent(sfHookHash))
return Unexpected(DOESNT_EXIST);
return hook.getFieldH256(sfHookHash);
}
Expected<int64_t, HookReturnCode>
HookAPI::hook_again() const
{
if (hookCtx.result.executeAgainAsWeak)
return Unexpected(ALREADY_SET);
if (hookCtx.result.isStrong)
{
hookCtx.result.executeAgainAsWeak = true;
return 1;
}
return Unexpected(PREREQUISITE_NOT_MET);
}
Expected<Blob, HookReturnCode>
HookAPI::hook_param(Bytes const& paramName) const
{
if (paramName.size() < 1)
return Unexpected(TOO_SMALL);
if (paramName.size() > 32)
return Unexpected(TOO_BIG);
// first check for overrides set by prior hooks in the chain
auto const& overrides = hookCtx.result.hookParamOverrides;
if (overrides.find(hookCtx.result.hookHash) != overrides.end())
{
auto const& params = overrides.at(hookCtx.result.hookHash);
if (params.find(paramName) != params.end())
{
auto const& param = params.at(paramName);
if (param.size() == 0)
// allow overrides to "delete" parameters
return Unexpected(DOESNT_EXIST);
return param;
}
}
// next check if there's a param set on this hook
auto const& params = hookCtx.result.hookParams;
if (params.find(paramName) != params.end())
{
auto const& param = params.at(paramName);
if (param.size() == 0)
return Unexpected(DOESNT_EXIST);
return param;
}
return Unexpected(DOESNT_EXIST);
}
Expected<uint64_t, HookReturnCode>
HookAPI::hook_param_set(
uint256 const& hash,
Bytes const& paramName,
Bytes const& paramValue) const
{
if (paramName.size() < 1)
return Unexpected(TOO_SMALL);
if (paramName.size() > hook::maxHookParameterKeySize())
return Unexpected(TOO_BIG);
if (paramValue.size() > hook::maxHookParameterValueSize())
return Unexpected(TOO_BIG);
if (hookCtx.result.overrideCount >= hook_api::max_params)
return Unexpected(TOO_MANY_PARAMS);
hookCtx.result.overrideCount++;
auto& overrides = hookCtx.result.hookParamOverrides;
if (overrides.find(hash) == overrides.end())
{
overrides[hash] = std::map<Bytes, Bytes>{
{std::move(paramName), std::move(paramValue)}};
}
else
overrides[hash][std::move(paramName)] = std::move(paramValue);
return paramValue.size();
}
Expected<uint64_t, HookReturnCode>
HookAPI::hook_skip(uint256 const& hash, uint32_t flags) const
{
if (flags != 0 && flags != 1)
return Unexpected(INVALID_ARGUMENT);
auto& skips = hookCtx.result.hookSkips;
if (flags == 1)
{
// delete flag
if (skips.find(hash) == skips.end())
return Unexpected(DOESNT_EXIST);
skips.erase(hash);
return 1;
}
// first check if it's already in the skips set
if (skips.find(hash) != skips.end())
return 1;
// next check if it's even in this chain
std::shared_ptr<SLE> hookSLE =
hookCtx.applyCtx.view().peek(hookCtx.result.hookKeylet);
if (!hookSLE || !hookSLE->isFieldPresent(sfHooks))
return Unexpected(INTERNAL_ERROR);
ripple::STArray const& hooks = hookSLE->getFieldArray(sfHooks);
bool found = false;
for (auto const& hookObj : hooks)
{
if (hookObj.isFieldPresent(sfHookHash))
{
if (hookObj.getFieldH256(sfHookHash) == hash)
{
found = true;
break;
}
}
}
if (!found)
return Unexpected(DOESNT_EXIST);
// finally add it to the skips list
hookCtx.result.hookSkips.emplace(hash);
return 1;
}
uint8_t
HookAPI::hook_pos() const
{
return hookCtx.result.hookChainPosition;
}
/// ledger APIs
uint64_t
HookAPI::fee_base() const
{
return hookCtx.applyCtx.view().fees().base.drops();
}
uint32_t
HookAPI::ledger_seq() const
{
return hookCtx.applyCtx.view().info().seq;
}
uint256
HookAPI::ledger_last_hash() const
{
return hookCtx.applyCtx.view().info().parentHash;
}
uint64_t
HookAPI::ledger_last_time() const
{
return hookCtx.applyCtx.view()
.info()
.parentCloseTime.time_since_epoch()
.count();
}
Expected<uint256, HookReturnCode>
HookAPI::ledger_nonce() const
{
auto& view = hookCtx.applyCtx.view();
if (hookCtx.ledger_nonce_counter > hook_api::max_nonce)
return Unexpected(TOO_MANY_NONCES);
auto hash = ripple::sha512Half(
ripple::HashPrefix::hookNonce,
view.info().seq,
view.info().parentCloseTime.time_since_epoch().count(),
view.info().parentHash,
hookCtx.applyCtx.tx.getTransactionID(),
hookCtx.ledger_nonce_counter++,
hookCtx.result.account);
return hash;
}
Expected<Keylet, HookReturnCode>
HookAPI::ledger_keylet(Keylet const& klLo, Keylet const& klHi) const
{
// keylets must be the same type!
if (klLo.type != klHi.type)
return Unexpected(DOES_NOT_MATCH);
std::optional<ripple::uint256> found =
hookCtx.applyCtx.view().succ(klLo.key, klHi.key.next());
if (!found)
return Unexpected(DOESNT_EXIST);
Keylet kl_out{klLo.type, *found};
return kl_out;
}
/// state APIs
// state
Expected<Bytes, HookReturnCode>
HookAPI::state_foreign(
uint256 const& key,
uint256 const& ns,
AccountID const& account) const
{
// first check if the requested state was previously cached this session
auto cacheEntryLookup = lookup_state_cache(account, ns, key);
if (cacheEntryLookup)
{
auto const& cacheEntry = cacheEntryLookup->get();
return cacheEntry.second;
}
auto hsSLE =
hookCtx.applyCtx.view().peek(keylet::hookState(account, key, ns));
if (!hsSLE)
return Unexpected(DOESNT_EXIST);
Blob b = hsSLE->getFieldVL(sfHookStateData);
// it exists add it to cache and return it
if (!set_state_cache(account, ns, key, b, false).has_value())
return Unexpected(INTERNAL_ERROR); // should never happen
return b;
}
// state_set
Expected<uint64_t, HookReturnCode>
HookAPI::state_foreign_set(
uint256 const& key,
uint256 const& ns,
AccountID const& account,
Bytes& data) const
{
// local modifications are always allowed
if (account == hookCtx.result.account)
{
if (auto ret = set_state_cache(account, ns, key, data, true);
!ret.has_value())
return ret.error();
return data.size();
}
// execution to here means it's actually a foreign set
if (hookCtx.result.foreignStateSetDisabled)
return Unexpected(PREVIOUS_FAILURE_PREVENTS_RETRY);
// first check if we've already modified this state
auto cacheEntry = lookup_state_cache(account, ns, key);
if (cacheEntry && cacheEntry->get().first)
{
// if a cache entry already exists and it has already been modified
// don't check grants again
if (auto ret = set_state_cache(account, ns, key, data, true);
!ret.has_value())
return ret.error();
return data.size();
}
// cache miss or cache was present but entry was not marked as previously
// modified therefore before continuing we need to check grants
auto const sle =
hookCtx.applyCtx.view().read(ripple::keylet::hook(account));
if (!sle)
return Unexpected(INTERNAL_ERROR);
bool found_auth = false;
// we do this by iterating the hooks installed on the foreign account and in
// turn their grants and namespaces
auto const& hooks = sle->getFieldArray(sfHooks);
for (auto const& hookObj : hooks)
{
// skip blank entries
if (!hookObj.isFieldPresent(sfHookHash))
continue;
if (!hookObj.isFieldPresent(sfHookGrants))
continue;
auto const& hookGrants = hookObj.getFieldArray(sfHookGrants);
if (hookGrants.size() < 1)
continue;
// the grant allows the hook to modify the granter's namespace only
if (hookObj.isFieldPresent(sfHookNamespace))
{
if (hookObj.getFieldH256(sfHookNamespace) != ns)
continue;
}
else
{
// fetch the hook definition
auto const def =
hookCtx.applyCtx.view().read(ripple::keylet::hookDefinition(
hookObj.getFieldH256(sfHookHash)));
if (!def) // should never happen except in a rare race condition
continue;
if (def->getFieldH256(sfHookNamespace) != ns)
continue;
}
// this is expensive search so we'll disallow after one failed attempt
for (auto const& hookGrantObj : hookGrants)
{
bool hasAuthorizedField = hookGrantObj.isFieldPresent(sfAuthorize);
if (hookGrantObj.getFieldH256(sfHookHash) ==
hookCtx.result.hookHash &&
(!hasAuthorizedField ||
hookGrantObj.getAccountID(sfAuthorize) ==
hookCtx.result.account))
{
found_auth = true;
break;
}
}
if (found_auth)
break;
}
if (!found_auth)
{
// hook only gets one attempt
hookCtx.result.foreignStateSetDisabled = true;
return Unexpected(NOT_AUTHORIZED);
}
if (auto ret = set_state_cache(account, ns, key, data, true);
!ret.has_value())
return ret.error();
return data.size();
}
/// slot APIs
Expected<const STBase*, HookReturnCode>
HookAPI::slot(uint32_t slot_no) const
{
if (hookCtx.slot.find(slot_no) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (hookCtx.slot[slot_no].entry == 0)
return Unexpected(INTERNAL_ERROR);
return hookCtx.slot[slot_no].entry;
}
Expected<uint64_t, HookReturnCode>
HookAPI::slot_clear(uint32_t slot_no) const
{
if (hookCtx.slot.find(slot_no) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
hookCtx.slot.erase(slot_no);
hookCtx.slot_free.push(slot_no);
return 1;
}
Expected<uint64_t, HookReturnCode>
HookAPI::slot_count(uint32_t slot_no) const
{
if (hookCtx.slot.find(slot_no) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (hookCtx.slot[slot_no].entry == 0)
return Unexpected(INTERNAL_ERROR);
if (hookCtx.slot[slot_no].entry->getSType() != STI_ARRAY)
return Unexpected(NOT_AN_ARRAY);
return hookCtx.slot[slot_no].entry->downcast<ripple::STArray>().size();
}
Expected<uint32_t, HookReturnCode>
HookAPI::slot_set(Bytes const& data, uint32_t slot_no) const
{
if ((data.size() != 32 && data.size() != 34) ||
slot_no > hook_api::max_slots)
return Unexpected(INVALID_ARGUMENT);
if (slot_no == 0 && no_free_slots())
return Unexpected(NO_FREE_SLOTS);
std::optional<std::shared_ptr<const ripple::STObject>> slot_value =
std::nullopt;
if (data.size() == 34)
{
std::optional<ripple::Keylet> kl = unserialize_keylet(data);
if (!kl)
return Unexpected(DOESNT_EXIST);
if (kl->key == beast::zero)
return Unexpected(DOESNT_EXIST);
auto const sle = hookCtx.applyCtx.view().read(*kl);
if (!sle)
return Unexpected(DOESNT_EXIST);
slot_value = sle;
}
else if (data.size() == 32)
{
uint256 hash = uint256::fromVoid(data.data());
ripple::error_code_i ec{ripple::error_code_i::rpcUNKNOWN};
auto hTx = hookCtx.applyCtx.app.getMasterTransaction().fetch(hash, ec);
if (auto const* p = std::get_if<std::pair<
std::shared_ptr<ripple::Transaction>,
std::shared_ptr<ripple::TxMeta>>>(&hTx))
slot_value = p->first->getSTransaction();
else
return Unexpected(DOESNT_EXIST);
}
else
return Unexpected(INVALID_ARGUMENT);
if (!slot_value.has_value())
return Unexpected(DOESNT_EXIST);
if (slot_no == 0)
{
if (auto found = get_free_slot(); found)
slot_no = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
hookCtx.slot[slot_no] = hook::SlotEntry{.storage = *slot_value, .entry = 0};
hookCtx.slot[slot_no].entry = &(*hookCtx.slot[slot_no].storage);
return slot_no;
}
Expected<uint64_t, HookReturnCode>
HookAPI::slot_size(uint32_t slot_no) const
{
if (hookCtx.slot.find(slot_no) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (hookCtx.slot[slot_no].entry == 0)
return Unexpected(INTERNAL_ERROR);
// RH TODO: this is a very expensive way of computing size, cache it
Serializer s;
hookCtx.slot[slot_no].entry->add(s);
return s.getDataLength();
}
Expected<uint32_t, HookReturnCode>
HookAPI::slot_subarray(
uint32_t parent_slot,
uint32_t array_id,
uint32_t new_slot) const
{
if (hookCtx.slot.find(parent_slot) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (hookCtx.slot[parent_slot].entry == 0)
return Unexpected(INTERNAL_ERROR);
if (hookCtx.slot[parent_slot].entry->getSType() != STI_ARRAY)
return Unexpected(NOT_AN_ARRAY);
if (new_slot == 0 && no_free_slots())
return Unexpected(NO_FREE_SLOTS);
if (new_slot > hook_api::max_slots)
return Unexpected(INVALID_ARGUMENT);
bool copied = false;
try
{
ripple::STArray& parent_obj =
const_cast<ripple::STBase&>(*hookCtx.slot[parent_slot].entry)
.downcast<ripple::STArray>();
if (parent_obj.size() <= array_id)
return Unexpected(DOESNT_EXIST);
if (new_slot == 0)
{
if (auto found = get_free_slot(); found)
new_slot = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
// copy
if (new_slot != parent_slot)
{
copied = true;
hookCtx.slot[new_slot] = hookCtx.slot[parent_slot];
}
hookCtx.slot[new_slot].entry = &(parent_obj[array_id]);
return new_slot;
}
catch (const std::bad_cast& e)
{
if (copied)
{
hookCtx.slot.erase(new_slot);
hookCtx.slot_free.push(new_slot);
}
return Unexpected(NOT_AN_ARRAY);
}
return new_slot;
}
Expected<uint32_t, HookReturnCode>
HookAPI::slot_subfield(
uint32_t parent_slot,
uint32_t field_id,
uint32_t new_slot) const
{
if (hookCtx.slot.find(parent_slot) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (new_slot == 0 && no_free_slots())
return Unexpected(NO_FREE_SLOTS);
if (new_slot > hook_api::max_slots)
return Unexpected(INVALID_ARGUMENT);
SField const& fieldCode = ripple::SField::getField(field_id);
if (fieldCode == sfInvalid)
return Unexpected(INVALID_FIELD);
if (hookCtx.slot[parent_slot].entry == 0)
return Unexpected(INTERNAL_ERROR);
bool copied = false;
try
{
ripple::STObject& parent_obj =
const_cast<ripple::STBase&>(*hookCtx.slot[parent_slot].entry)
.downcast<ripple::STObject>();
if (!parent_obj.isFieldPresent(fieldCode))
return Unexpected(DOESNT_EXIST);
if (new_slot == 0)
{
if (auto found = get_free_slot(); found)
new_slot = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
// copy
if (new_slot != parent_slot)
{
copied = true;
hookCtx.slot[new_slot] = hookCtx.slot[parent_slot];
}
hookCtx.slot[new_slot].entry = &(parent_obj.getField(fieldCode));
return new_slot;
}
catch (const std::bad_cast& e)
{
if (copied)
{
hookCtx.slot.erase(new_slot);
hookCtx.slot_free.push(new_slot);
}
return Unexpected(NOT_AN_OBJECT);
}
}
Expected<std::variant<STBase, STAmount>, HookReturnCode>
HookAPI::slot_type(uint32_t slot_no, uint32_t flags) const
{
if (hookCtx.slot.find(slot_no) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (hookCtx.slot[slot_no].entry == 0)
return Unexpected(INTERNAL_ERROR);
try
{
ripple::STBase& obj = const_cast<ripple::STBase&>(
*hookCtx.slot[slot_no].entry); //.downcast<ripple::STBase>();
if (flags == 0)
return obj;
// this flag is for use with an amount field to determine if the amount
// is native (xrp)
if (flags == 1)
{
if (obj.getSType() != STI_AMOUNT)
return Unexpected(NOT_AN_AMOUNT);
return const_cast<ripple::STBase&>(*hookCtx.slot[slot_no].entry)
.downcast<ripple::STAmount>();
}
return Unexpected(INVALID_ARGUMENT);
}
catch (const std::bad_cast& e)
{
return Unexpected(INTERNAL_ERROR);
}
}
Expected<uint64_t, HookReturnCode>
HookAPI::slot_float(uint32_t slot_no) const
{
if (hookCtx.slot.find(slot_no) == hookCtx.slot.end())
return Unexpected(DOESNT_EXIST);
if (hookCtx.slot[slot_no].entry == 0)
return Unexpected(INTERNAL_ERROR);
try
{
ripple::STAmount& st_amt =
const_cast<ripple::STBase&>(*hookCtx.slot[slot_no].entry)
.downcast<ripple::STAmount>();
int64_t normalized = 0;
if (st_amt.native())
{
ripple::XRPAmount amt = st_amt.xrp();
int64_t drops = amt.drops();
int32_t exp = -6;
// normalize
auto const ret = hook_float::normalize_xfl(drops, exp);
if (!ret)
{
if (ret.error() == EXPONENT_UNDERSIZED)
return 0;
return Unexpected(ret.error());
}
normalized = ret.value();
}
else
{
ripple::IOUAmount amt = st_amt.iou();
auto const ret = make_float(amt);
if (!ret)
{
if (ret.error() == EXPONENT_UNDERSIZED)
return 0;
return Unexpected(ret.error());
}
normalized = ret.value();
}
if (normalized == EXPONENT_UNDERSIZED)
/* exponent undersized (underflow) */
return 0; // return 0 in this case
return normalized;
}
catch (const std::bad_cast& e)
{
return Unexpected(NOT_AN_AMOUNT);
}
}
/// trace APIs
// trace
// trace_num
// trace_float
Expected<uint32_t, HookReturnCode>
HookAPI::meta_slot(uint32_t slot_into) const
{
if (!hookCtx.result.provisionalMeta)
return Unexpected(PREREQUISITE_NOT_MET);
if (slot_into > hook_api::max_slots)
return Unexpected(INVALID_ARGUMENT);
// check if we can emplace the object to a slot
if (slot_into == 0 && no_free_slots())
return Unexpected(NO_FREE_SLOTS);
if (slot_into == 0)
{
if (auto found = get_free_slot(); found)
slot_into = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
hookCtx.slot[slot_into] =
hook::SlotEntry{.storage = hookCtx.result.provisionalMeta, .entry = 0};
hookCtx.slot[slot_into].entry = &(*hookCtx.slot[slot_into].storage);
return slot_into;
}
Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
HookAPI::xpop_slot(uint32_t slot_into_tx, uint32_t slot_into_meta) const
{
if (hookCtx.applyCtx.tx.getFieldU16(sfTransactionType) != ttIMPORT)
return Unexpected(PREREQUISITE_NOT_MET);
if (slot_into_tx > hook_api::max_slots ||
slot_into_meta > hook_api::max_slots)
return Unexpected(INVALID_ARGUMENT);
size_t free_count = hook_api::max_slots - hookCtx.slot.size();
size_t needed_count = slot_into_tx == 0 && slot_into_meta == 0
? 2
: slot_into_tx != 0 && slot_into_meta != 0 ? 0 : 1;
if (free_count < needed_count)
return Unexpected(NO_FREE_SLOTS);
// if they supply the same slot number for both (other than 0)
// they will produce a collision
if (needed_count == 0 && slot_into_tx == slot_into_meta)
return Unexpected(INVALID_ARGUMENT);
if (slot_into_tx == 0)
{
if (no_free_slots())
return Unexpected(NO_FREE_SLOTS);
if (auto found = get_free_slot(); found)
slot_into_tx = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
if (slot_into_meta == 0)
{
if (no_free_slots())
return Unexpected(NO_FREE_SLOTS);
if (auto found = get_free_slot(); found)
slot_into_meta = *found;
else
return Unexpected(NO_FREE_SLOTS);
}
auto [tx, meta] =
Import::getInnerTxn(hookCtx.applyCtx.tx, hookCtx.applyCtx.journal);
if (!tx || !meta)
return Unexpected(INVALID_TXN);
hookCtx.slot[slot_into_tx] =
hook::SlotEntry{.storage = std::move(tx), .entry = 0};
hookCtx.slot[slot_into_tx].entry = &(*hookCtx.slot[slot_into_tx].storage);
hookCtx.slot[slot_into_meta] =
hook::SlotEntry{.storage = std::move(meta), .entry = 0};
hookCtx.slot[slot_into_meta].entry =
&(*hookCtx.slot[slot_into_meta].storage);
return std::make_pair(slot_into_tx, slot_into_meta);
}
/// private
inline int32_t
HookAPI::no_free_slots() const
{
return hook_api::max_slots - hookCtx.slot.size() <= 0;
}
inline std::optional<int32_t>
HookAPI::get_free_slot() const
{
// allocate a slot
int32_t slot_into = 0;
if (hookCtx.slot_free.size() > 0)
{
slot_into = hookCtx.slot_free.front();
hookCtx.slot_free.pop();
return slot_into;
}
// no slots were available in the queue so increment slot counter until we
// find a free slot usually this will be the next available but the hook
// developer may have allocated any slot ahead of when the counter gets
// there
do
{
slot_into = ++hookCtx.slot_counter;
} while (hookCtx.slot.find(slot_into) != hookCtx.slot.end() &&
// this condition should always be met, if for some reason, somehow
// it is not then we will return the final slot every time.
hookCtx.slot_counter <= hook_api::max_slots);
if (hookCtx.slot_counter > hook_api::max_slots)
return {};
return slot_into;
}
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 Unexpected(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 Unexpected(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;
}
std::optional<ripple::Keylet>
HookAPI::unserialize_keylet(Bytes const& data) const
{
if (data.size() != 34)
return {};
uint16_t ktype = ((uint16_t)data[0] << 8) + ((uint16_t)data[1]);
return ripple::Keylet{
static_cast<LedgerEntryType>(ktype),
ripple::uint256::fromVoid(data.data() + 2)};
}
inline std::optional<
std::reference_wrapper<std::pair<bool, ripple::Blob> const>>
HookAPI::lookup_state_cache(
AccountID const& acc,
uint256 const& ns,
uint256 const& key) const
{
auto& stateMap = hookCtx.result.stateMap;
if (stateMap.find(acc) == stateMap.end())
return std::nullopt;
auto& stateMapAcc = std::get<3>(stateMap[acc]);
if (stateMapAcc.find(ns) == stateMapAcc.end())
return std::nullopt;
auto& stateMapNs = stateMapAcc[ns];
auto const& ret = stateMapNs.find(key);
if (ret == stateMapNs.end())
return std::nullopt;
return std::cref(ret->second);
}
// update the state cache
inline Expected<uint64_t, HookReturnCode>
HookAPI::set_state_cache(
AccountID const& acc,
uint256 const& ns,
uint256 const& key,
Bytes const& data,
bool modified) const
{
auto& stateMap = hookCtx.result.stateMap;
auto& view = hookCtx.applyCtx.view();
if (modified && stateMap.modified_entry_count >= max_state_modifications)
return Unexpected(TOO_MANY_STATE_MODIFICATIONS);
bool const createNamespace = view.rules().enabled(fixXahauV1) &&
!view.exists(keylet::hookStateDir(acc, ns));
if (stateMap.find(acc) == stateMap.end())
{
// if this is the first time this account has been interacted with
// we will compute how many available reserve positions there are
auto const& fees = hookCtx.applyCtx.view().fees();
auto const accSLE = view.read(ripple::keylet::account(acc));
if (!accSLE)
return Unexpected(DOESNT_EXIST);
STAmount bal = accSLE->getFieldAmount(sfBalance);
uint16_t const hookStateScale = accSLE->isFieldPresent(sfHookStateScale)
? accSLE->getFieldU16(sfHookStateScale)
: 1;
int64_t availableForReserves = bal.xrp().drops() -
fees.accountReserve(accSLE->getFieldU32(sfOwnerCount)).drops();
int64_t increment = fees.increment.drops();
if (increment <= 0)
increment = 1;
availableForReserves /= increment;
if (availableForReserves < hookStateScale && modified)
return Unexpected(RESERVE_INSUFFICIENT);
int64_t namespaceCount = accSLE->isFieldPresent(sfHookNamespaces)
? accSLE->getFieldV256(sfHookNamespaces).size()
: 0;
if (createNamespace)
{
// overflow should never ever happen but check anyway
if (namespaceCount + 1 < namespaceCount)
return Unexpected(INTERNAL_ERROR);
if (++namespaceCount > hook::maxNamespaces())
return Unexpected(TOO_MANY_NAMESPACES);
}
stateMap.modified_entry_count++;
// sanity check
if (view.rules().enabled(featureExtendedHookState) &&
availableForReserves < hookStateScale)
return Unexpected(INTERNAL_ERROR);
stateMap[acc] = {
availableForReserves - hookStateScale,
namespaceCount,
hookStateScale,
{{ns, {{key, {modified, data}}}}}};
return 1;
}
auto& availableForReserves = std::get<0>(stateMap[acc]);
auto& namespaceCount = std::get<1>(stateMap[acc]);
auto& hookStateScale = std::get<2>(stateMap[acc]);
auto& stateMapAcc = std::get<3>(stateMap[acc]);
bool const canReserveNew = availableForReserves >= hookStateScale;
if (stateMapAcc.find(ns) == stateMapAcc.end())
{
if (modified)
{
if (!canReserveNew)
return Unexpected(RESERVE_INSUFFICIENT);
if (createNamespace)
{
// overflow should never ever happen but check anyway
if (namespaceCount + 1 < namespaceCount)
return Unexpected(INTERNAL_ERROR);
if (namespaceCount + 1 > hook::maxNamespaces())
return Unexpected(TOO_MANY_NAMESPACES);
namespaceCount++;
}
if (view.rules().enabled(featureExtendedHookState) &&
availableForReserves < hookStateScale)
return Unexpected(INTERNAL_ERROR);
availableForReserves -= hookStateScale;
stateMap.modified_entry_count++;
}
stateMapAcc[ns] = {{key, {modified, data}}};
return 1;
}
auto& stateMapNs = stateMapAcc[ns];
if (stateMapNs.find(key) == stateMapNs.end())
{
if (modified)
{
if (!canReserveNew)
return Unexpected(RESERVE_INSUFFICIENT);
if (view.rules().enabled(featureExtendedHookState) &&
availableForReserves < hookStateScale)
return Unexpected(INTERNAL_ERROR);
availableForReserves -= hookStateScale;
stateMap.modified_entry_count++;
}
stateMapNs[key] = {modified, data};
hookCtx.result.changedStateCount++;
return 1;
}
if (modified)
{
if (!stateMapNs[key].first)
hookCtx.result.changedStateCount++;
stateMap.modified_entry_count++;
stateMapNs[key].first = true;
}
stateMapNs[key].second = data;
return 1;
}
// RH NOTE this is a light-weight stobject parsing function for drilling into a
// provided serialzied object however it could probably be replaced by an
// existing class or routine or set of routines in XRPLD Returns object length
// including header bytes (and footer bytes in the event of array or object)
// negative indicates error
inline Expected<
int32_t,
HookAPI::parse_error>
HookAPI::get_stobject_length(
unsigned char* start, // in - begin iterator
unsigned char* maxptr, // in - end iterator
int& type, // out - populated by serialized type code
int& field, // out - populated by serialized field code
int& payload_start, // out - the start of actual payload data for this type
int& payload_length, // out - the length of actual payload data for this
// type
int recursion_depth) // used internally
const
{
if (recursion_depth > 10)
return Unexpected(pe_excessive_nesting);
unsigned char* end = maxptr;
unsigned char* upto = start;
int high = *upto >> 4;
int low = *upto & 0xF;
upto++;
if (upto >= end)
return Unexpected(pe_unexpected_end);
if (high > 0 && low > 0)
{
// common type common field
type = high;
field = low;
}
else if (high > 0)
{
// common type, uncommon field
type = high;
field = *upto++;
}
else if (low > 0)
{
// common field, uncommon type
field = low;
type = *upto++;
}
else
{
// uncommon type and field
type = *upto++;
if (upto >= end)
return Unexpected(pe_unexpected_end);
field = *upto++;
}
DBG_PRINTF(
"%d get_st_object found field %d type %d\n",
recursion_depth,
field,
type);
if (upto >= end)
return Unexpected(pe_unexpected_end);
// RH TODO: link this to rippled's internal STObject constants
// E.g.:
/*
int field_code = (safe_cast<int>(type) << 16) | field;
auto const& fieldObj = ripple::SField::getField;
*/
if (type < 1 || type > 19 || (type >= 9 && type <= 13))
return Unexpected(pe_unknown_type_early);
bool is_vl =
(type == SerializedTypeID::STI_ACCOUNT ||
type == SerializedTypeID::STI_VL ||
type == SerializedTypeID::STI_PATHSET ||
type == SerializedTypeID::STI_VECTOR256);
int length = -1;
if (is_vl)
{
length = *upto++;
if (upto >= end)
return Unexpected(pe_unexpected_end);
if (length < 193)
{
// do nothing
}
else if (length > 192 && length < 241)
{
length -= 193;
length *= 256;
length += *upto++ + 193;
if (upto > end)
return Unexpected(pe_unexpected_end);
}
else
{
int b2 = *upto++;
if (upto >= end)
return Unexpected(pe_unexpected_end);
length -= 241;
length *= 65536;
length += 12481 + (b2 * 256) + *upto++;
if (upto >= end)
return Unexpected(pe_unexpected_end);
}
}
else if ((type >= 1 && type <= 5) || type == 16 || type == 17)
{
switch (type)
{
case SerializedTypeID::STI_UINT16:
length = 2;
break;
case SerializedTypeID::STI_UINT32:
length = 4;
break;
case SerializedTypeID::STI_UINT64:
length = 8;
break;
case SerializedTypeID::STI_UINT128:
length = 16;
break;
case SerializedTypeID::STI_UINT256:
length = 32;
break;
case SerializedTypeID::STI_UINT8:
length = 1;
break;
case SerializedTypeID::STI_UINT160:
length = 20;
break;
default:
length = -1;
break;
}
}
else if (type == SerializedTypeID::STI_AMOUNT)
{
length = (*upto >> 6 == 1) ? 8 : 48;
if (upto >= end)
return Unexpected(pe_unexpected_end);
}
if (length > -1)
{
payload_start = upto - start;
payload_length = length;
DBG_PRINTF(
"%d get_stobject_length field: %d Type: %d VL: %s Len: %d "
"Payload_Start: %d Payload_Len: %d\n",
recursion_depth,
field,
type,
(is_vl ? "yes" : "no"),
length,
payload_start,
payload_length);
return length + (upto - start);
}
if (type == SerializedTypeID::STI_OBJECT ||
type == SerializedTypeID::STI_ARRAY)
{
payload_start = upto - start;
for (int i = 0; i < 1024; ++i)
{
int subfield = -1, subtype = -1, payload_start_ = -1,
payload_length_ = -1;
auto const sublength = get_stobject_length(
upto,
end,
subtype,
subfield,
payload_start_,
payload_length_,
recursion_depth + 1);
DBG_PRINTF(
"%d get_stobject_length i %d %d-%d, upto %d sublength %d\n",
recursion_depth,
i,
subtype,
subfield,
upto - start,
sublength);
if (!sublength)
return Unexpected(pe_unexpected_end);
upto += sublength.value();
if (upto >= end)
return Unexpected(pe_unexpected_end);
if ((*upto == 0xE1U && type == 0xEU) ||
(*upto == 0xF1U && type == 0xFU))
{
payload_length = upto - start - payload_start;
upto++;
return (upto - start);
}
}
return Unexpected(pe_excessive_size);
}
return Unexpected(pe_unknown_type_late);
};
} // namespace hook
Reference in New Issue View Git Blame Copy Permalink