account.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <graphene/protocol/base.hpp>
#include <graphene/protocol/asset.hpp>
#include <graphene/protocol/authority.hpp>
#include <graphene/protocol/buyback.hpp>
#include <graphene/protocol/special_authority.hpp>
#include <graphene/protocol/vote.hpp>
 
namespace graphene { namespace protocol {
 
   bool is_valid_name( const string& s );
   bool is_cheap_name( const string& n );
 
   struct account_options
   {
      public_key_type  memo_key;
      account_id_type voting_account = GRAPHENE_PROXY_TO_SELF_ACCOUNT;
 
      uint16_t num_witness = 0;
      uint16_t num_committee = 0;
      flat_set<vote_id_type> votes;
      extensions_type        extensions;
 
      inline bool is_voting() const
      {
         return ( voting_account != GRAPHENE_PROXY_TO_SELF_ACCOUNT || !votes.empty() );
      }
 
      uint16_t num_committee_voted() const
      {
         if( voting_account != GRAPHENE_PROXY_TO_SELF_ACCOUNT )
            return 0;
         return std::count_if( votes.begin(), votes.end(),
                               [](vote_id_type v){ return v.type() == vote_id_type::vote_type::committee; } );
      }
 
      void validate()const;
   };
 
   struct account_create_operation : public base_operation
   {
      struct ext
      {
         optional< void_t >            null_ext;
         optional< special_authority > owner_special_authority;
         optional< special_authority > active_special_authority;
         optional< buyback_account_options > buyback_options;
      };
 
      struct fee_params_t
      {
         uint64_t basic_fee      = 5*GRAPHENE_BLOCKCHAIN_PRECISION; 
         uint64_t premium_fee    = 2000*GRAPHENE_BLOCKCHAIN_PRECISION; 
         uint32_t price_per_kbyte = GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      asset           fee;
      account_id_type registrar;
 
      account_id_type referrer;
      uint16_t        referrer_percent = 0;
 
      string          name;
      authority       owner;
      authority       active;
 
      account_options options;
      extension< ext > extensions;
 
      account_id_type fee_payer()const { return registrar; }
      void            validate()const;
      share_type      calculate_fee(const fee_params_t& )const;
 
      void get_required_active_authorities( flat_set<account_id_type>& a )const
      {
         // registrar should be required anyway as it is the fee_payer(), but we insert it here just to be sure
         a.insert( registrar );
         if( extensions.value.buyback_options.valid() )
            a.insert( extensions.value.buyback_options->asset_to_buy_issuer );
      }
   };
 
   struct account_update_operation : public base_operation
   {
      struct ext
      {
         optional< void_t >            null_ext;
         optional< special_authority > owner_special_authority;
         optional< special_authority > active_special_authority;
      };
 
      struct fee_params_t
      {
         share_type fee             = 20 * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint32_t   price_per_kbyte = GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      asset fee;
      account_id_type account;
 
      optional<authority> owner;
      optional<authority> active;
 
      optional<account_options> new_options;
      extension< ext > extensions;
 
      account_id_type fee_payer()const { return account; }
      void       validate()const;
      share_type calculate_fee( const fee_params_t& k )const;
 
      bool is_owner_update()const
      { return owner || extensions.value.owner_special_authority.valid(); }
 
      void get_required_owner_authorities( flat_set<account_id_type>& a )const
      { if( is_owner_update() ) a.insert( account ); }
 
      void get_required_active_authorities( flat_set<account_id_type>& a )const
      { if( !is_owner_update() ) a.insert( account ); }
   };
 
   struct account_whitelist_operation : public base_operation
   {
      struct fee_params_t { share_type fee = 300000; };
      enum account_listing {
         no_listing = 0x0, 
         white_listed = 0x1, 
         black_listed = 0x2, 
         white_and_black_listed = white_listed | black_listed 
      };
 
      asset           fee;
      account_id_type authorizing_account;
      account_id_type account_to_list;
      uint8_t new_listing = no_listing;
      extensions_type extensions;
 
      account_id_type fee_payer()const { return authorizing_account; }
      void validate()const { FC_ASSERT( fee.amount >= 0 ); FC_ASSERT(new_listing < 0x4); }
   };
 
   struct account_upgrade_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t membership_annual_fee   =  2000 * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint64_t membership_lifetime_fee = 10000 * GRAPHENE_BLOCKCHAIN_PRECISION; 
      };
 
      asset             fee;
      account_id_type   account_to_upgrade;
      bool              upgrade_to_lifetime_member = false;
      extensions_type   extensions;
 
      account_id_type fee_payer()const { return account_to_upgrade; }
      void       validate()const;
      share_type calculate_fee( const fee_params_t& k )const;
   };
 
   struct account_transfer_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 500 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset           fee;
      account_id_type account_id;
      account_id_type new_owner;
      extensions_type extensions;
 
      account_id_type fee_payer()const { return account_id; }
      void        validate()const;
   };
 
} } // graphene::protocol
 
FC_REFLECT(graphene::protocol::account_options, (memo_key)(voting_account)(num_witness)(num_committee)(votes)(extensions))
FC_REFLECT_ENUM( graphene::protocol::account_whitelist_operation::account_listing,
                (no_listing)(white_listed)(black_listed)(white_and_black_listed))
 
FC_REFLECT(graphene::protocol::account_create_operation::ext, (null_ext)(owner_special_authority)(active_special_authority)(buyback_options) )
FC_REFLECT_TYPENAME(graphene::protocol::extension<graphene::protocol::account_create_operation::ext>)
FC_REFLECT( graphene::protocol::account_create_operation,
            (fee)(registrar)
            (referrer)(referrer_percent)
            (name)(owner)(active)(options)(extensions)
          )
 
FC_REFLECT(graphene::protocol::account_update_operation::ext, (null_ext)(owner_special_authority)(active_special_authority) )
FC_REFLECT_TYPENAME(graphene::protocol::extension<graphene::protocol::account_update_operation::ext>)
FC_REFLECT( graphene::protocol::account_update_operation,
            (fee)(account)(owner)(active)(new_options)(extensions)
          )
 
FC_REFLECT( graphene::protocol::account_upgrade_operation,
            (fee)(account_to_upgrade)(upgrade_to_lifetime_member)(extensions) )
 
FC_REFLECT( graphene::protocol::account_whitelist_operation, (fee)(authorizing_account)(account_to_list)(new_listing)(extensions))
 
FC_REFLECT( graphene::protocol::account_create_operation::fee_params_t, (basic_fee)(premium_fee)(price_per_kbyte) )
FC_REFLECT( graphene::protocol::account_whitelist_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::account_update_operation::fee_params_t, (fee)(price_per_kbyte) )
FC_REFLECT( graphene::protocol::account_upgrade_operation::fee_params_t, (membership_annual_fee)(membership_lifetime_fee) )
FC_REFLECT( graphene::protocol::account_transfer_operation::fee_params_t, (fee) )
 
FC_REFLECT( graphene::protocol::account_transfer_operation, (fee)(account_id)(new_owner)(extensions) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_options )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_create_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_whitelist_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_update_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_upgrade_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_transfer_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_create_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_whitelist_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_update_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_upgrade_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::account_transfer_operation )