account/BurnConfig.hpp

Genesis-seeded, quorum-signed, cache-refresh-via-quorum- re-derivation BURN_BASIS_POINTS value, built entirely on top of SecureCrdt/SecureCrdtRegistry/TrustedPeerRegistry (BURN-01, BURN-02, BURN-03). Direct structural template of TrustedPeerRegistry (Phase 10), replacing TransactionManager's hardcoded BURN_BASIS_POINTS constant. More...

Namespaces

Name
sgns
sgns::account

Classes

	Name
class	sgns::account::ConfirmedBurnValueProvider
class	sgns::account::BurnConfigPayload ISignedCRDTData payload type carrying the burn-basis-points value. Serialization/verification mirrors TrustedPeerListPayload's structural-only-verify convention (never diffs against cached state).
class	sgns::account::BurnConfig Genesis-seeded, in-memory-cached, quorum-updatable BURN_BASIS_POINTS value. Delegates ALL signature/quorum logic to SecureCrdt/SecureCrdtRegistry – no bespoke signature/quorum logic exists here (mirrors TPR-03 precedent).

Detailed Description

Genesis-seeded, quorum-signed, cache-refresh-via-quorum- re-derivation BURN_BASIS_POINTS value, built entirely on top of SecureCrdt/SecureCrdtRegistry/TrustedPeerRegistry (BURN-01, BURN-02, BURN-03). Direct structural template of TrustedPeerRegistry (Phase 10), replacing TransactionManager's hardcoded BURN_BASIS_POINTS constant.

Date: 2026-07-24 Henrique A. Klein ([email protected])

Source code

#ifndef SGNS_ACCOUNT_BURNCONFIG_HPP
#define SGNS_ACCOUNT_BURNCONFIG_HPP

#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <vector>

#include "base/logger.hpp"
#include "crdt/globaldb/globaldb.hpp"
#include "crdt/hierarchical_key.hpp"
#include "outcome/outcome.hpp"
#include "securecrdt/ISignedCRDTData.hpp"
#include "securecrdt/SecureCrdt.hpp"
#include "securecrdt/SecureCrdtRegistry.hpp"
#include "trustedpeer/TrustedPeerRegistry.hpp"

namespace sgns
{
    class GeniusAccount;
} // namespace sgns

namespace sgns::account
{
    class ConfirmedBurnValueProvider
    {
    public:
        [[nodiscard]] bool IsReady() const;
        [[nodiscard]] uint64_t GetBasisPoints() const;

    private:
        friend class BurnConfig;
        std::atomic<bool> ready_{ false };
        std::atomic<uint64_t> basis_points_{ 0 };
    };

    class BurnConfigPayload : public sgns::securecrdt::ISignedCRDTData
    {
    public:
        static constexpr uint64_t BASIS_POINTS_TOTAL = 10000;

        BurnConfigPayload() = default;

        explicit BurnConfigPayload( uint64_t basis_points );

        std::vector<uint8_t> SerializeToBytes() const override;
        bool                 DeserializeFromBytes( const std::vector<uint8_t> &bytes ) override;
        bool                 Verify( const std::vector<uint8_t> &payload ) const override;
        void                 Apply() override;

        uint64_t GetBasisPoints() const
        {
            return basis_points_;
        }

    private:
        uint64_t basis_points_ = 0;
        bool     applied_      = false;
    };

    class BurnConfig : public std::enable_shared_from_this<BurnConfig>
    {
    public:
        static constexpr uint64_t GENESIS_DEFAULT_BASIS_POINTS = 100;

        using RefreshCallback = std::function<void( uint64_t )>;
        using SignCallback = std::function<std::vector<uint8_t>( const std::vector<uint8_t> & )>;

        BurnConfig( std::shared_ptr<sgns::securecrdt::SecureCrdt>           secure_crdt,
                    std::shared_ptr<sgns::crdt::GlobalDB>                   db,
                    std::shared_ptr<sgns::trustedpeer::TrustedPeerRegistry> trusted_peer_registry,
                    uint64_t                                                quorum_threshold,
                    std::shared_ptr<sgns::GeniusAccount>                    account,
                    sgns::crdt::HierarchicalKey                             base_key );

        ~BurnConfig();

