HTLC Changes

libraries/chain/htlc_evaluator.cpp

@@ -60,7 +60,7 @@ namespace graphene {
             // 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 || 
-                  block_time <= HARDFORK_CORE_BSIP64_TIME )
+                  block_time < HARDFORK_CORE_BSIP64_TIME )
                FC_ASSERT(op.preimage.size() == htlc_obj->conditions.hash_lock.preimage_size, "Preimage size mismatch.");
          }
       } // end of graphene::chain::details
@@ -92,7 +92,7 @@ namespace graphene {
                ( "asset", asset_to_transfer.id )( "acct", from_account.id ) );
          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 ) );  
+               ( "asset", asset_to_transfer.id )( "acct", to_account.id ) );
          return void_result();
       }
 

libraries/protocol/fee_schedule_calc.cpp

@@ -61,7 +61,7 @@ namespace graphene { namespace protocol {
    template<>
    uint64_t calc_fee_visitor::operator()(const htlc_create_operation& op)const
    {
-      transfer_operation::fee_parameters_type t;
+      transfer_operation::fee_parameters_type t = param.get<transfer_operation>();
       return op.calculate_fee( param.get<htlc_create_operation>(), t.price_per_kbyte).value;
    }
 

libraries/protocol/htlc.cpp

@@ -38,12 +38,11 @@ namespace graphene { namespace protocol {
    {
       uint64_t days = ( claim_period_seconds + SECONDS_PER_DAY - 1 ) / SECONDS_PER_DAY;
       // multiply with overflow check
-      share_type per_day_fee = fee_params.fee_per_day * days;
-      share_type per_kb_fee = 0;
+      share_type total_fee = fee_params.fee; 
+      total_fee += share_type(fee_params.fee_per_day) * days;
       if (extensions.value.memo.valid())
-         per_kb_fee = calculate_data_fee( fc::raw::pack_size(extensions.value.memo), 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 + per_kb_fee;
+         total_fee += calculate_data_fee( fc::raw::pack_size(extensions.value.memo), fee_per_kb);
+      return total_fee;
    }
 
    void htlc_redeem_operation::validate()const {

libraries/wallet/operation_printer.cpp

@@ -90,6 +90,32 @@ string operation_printer::print_memo( const fc::optional<graphene::protocol::mem
    return outstr;  
 }
 
+void operation_printer::print_preimage(const std::vector<char>& preimage)const
+{
+   if (preimage.size() == 0)
+      return;
+   out << " with preimage \"";
+   // cut it at 50 bytes max
+   auto flags = out.flags();
+   out << std::hex << setw(2) << setfill('0');
+   for (size_t i = 0; i < std::min<size_t>(50, preimage.size()); i++)
+      out << +preimage[i];
+   out.flags(flags);
+   if (preimage.size() > 50)
+      out << "...(truncated due to size)";
+   out << "\"";
+}
+
+string operation_printer::print_redeem(const graphene::protocol::htlc_id_type& id,
+      const std::string& redeemer, const std::vector<char>& preimage, 
+      const graphene::protocol::asset& op_fee)const
+{
+   out << redeemer << " redeemed HTLC with id "
+         << std::string( static_cast<object_id_type>(id));
+   print_preimage( preimage );
+   return fee(op_fee);
+}
+
 std::string operation_printer::operator()(const transfer_from_blind_operation& op)const
 {
    auto a = wallet.get_asset( op.fee.asset_id );
@@ -146,34 +172,12 @@ 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);
+   return print_redeem(op.htlc_id, wallet.get_account(op.redeemer).name, op.preimage, 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);
+   return print_redeem(op.htlc_id, wallet.get_account(op.redeemer).name, op.preimage, op.fee);
 }
 
 std::string operation_printer::operator()(const htlc_create_operation& op) const
@@ -182,10 +186,12 @@ std::string operation_printer::operator()(const htlc_create_operation& op) const
 
    auto fee_asset = wallet.get_asset( op.fee.asset_id );
    auto to = wallet.get_account( op.to );
+   auto from = wallet.get_account( op.from );
    operation_result_printer rprinter(wallet);
    std::string database_id = result.visit(rprinter);
 
-   out << "Create HTLC to " << to.name << " with id " << database_id
+   out << "Create HTLC from " << from.name << " to " << to.name 
+         << " with id " << database_id
          << " preimage hash: [" << op.preimage_hash.visit( vtor ) << "] ";
    print_memo( op.extensions.value.memo );
    // determine if the block that the HTLC is in is before or after LIB

libraries/wallet/operation_printer.hpp

@@ -101,6 +101,10 @@ struct operation_printer
    std::string operator()(const graphene::protocol::htlc_redeemed_operation& op)const;
    protected:
    std::string print_memo( const fc::optional<graphene::protocol::memo_data>& memo)const;
+   void print_preimage( const std::vector<char>& preimage)const;
+   std::string print_redeem(const graphene::protocol::htlc_id_type& id, 
+         const std::string& redeemer, const std::vector<char>& preimage, 
+         const graphene::protocol::asset& op_fee)const;
 };
 
 }}} // namespace graphene::wallet::detail

tests/cli/main.cpp

@@ -1686,7 +1686,7 @@ BOOST_AUTO_TEST_CASE( cli_create_htlc_bsip64 )
 
       BOOST_TEST_MESSAGE("Alice has agreed to buy 3 BOBCOIN from Bob for 3 BTS. Alice creates an HTLC");
       // create an HTLC
-      std::string preimage_string = "My Secret";
+      std::string preimage_string = "My Super Long Secret that is larger than 50 charaters. How do I look?\n";
       fc::hash160 preimage_md = fc::hash160::hash(preimage_string);
       std::stringstream ss;
       for(size_t i = 0; i < preimage_md.data_size(); i++)
@@ -1735,35 +1735,6 @@ BOOST_AUTO_TEST_CASE( cli_create_htlc_bsip64 )
          htlc_id_type htlc_id = result_block.transactions[result_block.transactions.size()-1].operation_results[0].get<object_id_type>();
          bob_htlc_id_as_string = (std::string)(object_id_type)htlc_id;
          BOOST_TEST_MESSAGE("Bob shares the HTLC ID with Alice. The HTLC ID is: " + bob_htlc_id_as_string);
-         // test operation_printer
-         auto hist = con.wallet_api_ptr->get_account_history("alice", 10);
-         for(size_t i = 0; i < hist.size(); ++i)
-         {
-            auto obj = hist[i];
-            std::stringstream ss;
-            ss << "Description: " << obj.description << "\n";
-            auto str = ss.str();
-            BOOST_TEST_MESSAGE( str );
-            if (i < 2)
-            {
-               BOOST_CHECK( str.find("HASH160 008e") != std::string::npos );
-            }
-         }
-         con.wallet_api_ptr->lock();
-         hist = con.wallet_api_ptr->get_account_history("alice", 10);
-         for(size_t i = 0; i < hist.size(); ++i)
-         {
-            auto obj = hist[i];
-            std::stringstream ss;
-            ss << "Description: " << obj.description << "\n";
-            auto str = ss.str();
-            BOOST_TEST_MESSAGE( str );
-            if (i < 2)
-            {
-               BOOST_CHECK( str.find("HASH160 008e") != std::string::npos );
-            }
-         } 
-         con.wallet_api_ptr->unlock("supersecret");        
       }
 
       // Alice can now look over Bob's HTLC, to see if it is what was agreed to:
