PreimageSha256.h

#pragma once
 
#include <xrpl/basics/Buffer.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/conditions/Condition.h>
#include <xrpl/conditions/Fulfillment.h>
#include <xrpl/conditions/detail/error.h>
#include <xrpl/protocol/digest.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <system_error>
#include <utility>
 
namespace xrpl::cryptoconditions {
 
class PreimageSha256 final : public Fulfillment
{
public:
    static constexpr std::size_t kMaxPreimageLength = 128;

    static std::unique_ptr<Fulfillment>
    deserialize(Slice s, std::error_code& ec)
    {
        // Per the RFC, a preimage fulfillment is defined as
        // follows:
        //
        // PreimageFulfillment ::= SEQUENCE {
        //     preimage             OCTET STRING
        // }
 
        using namespace der;
 
        auto p = parsePreamble(s, ec);
        if (ec)
            return nullptr;
 
        if (!isPrimitive(p) || !isContextSpecific(p))
        {
            ec = Error::IncorrectEncoding;
            return {};
        }
 
        if (p.tag != 0)
        {
            ec = Error::UnexpectedTag;
            return {};
        }
 
        if (s.size() != p.length)
        {
            ec = Error::TrailingGarbage;
            return {};
        }
 
        if (s.size() > kMaxPreimageLength)
        {
            ec = Error::PreimageTooLong;
            return {};
        }
 
        auto b = parseOctetString(s, p.length, ec);
        if (ec)
            return {};
 
        return std::make_unique<PreimageSha256>(std::move(b));
    }
 
private:
    Buffer payload_;
 
public:
    PreimageSha256(Buffer&& b) noexcept : payload_(std::move(b))
    {
    }
 
    PreimageSha256(Slice s) noexcept : payload_(s)
    {
    }
 
    [[nodiscard]] Type
    type() const override
    {
        return Type::PreimageSha256;
    }
 
    [[nodiscard]] Buffer
    fingerprint() const override
    {
        sha256_hasher h;
        h(payload_.data(), payload_.size());
        auto const d = static_cast<sha256_hasher::result_type>(h);
        return {d.data(), d.size()};
    }
 
    [[nodiscard]] std::uint32_t
    cost() const override
    {
        return static_cast<std::uint32_t>(payload_.size());
    }
 
    [[nodiscard]] Condition
    condition() const override
    {
        return {type(), cost(), fingerprint()};
    }
 
    [[nodiscard]] bool
    validate(Slice) const override
    {
        // Perhaps counterintuitively, the message isn't
        // relevant.
        return true;
    }
};
 
}  // namespace xrpl::cryptoconditions