Custom authorities

libraries/chain/CMakeLists.txt

@@ -32,6 +32,8 @@ endif( GRAPHENE_DISABLE_UNITY_BUILD )
 ## SORT .cpp by most likely to change / break compile
 add_library( graphene_chain
 
+             protocol/restriction.cpp
+             protocol/custom_authority.cpp
              # As database takes the longest to compile, start it first
              ${GRAPHENE_DB_FILES}
              fork_database.cpp
@@ -80,6 +82,7 @@ add_library( graphene_chain
              confidential_evaluator.cpp
              special_authority.cpp
              buyback.cpp
+             custom_authority_evaluator.cpp
 
              account_object.cpp
              asset_object.cpp

libraries/chain/custom_authority_evaluator.cpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2018 Abit More, 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.
+ */
+#include <graphene/chain/custom_authority_evaluator.hpp>
+#include <graphene/chain/custom_authority_object.hpp>
+#include <graphene/chain/account_object.hpp>
+#include <graphene/chain/database.hpp>
+#include <graphene/chain/exceptions.hpp>
+#include <graphene/chain/hardfork.hpp>
+
+namespace graphene { namespace chain {
+
+void_result custom_authority_create_evaluator::do_evaluate(const custom_authority_create_operation& op)
+{ try {
+   const database& d = db();
+
+   // account is fee payer so should be valid
+
+   // custom_id should be unique per account
+
+   // valid_from ?
+   // valid_to should not be too far in the future
+
+   // operation_type HF check
+
+   // if there is an account in auth, need to be valid
+
+   // restrictions size check? global limitation?
+
+   // how many custom authorities per account?
+
+/*
+      asset                           fee;
+      account_id_type                 account;
+      uint32_t                        custom_id;
+      bool                            enabled;
+      time_point_sec                  valid_from;
+      time_point_sec                  valid_to;
+      unsigned_int                    operation_type;
+      authority                       auth;
+      vector<restriction>             restrictions;
+
+      empty_extensions_type           extensions;
+*/
+
+   return void_result();
+} FC_CAPTURE_AND_RETHROW( (op) ) }
+
+object_id_type custom_authority_create_evaluator::do_apply(const custom_authority_create_operation& op)
+{ try {
+   database& d = db();
+
+   const auto& new_object = d.create<custom_authority_object>( [&op]( custom_authority_object& obj ){
+      obj.account        = op.account;
+      obj.custom_id      = op.custom_id;
+      obj.enabled        = op.enabled;
+      obj.valid_from     = op.valid_from;
+      obj.valid_to       = op.valid_to;
+      obj.operation_type = op.operation_type;
+      obj.auth           = op.auth;
+      obj.restrictions   = op.restrictions;
+   });
+
+   return new_object.id;
+
+} FC_CAPTURE_AND_RETHROW( (op) ) }
+
+void_result custom_authority_update_evaluator::do_evaluate(const custom_authority_update_operation& op)
+{ try {
+   const database& d = db();
+
+   return void_result();
+} FC_CAPTURE_AND_RETHROW( (op) ) }
+
+void_result custom_authority_update_evaluator::do_apply(const custom_authority_update_operation& op)
+{ try {
+   database& d = db();
+
+   return void_result();
+} FC_CAPTURE_AND_RETHROW( (op) ) }
+
+void_result custom_authority_delete_evaluator::do_evaluate(const custom_authority_delete_operation& op)
+{ try {
+   const database& d = db();
+
+   return void_result();
+} FC_CAPTURE_AND_RETHROW( (op) ) }
+
+void_result custom_authority_delete_evaluator::do_apply(const custom_authority_delete_operation& op)
+{ try {
+   database& d = db();
+
+   return void_result();
+} FC_CAPTURE_AND_RETHROW( (op) ) }
+
+} } // graphene::chain

libraries/chain/db_init.cpp

@@ -33,6 +33,7 @@
 #include <graphene/chain/chain_property_object.hpp>
 #include <graphene/chain/committee_member_object.hpp>
 #include <graphene/chain/confidential_object.hpp>
+#include <graphene/chain/custom_authority_object.hpp>
 #include <graphene/chain/fba_object.hpp>
 #include <graphene/chain/global_property_object.hpp>
 #include <graphene/chain/market_object.hpp>
@@ -53,6 +54,7 @@
 #include <graphene/chain/committee_member_evaluator.hpp>
 #include <graphene/chain/confidential_evaluator.hpp>
 #include <graphene/chain/custom_evaluator.hpp>
+#include <graphene/chain/custom_authority_evaluator.hpp>
 #include <graphene/chain/market_evaluator.hpp>
 #include <graphene/chain/proposal_evaluator.hpp>
 #include <graphene/chain/transfer_evaluator.hpp>
@@ -173,6 +175,9 @@ void database::initialize_evaluators()
    register_evaluator<asset_claim_fees_evaluator>();
    register_evaluator<asset_update_issuer_evaluator>();
    register_evaluator<asset_claim_pool_evaluator>();
+   register_evaluator<custom_authority_create_evaluator>();
+   register_evaluator<custom_authority_update_evaluator>();
+   register_evaluator<custom_authority_delete_evaluator>();
 }
 
 void database::initialize_indexes()
@@ -216,6 +221,7 @@ void database::initialize_indexes()
    add_index< primary_index< special_authority_index                      > >();
    add_index< primary_index< buyback_index                                > >();
    add_index< primary_index<collateral_bid_index                          > >();
+   add_index< primary_index<custom_authority_index                        > >();
 
    add_index< primary_index< simple_index< fba_accumulator_object       > > >();
 }

