update 3rd party include

Author: roman-modelist-dev

3rd-party-components/include/fc/io/json_relaxed.hpp

@@ -724,7 +724,7 @@ namespace fc { namespace json_relaxed
        FC_RETHROW_EXCEPTIONS( warn, "Atempting to use @fname for ${fname}", ("fname", fname ) );
    }
 
-   template<typename T, bool strict, bool cmdline = false>
+   template<typename T, bool strict, bool cmdline>
    variant variant_from_stream( T& in )
    {
       skip_white_space(in);

3rd-party-components/include/fc/reflect/typename.hpp

@@ -15,7 +15,7 @@ namespace fc {
   class exception;
   namespace ip { class address; }
 
-  template<typename T> class get_typename{};
+  template<typename ...T> struct get_typename;
   template<> struct get_typename<int32_t>  { static const char* name()  { return "int32_t";  } };
   template<> struct get_typename<int64_t>  { static const char* name()  { return "int64_t";  } };
   template<> struct get_typename<int16_t>  { static const char* name()  { return "int16_t";  } };

3rd-party-components/include/fc/static_variant.hpp

@@ -382,5 +382,5 @@ struct visitor {
       s.visit( to_static_variant(ar[1]) );
    }
 
-  template<typename... T> struct get_typename<T...>  { static const char* name()   { return typeid(static_variant<T...>).name();   } };
+  template<typename... T> struct get_typename { static const char* name()   { return typeid(static_variant<T...>).name();   } };
 } // namespace fc

3rd-party-components/include/fc/variant.hpp

@@ -44,7 +44,7 @@ namespace fc
 
    struct blob { std::vector<char> data; };
 
-   void bto_variant( const blob& var,  variant& vo );
+   void to_variant( const blob& var,  variant& vo );
    void from_variant( const variant& var,  blob& vo );
 
 

3rd-party-components/include/graphene/chain/IFMHostImpl.hpp

@@ -33,8 +33,10 @@ struct IFMHostImpl: IFMHost
 
     // { IFMHost
     virtual bool stg_get(const TStgKey& key, TStgVal& val_out) override;
-    virtual std::vector<TStgVal> stg_get(const TStgKey& key, uint32_t num_of_keys) override;
-    virtual void stg_set(const TStgKey& key, const TStgVal& val) override;
+    virtual uint32_t stg_get(const IFMHost::TStgKey& key, uint32_t num_of_keys, std::vector<IFMHost::TStgVal>& data) override;
+    virtual bool stg_set(const TStgKey& key, const TStgVal& val) override;
+    virtual uint32_t stg_set(const TStgKey& key, const std::vector<TStgVal>& vals);
+    virtual uint32_t stg_del(const TStgKey& key, uint32_t num_of_keys);
     virtual TAccountID env_get_caller() override
     { return(get_caller().operator uint64_t()); }
     virtual TAccountID env_get_contract_id() override
@@ -59,6 +61,7 @@ struct IFMHostImpl: IFMHost
     virtual void block_hash (TNumberBlock& numberBlock, TBlockHash blockHash[5]) override;
     virtual const std::vector<char> env_get_contract_code(const TAccountID contract_id) override;
     virtual const std::vector<char> env_get_contract_code(const std::string& contract_name) override;
+    virtual bool env_map_address(const TAddr& addr, TAccountID& account, bool *create) override;
 
     virtual TPDAddr construct_address(TAssetID assetID, TAccountID accountID) override;
     virtual bool parse_address(const TPDAddr& address, TAssetID& assetID, TAccountID& accountID) override;

3rd-party-components/include/graphene/chain/account_evaluator.hpp

@@ -36,6 +36,17 @@ class account_create_evaluator : public evaluator<account_create_evaluator>
    object_id_type do_apply( const account_create_operation& o ) ;
 };
 
