scorum_operations.hpp

Go to the documentation of this file.

#pragma once
#include <scorum/protocol/base.hpp>
#include <scorum/protocol/block_header.hpp>
#include <scorum/protocol/asset.hpp>
#include <scorum/protocol/chain_properties.hpp>
#include <scorum/protocol/comment.hpp>
#include <scorum/protocol/types.hpp>
 
#include <scorum/protocol/betting/game.hpp>
#include <scorum/protocol/betting/market.hpp>
#include <scorum/protocol/proposal_operations.hpp>
 
#include <fc/crypto/ripemd160.hpp>
 
#include <boost/uuid/nil_generator.hpp>
 
namespace scorum {
namespace protocol {
 
struct account_create_operation : public base_operation
{
    asset fee = asset(0, SCORUM_SYMBOL);
    account_name_type creator;
    account_name_type new_account_name;
    authority owner;
    authority active;
    authority posting;
    public_key_type memo_key;
    std::string json_metadata;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(creator);
    }
};
 
struct account_create_with_delegation_operation : public base_operation
{
    asset fee = asset(0, SCORUM_SYMBOL);
    asset delegation = asset(0, SP_SYMBOL);
    account_name_type creator;
    account_name_type new_account_name;
    authority owner;
    authority active;
    authority posting;
    public_key_type memo_key;
    std::string json_metadata;
 
    extensions_type extensions;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(creator);
    }
};
 
struct account_create_by_committee_operation : public base_operation
{
    account_name_type creator;
    account_name_type new_account_name;
    authority owner;
    authority active;
    authority posting;
    public_key_type memo_key;
    std::string json_metadata;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(creator);
    }
};
 
struct account_update_operation : public base_operation
{
    account_name_type account;
    optional<authority> owner;
    optional<authority> active;
    optional<authority> posting;
    public_key_type memo_key;
    std::string json_metadata;
 
    void validate() const;
 
    void get_required_owner_authorities(flat_set<account_name_type>& a) const
    {
        if (owner)
            a.insert(account);
    }
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        if (!owner)
            a.insert(account);
    }
};
 
struct comment_operation : public base_operation
{
    account_name_type parent_author;
    std::string parent_permlink;
 
    account_name_type author;
    std::string permlink;
 
    std::string title;
    std::string body;
    std::string json_metadata;
 
    void validate() const;
    void get_required_posting_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(author);
    }
};
 
struct comment_options_operation : public base_operation
{
    account_name_type author;
    std::string permlink;
 
    asset max_accepted_payout
        = asset::maximum(SCORUM_SYMBOL); 
    bool allow_votes = true; 
    bool allow_curation_rewards = true; 
    comment_options_extensions_type extensions;
 
    void validate() const;
    void get_required_posting_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(author);
    }
};
 
struct prove_authority_operation : public base_operation
{
    account_name_type challenged;
    bool require_owner = false;
 
    void validate() const;
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        if (!require_owner)
            a.insert(challenged);
    }
    void get_required_owner_authorities(flat_set<account_name_type>& a) const
    {
        if (require_owner)
            a.insert(challenged);
    }
};
 
struct delete_comment_operation : public base_operation
{
    account_name_type author;
    std::string permlink;
 
    void validate() const;
    void get_required_posting_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(author);
    }
};
 
struct vote_operation : public base_operation
{
    account_name_type voter;
    account_name_type author;
    std::string permlink;
    int16_t weight = 0;
 
    void validate() const;
    void get_required_posting_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(voter);
    }
};
 
struct transfer_operation : public base_operation
{
    account_name_type from;
    account_name_type to;
    asset amount = asset(0, SCORUM_SYMBOL);
 
    std::string memo;
 
    void validate() const;
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(from);
    }
};
 
struct escrow_transfer_operation : public base_operation
{
    account_name_type from;
    account_name_type to;
    account_name_type agent;
    uint32_t escrow_id = 30;
 
    asset scorum_amount = asset(0, SCORUM_SYMBOL);
    asset fee = asset(0, SCORUM_SYMBOL);
 