@@ -1774,8 +1745,7 @@ BOOST_AUTO_TEST_CASE( cli_create_htlc_bsip64 )
       // Alice likes what she sees, so uses her preimage to get her BOBCOIN
       {
          BOOST_TEST_MESSAGE("Alice uses her preimage to retrieve the BOBCOIN");
-         std::string secret = "My Secret";
-         con.wallet_api_ptr->htlc_redeem(bob_htlc_id_as_string, "alice", secret, true);
+         con.wallet_api_ptr->htlc_redeem(bob_htlc_id_as_string, "alice", preimage_string, true);
          BOOST_TEST_MESSAGE("The system is generating a block");
          BOOST_CHECK(generate_block(app1));
       }
@@ -1784,12 +1754,41 @@ BOOST_AUTO_TEST_CASE( cli_create_htlc_bsip64 )
       // Bob can use the preimage to retrieve his BTS
       {
          BOOST_TEST_MESSAGE("Bob uses Alice's preimage to retrieve the BOBCOIN");
-         std::string secret = "My Secret";
-         con.wallet_api_ptr->htlc_redeem(alice_htlc_id_as_string, "bob", secret, true);
+         con.wallet_api_ptr->htlc_redeem(alice_htlc_id_as_string, "bob", preimage_string, true);
          BOOST_TEST_MESSAGE("The system is generating a block");
          BOOST_CHECK(generate_block(app1));
       }
 