+class account_auto_create_evaluator : public evaluator<account_create_evaluator>
+{
+public:
+   typedef account_auto_create_operation operation_type;
+
+   void_result do_evaluate( const account_auto_create_operation& o );
+   object_id_type do_apply( const account_auto_create_operation& o ) ;
+
+   string name;
+};
+
 class account_update_evaluator : public evaluator<account_update_evaluator>
 {
 public:

3rd-party-components/include/graphene/chain/account_object.hpp

@@ -25,6 +25,7 @@
 #include <graphene/chain/protocol/operations.hpp>
 #include <graphene/db/generic_index.hpp>
 #include <boost/multi_index/composite_key.hpp>
+#include <boost/multi_index/hashed_index.hpp>
 
 namespace graphene { namespace chain {
    class database;
@@ -155,6 +156,9 @@ namespace graphene { namespace chain {
          /// The account's name. This name must be unique among all account names on the graph. May not be empty.
          string name;
 
+         /// The account's address. Must be unique among all account addresses if valid. Allows for Etherium-compatible account addressing.
+         optional<address> addr;
+
          /**
           * The owner authority represents absolute control over the account. Usually the keys in this authority will
           * be kept in cold storage, as they should not be needed very often and compromise of these keys constitutes
@@ -316,6 +320,23 @@ namespace graphene { namespace chain {
          map< account_id_type, set<account_id_type> > referred_by;
    };
 
+   /**
+    *  @brief This secondary index will allow a reverse lookup of accounts by their address.
+    *  (To provide Etherium compatibility)
+    */
+   class account_address_index : public secondary_index
+   {
+      public:
+         virtual void object_inserted( const object& obj ) override;
+         virtual void object_removed( const object& obj ) override;
+         virtual void about_to_modify( const object& before ) override;
+         virtual void object_modified( const object& after  ) override;
+
+         typedef unordered_map< address, account_id_type > TAddressesCont;
+         /** maps the address to the account */
+         TAddressesCont addresses;
+   };
+
    struct by_account_asset;
    struct by_asset_balance;
    /**
@@ -379,7 +400,7 @@ FC_REFLECT_DERIVED( graphene::chain::account_object,
                     (graphene::db::object),
                     (membership_expiration_date)(registrar)(referrer)(lifetime_referrer)
                     (network_fee_percentage)(lifetime_referrer_fee_percentage)(referrer_rewards_percentage)
-                    (name)(owner)(active)(options)(contract_opts)(statistics)(whitelisting_accounts)(blacklisting_accounts)
+                    (name)(addr)(owner)(active)(options)(contract_opts)(statistics)(whitelisting_accounts)(blacklisting_accounts)
                     (whitelisted_accounts)(blacklisted_accounts)
                     (cashback_vb)
                     (owner_special_authority)(active_special_authority)

3rd-party-components/include/graphene/chain/confidential_evaluator.hpp

@@ -47,6 +47,7 @@ class transfer_from_blind_evaluator : public evaluator<transfer_from_blind_evalu
       typedef transfer_from_blind_operation operation_type;
 
       void_result do_evaluate( const transfer_from_blind_operation& o );
+      void        pre_apply( const transfer_from_blind_operation& op );
       void_result do_apply( const transfer_from_blind_operation& o ) ;
 
       virtual void pay_fee() override;
@@ -58,6 +59,7 @@ class blind_transfer_evaluator : public evaluator<blind_transfer_evaluator>
       typedef blind_transfer_operation operation_type;
 
       void_result do_evaluate( const blind_transfer_operation& o );
+      void        pre_apply( const blind_transfer_operation& op );
       void_result do_apply( const blind_transfer_operation& o ) ;
 
       virtual void pay_fee() override;

3rd-party-components/include/graphene/chain/evaluator.hpp

@@ -137,6 +137,7 @@ namespace graphene { namespace chain {
 
       safe<uint32_t>                   gas_left = 0;
       asset                            gas_fee_used;
+      asset                            gas_fee_refund;
       share_type                       core_gas_fee_used;
       share_type                       core_gas_fee_refund;
 
@@ -203,25 +204,30 @@ namespace graphene { namespace chain {
          auto* eval = static_cast<DerivedEvaluator*>(this);
          const auto& op = o.get<typename DerivedEvaluator::operation_type>();
 
+         eval->pre_apply(op);
+
          convert_fee();
+         {
+             asset fee = (gas_limit_from_account == 0) ?
+                     fee_from_account : (fee_from_account + gas_fee_limit);
+             db_adjust_balance(op.fee_payer(), -fee);
+         }
 
          auto result = eval->do_apply(op);
 
          if(gas_limit_from_account != 0)
          {
              prepare_gas_fee_refund();
              convert_gas_fee_refund();
+             db_adjust_balance(op.fee_payer(), gas_fee_refund);
          }
 
          pay_fee();
 
-         // XXX does it check that account can pay the fee before the very end of operation? (might matter for contract calls)
-         // XXX may be it should be taken before applying the operation?
-         asset fee = (gas_limit_from_account == 0) ?
-                 fee_from_account : (fee_from_account + gas_fee_used);
-         db_adjust_balance(op.fee_payer(), -fee);
-
          return result;
       }
+
+   protected:
+      void pre_apply(const base_operation& op) {}
    };
 } }

3rd-party-components/include/graphene/chain/protocol/account.hpp

@@ -110,6 +110,42 @@ namespace graphene { namespace chain {
       }
    };
 
+   /**
+    *  @ingroup operations
+    */
+   struct account_auto_create_operation : public base_operation
+   {
+      struct fee_parameters_type
+      {
+         uint64_t fee      = 5*GRAPHENE_BLOCKCHAIN_PRECISION; ///< the cost to register the cheapest non-free account
+      };
+
+      asset           fee;
+      account_id_type caller;
+      /// Must be a lifetime member.
+      account_id_type registrar;
+      /// This account receives a portion of the fee split between registrar and referrer. Must be a member.
+      account_id_type referrer;
+      /// Of the fee split between registrar and referrer, this percentage goes to the referrer. The rest goes to the
+      /// registrar.
+      uint16_t        referrer_percent = 0;
+
+      address         addr;
+
+      extensions_type extensions;
+
+      account_id_type fee_payer()const { FC_ASSERT( !"virtual operation" ); return account_id_type(); /*return caller;*/ }
+      void            validate()const;
+      //share_type      calculate_fee(const fee_parameters_type& )const;
+
+      // void get_required_authorities( vector<authority>& auth)const { auth.emplace_back(1, addr, 1); }
+      /*void get_required_active_authorities( flat_set<account_id_type>& a )const
+      {
+         // caller should be required anyway as it is the fee_payer(), but we insert it here just to be sure
+         a.insert( caller );
+      }*/
+   };
+
    /**
     * @ingroup operations
     * @brief Update an existing account
@@ -274,6 +310,12 @@ FC_REFLECT( graphene::chain::account_create_operation,
             (name)(owner)(active)(options)(extensions)
           )
 
+FC_REFLECT( graphene::chain::account_auto_create_operation,
+            (fee)(caller)(registrar)
+            (referrer)(referrer_percent)
+            (addr)(extensions)
+          )
+
 FC_REFLECT(graphene::chain::account_update_operation::ext, (null_ext)(owner_special_authority)(active_special_authority) )
 FC_REFLECT( graphene::chain::account_update_operation,
             (fee)(account)(owner)(active)(new_options)(extensions)
@@ -285,6 +327,7 @@ FC_REFLECT( graphene::chain::account_upgrade_operation,
 FC_REFLECT( graphene::chain::account_whitelist_operation, (fee)(authorizing_account)(account_to_list)(new_listing)(extensions))
 
 FC_REFLECT( graphene::chain::account_create_operation::fee_parameters_type, (basic_fee)(premium_fee)(price_per_kbyte) )
+FC_REFLECT( graphene::chain::account_auto_create_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::chain::account_whitelist_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::chain::account_update_operation::fee_parameters_type, (fee)(price_per_kbyte) )
 FC_REFLECT( graphene::chain::account_upgrade_operation::fee_parameters_type, (membership_annual_fee)(membership_lifetime_fee) )