feat: Support single asset vault

conanfile.py

@@ -29,7 +29,7 @@ class Clio(ConanFile):
         'protobuf/3.21.9',
         'grpc/1.50.1',
         'openssl/1.1.1v',
-        'xrpl/2.4.0',
+        'xrpl/2.4.0@my/singleAssetVault',
         'zlib/1.3.1',
         'libbacktrace/cci.20210118'
     ]

src/data/AmendmentCenter.hpp

@@ -137,6 +137,7 @@ struct Amendments {
     REGISTER(fixInvalidTxFlags);
     REGISTER(fixFrozenLPTokenTransfer);
     REGISTER(DeepFreeze);
+    REGISTER(SingleAssetVault);
 
     // Obsolete but supported by libxrpl
     REGISTER(CryptoConditionsSuite);

src/rpc/CMakeLists.txt

@@ -46,6 +46,7 @@ target_sources(
           handlers/Subscribe.cpp
           handlers/TransactionEntry.cpp
           handlers/Unsubscribe.cpp
+          handlers/VaultInfo.cpp
 )
 
 target_link_libraries(clio_rpc PRIVATE clio_util)

src/rpc/Errors.cpp

@@ -89,7 +89,7 @@ getErrorInfo(ClioError code)
         {.code = ClioError::RpcMalformedAuthorizedCredentials,
          .error = "malformedAuthorizedCredentials",
          .message = "Malformed authorized credentials."},
-
+        {.code = ClioError::RpcEntryNotFound, .error = "entryNotFound", .message = "Entry Not Found."},
         // special system errors
         {.code = ClioError::RpcInvalidApiVersion, .error = JS(invalid_API_version), .message = "Invalid API version."},
         {.code = ClioError::RpcCommandIsMissing,

src/rpc/Errors.hpp

@@ -43,6 +43,7 @@ enum class ClioError {
     RpcFieldNotFoundTransaction = 5006,
     RpcMalformedOracleDocumentId = 5007,
     RpcMalformedAuthorizedCredentials = 5008,
+    RpcEntryNotFound = 5009,
 
     // special system errors start with 6000
     RpcInvalidApiVersion = 6000,

src/rpc/RPCHelpers.hpp

@@ -28,6 +28,7 @@
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
 #include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
 #include "rpc/common/Types.hpp"
 #include "util/JsonUtils.hpp"
 #include "util/Taggable.hpp"
@@ -42,6 +43,7 @@
 #include <boost/regex/v5/regex_fwd.hpp>
 #include <boost/regex/v5/regex_match.hpp>
 #include <fmt/core.h>
+#include <xrpl/basics/Number.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/AccountID.h>
@@ -50,19 +52,24 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/Rate.h>
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STBase.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Seed.h>
+#include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/TxMeta.h>
 #include <xrpl/protocol/UintTypes.h>
 #include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/protocol/jss.h>
 
 #include <chrono>
 #include <cstddef>

src/rpc/common/impl/HandlerProvider.cpp

@@ -60,6 +60,7 @@
 #include "rpc/handlers/TransactionEntry.hpp"
 #include "rpc/handlers/Tx.hpp"
 #include "rpc/handlers/Unsubscribe.hpp"
+#include "rpc/handlers/VaultInfo.hpp"
 #include "rpc/handlers/VersionHandler.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
 
@@ -113,6 +114,7 @@ ProductionHandlerProvider::ProductionHandlerProvider(
           {"tx", {.handler = TxHandler{backend, etl}}},
           {"subscribe", {.handler = SubscribeHandler{backend, amendmentCenter, subscriptionManager}}},
           {"unsubscribe", {.handler = UnsubscribeHandler{subscriptionManager}}},
+          {"vault_info", {.handler = VaultInfoHandler{backend}}},
           {"version", {.handler = VersionHandler{config}}},
       }
 {

src/rpc/handlers/LedgerEntry.cpp

@@ -185,6 +185,11 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input input, Context const& ctx)
         );
         auto const seq = input.permissionedDomain->at(JS(seq)).as_int64();
         key = ripple::keylet::permissionedDomain(*account, seq).key;
+    } else if (input.vault) {
+        auto const account =
+            ripple::parseBase58<ripple::AccountID>(boost::json::value_to<std::string>(input.vault->at(JS(owner))));
+        auto const seq = input.vault->at(JS(seq)).as_int64();
+        key = ripple::keylet::vault(*account, seq).key;
     } else {
         // Must specify 1 of the following fields to indicate what type
         if (ctx.apiVersion == 1)
@@ -208,13 +213,13 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input input, Context const& ctx)
 
     if (!ledgerObject || ledgerObject->empty()) {
         if (not input.includeDeleted)
-            return Error{Status{"entryNotFound"}};
+            return Error{Status{ClioError::RpcEntryNotFound}};
         auto const deletedSeq = sharedPtrBackend_->fetchLedgerObjectSeq(key, lgrInfo.seq, ctx.yield);
         if (!deletedSeq)
-            return Error{Status{"entryNotFound"}};
+            return Error{Status{ClioError::RpcEntryNotFound}};
         ledgerObject = sharedPtrBackend_->fetchLedgerObject(key, deletedSeq.value() - 1, ctx.yield);
         if (!ledgerObject || ledgerObject->empty())
-            return Error{Status{"entryNotFound"}};
+            return Error{Status{ClioError::RpcEntryNotFound}};
         output.deletedLedgerIndex = deletedSeq;
     }
 
@@ -319,7 +324,8 @@ tag_invoke(boost::json::value_to_tag<LedgerEntryHandler::Input>, boost::json::va
         {JS(oracle), ripple::ltORACLE},
         {JS(credential), ripple::ltCREDENTIAL},
         {JS(mptoken), ripple::ltMPTOKEN},
-        {JS(permissioned_domain), ripple::ltPERMISSIONED_DOMAIN}
+        {JS(permissioned_domain), ripple::ltPERMISSIONED_DOMAIN},
+        {JS(vault), ripple::ltVAULT}
     };
 
     auto const parseBridgeFromJson = [](boost::json::value const& bridgeJson) {
@@ -408,6 +414,8 @@ tag_invoke(boost::json::value_to_tag<LedgerEntryHandler::Input>, boost::json::va
         input.mptoken = jv.at(JS(mptoken)).as_object();
     } else if (jsonObject.contains(JS(permissioned_domain))) {
         input.permissionedDomain = jv.at(JS(permissioned_domain)).as_object();
+    } else if (jsonObject.contains(JS(vault))) {
+        input.vault = jv.at(JS(vault)).as_object();
     }
 
     if (jsonObject.contains("include_deleted"))

src/rpc/handlers/LedgerEntry.hpp

@@ -104,6 +104,7 @@ class LedgerEntryHandler {
         std::optional<boost::json::object> amm;
         std::optional<boost::json::object> mptoken;
         std::optional<boost::json::object> permissionedDomain;
+        std::optional<boost::json::object> vault;
         std::optional<ripple::STXChainBridge> bridge;
         std::optional<std::string> bridgeAccount;
         std::optional<uint32_t> chainClaimId;
@@ -392,6 +393,23 @@ class LedgerEntryHandler {
                      },
                  },
              }}},