libraries/chain/db_notify.cpp

@@ -256,6 +256,19 @@ struct get_impacted_account_visitor
    {
       _impacted.insert( op.fee_payer() ); // account_id
    }
+   void operator()( const custom_authority_create_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // account
+      add_authority_accounts( _impacted, op.auth );
+   }
+   void operator()( const custom_authority_update_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // account
+   }
+   void operator()( const custom_authority_delete_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // account
+   }
 };
 
 void graphene::chain::operation_get_impacted_accounts( const operation& op, flat_set<account_id_type>& result )
@@ -406,6 +419,12 @@ void get_relevant_accounts( const object* obj, flat_set<account_id_type>& accoun
               FC_ASSERT( aobj != nullptr );
               accounts.insert( aobj->bidder );
               break;
+           } case impl_custom_authority_object_type:{
+              const auto& aobj = dynamic_cast<const custom_authority_object*>(obj);
+              FC_ASSERT( aobj != nullptr );
+              accounts.insert( aobj->account );
+              add_authority_accounts( accounts, aobj->auth );
+              break;
            }
       }
    }

libraries/chain/include/graphene/chain/custom_authority_evaluator.hpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2018 Abit More, 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/chain/evaluator.hpp>
+
+namespace graphene { namespace chain {
+
+class custom_authority_create_evaluator : public evaluator<custom_authority_create_evaluator>
+{
+public:
+   typedef custom_authority_create_operation operation_type;
+
+   void_result do_evaluate( const operation_type& op );
+   object_id_type do_apply( const operation_type& op );
+};
+
+class custom_authority_update_evaluator : public evaluator<custom_authority_update_evaluator>
+{
+public:
+   typedef custom_authority_update_operation operation_type;
+
+   void_result do_evaluate( const operation_type& op );
+   void_result do_apply( const operation_type& op );
+};
+
+class custom_authority_delete_evaluator : public evaluator<custom_authority_delete_evaluator>
+{
+public:
+   typedef custom_authority_delete_operation operation_type;
+
+   void_result do_evaluate( const operation_type& op );
+   void_result do_apply( const operation_type& op );
+};
+
+} } // graphene::chain

libraries/chain/include/graphene/chain/custom_authority_object.hpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2018 Abit More, 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/chain/protocol/authority.hpp>
+#include <graphene/chain/protocol/custom_authority.hpp>
+#include <graphene/db/generic_index.hpp>
+#include <boost/multi_index/composite_key.hpp>
+
+namespace graphene { namespace chain {
+
+   /**
+    * @brief Tracks account custom authorities
+    * @ingroup object
+    *
+    */
+   class custom_authority_object : public abstract_object<custom_authority_object>
+   {
+      public:
+         static const uint8_t space_id = implementation_ids;
+         static const uint8_t type_id  = impl_custom_authority_object_type;
+
+         account_id_type                 account;
+         uint32_t                        custom_id;
+         bool                            enabled;
+         time_point_sec                  valid_from;
+         time_point_sec                  valid_to;
+         unsigned_int                    operation_type;
+         authority                       auth;
+         vector<restriction>             restrictions;
+   };
+
+   struct by_account_custom;
+
+   /**
+    * @ingroup object_index
+    */
+   typedef multi_index_container<
+      custom_authority_object,
+      indexed_by<
+         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,
+         ordered_unique< tag<by_account_custom>,
+            composite_key<
+               custom_authority_object,
+               member<custom_authority_object, account_id_type, &custom_authority_object::account>,
+               member<custom_authority_object, uint32_t, &custom_authority_object::custom_id>
+            >
+         >
+      >
+   > custom_authority_multi_index_type;
+
+   /**
+    * @ingroup object_index
+    */
+   typedef generic_index<custom_authority_object, custom_authority_multi_index_type> custom_authority_index;
+
+} } // graphene::chain
+
+FC_REFLECT_DERIVED( graphene::chain::custom_authority_object,
+                    (graphene::db::object),
+                    (account)
+                    (custom_id)
+                    (enabled)
+                    (valid_from)
+                    (valid_to)
+                    (operation_type)
+                    (auth)
+                    (restrictions)
+                  )