refactor: Make getLedgerIndex return std::expected instead of throwing (#2788)

Co-authored-by: Ayaz Salikhov <mathbunnyru@users.noreply.github.com>
Co-authored-by: Sergey Kuznetsov <kuzzz99@gmail.com>

src/rpc/handlers/AMMInfo.cpp

@@ -316,8 +316,11 @@ tag_invoke(boost::json::value_to_tag<AMMInfoHandler::Input>, boost::json::value
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(asset)))
         input.issue1 = parseIssue(jsonObject.at(JS(asset)).as_object());

src/rpc/handlers/AccountChannels.cpp

@@ -154,8 +154,11 @@ tag_invoke(boost::json::value_to_tag<AccountChannelsHandler::Input>, boost::json
     if (jsonObject.contains(JS(destination_account)))
         input.destinationAccount = boost::json::value_to<std::string>(jv.at(JS(destination_account)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/AccountCurrencies.cpp

@@ -128,8 +128,11 @@ tag_invoke(boost::json::value_to_tag<AccountCurrenciesHandler::Input>, boost::js
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/AccountInfo.cpp

@@ -204,8 +204,11 @@ tag_invoke(boost::json::value_to_tag<AccountInfoHandler::Input>, boost::json::va
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(signer_lists)))
         input.signerLists = boost::json::value_to<JsonBool>(jsonObject.at(JS(signer_lists)));

src/rpc/handlers/AccountLines.cpp

@@ -215,8 +215,11 @@ tag_invoke(boost::json::value_to_tag<AccountLinesHandler::Input>, boost::json::v
     if (jsonObject.contains(JS(ignore_default)))
         input.ignoreDefault = jv.at(JS(ignore_default)).as_bool();
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/AccountMPTokenIssuances.cpp

@@ -164,8 +164,11 @@ tag_invoke(boost::json::value_to_tag<AccountMPTokenIssuancesHandler::Input>, boo
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/AccountMPTokens.cpp

@@ -139,8 +139,11 @@ tag_invoke(boost::json::value_to_tag<AccountMPTokensHandler::Input>, boost::json
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/AccountNFTs.cpp

@@ -157,8 +157,11 @@ tag_invoke(boost::json::value_to_tag<AccountNFTsHandler::Input>, boost::json::va
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(limit)))
         input.limit = util::integralValueAs<uint32_t>(jsonObject.at(JS(limit)));

src/rpc/handlers/AccountObjects.cpp

@@ -153,8 +153,11 @@ tag_invoke(boost::json::value_to_tag<AccountObjectsHandler::Input>, boost::json:
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(type))) {
         input.type =

src/rpc/handlers/AccountOffers.cpp

@@ -169,8 +169,11 @@ tag_invoke(boost::json::value_to_tag<AccountOffersHandler::Input>, boost::json::
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(limit)))
         input.limit = util::integralValueAs<uint32_t>(jsonObject.at(JS(limit)));

src/rpc/handlers/AccountTx.cpp

@@ -258,8 +258,10 @@ tag_invoke(boost::json::value_to_tag<AccountTxHandler::Input>, boost::json::valu
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
     if (jsonObject.contains(JS(ledger_index))) {
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
-        if (not input.ledgerIndex.has_value()) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value()) {
+            input.ledgerIndex = *expectedLedgerIndex;
+        } else {
             // could not get the latest validated ledger seq here, using this flag to indicate that
             input.usingValidatedLedger = true;
         }

src/rpc/handlers/BookChanges.cpp

@@ -90,8 +90,11 @@ tag_invoke(boost::json::value_to_tag<BookChangesHandler::Input>, boost::json::va
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/BookOffers.cpp

@@ -122,8 +122,11 @@ tag_invoke(boost::json::value_to_tag<BookOffersHandler::Input>, boost::json::val
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(taker)))
         input.taker = accountFromStringStrict(boost::json::value_to<std::string>(jv.at(JS(taker))));

src/rpc/handlers/DepositAuthorized.cpp

@@ -145,8 +145,11 @@ tag_invoke(boost::json::value_to_tag<DepositAuthorizedHandler::Input>, boost::js
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(credentials)))
         input.credentials = boost::json::value_to<boost::json::array>(jv.at(JS(credentials)));

src/rpc/handlers/Feature.cpp

@@ -168,8 +168,11 @@ tag_invoke(boost::json::value_to_tag<FeatureHandler::Input>, boost::json::value
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/GatewayBalances.cpp

@@ -249,8 +249,11 @@ tag_invoke(boost::json::value_to_tag<GatewayBalancesHandler::Input>, boost::json
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(hotwallet))) {
         if (jsonObject.at(JS(hotwallet)).is_string()) {

src/rpc/handlers/GetAggregatePrice.cpp

@@ -263,8 +263,11 @@ tag_invoke(boost::json::value_to_tag<GetAggregatePriceHandler::Input>, boost::js
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     for (auto const& oracle : jsonObject.at(JS(oracles)).as_array()) {
         input.oracles.push_back(

src/rpc/handlers/Ledger.cpp

@@ -208,8 +208,11 @@ tag_invoke(boost::json::value_to_tag<LedgerHandler::Input>, boost::json::value c
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(transactions)))
         input.transactions = jv.at(JS(transactions)).as_bool();

src/rpc/handlers/LedgerData.cpp

@@ -210,8 +210,11 @@ tag_invoke(boost::json::value_to_tag<LedgerDataHandler::Input>, boost::json::val
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(type)))
         input.type = util::LedgerTypes::getLedgerEntryTypeFromStr(boost::json::value_to<std::string>(jv.at(JS(type))));

src/rpc/handlers/LedgerEntry.cpp

@@ -305,8 +305,11 @@ tag_invoke(boost::json::value_to_tag<LedgerEntryHandler::Input>, boost::json::va
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(binary)))
         input.binary = jv.at(JS(binary)).as_bool();

src/rpc/handlers/MPTHolders.cpp

@@ -124,8 +124,11 @@ tag_invoke(boost::json::value_to_tag<MPTHoldersHandler::Input>, boost::json::val
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = jsonObject.at(JS(ledger_hash)).as_string().c_str();
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(limit)))
         input.limit = util::integralValueAs<uint32_t>(jsonObject.at(JS(limit)));

src/rpc/handlers/NFTHistory.cpp

@@ -215,8 +215,11 @@ tag_invoke(boost::json::value_to_tag<NFTHistoryHandler::Input>, boost::json::val
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(binary)))
         input.binary = jsonObject.at(JS(binary)).as_bool();

src/rpc/handlers/NFTInfo.cpp

@@ -115,8 +115,11 @@ tag_invoke(boost::json::value_to_tag<NFTInfoHandler::Input>, boost::json::value
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/NFTOffersCommon.cpp

@@ -194,8 +194,11 @@ tag_invoke(boost::json::value_to_tag<NFTOffersHandlerBase::Input>, boost::json::
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(marker)))
         input.marker = boost::json::value_to<std::string>(jsonObject.at(JS(marker)));

src/rpc/handlers/NFTsByIssuer.cpp

@@ -136,8 +136,11 @@ tag_invoke(boost::json::value_to_tag<NFTsByIssuerHandler::Input>, boost::json::v
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     if (jsonObject.contains(JS(limit)))
         input.limit = util::integralValueAs<uint32_t>(jsonObject.at(JS(limit)));

src/rpc/handlers/NoRippleCheck.cpp

@@ -196,8 +196,11 @@ tag_invoke(boost::json::value_to_tag<NoRippleCheckHandler::Input>, boost::json::
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jsonObject.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/TransactionEntry.cpp

@@ -109,8 +109,11 @@ tag_invoke(boost::json::value_to_tag<TransactionEntryHandler::Input>, boost::jso
     if (jsonObject.contains(JS(ledger_hash)))
         input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jv.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/rpc/handlers/VaultInfo.cpp

@@ -177,8 +177,11 @@ tag_invoke(boost::json::value_to_tag<VaultInfoHandler::Input>, boost::json::valu
     if (jsonObject.contains(JS(vault_id)))
         input.vaultID = jsonObject.at(JS(vault_id)).as_string();
 
-    if (jsonObject.contains(JS(ledger_index)))
-        input.ledgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        auto const expectedLedgerIndex = util::getLedgerIndex(jsonObject.at(JS(ledger_index)));
+        if (expectedLedgerIndex.has_value())
+            input.ledgerIndex = *expectedLedgerIndex;
+    }
 
     return input;
 }

src/util/JsonUtils.hpp

@@ -23,10 +23,13 @@
 
 #include <boost/json.hpp>
 #include <boost/json/object.hpp>
+#include <xrpl/beast/core/LexicalCast.h>
 
 #include <algorithm>
 #include <cctype>
+#include <charconv>
 #include <concepts>
+#include <expected>
 #include <stdexcept>
 #include <string>
 
@@ -96,12 +99,11 @@ removeSecret(boost::json::object const& object)
  *
  * @tparam Type The type to cast to
  * @param value The JSON value to cast
- * @return Value casted to the requested type
- * @throws logic_error if the underlying number is neither int64 nor uint64
+ * @return Value casted to the requested type or an error message
  */
 template <std::integral Type>
-Type
-integralValueAs(boost::json::value const& value)
+std::expected<Type, std::string>
+tryIntegralValueAs(boost::json::value const& value)
 {
     if (value.is_uint64())
         return static_cast<Type>(value.as_uint64());
@@ -109,29 +111,49 @@ integralValueAs(boost::json::value const& value)
     if (value.is_int64())
         return static_cast<Type>(value.as_int64());
 
-    throw std::logic_error("Value neither uint64 nor int64");
+    return std::unexpected("Value neither uint64 nor int64");
+}
+
+/**
+ * @brief Detects the type of number stored in value and casts it back to the requested Type.
+ * @note This conversion can possibly cause wrapping around or UB. Use with caution.
+ *
+ * @tparam Type The type to cast to
+ * @param value The JSON value to cast
+ * @return Value casted to the requested type
+ * @throws logic_error if the underlying number is neither int64 nor uint64
+ */
+template <std::integral Type>
+Type
+integralValueAs(boost::json::value const& value)
+{
+    auto expectedResult = tryIntegralValueAs<Type>(value);
+    if (expectedResult.has_value())
+        return *expectedResult;
+
+    throw std::logic_error(std::move(expectedResult).error());
 }
 
 /**
  * @brief Extracts ledger index from a JSON value which can be either a number or a string.
  *
  * @param value The JSON value to extract ledger index from
- * @return An optional containing the ledger index if it is a number; std::nullopt otherwise
- * @throws logic_error comes from integralValueAs if the underlying number is neither int64 nor uint64
- * @throws std::invalid_argument or std::out_of_range if the string cannot be converted to a number
+ * @return The extracted ledger index or an error message
  */
-[[nodiscard]] inline std::optional<uint32_t>
+[[nodiscard]] inline std::expected<uint32_t, std::string>
 getLedgerIndex(boost::json::value const& value)
 {
-    std::optional<uint32_t> ledgerIndex;
-
     if (not value.is_string()) {
-        ledgerIndex = util::integralValueAs<uint32_t>(value);
+        return tryIntegralValueAs<uint32_t>(value);
     } else if (value.as_string() != "validated") {
-        ledgerIndex = std::stoi(value.as_string().c_str());
+        uint32_t ledgerIndex{};
+        if (beast::lexicalCastChecked(ledgerIndex, value.as_string().c_str()))
+            return ledgerIndex;
+        else
+            return std::unexpected("Invalid ledger index string");
+    } else {
+        return std::unexpected("'validated' ledger index is requested");
     }
-
-    return ledgerIndex;
 }
 
 }  // namespace util

tests/unit/JsonUtilTests.cpp

@@ -18,6 +18,7 @@
 //==============================================================================
 
 #include "util/JsonUtils.hpp"
+#include "util/NameGenerator.hpp"
 
 #include <boost/json/parse.hpp>
 #include <boost/json/value.hpp>
@@ -90,28 +91,123 @@ TEST(JsonUtils, integralValueAs)
     EXPECT_THROW(util::integralValueAs<int>(stringJson), std::logic_error);
 }
 
-TEST(JsonUtils, getLedgerIndex)
+TEST(JsonUtils, tryIntegralValueAs)
 {
-    auto const emptyJson = boost::json::value();
-    EXPECT_THROW(std::ignore = util::getLedgerIndex(emptyJson), std::logic_error);
+    auto const expectedResultUint64 = static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) + 1u;
+    auto const uint64Json = boost::json::value(expectedResultUint64);
 
-    auto const boolJson = boost::json::value(true);
-    EXPECT_THROW(std::ignore = util::getLedgerIndex(emptyJson), std::logic_error);
+    auto const expectedResultInt64 = static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1u;
+    auto const int64Json = boost::json::value(expectedResultInt64);
 
-    auto const numberJson = boost::json::value(12345);
-    auto ledgerIndex = util::getLedgerIndex(numberJson);
-    EXPECT_TRUE(ledgerIndex.has_value());
-    EXPECT_EQ(ledgerIndex.value(), 12345u);
+    auto checkHasValue = [&](boost::json::value const& jv, auto const& expectedValue) {
+        using T = std::remove_cvref_t<decltype(expectedValue)>;
+        auto const res = util::tryIntegralValueAs<T>(jv);
+        ASSERT_TRUE(res.has_value());
+        EXPECT_EQ(res.value(), expectedValue);
+    };
 
-    auto const validStringJson = boost::json::value("12345");
-    ledgerIndex = util::getLedgerIndex(validStringJson);
-    EXPECT_TRUE(ledgerIndex.has_value());
-    EXPECT_EQ(ledgerIndex.value(), 12345u);
+    auto checkError = [&](boost::json::value const& jv) {
+        auto res = util::tryIntegralValueAs<int>(jv);
+        EXPECT_FALSE(res.has_value());
+        EXPECT_EQ(res.error(), "Value neither uint64 nor int64");
+    };
 
-    auto const invalidStringJson = boost::json::value("invalid123");
-    EXPECT_THROW(std::ignore = util::getLedgerIndex(invalidStringJson), std::invalid_argument);
+    // checks for uint64Json
+    checkHasValue(uint64Json, std::numeric_limits<int32_t>::min());
+    checkHasValue(uint64Json, static_cast<uint32_t>(expectedResultUint64));
+    checkHasValue(uint64Json, static_cast<int64_t>(expectedResultUint64));
+    checkHasValue(uint64Json, expectedResultUint64);
 
-    auto const validatedJson = boost::json::value("validated");
-    ledgerIndex = util::getLedgerIndex(validatedJson);
-    EXPECT_FALSE(ledgerIndex.has_value());
+    // checks for int64Json
+    checkHasValue(int64Json, std::numeric_limits<int32_t>::min());
+    checkHasValue(int64Json, static_cast<uint32_t>(expectedResultInt64));
+    checkHasValue(int64Json, expectedResultInt64);
+    checkHasValue(int64Json, static_cast<uint64_t>(expectedResultInt64));
+
+    // non-integral inputs
+    checkError(boost::json::value());
+    checkError(boost::json::value(false));
+    checkError(boost::json::value(3.14));
+    checkError(boost::json::value("not a number"));
+}
+
+struct GetLedgerIndexParameterTestBundle {
+    std::string testName;
+    boost::json::value jv;
+    std::expected<uint32_t, std::string> expectedResult;
+};
+
+// parameterized test cases for parameters check
+struct GetLedgerIndexParameterTest : ::testing::TestWithParam<GetLedgerIndexParameterTestBundle> {};
+
+INSTANTIATE_TEST_CASE_P(
+    JsonUtils,
+    GetLedgerIndexParameterTest,
+    testing::Values(
+        GetLedgerIndexParameterTestBundle{
+            .testName = "EmptyValue",
+            .jv = boost::json::value(),
+            .expectedResult = std::unexpected{"Value neither uint64 nor int64"}
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "BoolValue",
+            .jv = boost::json::value(false),
+            .expectedResult = std::unexpected{"Value neither uint64 nor int64"}
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "NumberValue",
+            .jv = boost::json::value(123),
+            .expectedResult = 123u
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "StringNumberValue",
+            .jv = boost::json::value("123"),
+            .expectedResult = 123u
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "StringNumberWithPlusSignValue",
+            .jv = boost::json::value("+123"),
+            .expectedResult = 123u
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "StringEmptyValue",
+            .jv = boost::json::value(""),
+            .expectedResult = std::unexpected{"Invalid ledger index string"}
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "StringWithLeadingCharsValue",
+            .jv = boost::json::value("123invalid"),
+            .expectedResult = std::unexpected{"Invalid ledger index string"}
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "StringWithTrailingCharsValue",
+            .jv = boost::json::value("invalid123"),
+            .expectedResult = std::unexpected{"Invalid ledger index string"}
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "StringWithLeadingAndTrailingCharsValue",
+            .jv = boost::json::value("123invalid123"),
+            .expectedResult = std::unexpected{"Invalid ledger index string"}
+        },
+        GetLedgerIndexParameterTestBundle{
+            .testName = "ValidatedStringValue",
+            .jv = boost::json::value("validated"),
+            .expectedResult = std::unexpected{"'validated' ledger index is requested"}
+        }
+    ),
+    tests::util::kNAME_GENERATOR
+);
+
+TEST_P(GetLedgerIndexParameterTest, getLedgerIndexParams)
+{
+    auto const& testBundle = GetParam();
+    auto const ledgerIndex = util::getLedgerIndex(testBundle.jv);
+
+    if (testBundle.expectedResult.has_value()) {
+        EXPECT_TRUE(ledgerIndex.has_value());
+        EXPECT_EQ(ledgerIndex.value(), testBundle.expectedResult.value());
+    } else {
+        EXPECT_FALSE(ledgerIndex.has_value());
+        EXPECT_EQ(ledgerIndex.error(), testBundle.expectedResult.error());
+    }
 }