    time_point_sec ratification_deadline;
    time_point_sec escrow_expiration;
 
    std::string json_meta;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(from);
    }
};
 
struct escrow_approve_operation : public base_operation
{
    account_name_type from;
    account_name_type to;
    account_name_type agent;
    account_name_type who; // Either to or agent
 
    uint32_t escrow_id = 30;
    bool approve = true;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(who);
    }
};
 
struct escrow_dispute_operation : public base_operation
{
    account_name_type from;
    account_name_type to;
    account_name_type agent;
    account_name_type who;
 
    uint32_t escrow_id = 30;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(who);
    }
};
 
struct escrow_release_operation : public base_operation
{
    account_name_type from;
    account_name_type to; 
    account_name_type agent;
    account_name_type who; 
    account_name_type receiver; 
 
    uint32_t escrow_id = 30;
    asset scorum_amount = asset(0, SCORUM_SYMBOL); 
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(who);
    }
};
 
struct transfer_to_scorumpower_operation : public base_operation
{
    account_name_type from;
    account_name_type to; 
    asset amount = asset(0, SCORUM_SYMBOL);
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(from);
    }
};
 
struct withdraw_scorumpower_operation : public base_operation
{
    account_name_type account;
    asset scorumpower = asset(0, SP_SYMBOL);
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(account);
    }
};
 
struct set_withdraw_scorumpower_route_to_account_operation : public base_operation
{
    account_name_type from_account;
    account_name_type to_account;
    uint16_t percent = 0;
    bool auto_vest = false;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(from_account);
    }
};
 
struct set_withdraw_scorumpower_route_to_dev_pool_operation : public base_operation
{
    account_name_type from_account;
    uint16_t percent = 0;
    bool auto_vest = false;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(from_account);
    }
};
 
struct witness_update_operation : public base_operation
{
    account_name_type owner;
    std::string url;
    public_key_type block_signing_key;
    chain_properties proposed_chain_props;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct account_witness_vote_operation : public base_operation
{
    account_name_type account;
    account_name_type witness;
    bool approve = true;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(account);
    }
};
 
struct account_witness_proxy_operation : public base_operation
{
    account_name_type account;
    account_name_type proxy;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(account);
    }
};
 
struct request_account_recovery_operation : public base_operation
{
    account_name_type
        recovery_account; 
 
    account_name_type
        account_to_recover; 
 
    authority new_owner_authority; 
 
    extensions_type extensions; 
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(recovery_account);
    }
 
    void validate() const;
};
 
struct recover_account_operation : public base_operation
{
    account_name_type account_to_recover; 
 
    authority new_owner_authority; 
 
    authority recent_owner_authority; 
 
    extensions_type extensions; 
 
    void get_required_authorities(std::vector<authority>& a) const
    {
        a.push_back(new_owner_authority);
        a.push_back(recent_owner_authority);
    }
 
    void validate() const;
};
 
struct change_recovery_account_operation : public base_operation
{
    account_name_type account_to_recover; 
    account_name_type new_recovery_account; 
    extensions_type extensions; 
 
    void get_required_owner_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(account_to_recover);
    }
    void validate() const;
};
 
struct decline_voting_rights_operation : public base_operation
{
    account_name_type account;
    bool decline = true;
 
    void get_required_owner_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(account);
    }
    void validate() const;
};
 
struct delegate_scorumpower_operation : public base_operation
{
    account_name_type delegator; 
    account_name_type delegatee; 
    asset scorumpower = asset(0, SP_SYMBOL); 
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(delegator);
    }
    void validate() const;
};
 
struct delegate_sp_from_reg_pool_operation : public base_operation
{
    account_name_type reg_committee_member;
    account_name_type delegatee;
    asset scorumpower = asset(0, SP_SYMBOL);
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(reg_committee_member);
    }
};
 
 
struct create_budget_operation : public base_operation
{
    budget_type type = budget_type::post;
 
