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::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 <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 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 )>;

        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" ) );

        uint64_t GetCachedBasisPoints() const;

        void RegisterRefreshCallback( RefreshCallback cb );

        void Unregister();

    private:
        void RegisterSignerSetSource();

        void RegisterCrdtChangeCallback();

        void OnCrdtElementChanged();

        void TrySeedGenesisIfEligible();

        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;

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

#endif // SGNS_ACCOUNT_BURNCONFIG_HPP

---

Updated on 2026-08-07 at 17:48:03 +0000