Permissions.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/SOTemplate.h>
#include <xrpl/protocol/TxFormats.h>
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace xrpl {
 
class STTx;

// Macro-generated, complex
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum GranularPermissionType : std::uint32_t {
#pragma push_macro("GRANULAR_PERMISSION")
#undef GRANULAR_PERMISSION
 
#define GRANULAR_PERMISSION(name, txType, value, ...) name = (value),
 
#include <xrpl/protocol/detail/permissions.macro>
 
#undef GRANULAR_PERMISSION
#pragma pop_macro("GRANULAR_PERMISSION")
};
 
// Injected bare enumerators (xrpl::delegable / xrpl::notDelegable) are required by preprocessor
// tricks in tests and macro-generated code; enum class would break that.
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum Delegation { Delegable, NotDelegable };
 
class Permission
{
private:
    Permission();
 
    struct GranularPermissionEntry
    {
        std::string name;
        TxType txType;
        std::uint32_t permittedFlags;
        SOTemplate permittedFields;
 
        GranularPermissionEntry(
            std::string name,
            TxType txType,
            std::uint32_t permittedFlags,
            std::vector<SOElement> fields);
    };
 
    struct TxDelegationEntry
    {
        uint256 amendment;
        Delegation delegable{NotDelegable};
    };
 
    std::unordered_set<TxType> granularTxTypes_;
    std::unordered_map<TxType, TxDelegationEntry> txDelegationMap_;
    std::unordered_map<std::string, GranularPermissionType> granularPermissionsByName_;
    std::unordered_map<GranularPermissionType, GranularPermissionEntry> granularPermissions_;
 
public:
    static Permission const&
    getInstance();
 
    Permission(Permission const&) = delete;
    Permission&
    operator=(Permission const&) = delete;
 
    [[nodiscard]] std::optional<std::string>
    getPermissionName(std::uint32_t value) const;
 
    [[nodiscard]] std::optional<std::uint32_t>
    getGranularValue(std::string const& name) const;
 
    [[nodiscard]] std::optional<std::string>
    getGranularName(GranularPermissionType value) const;
 
    [[nodiscard]] std::optional<TxType>
    getGranularTxType(GranularPermissionType gpType) const;
 
    // Returns a reference to avoid copying uint256 - 32 bytes. std::optional
    // cannot hold references directly, so std::reference_wrapper is used.
    [[nodiscard]] std::optional<std::reference_wrapper<uint256 const>>
    getTxFeature(TxType txType) const;
 
    [[nodiscard]] bool
    isDelegable(std::uint32_t permissionValue, Rules const& rules) const;
 
    [[nodiscard]] bool
    hasGranularPermissions(TxType txType) const;
 
    // for tx level permission, permission value is equal to tx type plus one
    [[nodiscard]] static uint32_t
    txToPermissionType(TxType type);
 
    // tx type value is permission value minus one
    [[nodiscard]] static std::optional<TxType>
    permissionToTxType(std::uint32_t value);

    [[nodiscard]] bool
    checkGranularSandbox(
        STTx const& tx,
        std::unordered_set<GranularPermissionType> const& heldPermissions) const;
};
 
}  // namespace xrpl