+      // test operation_printer
+      auto hist = con.wallet_api_ptr->get_account_history("alice", 10);
+      for(size_t i = 0; i < hist.size(); ++i)
+      {
+         auto obj = hist[i];
+         std::stringstream ss;
+         ss << "Description: " << obj.description << "\n";
+         auto str = ss.str();
+         BOOST_TEST_MESSAGE( str );
+         if (i == 3 || i == 4)
+         {
+            BOOST_CHECK( str.find("HASH160 620e4d5ba") != std::string::npos );
+         }
+      }
+      con.wallet_api_ptr->lock();
+      hist = con.wallet_api_ptr->get_account_history("alice", 10);
+      for(size_t i = 0; i < hist.size(); ++i)
+      {
+         auto obj = hist[i];
+         std::stringstream ss;
+         ss << "Description: " << obj.description << "\n";
+         auto str = ss.str();
+         BOOST_TEST_MESSAGE( str );
+         if (i == 3 || i == 4)
+         {
+            BOOST_CHECK( str.find("HASH160 620e4d5ba") != std::string::npos );
+         }
+      } 
+      con.wallet_api_ptr->unlock("supersecret");        
+
       // wait for everything to finish up
       fc::usleep(fc::seconds(1));
    } catch( fc::exception& e ) {

tests/common/database_fixture.cpp

@@ -1457,6 +1457,12 @@ flat_map< uint64_t, graphene::chain::fee_parameters > database_fixture::get_htlc
    extend_param.fee_per_day = 2 * GRAPHENE_BLOCKCHAIN_PRECISION;
    ret_val[((operation)htlc_extend_operation()).which()] = extend_param;
 
+   // set the transfer kb fee to something other than default, to verify we're looking
+   // at the correct fee
+   transfer_operation::fee_parameters_type transfer_param;
+   transfer_param.price_per_kbyte *= 2;
+   ret_val[ ((operation)transfer_operation()).which() ] = transfer_param;
+
    return ret_val;
 }
 

tests/tests/htlc_tests.cpp

@@ -345,8 +345,8 @@ try {
       generate_block();
    }
 
-   // verify funds on hold... 100 - 3 = 97, minus the transaction fee = 91.78907
-   BOOST_CHECK_EQUAL( get_balance(alice_id, graphene::chain::asset_id_type()), 91.78907 * GRAPHENE_BLOCKCHAIN_PRECISION );
+   // verify funds on hold... 100 - 3 = 97, minus the transaction fee = 90.57813
+   BOOST_CHECK_EQUAL( get_balance(alice_id, graphene::chain::asset_id_type()), 90.57813 * GRAPHENE_BLOCKCHAIN_PRECISION );
 
    // make sure Bob (or anyone) can see the details of the transaction
    graphene::app::database_api db_api(db);
@@ -389,7 +389,7 @@ try {
    // verify funds end up in Bob's account (3)
    BOOST_CHECK_EQUAL( get_balance(bob_id,   graphene::chain::asset_id_type()), 3 * GRAPHENE_BLOCKCHAIN_PRECISION );
    // verify funds remain out of Alice's acount ( 100 - 3 - transaction fee )
-   BOOST_CHECK_EQUAL( get_balance(alice_id, graphene::chain::asset_id_type()), 91.78907 * GRAPHENE_BLOCKCHAIN_PRECISION );
+   BOOST_CHECK_EQUAL( get_balance(alice_id, graphene::chain::asset_id_type()), 90.57813 * GRAPHENE_BLOCKCHAIN_PRECISION );
    // verify all three get notified
    std::vector<operation_history_object> history = get_operation_history(alice_id);
    BOOST_CHECK_EQUAL( history.size(), alice_num_history + 1);