HTLC Changes

libraries/chain/hardfork.d/CORE_BSIP64.hf

@@ -0,0 +1,4 @@
+// bitshares BSIP 64 HTLC modifications
+#ifndef HARDFORK_CORE_BSIP64_TIME
+#define HARDFORK_CORE_BSIP64_TIME (fc::time_point_sec( 1600000000 ) ) // Sep 2020
+#endif

libraries/chain/htlc_evaluator.cpp

@@ -48,6 +48,13 @@ namespace graphene {
          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( d.get_balance( o.from, o.amount.asset_id) >= (o.amount), "Insufficient funds") ;
+         // memo field added at harfork BSIP64
+         // NOTE: this check can be removed after hardfork time
+         FC_ASSERT( d.head_block_time() > HARDFORK_CORE_BSIP64_TIME || !o.extensions.value.memo.valid(), 
+               "Memo unavailable until after HARDFORK BSIP64");
+         // HASH160 added at hardfork BSIP64
+         FC_ASSERT( d.head_block_time() > HARDFORK_CORE_BSIP64_TIME || o.preimage_hash.which() != 
+               htlc_hash(fc::hash160()).which(), "HASH160 unavailable until after HARDFORK BSIP64" );
          const auto& asset_to_transfer = o.amount.asset_id( d );
          const auto& from_account = o.from( d );
          const auto& to_account = o.to( d );
@@ -74,6 +81,8 @@ namespace graphene {
                esc.conditions.hash_lock.preimage_hash = o.preimage_hash;
                esc.conditions.hash_lock.preimage_size = o.preimage_size;
                esc.conditions.time_lock.expiration    = dbase.head_block_time() + o.claim_period_seconds;
+               if ( o.extensions.value.memo.valid() )
+                  esc.memo = o.extensions.value.memo;
             });
             return  esc.id;
 
@@ -100,8 +109,11 @@ namespace graphene {
       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->conditions.hash_lock.preimage_size, "Preimage size mismatch.");
+         // TODO: The hardfork portion of this check can be removed if no HTLC redemptions are 
+         // attempted on an HTLC with a 0 preimage size before the hardfork date.
+         if ( htlc_obj->conditions.hash_lock.preimage_size > 0U || 
+               db().head_block_time() <= HARDFORK_CORE_BSIP64_TIME )
+            FC_ASSERT(o.preimage.size() == htlc_obj->conditions.hash_lock.preimage_size, "Preimage size mismatch.");
          const htlc_redeem_visitor vtor( o.preimage );
          FC_ASSERT( htlc_obj->conditions.hash_lock.preimage_hash.visit( vtor ), 
                "Provided preimage does not generate correct hash.");

libraries/chain/include/graphene/chain/htlc_object.hpp

@@ -59,6 +59,8 @@ namespace graphene { namespace chain {
             } time_lock;
          } conditions;
 
+         fc::optional<memo_data> memo;
+
       /****
        * Index helper for timelock
        */

libraries/protocol/include/graphene/protocol/htlc.hpp

@@ -26,17 +26,20 @@
 #include <fc/time.hpp>
 #include <graphene/protocol/base.hpp>
 #include <graphene/protocol/asset.hpp>
