src/account/IGeniusTransactions.hpp

Transaction interface class. More...

Namespaces

Name
sgns

Classes

	Name
class	sgns::IGeniusTransactions

Detailed Description

Transaction interface class.

Date: 2024-03-11 Henrique A. Klein ([email protected])

Source code

#ifndef _IGENIUS_TRANSACTIONS_HPP_
#define _IGENIUS_TRANSACTIONS_HPP_

#include <utility>
#include <vector>
#include <string>

#include <boost/format.hpp>

#include "outcome/outcome.hpp"
#include "account/proto/SGTransaction.pb.h"
#include "GeniusAccount.hpp"

#include <gsl/span>

namespace sgns
{
    using namespace boost::multiprecision;

    //class GeniusBlockHeader; //TODO - Design new header or rework old one

    class IGeniusTransactions
    {
    public:
        using TransactionDeserializeFn =
            std::function<std::shared_ptr<IGeniusTransactions>( const std::vector<uint8_t> & )>;

        IGeniusTransactions( std::string type, SGTransaction::DAGStruct dag ) :
            dag_st( std::move( dag ) ), transaction_type( std::move( type ) )
        {
        }

        virtual ~IGeniusTransactions() = default;

        [[nodiscard]] std::string GetType() const
        {
            return transaction_type;
        }

        static outcome::result<SGTransaction::DAGStruct> DeSerializeDAGStruct( const std::vector<uint8_t> &data );
        static outcome::result<SGTransaction::DAGStruct> DeSerializeDAGStruct( const std::string &data );

        static SGTransaction::DAGStruct SetDAGWithType( SGTransaction::DAGStruct dag, const std::string &type )
        {
            dag.set_type( type );
            return dag;
        }

        virtual std::vector<uint8_t> SerializeByteVector() = 0;

        virtual std::string GetTransactionSpecificPath() const = 0;

        static std::string GetTransactionFullPath( const std::string &tx_hash )
        {
            return "tx/" + tx_hash;
        }

        std::string GetTransactionFullPath() const
        {
            return "tx/" + GetHash();
        }

        std::string GetProofFullPath() const
        {
            return "proof/" + GetHash();
        }

        std::string GetSrcAddress() const
        {
            return dag_st.source_addr();
        }

        std::string GetHash() const;

        uint64_t GetTimestamp() const
        {
            return dag_st.timestamp();
        }

        virtual std::unordered_set<std::string> GetTopics() const;

        void FillHash();
        bool CheckHash();

        std::vector<uint8_t> MakeSignature( GeniusAccount &account );
        bool                 CheckSignature();
        bool                 CheckDAGSignatureLegacy();

        SGTransaction::DAGStruct dag_st;

    private:
        static inline std::unordered_map<std::string, TransactionDeserializeFn> deserializers_map;
        const std::string                                                       transaction_type;

    public:
        static void RegisterDeserializer( const std::string &transaction_type, TransactionDeserializeFn fn )
        {
            deserializers_map[transaction_type] = std::move( fn );
        }

        static std::unordered_map<std::string, TransactionDeserializeFn> &GetDeSerializers()
        {
            return deserializers_map;
        }
    };
}

#endif

---

Updated on 2026-03-04 at 13:10:44 -0800