Hashed Time-Locked Contracts

libraries/chain/CMakeLists.txt

@@ -58,7 +58,7 @@ add_library( graphene_chain
              protocol/fee_schedule.cpp
              protocol/confidential.cpp
              protocol/vote.cpp
-
+             protocol/htlc.cpp
              genesis_state.cpp
              get_config.cpp
 
@@ -77,6 +77,7 @@ add_library( graphene_chain
              vesting_balance_evaluator.cpp
              withdraw_permission_evaluator.cpp
              worker_evaluator.cpp
+             htlc_evaluator.cpp
              confidential_evaluator.cpp
              special_authority.cpp
              buyback.cpp

libraries/chain/committee_member_evaluator.cpp

@@ -24,6 +24,7 @@
 #include <graphene/chain/committee_member_evaluator.hpp>
 #include <graphene/chain/committee_member_object.hpp>
 #include <graphene/chain/database.hpp>
+#include <graphene/chain/hardfork.hpp>
 #include <graphene/chain/account_object.hpp>
 #include <graphene/chain/protocol/fee_schedule.hpp>
 #include <graphene/chain/protocol/vote.hpp>
@@ -77,6 +78,9 @@ void_result committee_member_update_global_parameters_evaluator::do_evaluate(con
 { try {
    FC_ASSERT(trx_state->_is_proposed_trx);
 
+   FC_ASSERT( db().head_block_time() > HARDFORK_CORE_1468_TIME || !o.new_parameters.extensions.value.updatable_htlc_options.valid(), 
+         "Unable to set HTLC parameters until hardfork." );
+
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 

libraries/chain/db_block.cpp

@@ -584,6 +584,7 @@ void database::_apply_block( const signed_block& next_block )
    clear_expired_transactions();
    clear_expired_proposals();
    clear_expired_orders();
+   clear_expired_htlcs();
    update_expired_feeds();       // this will update expired feeds and some core exchange rates
    update_core_exchange_rates(); // this will update remaining core exchange rates
    update_withdraw_permissions();

libraries/chain/db_init.cpp

@@ -45,6 +45,7 @@
 #include <graphene/chain/witness_object.hpp>
 #include <graphene/chain/witness_schedule_object.hpp>
 #include <graphene/chain/worker_object.hpp>
+#include <graphene/chain/htlc_object.hpp>
 
 #include <graphene/chain/account_evaluator.hpp>
 #include <graphene/chain/asset_evaluator.hpp>
@@ -60,6 +61,7 @@
 #include <graphene/chain/withdraw_permission_evaluator.hpp>
 #include <graphene/chain/witness_evaluator.hpp>
 #include <graphene/chain/worker_evaluator.hpp>
+#include <graphene/chain/htlc_evaluator.hpp>
 
 #include <graphene/chain/protocol/fee_schedule.hpp>
 
@@ -125,6 +127,9 @@ const uint8_t witness_object::type_id;
 const uint8_t worker_object::space_id;
 const uint8_t worker_object::type_id;
 
+const uint8_t htlc_object::space_id;
+const uint8_t htlc_object::type_id;
+
 
 void database::initialize_evaluators()
 {
@@ -173,6 +178,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<htlc_create_evaluator>();
+   register_evaluator<htlc_redeem_evaluator>();
+   register_evaluator<htlc_extend_evaluator>();
 }
 
 void database::initialize_indexes()
@@ -201,6 +209,7 @@ void database::initialize_indexes()
    add_index< primary_index<worker_index> >();
    add_index< primary_index<balance_index> >();
    add_index< primary_index<blinded_balance_index> >();
+   add_index< primary_index< htlc_index> >();
 
    //Implementation object indexes
    add_index< primary_index<transaction_index                             > >();
@@ -216,7 +225,6 @@ 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< simple_index< fba_accumulator_object       > > >();
 }
 

libraries/chain/db_notify.cpp

@@ -7,6 +7,7 @@
 #include <graphene/chain/database.hpp>
 #include <graphene/chain/worker_object.hpp>
 #include <graphene/chain/confidential_object.hpp>
+#include <graphene/chain/htlc_object.hpp>
 #include <graphene/chain/market_object.hpp>
 #include <graphene/chain/committee_member_object.hpp>
 #include <graphene/chain/witness_object.hpp>
@@ -256,6 +257,22 @@ struct get_impacted_account_visitor
    {
       _impacted.insert( op.fee_payer() ); // account_id
    }
+   void operator()( const htlc_create_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); 
+   }
+   void operator()( const htlc_redeem_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); 
+   }
+   void operator()( const htlc_extend_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); 
+   }
+   void operator()( const htlc_refund_operation& op ) 
+   { 
+      _impacted.insert( op.fee_payer() );
+   }
 };
 
 void graphene::chain::operation_get_impacted_accounts( const operation& op, flat_set<account_id_type>& result )