+#include <graphene/protocol/memo.hpp>
 #include <algorithm> // std::max
 
 namespace graphene { namespace protocol {
       typedef fc::ripemd160    htlc_algo_ripemd160;
       typedef fc::sha1         htlc_algo_sha1;
       typedef fc::sha256       htlc_algo_sha256;
+      typedef fc::hash160      htlc_algo_hash160;
 
       typedef fc::static_variant<
          htlc_algo_ripemd160,
          htlc_algo_sha1,
-         htlc_algo_sha256
+         htlc_algo_sha256,
+         htlc_algo_hash160
       > htlc_hash;
 
       struct htlc_create_operation : public base_operation 
@@ -45,6 +48,7 @@ namespace graphene { namespace protocol {
             uint64_t fee = 1 * GRAPHENE_BLOCKCHAIN_PRECISION;
             uint64_t fee_per_day = 1 * GRAPHENE_BLOCKCHAIN_PRECISION;
          };
+
          // paid to network
          asset fee;
          // where the held monies are to come from
@@ -59,8 +63,13 @@ namespace graphene { namespace protocol {
          uint16_t preimage_size;
          // The time the funds will be returned to the source if not claimed
          uint32_t claim_period_seconds;
-         // for future expansion
-         extensions_type extensions;
+
+         // additional extensions
+         struct additional_options_type
+         {
+            fc::optional<memo_data> memo;
+         };
+         extension<additional_options_type> extensions;
 
          /***
           * @brief Does simple validation of this object
@@ -137,6 +146,7 @@ namespace graphene { namespace protocol {
          uint16_t htlc_preimage_size;
 
          asset fee;
+         std::vector<char> preimage;
       };
 
       struct htlc_extend_operation : public base_operation
@@ -206,6 +216,7 @@ namespace graphene { namespace protocol {
 FC_REFLECT_TYPENAME( graphene::protocol::htlc_hash )
 
 FC_REFLECT( graphene::protocol::htlc_create_operation::fee_parameters_type, (fee) (fee_per_day) )
+FC_REFLECT( graphene::protocol::htlc_create_operation::additional_options_type, (memo))
 FC_REFLECT( graphene::protocol::htlc_redeem_operation::fee_parameters_type, (fee) (fee_per_kb) )
 FC_REFLECT( graphene::protocol::htlc_redeemed_operation::fee_parameters_type, ) // VIRTUAL
 FC_REFLECT( graphene::protocol::htlc_extend_operation::fee_parameters_type, (fee) (fee_per_day))
@@ -221,6 +232,7 @@ FC_REFLECT( graphene::protocol::htlc_refund_operation,
       (fee)(htlc_id)(to)(original_htlc_recipient)(htlc_amount)(htlc_preimage_hash)(htlc_preimage_size))
 
 GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::htlc_create_operation::fee_parameters_type )
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::htlc_create_operation::additional_options_type )
 GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::htlc_redeem_operation::fee_parameters_type )
 GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::htlc_extend_operation::fee_parameters_type )
 GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::htlc_create_operation )

libraries/protocol/include/graphene/protocol/types.hpp

@@ -44,6 +44,7 @@
 #include <fc/crypto/sha1.hpp>
 #include <fc/crypto/sha224.hpp>
 #include <fc/crypto/sha256.hpp>
+#include <fc/crypto/hash160.hpp>
 #include <fc/crypto/elliptic.hpp>
 #include <fc/reflect/reflect.hpp>
 #include <fc/reflect/variant.hpp>

libraries/wallet/operation_printer.cpp

@@ -47,6 +47,10 @@ class htlc_hash_to_string_visitor
    {
       return "SHA256 " + hash.str();
    }
+   result_type operator()( const fc::hash160& hash )const
+   {
+      return "HASH160 " + hash.str();
+   }
 };
 
 std::string operation_printer::fee(const graphene::protocol::asset& a)const {
@@ -146,6 +150,19 @@ std::string operation_printer::operator()(const htlc_redeem_operation& op) const
    return fee(op.fee);
 }
 
+std::string operation_printer::operator()(const htlc_redeemed_operation& op) const
+{
+   out << "Redeem HTLC with database id "
+         << std::to_string(op.htlc_id.space_id)
+         << "." << std::to_string(op.htlc_id.type_id)
+         << "." << std::to_string((uint64_t)op.htlc_id.instance)
+         << " with preimage \"";
+   for (unsigned char c : op.preimage)
+      out << c;
+   out << "\"";
+   return fee(op.fee);
+}
+
 std::string operation_printer::operator()(const htlc_create_operation& op) const
 {
    static htlc_hash_to_string_visitor vtor;

libraries/wallet/operation_printer.hpp

@@ -98,6 +98,7 @@ struct operation_printer
    std::string operator()(const graphene::protocol::asset_create_operation& op)const;
    std::string operator()(const graphene::protocol::htlc_create_operation& op)const;
    std::string operator()(const graphene::protocol::htlc_redeem_operation& op)const;
+   std::string operator()(const graphene::protocol::htlc_redeemed_operation& op)const;
 };
 
 }}} // namespace graphene::wallet::detail

libraries/wallet/wallet.cpp

@@ -234,6 +234,8 @@ fc::optional<fc::variant> wallet_api::get_htlc(std::string htlc_id) const
          { return convert("SHA1", obj.str()); }
          result_type operator()(const fc::sha256& obj)const
          { return convert("SHA256", obj.str()); }
+         result_type operator()(const fc::hash160& obj)const
+         { return convert("HASH160", obj.str()); }
          private:
          result_type convert(const std::string& type, const std::string& hash)const
          {