+            {JS(vault),
+             meta::WithCustomError{
+                 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
+             },
+             meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
+             meta::IfType<boost::json::object>{meta::Section{
+                 {JS(seq),
+                  meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
+                  meta::WithCustomError{validation::Type<uint32_t>{}, Status(ClioError::RpcMalformedRequest)}},
+                 {
+                     JS(owner),
+                     meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
+                     meta::WithCustomError{
+                         validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedOwner)
+                     },
+                 },
+             }}},
             {JS(ledger), check::Deprecated{}},
             {"include_deleted", validation::Type<bool>{}},
         };

src/rpc/handlers/VaultInfo.cpp

@@ -0,0 +1,181 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "rpc/handlers/VaultInfo.hpp"
+
+#include "data/BackendInterface.hpp"
+#include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
+#include "rpc/RPCHelpers.hpp"
+#include "rpc/common/Types.hpp"
+#include "util/Assert.hpp"
+
+#include <boost/json/conversion.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/value.hpp>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STBase.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/jss.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace rpc {
+
+VaultInfoHandler::VaultInfoHandler(std::shared_ptr<BackendInterface> const& sharedPtrBackend)
+    : sharedPtrBackend_{sharedPtrBackend}
+{
+}
+
+static std::expected<void, ClioError>
+parseVaultField(VaultInfoHandler::Input const& input)
+{
+    auto const hasVaultId = input.vaultID.has_value();
+    auto const hasOwner = input.owner.has_value();
+    auto const hasSeq = input.tnxSequence.has_value();
+
+    // Only valid combinations: (vaultID) or (owner + ledgerIndex)
+    if ((hasVaultId && !hasOwner && !hasSeq) || (!hasVaultId && hasOwner && hasSeq))
+        return {};
+
+    return std::unexpected<ClioError>{ClioError::RpcMalformedRequest};
+}
+
+VaultInfoHandler::Result
+VaultInfoHandler::process(VaultInfoHandler::Input input, Context const& ctx) const
+{
+    // vault info input must either have owner and sequence, or vault_id only.
+    if (auto const res = parseVaultField(input); !res.has_value())
+        return Error{res.error()};
+
+    auto const range = sharedPtrBackend_->fetchLedgerRange();
+    ASSERT(range.has_value(), "VaultInfo's ledger range must be available");
+
+    auto const lgrInfoOrStatus = getLedgerHeaderFromHashOrSeq(
+        *sharedPtrBackend_, ctx.yield, std::nullopt, input.ledgerIndex, range->maxSequence
+    );
+
+    if (auto const status = std::get_if<Status>(&lgrInfoOrStatus))
+        return Error{*status};
+
+    auto const lgrInfo = std::get<ripple::LedgerHeader>(lgrInfoOrStatus);
+
+    // Extract the vault keylet based on input
+    auto const vaultKeylet = [&]() -> std::expected<ripple::Keylet, Status> {
+        if (input.owner && input.tnxSequence) {
+            auto const accountStr = *input.owner;
+            auto const accountID = accountFromStringStrict(accountStr);
+
+            // checks that account exists
+            {
+                auto const accountKeylet = ripple::keylet::account(*accountID);
+                auto const accountLedgerObject =
+                    sharedPtrBackend_->fetchLedgerObject(accountKeylet.key, lgrInfo.seq, ctx.yield);
+
+                if (!accountLedgerObject)
+                    return std::unexpected{Status{ClioError::RpcEntryNotFound}};
+            }
+
+            return ripple::keylet::vault(*accountID, *input.tnxSequence);
+        }
+        ripple::uint256 nodeIndex;
+        if (nodeIndex.parseHex(*input.vaultID))
+            return ripple::keylet::vault(nodeIndex);
+
+        return std::unexpected{Status{ClioError::RpcEntryNotFound}};
+    }();
+
+    if (!vaultKeylet.has_value())
+        return Error{vaultKeylet.error()};
+
+    // Fetch the vault object and it's associated issuance ID
+    auto const vaultLedgerObject =
+        sharedPtrBackend_->fetchLedgerObject(vaultKeylet.value().key, lgrInfo.seq, ctx.yield);
+
+    if (!vaultLedgerObject)
+        return Error{Status{ClioError::RpcEntryNotFound, "vault object not found."}};
+
+    ripple::STLedgerEntry const vaultSle{
+        ripple::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, vaultKeylet.value().key
+    };
+
+    auto const issuanceKeylet = ripple::keylet::mptIssuance(vaultSle[ripple::sfShareMPTID]).key;
+    auto const issuanceObject = sharedPtrBackend_->fetchLedgerObject(issuanceKeylet, lgrInfo.seq, ctx.yield);
+
+    if (!issuanceObject)
+        return Error{Status{ClioError::RpcEntryNotFound, "issuance object not found."}};
+
+    ripple::STLedgerEntry const issuanceSle{
+        ripple::SerialIter{issuanceObject->data(), issuanceObject->size()}, issuanceKeylet
+    };
+
+    // put issuance object into "shares" field of vault object
+    Output response;
+    response.vault = toBoostJson(vaultSle.getJson(ripple::JsonOptions::none));
+    response.vault.as_object()[JS(shares)] = toBoostJson(issuanceSle.getJson(ripple::JsonOptions::none));
+    response.ledgerIndex = lgrInfo.seq;
+
+    return response;
+}
+
+void
+tag_invoke(boost::json::value_from_tag, boost::json::value& jv, VaultInfoHandler::Output const& output)
+{
+    jv = boost::json::object{
+        {JS(ledger_index), output.ledgerIndex}, {JS(validated), output.validated}, {JS(vault), output.vault}
+    };
+}
+
+VaultInfoHandler::Input
+tag_invoke(boost::json::value_to_tag<VaultInfoHandler::Input>, boost::json::value const& jv)
+{
+    auto input = VaultInfoHandler::Input{};
+    auto const& jsonObject = jv.as_object();
+
+    if (jsonObject.contains(JS(owner)))
+        input.owner = jsonObject.at(JS(owner)).as_string();
+
+    if (jsonObject.contains(JS(seq)))
+        input.tnxSequence = static_cast<uint32_t>(jsonObject.at(JS(seq)).as_int64());
+
+    if (jsonObject.contains(JS(vault_id)))
+        input.vaultID = jsonObject.at(JS(vault_id)).as_string();
+
+    if (jsonObject.contains(JS(ledger_index))) {
+        if (!jsonObject.at(JS(ledger_index)).is_string()) {
+            input.ledgerIndex = jsonObject.at(JS(ledger_index)).as_int64();
+        } else if (jsonObject.at(JS(ledger_index)).as_string() != "validated") {
+            input.ledgerIndex = std::stoi(jsonObject.at(JS(ledger_index)).as_string().c_str());
+        }
+    }
+
+    return input;
+}
+
+}  // namespace rpc