        static outcome::result<std::shared_ptr<BurnConfig>> New(
            std::shared_ptr<sgns::securecrdt::SecureCrdt>           secure_crdt,
            std::shared_ptr<sgns::crdt::GlobalDB>                   db,
            std::shared_ptr<sgns::trustedpeer::TrustedPeerRegistry> trusted_peer_registry,
            uint64_t                                                quorum_threshold,
            std::shared_ptr<sgns::GeniusAccount>                    account,
            sgns::crdt::HierarchicalKey base_key = sgns::crdt::HierarchicalKey( "burn-config" ) );

        static outcome::result<std::shared_ptr<BurnConfig>> NewProduction(
            std::shared_ptr<sgns::securecrdt::SecureCrdt>           secure_crdt,
            std::shared_ptr<sgns::trustedpeer::TrustedPeerRegistry> trusted_peer_registry,
            std::shared_ptr<sgns::trustedpeer::TrustStateStore>     trust_store,
            std::string                                             local_signer_address,
            SignCallback                                            sign_callback,
            std::string                                             candidate_domain = "burn-config" );

        outcome::result<sgns::securecrdt::CandidateId> OnTrustedPeerGenesisConfirmed();
        outcome::result<std::vector<sgns::securecrdt::CandidateId>> ListPendingBurnCandidates() const;
        outcome::result<sgns::securecrdt::CandidateId> ProposeBurnCandidate( uint64_t basis_points );
        outcome::result<sgns::securecrdt::CandidateId> ApproveBurnCandidate(
            const sgns::securecrdt::CandidateId &candidate_id );
        outcome::result<bool> TryActivateBurnCandidate( const sgns::securecrdt::CandidateId &candidate_id );
        [[nodiscard]] bool IsEconomicallyReady() const;
        [[nodiscard]] std::shared_ptr<const ConfirmedBurnValueProvider> GetConfirmedValueProvider() const;
        [[nodiscard]] static std::optional<sgns::securecrdt::CandidateCore> BurnCandidateCore(
            const sgns::trustedpeer::ConfirmedBurnState &candidate,
            const std::string &domain = "burn-config" );

        uint64_t GetCachedBasisPoints() const;

        void RegisterRefreshCallback( RefreshCallback cb );

        void Unregister();

    private:
        bool RegisterSignerSetSource();

        void RegisterCrdtChangeCallback();

        void OnCrdtElementChanged();

        void TrySeedGenesisIfEligible();

        bool RegisterProductionDomain();
        outcome::result<sgns::securecrdt::CandidateAuthorizationSnapshot> ResolveBurnAuthorization() const;
        outcome::result<sgns::securecrdt::CandidateId> SubmitLocalApproval(
            const sgns::securecrdt::CandidateCore &core );
        void PublishConfirmedBurn( const sgns::trustedpeer::ConfirmedTrustSnapshot &snapshot );
        void NotifyBasisPointsChanged( uint64_t new_value );

        std::shared_ptr<sgns::securecrdt::SecureCrdt>           secure_crdt_;
        std::shared_ptr<sgns::crdt::GlobalDB>                   db_;
        std::shared_ptr<sgns::trustedpeer::TrustedPeerRegistry> trusted_peer_registry_;
        uint64_t                                                quorum_threshold_;
        std::shared_ptr<sgns::GeniusAccount>                    account_;
        sgns::crdt::HierarchicalKey                             base_key_;

        std::atomic<uint64_t> cached_basis_points_{ GENESIS_DEFAULT_BASIS_POINTS };

        std::mutex                   refresh_callbacks_mutex_;
        std::vector<RefreshCallback> refresh_callbacks_;

        int registry_token_ = 0;

        bool production_mode_ = false;
        std::shared_ptr<sgns::trustedpeer::TrustStateStore> trust_store_;
        std::string local_signer_address_;
        SignCallback sign_callback_;
        std::string candidate_domain_ = "burn-config";
        std::optional<sgns::securecrdt::CandidateId> automatic_genesis_candidate_;
        std::shared_ptr<ConfirmedBurnValueProvider> confirmed_value_provider_ =
            std::make_shared<ConfirmedBurnValueProvider>();

        sgns::base::Logger logger_ = sgns::base::createLogger( "BurnConfig" );
    };
} // namespace sgns::account

#endif // SGNS_ACCOUNT_BURNCONFIG_HPP

---

Updated on 2026-10-10 at 04:54:22 +0000