witness_objects.hpp

Go to the documentation of this file.

#pragma once
 
#include <scorum/protocol/authority.hpp>
 
#include <scorum/chain/schema/scorum_object_types.hpp>
 
#include <boost/multi_index/composite_key.hpp>
 
namespace scorum {
namespace chain {
 
using scorum::protocol::asset;
using scorum::protocol::asset_symbol_type;
using scorum::protocol::chain_properties;
using scorum::protocol::digest_type;
using scorum::protocol::hardfork_version;
using scorum::protocol::public_key_type;
using scorum::protocol::version;
using scorum::protocol::share_type;
 
class witness_object : public object<witness_object_type, witness_object>
{
public:
    CHAINBASE_DEFAULT_DYNAMIC_CONSTRUCTOR(witness_object, (url))
 
    enum witness_schedule_type
    {
        top20,
        timeshare,
        none
    };
 
    id_type id;
 
    account_name_type owner;
    time_point_sec created;
    fc::shared_string url;
    uint32_t total_missed = 0;
    uint64_t last_confirmed_block_num = 0;
 
    public_key_type signing_key;
 
    chain_properties proposed_chain_props;
 
    share_type votes;
    witness_schedule_type schedule = none; 
 
    fc::uint128 virtual_last_update;
    fc::uint128 virtual_position;
    fc::uint128 virtual_scheduled_time = fc::uint128::max_value();
 
    version running_version;
 
    hardfork_version hardfork_version_vote;
    time_point_sec hardfork_time_vote;
};
 
class witness_vote_object : public object<witness_vote_object_type, witness_vote_object>
{
public:
    CHAINBASE_DEFAULT_CONSTRUCTOR(witness_vote_object)
 
    id_type id;
 
    witness_id_type witness;
    account_id_type account;
};
 
class witness_schedule_object : public object<witness_schedule_object_type, witness_schedule_object>
{
public:
    CHAINBASE_DEFAULT_CONSTRUCTOR(witness_schedule_object)
 
    id_type id;
 
    fc::uint128 current_virtual_time;
    fc::array<account_name_type, SCORUM_MAX_WITNESSES_LIMIT> current_shuffled_witnesses;
    uint8_t num_scheduled_witnesses = 1;
};
 
class witness_reward_in_sp_migration_object
    : public object<witness_reward_in_sp_migration_object_type, witness_reward_in_sp_migration_object>
{
public:
    CHAINBASE_DEFAULT_CONSTRUCTOR(witness_reward_in_sp_migration_object)
 
    id_type id;
 
    share_type balance;
};
 
struct by_vote_name;
struct by_name;
struct by_pow;
struct by_schedule_time;
typedef shared_multi_index_container<witness_object,
                                     indexed_by<ordered_unique<tag<by_id>,
                                                               member<witness_object,
                                                                      witness_id_type,
                                                                      &witness_object::id>>,
                                                ordered_unique<tag<by_name>,
                                                               member<witness_object,
                                                                      account_name_type,
                                                                      &witness_object::owner>>,
                                                ordered_unique<tag<by_vote_name>,
                                                               composite_key<witness_object,
                                                                             member<witness_object,
                                                                                    share_type,
                                                                                    &witness_object::votes>,
                                                                             member<witness_object,
                                                                                    account_name_type,
                                                                                    &witness_object::owner>>,
                                                               composite_key_compare<std::greater<share_type>,
                                                                                     std::less<account_name_type>>>,
                                                ordered_unique<tag<by_schedule_time>,
                                                               composite_key<witness_object,
                                                                             member<witness_object,
                                                                                    fc::uint128,
                                                                                    &witness_object::
                                                                                        virtual_scheduled_time>,
                                                                             member<witness_object,
                                                                                    witness_id_type,
                                                                                    &witness_object::id>>>>>
    witness_index;
 
struct by_account_witness;
struct by_witness_account;
typedef shared_multi_index_container<witness_vote_object,
                                     indexed_by<ordered_unique<tag<by_id>,
                                                               member<witness_vote_object,
                                                                      witness_vote_id_type,
                                                                      &witness_vote_object::id>>,
                                                ordered_unique<tag<by_account_witness>,
                                                               composite_key<witness_vote_object,
                                                                             member<witness_vote_object,
                                                                                    account_id_type,
                                                                                    &witness_vote_object::account>,
                                                                             member<witness_vote_object,
                                                                                    witness_id_type,
                                                                                    &witness_vote_object::witness>>,
                                                               composite_key_compare<std::less<account_id_type>,
                                                                                     std::less<witness_id_type>>>,
                                                ordered_unique<tag<by_witness_account>,
                                                               composite_key<witness_vote_object,
                                                                             member<witness_vote_object,
                                                                                    witness_id_type,
                                                                                    &witness_vote_object::witness>,
                                                                             member<witness_vote_object,
                                                                                    account_id_type,
                                                                                    &witness_vote_object::account>>,
                                                               composite_key_compare<std::less<witness_id_type>,
                                                                                     std::
                                                                                         less<account_id_type>>>> // indexed_by
                                     >
    witness_vote_index;
 
typedef shared_multi_index_container<witness_schedule_object,
                                     indexed_by<ordered_unique<tag<by_id>,
                                                               member<witness_schedule_object,
                                                                      witness_schedule_id_type,
                                                                      &witness_schedule_object::id>>>>
    witness_schedule_index;
 
typedef shared_multi_index_container<witness_reward_in_sp_migration_object,
                                     indexed_by<ordered_unique<tag<by_id>,
                                                               member<witness_reward_in_sp_migration_object,
                                                                      witness_reward_in_sp_migration_id_type,
                                                                      &witness_reward_in_sp_migration_object::id>>>>
    witness_reward_in_sp_migration_index;
 
} // namespace chain
} // namespace scorum
 
// clang-format off
 
FC_REFLECT_ENUM( scorum::chain::witness_object::witness_schedule_type, (top20)(timeshare)(none) )
 
FC_REFLECT( scorum::chain::witness_object,
             (id)
             (owner)
             (created)
             (url)(votes)(schedule)(virtual_last_update)(virtual_position)(virtual_scheduled_time)(total_missed)
             (last_confirmed_block_num)(signing_key)
             (proposed_chain_props)
             (running_version)
             (hardfork_version_vote)(hardfork_time_vote)
          )
CHAINBASE_SET_INDEX_TYPE( scorum::chain::witness_object, scorum::chain::witness_index )
 
FC_REFLECT( scorum::chain::witness_vote_object, (id)(witness)(account) )
CHAINBASE_SET_INDEX_TYPE( scorum::chain::witness_vote_object, scorum::chain::witness_vote_index )
 
FC_REFLECT( scorum::chain::witness_schedule_object,
             (id)(current_virtual_time)(current_shuffled_witnesses)(num_scheduled_witnesses)
          )
CHAINBASE_SET_INDEX_TYPE( scorum::chain::witness_schedule_object, scorum::chain::witness_schedule_index )
 
FC_REFLECT( scorum::chain::witness_reward_in_sp_migration_object,
             (id)(balance)
          )
CHAINBASE_SET_INDEX_TYPE( scorum::chain::witness_reward_in_sp_migration_object, scorum::chain::witness_reward_in_sp_migration_index )
 
// clang-format on