    uuid_type uuid = boost::uuids::nil_uuid();
    account_name_type owner;
    std::string json_metadata;
 
    asset balance = asset(0, SCORUM_SYMBOL);
    fc::time_point_sec start;
    fc::time_point_sec deadline;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct update_budget_operation : public base_operation
{
    budget_type type = budget_type::post;
 
    uuid_type uuid = boost::uuids::nil_uuid();
    account_name_type owner;
    std::string json_metadata;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct close_budget_operation : public base_operation
{
    budget_type type = budget_type::post;
 
    uuid_type uuid = boost::uuids::nil_uuid();
    account_name_type owner;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct close_budget_by_advertising_moderator_operation : public base_operation
{
    budget_type type = budget_type::post;
 
    uuid_type uuid = boost::uuids::nil_uuid();
    account_name_type moderator;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
 
struct proposal_create_operation : public base_operation
{
    account_name_type creator;
    uint32_t lifetime_sec = 0;
 
    proposal_operation operation;
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(creator);
    }
 
    void validate() const;
};
 
struct proposal_vote_operation : public base_operation
{
    account_name_type voting_account;
    int64_t proposal_id;
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(voting_account);
    }
 
    void validate() const;
};
 
struct atomicswap_initiate_operation : public base_operation
{
    enum operation_type : bool
    {
        by_initiator = 0,
        by_participant,
    };
 
    operation_type type = by_initiator;
 
    account_name_type owner;
    account_name_type recipient;
 
    asset amount = asset(0, SCORUM_SYMBOL);
 
    std::string secret_hash;
 
    std::string metadata;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct atomicswap_redeem_operation : public base_operation
{
    account_name_type from;
    account_name_type to; // participant or initiator
 
    std::string secret;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(to);
    }
};
 
struct atomicswap_refund_operation : public base_operation
{
    account_name_type participant;
    account_name_type initiator;
    std::string secret_hash;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(participant);
    }
};
 
struct odds_input
{
    odds_value_type numerator;
    odds_value_type denominator;
};
 
 
struct create_game_operation : public base_operation
{
    uuid_type uuid = boost::uuids::nil_uuid();
 
    account_name_type moderator;
 
    std::string json_metadata;
 
    time_point_sec start_time;
 
    uint32_t auto_resolve_delay_sec = 0;
 
    game_type game;
 
