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 );
@@ -57,6 +64,8 @@ namespace graphene {
          FC_ASSERT( is_authorized_asset( d, to_account, asset_to_transfer ), 
                "Asset ${asset} is not authorized for account ${acct}.", 
                ( "asset", asset_to_transfer.id )( "acct", to_account.id ) );
+         FC_ASSERT( d.head_block_time() < HARDFORK_CORE_BSIP64_TIME || !asset_to_transfer.is_transfer_restricted(), 
+               "Asset ${asset} cannot be transfered.", ("asset", asset_to_transfer.id) );   
          return void_result();
       }
 
@@ -73,6 +82,8 @@ namespace graphene {
                esc.transfer.asset_id              = o.amount.asset_id;
                esc.conditions.hash_lock.preimage_hash = o.preimage_hash;
                esc.conditions.hash_lock.preimage_size = o.preimage_size;
+               if ( o.extensions.value.memo.valid() )
+                  esc.memo = o.extensions.value.memo;
                esc.conditions.time_lock.expiration    = dbase.head_block_time() + o.claim_period_seconds;
             });
             return  esc.id;
@@ -100,8 +111,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/chain/proposal_evaluator.cpp

@@ -61,6 +61,11 @@ struct proposal_operation_hardfork_visitor
          FC_ASSERT(!op.new_parameters.current_fees->exists<htlc_redeem_operation>());
          FC_ASSERT(!op.new_parameters.current_fees->exists<htlc_extend_operation>());
       }
+      if (block_time < HARDFORK_CORE_BSIP64_TIME) 
+      {
+         FC_ASSERT( op.new_parameters.current_fees->get<htlc_create_operation>().fee_per_kb == 0,
+               "Unable to set htlc_create_operation per_kb_fee until after BSIP 64 hardfork");
+      }
       if (!HARDFORK_BSIP_40_PASSED(block_time)) {
          FC_ASSERT(!op.new_parameters.extensions.value.custom_authority_options.valid(),
                    "Unable to set Custom Authority Options before hardfork BSIP 40");

libraries/chain/small_objects.cpp

@@ -128,7 +128,7 @@ FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::htlc_object::condition_info::ti
 FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::htlc_object::condition_info, BOOST_PP_SEQ_NIL,
    (hash_lock)(time_lock) )
 FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::htlc_object, (graphene::db::object),
-               (transfer) (conditions) )
+               (transfer) (conditions) (memo) )
 
 FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::operation_history_object, (graphene::chain::object),
                     (op)(result)(block_num)(trx_in_block)(op_in_trx)(virtual_op) )

libraries/protocol/htlc.cpp

