contributor.hpp

См. документацию.

// contributor.hpp
 
#pragma once
 
 
#include "../lib/core/ram_payer.hpp"
#include <eosio/eosio.hpp>
#include <eosio/asset.hpp>
#include "../lib/index.hpp"
 
using namespace eosio;
using std::string;
 
class [[eosio::contract]] contributor : public coop_contract {
public:
    using coop_contract::coop_contract;
 
    [[eosio::action]] void cleanup();
 
    [[eosio::action]]
    void init(name coopname);
 
    [[eosio::action]]
    void contribute(name coopname, name username, asset amount, name type);
 
    [[eosio::action]]
    void refresh(name coopname, name username);
 
    [[eosio::action]]
    void withdraw1(name coopname, name username, asset amount); // Вывод для интеллектуальных вкладов
 
    [[eosio::action]]
    void withdraw2(name coopname, name username, asset amount); // Вывод через очередь из членских взносов
 
    [[eosio::action]]
    void addfee(name coopname, asset amount); // Добавление входящих членских взносов
 
private:
    static constexpr symbol TOKEN_SYMBOL = _root_govern_symbol; 
    
 
    struct [[eosio::table]] participant {
        uint64_t id;                                
        name account;                               
        asset share_balance = asset(0, _root_govern_symbol); 
        asset pending_rewards = asset(0, _root_symbol); 
        asset intellectual_contributions = asset(0, _root_govern_symbol); 
        asset property_contributions = asset(0, _root_govern_symbol); 
        asset total_contributions = asset(0, _root_govern_symbol); 
        int64_t reward_per_share_last = 0;          
        asset withdrawed = asset(0, _root_symbol);  
        asset queued_withdrawal = asset(0, _root_symbol); 
 
        uint64_t primary_key() const { return id; }             
        uint64_t by_account() const { return account.value; }   
    };
    
    typedef eosio::multi_index<"participants"_n, participant,
        indexed_by<"byaccount"_n, const_mem_fun<participant, uint64_t, &participant::by_account>>
    > participants_table; 
 
    
 
    struct [[eosio::table]] global_state {
        eosio::name coopname;                                
        asset total_shares = asset(0, _root_govern_symbol);    
        asset total_contributions = asset(0, _root_govern_symbol); 
        asset total_rewards_distributed = asset(0, _root_symbol); 
        asset total_withdrawed = asset(0, _root_symbol); 
        asset total_intellectual_contributions = asset(0, _root_govern_symbol); 
        asset total_property_contributions = asset(0, _root_govern_symbol); 
        asset accumulated_fees = asset(0, TOKEN_SYMBOL); 
        int64_t cumulative_reward_per_share = 0;        
 
        uint64_t primary_key() const { return coopname.value; }     
    };
    
    typedef eosio::multi_index<"globalstate"_n, global_state> global_state_table; 
 
 
    struct [[eosio::table]] withdrawal_request {
        uint64_t id;                                
        name account;                               
        asset amount = asset(0, TOKEN_SYMBOL);      
        uint64_t timestamp;                         
 
        uint64_t primary_key() const { return id; }             
        uint64_t by_account() const { return account.value; }   
        uint64_t by_timestamp() const { return timestamp; }     
    };
 
    typedef eosio::multi_index<"withdrawals"_n, withdrawal_request,
        indexed_by<"byaccount"_n, const_mem_fun<withdrawal_request, uint64_t, &withdrawal_request::by_account>>,
        indexed_by<"bytimestamp"_n, const_mem_fun<withdrawal_request, uint64_t, &withdrawal_request::by_timestamp>>
    > withdrawals_table; 
 
    void process_property(const name& coopname, const name& username, const asset& amount);
 
    void process_intellectual(const name& coopname, const name& username, const asset& amount);
 
    void update_global_state(const global_state& gs);
        
    global_state get_global_state(name coopname) {
        global_state_table global_state_inst(_self, _self.value);
        auto itr = global_state_inst.find(coopname.value);
        eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
        return *itr;
    }
 
    void process_withdrawals(const name& coopname); // Обработка очереди на вывод
};
 
// Плательщик за оперативную память строк таблицы — правило в lib/core/ram_payer.hpp.
RAM_PAYER_CLASS(contributor::participant, contract);
RAM_PAYER_CLASS(contributor::global_state, contract);
RAM_PAYER_CLASS(contributor::withdrawal_request, contract);