    std::vector<market_type> markets;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct cancel_game_operation : public base_operation
{
    uuid_type uuid = boost::uuids::nil_uuid();
 
    account_name_type moderator;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct update_game_markets_operation : public base_operation
{
    uuid_type uuid = boost::uuids::nil_uuid();
 
    account_name_type moderator;
 
    std::vector<market_type> markets;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct update_game_start_time_operation : public base_operation
{
    uuid_type uuid = boost::uuids::nil_uuid();
 
    account_name_type moderator;
 
    time_point_sec start_time;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct post_game_results_operation : public base_operation
{
    uuid_type uuid = boost::uuids::nil_uuid();
 
    account_name_type moderator;
 
    std::vector<wincase_type> wincases;
 
    void validate() const;
 
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct post_bet_operation : public base_operation
{
    uuid_type uuid = boost::uuids::nil_uuid();
 
    account_name_type better;
 
    uuid_type game_uuid = boost::uuids::nil_uuid();
 
    wincase_type wincase;
 
    odds_input odds;
 
    asset stake;
 
    bool live = true;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(better);
    }
};
 
struct cancel_pending_bets_operation : public base_operation
{
    std::vector<uuid_type> bet_uuids;
 
    account_name_type better;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(better);
    }
};
 
 
struct create_nft_operation : public base_operation
{
    account_name_type owner;
    uuid_type uuid = boost::uuids::nil_uuid();
    account_name_type name;
    std::string json_metadata;
    int32_t initial_power = 0;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct update_nft_meta_operation : public base_operation
{
    account_name_type moderator;
    uuid_type uuid = boost::uuids::nil_uuid();
    std::string json_metadata;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct adjust_nft_experience_operation : public base_operation
{
    account_name_type moderator;
    uuid_type uuid = boost::uuids::nil_uuid();
    int32_t experience = 0;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct update_nft_name_operation : public base_operation
{
    account_name_type moderator;
    uuid_type uuid = boost::uuids::nil_uuid();
    account_name_type name;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(moderator);
    }
};
 
struct create_game_round_operation : public base_operation
{
    account_name_type owner;
    uuid_type uuid = boost::uuids::nil_uuid();
    std::string verification_key;
    std::string seed;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
struct update_game_round_result_operation : public base_operation
{
    account_name_type owner;
    uuid_type uuid = boost::uuids::nil_uuid();
    std::string proof;
    std::string vrf;
    int32_t result = 0;
 
    void validate() const;
    void get_required_active_authorities(flat_set<account_name_type>& a) const
    {
        a.insert(owner);
    }
};
 
} // namespace protocol
} // namespace scorum
 
// clang-format off
 
FC_REFLECT( scorum::protocol::account_create_operation,
            (fee)
            (creator)
            (new_account_name)
            (owner)
            (active)
            (posting)
            (memo_key)
            (json_metadata) )
 
FC_REFLECT( scorum::protocol::account_create_with_delegation_operation,
            (fee)
            (delegation)
            (creator)
            (new_account_name)
            (owner)
            (active)
            (posting)
            (memo_key)
            (json_metadata)
            (extensions) )
 
FC_REFLECT( scorum::protocol::account_create_by_committee_operation,
            (creator)
            (new_account_name)
            (owner)
            (active)
            (posting)
            (memo_key)
            (json_metadata) )
 
FC_REFLECT( scorum::protocol::account_update_operation,
            (account)
            (owner)
            (active)
            (posting)
            (memo_key)
            (json_metadata) )
 
FC_REFLECT( scorum::protocol::transfer_operation, (from)(to)(amount)(memo) )
FC_REFLECT( scorum::protocol::transfer_to_scorumpower_operation, (from)(to)(amount) )
FC_REFLECT( scorum::protocol::withdraw_scorumpower_operation, (account)(scorumpower) )
FC_REFLECT( scorum::protocol::set_withdraw_scorumpower_route_to_account_operation, (from_account)(to_account)(percent)(auto_vest) )
FC_REFLECT( scorum::protocol::set_withdraw_scorumpower_route_to_dev_pool_operation, (from_account)(percent)(auto_vest) )
FC_REFLECT( scorum::protocol::witness_update_operation, (owner)(url)(block_signing_key)(proposed_chain_props) )
FC_REFLECT( scorum::protocol::account_witness_vote_operation, (account)(witness)(approve) )
FC_REFLECT( scorum::protocol::account_witness_proxy_operation, (account)(proxy) )
FC_REFLECT( scorum::protocol::comment_operation, (parent_author)(parent_permlink)(author)(permlink)(title)(body)(json_metadata) )
FC_REFLECT( scorum::protocol::vote_operation, (voter)(author)(permlink)(weight) )
 
FC_REFLECT( scorum::protocol::delete_comment_operation, (author)(permlink) )
FC_REFLECT( scorum::protocol::comment_options_operation, (author)(permlink)(max_accepted_payout)(allow_votes)(allow_curation_rewards)(extensions) )
 
FC_REFLECT( scorum::protocol::escrow_transfer_operation, (from)(to)(scorum_amount)(escrow_id)(agent)(fee)(json_meta)(ratification_deadline)(escrow_expiration) )
FC_REFLECT( scorum::protocol::escrow_approve_operation, (from)(to)(agent)(who)(escrow_id)(approve) )
FC_REFLECT( scorum::protocol::escrow_dispute_operation, (from)(to)(agent)(who)(escrow_id) )
FC_REFLECT( scorum::protocol::escrow_release_operation, (from)(to)(agent)(who)(receiver)(escrow_id)(scorum_amount) )
FC_REFLECT( scorum::protocol::prove_authority_operation, (challenged)(require_owner) )
FC_REFLECT( scorum::protocol::request_account_recovery_operation, (recovery_account)(account_to_recover)(new_owner_authority)(extensions) )
FC_REFLECT( scorum::protocol::recover_account_operation, (account_to_recover)(new_owner_authority)(recent_owner_authority)(extensions) )
FC_REFLECT( scorum::protocol::change_recovery_account_operation, (account_to_recover)(new_recovery_account)(extensions) )
FC_REFLECT( scorum::protocol::decline_voting_rights_operation, (account)(decline) )
FC_REFLECT( scorum::protocol::delegate_scorumpower_operation, (delegator)(delegatee)(scorumpower) )
FC_REFLECT( scorum::protocol::delegate_sp_from_reg_pool_operation, (reg_committee_member)(delegatee)(scorumpower) )
 
FC_REFLECT( scorum::protocol::create_budget_operation, (type)(uuid)(owner)(json_metadata)(balance)(start)(deadline) )
FC_REFLECT( scorum::protocol::update_budget_operation, (type)(uuid)(owner)(json_metadata) )
FC_REFLECT( scorum::protocol::close_budget_operation, (type)(uuid)(owner) )
FC_REFLECT( scorum::protocol::close_budget_by_advertising_moderator_operation, (type)(uuid)(moderator) )
 
FC_REFLECT( scorum::protocol::atomicswap_initiate_operation, (type)(owner)(recipient)(amount)(secret_hash)(metadata) )
FC_REFLECT_ENUM(scorum::protocol::atomicswap_initiate_operation::operation_type,(by_initiator)(by_participant))
FC_REFLECT( scorum::protocol::atomicswap_redeem_operation, (from)(to)(secret) )
FC_REFLECT( scorum::protocol::atomicswap_refund_operation, (participant)(initiator)(secret_hash) )
 
FC_REFLECT( scorum::protocol::create_game_operation, (uuid)(moderator)(json_metadata)(start_time)(auto_resolve_delay_sec)(game)(markets) )
FC_REFLECT( scorum::protocol::cancel_game_operation, (uuid)(moderator) )
FC_REFLECT( scorum::protocol::update_game_markets_operation, (uuid)(moderator)(markets) )
FC_REFLECT( scorum::protocol::update_game_start_time_operation, (uuid)(moderator)(start_time) )
FC_REFLECT( scorum::protocol::post_game_results_operation, (uuid)(moderator)(wincases) )
 
 
FC_REFLECT( scorum::protocol::proposal_vote_operation,
            (voting_account)
            (proposal_id))
 
FC_REFLECT( scorum::protocol::proposal_create_operation,
            (creator)
            (lifetime_sec)
            (operation))
 
FC_REFLECT(scorum::protocol::odds_input,
           (numerator)
           (denominator))
 
FC_REFLECT( scorum::protocol::post_bet_operation,
           (uuid)
           (better)
           (game_uuid)
           (wincase)
           (odds)
           (stake)
           (live))
FC_REFLECT( scorum::protocol::cancel_pending_bets_operation,
           (bet_uuids)
           (better))
 
FC_REFLECT( scorum::protocol::create_nft_operation,
            (owner)
            (uuid)
            (name)
            (json_metadata)
            (initial_power))
 
FC_REFLECT( scorum::protocol::update_nft_meta_operation,
            (moderator)
            (uuid)
            (json_metadata))
 
FC_REFLECT( scorum::protocol::adjust_nft_experience_operation,
            (moderator)
            (uuid)
            (experience))
 
FC_REFLECT( scorum::protocol::update_nft_name_operation,
            (moderator)
            (uuid)
            (name))
 
FC_REFLECT( scorum::protocol::create_game_round_operation,
            (owner)
            (uuid)
            (verification_key)
            (seed))
 
FC_REFLECT( scorum::protocol::update_game_round_result_operation,
            (owner)
            (uuid)
            (proof)
            (vrf)
            (result))
 
// clang-format on