@@ -344,6 +361,12 @@ void get_relevant_accounts( const object* obj, flat_set<account_id_type>& accoun
         } case balance_object_type:{
            /** these are free from any accounts */
            break;
+        } case htlc_object_type:{
+              const auto& htlc_obj = dynamic_cast<const htlc_object*>(obj);
+              FC_ASSERT( htlc_obj != nullptr );
+              accounts.insert( htlc_obj->from );
+              accounts.insert( htlc_obj->to );
+              break;
         }
       }
    }

libraries/chain/db_update.cpp

@@ -28,6 +28,7 @@
 #include <graphene/chain/asset_object.hpp>
 #include <graphene/chain/global_property_object.hpp>
 #include <graphene/chain/hardfork.hpp>
+#include <graphene/chain/htlc_object.hpp>
 #include <graphene/chain/market_object.hpp>
 #include <graphene/chain/proposal_object.hpp>
 #include <graphene/chain/transaction_object.hpp>
@@ -558,4 +559,22 @@ void database::update_withdraw_permissions()
       remove(*permit_index.begin());
 }
 
+void database::clear_expired_htlcs()
+{
+   const auto& htlc_idx = get_index_type<htlc_index>().indices().get<by_expiration>();
+   while ( htlc_idx.begin() != htlc_idx.end()
+         && htlc_idx.begin()->expiration <= head_block_time() )
+   {
+      const htlc_object& obj = *htlc_idx.begin();
+      adjust_balance( obj.from, obj.amount );
+      // virtual op
+      htlc_refund_operation vop( obj.id, obj.from );
+      vop.htlc_id = htlc_idx.begin()->id;
+      push_applied_operation( vop );
+
+      // remove the db object
+      remove( *htlc_idx.begin() );
+   }
+}
+
 } }

libraries/chain/hardfork.d/core-1468.hf

@@ -0,0 +1,4 @@
+// HTLC implementation
+#ifndef HARDFORK_CORE_1468_TIME
+#define HARDFORK_CORE_1468_TIME (fc::time_point_sec( 1600000000 ) )
+#endif

