account/RegistrationTransaction.hpp

Transaction for child-wallet registration. More...

Namespaces

Name
sgns

Classes

	Name
class	sgns::RegistrationTransaction Transaction for child-wallet registration under a main wallet.

Detailed Description

Transaction for child-wallet registration.

Date: 2026-07-15 (Phase 4)

Source code

#ifndef _REGISTRATION_TRANSACTION_HPP_
#define _REGISTRATION_TRANSACTION_HPP_

#include "account/GeniusTransaction.hpp"
#include "account/proto/SGTransaction.pb.h"

namespace sgns
{
    class RegistrationTransaction final : public GeniusTransaction
    {
    public:
        static RegistrationTransaction New( std::string                    main_address,
                                            uint64_t                      sequence,
                                            SGTransaction::RegistrationMetadata metadata,
                                            SGTransaction::DAGStruct      dag,
                                            bool                          detach_flag = false,
                                            uint64_t                      supersedes_sequence = 0 );

        ~RegistrationTransaction() override = default;

        using GeniusTransaction::SerializeByteVector;
        std::vector<uint8_t> SerializeByteVector( const SGTransaction::DAGStruct &dag ) const override;

        using GeniusTransaction::SerializeToEmbeddedTransaction;
        EmbeddedTransaction SerializeToEmbeddedTransaction( const SGTransaction::DAGStruct &dag ) const override;

        static std::shared_ptr<RegistrationTransaction> DeSerializeByteVector( const std::vector<uint8_t> &data );

        const std::string &GetMainAddress() const
        {
            return main_address_;
        }

        uint64_t GetSequence() const
        {
            return sequence_;
        }

        const SGTransaction::RegistrationMetadata &GetMetadata() const
        {
            return metadata_;
        }

        bool GetDetachFlag() const
        {
            return detach_flag_;
        }

        uint64_t GetSupersedesSequence() const
        {
            return supersedes_sequence_;
        }

        std::string GetTransactionSpecificPath() const override
        {
            return GetType();
        }

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

    private:
        RegistrationTransaction( std::string                          main_address,
                                 uint64_t                             sequence,
                                 SGTransaction::RegistrationMetadata  metadata,
                                 SGTransaction::DAGStruct             dag,
                                 bool                                 detach_flag,
                                 uint64_t                             supersedes_sequence );

        std::string                         main_address_;  
        uint64_t                            sequence_;      
        SGTransaction::RegistrationMetadata metadata_;      
        bool                                detach_flag_;         
        uint64_t                            supersedes_sequence_; 

        static bool Register()
        {
            RegisterDeserializer( "registration", &RegistrationTransaction::DeSerializeByteVector );
            return true;
        }

        static inline bool registered = Register();
    };

}

#endif

---

Updated on 2026-09-17 at 06:29:15 +0000