account/InputValidators.hpp

Input validation strategy interface for transaction inputs. More...

Namespaces

Name
sgns
sgns::input_validator_constants

Classes

	Name
class	sgns::IInputValidator Strategy interface for validating transaction inputs and their witness data.

Attributes

	Name
constexpr size_t	HASH256_BYTES
constexpr size_t	SERIALIZED_UINT32_BYTES
constexpr size_t	SERIALIZED_UINT64_BYTES
constexpr size_t	OUTPUT_INDEX_OFFSET
constexpr size_t	OWNER_ADDRESS_LENGTH_OFFSET
constexpr size_t	OWNER_ADDRESS_OFFSET
constexpr size_t	TOKEN_ID_BYTES_IN_PAYLOAD
constexpr size_t	AMOUNT_BYTES_IN_PAYLOAD
constexpr uint32_t	ESCROW_LOCK_OUTPUT_INDEX
constexpr std::string_view	TRANSFER_TX_TYPE

Detailed Description

Input validation strategy interface for transaction inputs.

Date: 2026-03-23 Henrique A. Klein ([email protected])

Attributes Documentation

variable HASH256_BYTES

constexpr size_t HASH256_BYTES = base::Hash256::size();

variable SERIALIZED_UINT32_BYTES

constexpr size_t SERIALIZED_UINT32_BYTES = sizeof( uint32_t );

variable SERIALIZED_UINT64_BYTES

constexpr size_t SERIALIZED_UINT64_BYTES = sizeof( uint64_t );

variable OUTPUT_INDEX_OFFSET

constexpr size_t OUTPUT_INDEX_OFFSET = HASH256_BYTES;

variable OWNER_ADDRESS_LENGTH_OFFSET

constexpr size_t OWNER_ADDRESS_LENGTH_OFFSET = OUTPUT_INDEX_OFFSET + SERIALIZED_UINT32_BYTES;

variable OWNER_ADDRESS_OFFSET

constexpr size_t OWNER_ADDRESS_OFFSET = OWNER_ADDRESS_LENGTH_OFFSET + SERIALIZED_UINT32_BYTES;

variable TOKEN_ID_BYTES_IN_PAYLOAD

constexpr size_t TOKEN_ID_BYTES_IN_PAYLOAD = HASH256_BYTES;

variable AMOUNT_BYTES_IN_PAYLOAD

constexpr size_t AMOUNT_BYTES_IN_PAYLOAD = SERIALIZED_UINT64_BYTES;

variable ESCROW_LOCK_OUTPUT_INDEX

constexpr uint32_t ESCROW_LOCK_OUTPUT_INDEX = 0;

variable TRANSFER_TX_TYPE

constexpr std::string_view TRANSFER_TX_TYPE = "transfer";

Source code

#ifndef SGNS_INPUT_VALIDATORS_HPP
#define SGNS_INPUT_VALIDATORS_HPP

#include <cstddef>
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>

#include "account/UTXOStructs.hpp"
#include "base/blob.hpp"

namespace sgns
{
    namespace input_validator_constants
    {
        constexpr size_t HASH256_BYTES               = base::Hash256::size();
        constexpr size_t SERIALIZED_UINT32_BYTES     = sizeof( uint32_t );
        constexpr size_t SERIALIZED_UINT64_BYTES     = sizeof( uint64_t );
        constexpr size_t OUTPUT_INDEX_OFFSET         = HASH256_BYTES;
        constexpr size_t OWNER_ADDRESS_LENGTH_OFFSET = OUTPUT_INDEX_OFFSET + SERIALIZED_UINT32_BYTES;
        constexpr size_t OWNER_ADDRESS_OFFSET        = OWNER_ADDRESS_LENGTH_OFFSET + SERIALIZED_UINT32_BYTES;
        constexpr size_t TOKEN_ID_BYTES_IN_PAYLOAD   = HASH256_BYTES;
        constexpr size_t AMOUNT_BYTES_IN_PAYLOAD     = SERIALIZED_UINT64_BYTES;

        constexpr uint32_t         ESCROW_LOCK_OUTPUT_INDEX = 0;
        constexpr std::string_view TRANSFER_TX_TYPE         = "transfer";
    } // namespace input_validator_constants

    class Blockchain;
    class ConsensusSubject;
    class GeniusTransaction;
    class UTXOManager;

    class IInputValidator
    {
    public:
        virtual ~IInputValidator() = default;

        virtual bool ValidateUTXOParameters( const UTXOTxParameters &params,
                                             const std::string      &address,
                                             const UTXOManager      &utxo_manager ) const = 0;

        virtual bool ValidateWitness( const ConsensusSubject                     &subject,
                                      const std::shared_ptr<GeniusTransaction> &tx,
                                      const UTXOTxParameters                     &params,
                                      const std::shared_ptr<Blockchain>          &blockchain ) const = 0;

        virtual bool RequiresConsensusUTXOData() const = 0;

        using ValidatorPtr = const IInputValidator *;

        static bool Register( const std::string &chain_id, ValidatorPtr validator )
        {
            if ( validator == nullptr )
            {
                return false;
            }

            auto &state = registryState();
            std::lock_guard<std::mutex> lock( state.mutex );
            return state.validators.emplace( chain_id, validator ).second;
        }

        static void UnregisterIf( const std::string &chain_id, ValidatorPtr expected )
        {
            auto &state = registryState();
            std::lock_guard<std::mutex> lock( state.mutex );
            auto it = state.validators.find( chain_id );
            if ( it != state.validators.end() && it->second == expected )
            {
                state.validators.erase( it );
            }
        }

        static ValidatorPtr Get( const std::string &chain_id )
        {
            auto &state = registryState();
            std::lock_guard<std::mutex> lock( state.mutex );
            auto it = state.validators.find( chain_id );
            return it != state.validators.end() ? it->second : nullptr;
        }

    private:
        struct RegistryState
        {
            std::mutex                                    mutex;
            std::unordered_map<std::string, ValidatorPtr> validators;
        };

        static RegistryState &registryState()
        {
            static RegistryState state;
            return state;
        }
    };
} // namespace sgns

#endif // SGNS_INPUT_VALIDATORS_HPP

---

Updated on 2026-08-14 at 19:28:59 +0000