libraries/chain/htlc_evaluator.cpp

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2018 jmjatlanta 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/database.hpp>
+#include <graphene/chain/htlc_evaluator.hpp>
+#include <graphene/chain/htlc_object.hpp>
+#include <graphene/chain/hardfork.hpp>
+
+namespace graphene { 
+   namespace chain {
+
+      optional<htlc_options> get_committee_htlc_options(graphene::chain::database& db)
+      {
+         return db.get_global_properties().parameters.extensions.value.updatable_htlc_options;
+      }
+
+      void_result htlc_create_evaluator::do_evaluate(const htlc_create_operation& o)
+      {
+         optional<htlc_options> htlc_options = get_committee_htlc_options(db());
+
+         FC_ASSERT(htlc_options, "HTLC Committee options are not set.");
+
+         // make sure the expiration is reasonable
+         FC_ASSERT( o.claim_period_seconds <= htlc_options->max_timeout_secs, "HTLC Timeout exceeds allowed length" );
+         // make sure the preimage length is reasonable
+         FC_ASSERT( o.preimage_size <= htlc_options->max_preimage_size, "HTLC preimage length exceeds allowed length" ); 
+         // make sure the sender has the funds for the HTLC
+         FC_ASSERT( db().get_balance( o.from, o.amount.asset_id) >= (o.amount), "Insufficient funds") ;
+         return void_result();
+      }
+
+      object_id_type htlc_create_evaluator::do_apply(const htlc_create_operation& o)
+      {
+         try {
+            graphene::chain::database& dbase = db();
+            dbase.adjust_balance( o.from, -o.amount );
+
+            const htlc_object& esc = db().create<htlc_object>([&dbase,&o]( htlc_object& esc ) {
+               esc.from                  = o.from;
+               esc.to                    = o.to;
+               esc.amount                = o.amount;
+               esc.preimage_hash         = o.preimage_hash;
+               esc.preimage_size         = o.preimage_size;
+               esc.expiration            = dbase.head_block_time() + o.claim_period_seconds;
+            });
+            return  esc.id;
+
+         } FC_CAPTURE_AND_RETHROW( (o) )
+      }
+
+      class htlc_redeem_visitor
+      {
+      //private:
+         const std::vector<uint8_t>& data;
+      public:
+         typedef bool result_type;
+
+         htlc_redeem_visitor( const std::vector<uint8_t>& preimage )
+            : data( preimage ) {}
+
+         template<typename T>
+         bool operator()( const T& preimage_hash )const
+         {
+            return T::hash( (const char*)data.data(), (uint32_t) data.size() ) == preimage_hash;
+         }
+      };
+
+      void_result htlc_redeem_evaluator::do_evaluate(const htlc_redeem_operation& o)
+      {
+         htlc_obj = &db().get<htlc_object>(o.htlc_id);
+
+         FC_ASSERT(o.preimage.size() == htlc_obj->preimage_size, "Preimage size mismatch.");
+
+         const htlc_redeem_visitor vtor( o.preimage );
+         FC_ASSERT( htlc_obj->preimage_hash.visit( vtor ), "Provided preimage does not generate correct hash.");
+
+         return void_result();
+      }
+
+      void_result htlc_redeem_evaluator::do_apply(const htlc_redeem_operation& o)
+      {
+         db().adjust_balance(htlc_obj->to, htlc_obj->amount);
+         db().remove(*htlc_obj);
+         return void_result();
+      }
+
+      void_result htlc_extend_evaluator::do_evaluate(const htlc_extend_operation& o)
+      {
+         htlc_obj = &db().get<htlc_object>(o.htlc_id);
+         return void_result();
+      }
+
+      void_result htlc_extend_evaluator::do_apply(const htlc_extend_operation& o)
+      {
+         db().modify(*htlc_obj, [&o](htlc_object& db_obj) {
+            db_obj.expiration += o.seconds_to_add;
+         });
+
+         return void_result();
+      }
+
+   } // namespace chain
+} // namespace graphene

libraries/chain/include/graphene/chain/database.hpp

@@ -466,6 +466,7 @@ namespace graphene { namespace chain {
          void update_withdraw_permissions();
          bool check_for_blackswan( const asset_object& mia, bool enable_black_swan = true,
                                    const asset_bitasset_data_object* bitasset_ptr = nullptr );
+         void clear_expired_htlcs();
 
          ///Steps performed only at maintenance intervals
          ///@{

libraries/chain/include/graphene/chain/htlc_evaluator.hpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 jmjatlanta 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 htlc_create_evaluator : public evaluator<htlc_create_evaluator>
+      {
+         public:
+    	      typedef htlc_create_operation operation_type;
+
+    	      void_result do_evaluate( const htlc_create_operation& o);
+    	      object_id_type do_apply( const htlc_create_operation& o);
+      };
+
+      class htlc_redeem_evaluator : public evaluator<htlc_redeem_evaluator>
+      {
+         public:
+    	      typedef htlc_redeem_operation operation_type;
+
+    	      void_result do_evaluate( const htlc_redeem_operation& o);
+    	      void_result do_apply( const htlc_redeem_operation& o);
+    	      const htlc_object* htlc_obj = nullptr;
+      };
+
+      class htlc_extend_evaluator : public evaluator<htlc_extend_evaluator>
+      {
+         public:
+    	      typedef htlc_extend_operation operation_type;
+
+    	      void_result do_evaluate( const htlc_extend_operation& o);
+    	      void_result do_apply( const htlc_extend_operation& o);
+    	      const htlc_object* htlc_obj = nullptr;
+      };
+   } // namespace graphene
+} // namespace graphene