@@ -39,8 +39,11 @@ namespace graphene { namespace protocol {
       uint64_t days = ( claim_period_seconds + SECONDS_PER_DAY - 1 ) / SECONDS_PER_DAY;
       // multiply with overflow check
       uint64_t per_day_fee = fee_params.fee_per_day * days;
+      uint64_t per_kb_fee = 0;
+      if (extensions.value.memo.valid())
+         per_kb_fee = calculate_data_fee( fc::raw::pack_size(extensions.value.memo), fee_params.fee_per_kb);
       FC_ASSERT( days == 0 || per_day_fee / days == fee_params.fee_per_day, "Fee calculation overflow" );
-      return fee_params.fee + per_day_fee;
+      return fee_params.fee + per_day_fee + per_kb_fee;
    }
 
    void htlc_redeem_operation::validate()const {

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

@@ -26,25 +26,30 @@
 #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 
       {
          struct fee_parameters_type {
             uint64_t fee = 1 * GRAPHENE_BLOCKCHAIN_PRECISION;
             uint64_t fee_per_day = 1 * GRAPHENE_BLOCKCHAIN_PRECISION;
+            uint64_t fee_per_kb = 0;
          };
+
          // paid to network
          asset fee;
          // where the held monies are to come from
@@ -59,8 +64,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 +147,7 @@ namespace graphene { namespace protocol {
          uint16_t htlc_preimage_size;
 
          asset fee;
+         std::vector<char> preimage;
       };
 
       struct htlc_extend_operation : public base_operation
@@ -205,7 +216,8 @@ 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::fee_parameters_type, (fee) (fee_per_day) (fee_per_kb) )
+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 +233,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/include/graphene/wallet/wallet.hpp

@@ -1446,12 +1446,13 @@ class wallet_api
        * @param preimage_hash the hash of the preimage
        * @param preimage_size the size of the preimage in bytes
        * @param claim_period_seconds how long after creation until the lock expires
+       * @param memo the memo
        * @param broadcast true if you wish to broadcast the transaction
        * @return the signed transaction
        */
       signed_transaction htlc_create( string source, string destination, string amount, string asset_symbol,
             string hash_algorithm, const std::string& preimage_hash, uint32_t preimage_size,
-            const uint32_t claim_period_seconds, bool broadcast = false );
+            const uint32_t claim_period_seconds, const std::string& memo, bool broadcast = false );
 
       /****
        * Update a hashed time lock contract

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 {
@@ -135,13 +139,32 @@ std::string operation_printer::operator()(const asset_create_operation& op) cons
 
 std::string operation_printer::operator()(const htlc_redeem_operation& op) const
 {
+   auto flags = out.flags();
+   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 \"";
+   out << std::hex;
+   for (unsigned char c : op.preimage)
+      out << c;
+   out.flags(flags);
+   out << "\"";
+   return fee(op.fee);
+}
+
+std::string operation_printer::operator()(const htlc_redeemed_operation& op) const
+{
+   auto flags = out.flags();
    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 \"";
+   out << std::hex;
    for (unsigned char c : op.preimage)
       out << c;
+   out.flags(flags);
    out << "\"";
    return fee(op.fee);
 }

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

@@ -202,10 +202,10 @@ uint64_t wallet_api::get_asset_count()const
 
 signed_transaction wallet_api::htlc_create( string source, string destination, string amount, string asset_symbol,
          string hash_algorithm, const std::string& preimage_hash, uint32_t preimage_size,
-         const uint32_t claim_period_seconds, bool broadcast)
+         const uint32_t claim_period_seconds, const std::string& memo, bool broadcast)
 {
    return my->htlc_create(source, destination, amount, asset_symbol, hash_algorithm, preimage_hash, preimage_size,
-         claim_period_seconds, broadcast);
+         claim_period_seconds, memo, broadcast);
 }
 
 fc::optional<fc::variant> wallet_api::get_htlc(std::string htlc_id) const
@@ -223,6 +223,8 @@ fc::optional<fc::variant> wallet_api::get_htlc(std::string htlc_id) const
       const auto& asset = my->get_asset( obj.transfer.asset_id );
       transfer["asset"] = asset.symbol;
       transfer["amount"] = graphene::app::uint128_amount_to_string( obj.transfer.amount.value, asset.precision );
+      if (obj.memo.valid())
+         transfer["memo"] = my->read_memo( *obj.memo );
       class htlc_hash_to_variant_visitor
       {
          public:
@@ -234,6 +236,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
          {

libraries/wallet/wallet_api_impl.hpp

@@ -300,7 +300,7 @@ class wallet_api_impl
 
    signed_transaction htlc_create( string source, string destination, string amount, string asset_symbol,
          string hash_algorithm, const std::string& preimage_hash, uint32_t preimage_size,
-         const uint32_t claim_period_seconds, bool broadcast = false );
+         const uint32_t claim_period_seconds, const std::string& memo, bool broadcast = false );
 
    signed_transaction htlc_redeem( string htlc_id, string issuer, const std::vector<char>& preimage, bool broadcast );
 

libraries/wallet/wallet_transfer.cpp

@@ -43,6 +43,8 @@ namespace graphene { namespace wallet { namespace detail {
          return fc::sha256( hash );
       if( name_upper == "SHA1" )
          return fc::sha1( hash );
+      if( name_upper == "HASH160" )
+         return fc::hash160( hash );
       FC_THROW_EXCEPTION( fc::invalid_arg_exception, "Unknown algorithm '${a}'", ("a",algorithm) );
    }
 
@@ -83,21 +85,32 @@ namespace graphene { namespace wallet { namespace detail {
 
    signed_transaction wallet_api_impl::htlc_create( string source, string destination, string amount, string asset_symbol,
          string hash_algorithm, const std::string& preimage_hash, uint32_t preimage_size,
-         const uint32_t claim_period_seconds, bool broadcast )
+         const uint32_t claim_period_seconds, const std::string& memo, bool broadcast )
    {
       try
       {
          FC_ASSERT( !self.is_locked() );
          fc::optional<asset_object> asset_obj = get_asset(asset_symbol);
          FC_ASSERT(asset_obj, "Could not find asset matching ${asset}", ("asset", asset_symbol));
 
+         const account_object& from_acct = get_account(source);
+         const account_object& to_acct = get_account(destination);
          htlc_create_operation create_op;
          create_op.from = get_account(source).id;
          create_op.to = get_account(destination).id;
          create_op.amount = asset_obj->amount_from_string(amount);
          create_op.claim_period_seconds = claim_period_seconds;
          create_op.preimage_hash = do_hash( hash_algorithm, preimage_hash );
          create_op.preimage_size = preimage_size;
+         if (!memo.empty())
+         {
+            memo_data data;
+            data.from = from_acct.options.memo_key;
+            data.to = to_acct.options.memo_key;
+            data.set_message( 
+                  get_private_key(from_acct.options.memo_key), to_acct.options.memo_key, memo);
+            create_op.extensions.value.memo = data;
+         }
 
          signed_transaction tx;
          tx.operations.push_back(create_op);

programs/build_helpers/member_enumerator.cpp

@@ -103,7 +103,7 @@ void class_processor::process_class( const static_variant< T... >* dummy )
    static_variant<T...> dummy2;
    static_variant_visitor vtor( this );
 
-   for( int w=0; w<dummy2.count(); w++ )
+   for( size_t w=0; w<dummy2.count(); w++ )
    {
       dummy2.set_which(w);
       dummy2.visit( vtor );

programs/js_operation_serializer/main.cpp

@@ -293,7 +293,7 @@ struct serializer< fc::static_variant<T...>, false >
       {
          init = true;
          fc::static_variant<T...> var;
-         for( int i = 0; i < var.count(); ++i )
+         for( size_t i = 0; i < var.count(); ++i )
          {
             var.set_which(i);
             var.visit( register_type_visitor() );
@@ -372,7 +372,7 @@ int main( int argc, char** argv )
     operation op;
 
     std::cout << "ChainTypes.operations=\n";
-    for( int i = 0; i < op.count(); ++i )
+    for( size_t i = 0; i < op.count(); ++i )
     {
        op.set_which(i);
        op.visit( detail_ns::serialize_type_visitor(i) );

programs/size_checker/main.cpp

@@ -85,7 +85,7 @@ int main( int argc, char** argv )
 
       idump( (witnesses) );
 
-      for( int32_t i = 0; i < op.count(); ++i )
+      for( size_t i = 0; i < op.count(); ++i )
       {
          op.set_which(i);
          op.visit( size_check_type_visitor(i) );