Issue867 Add CLI command to add signatures to a partially signed transaction

libraries/wallet/include/graphene/wallet/wallet.hpp

@@ -252,8 +252,9 @@ struct vesting_balance_object_with_info : public vesting_balance_object
    fc::time_point_sec allowed_withdraw_time;
 };
 
-namespace detail {
-class wallet_api_impl;
+namespace detail
+{
+   class wallet_api_impl;
 }
 
 /***
@@ -1538,6 +1539,11 @@ class wallet_api
 
       order_book get_order_book( const string& base, const string& quote, unsigned limit = 50);
 
+      bool multisig_mode(string on_or_off, fc::optional<string> tx_filename);
+      optional<signed_transaction> multisig_import_transaction( string tx_filename );
+      signed_transaction multisig_sign_transaction( const vector<string> &wif_keys,
+                                                   bool broadcast = false );
+
       void dbg_make_uia(string creator, string symbol);
       void dbg_make_mia(string creator, string symbol);
       void dbg_push_blocks( std::string src_filename, uint32_t count );
@@ -1751,4 +1757,7 @@ FC_API( graphene::wallet::wallet_api,
         (blind_history)
         (receive_blind_transfer)
         (get_order_book)
+        (multisig_mode)
+        (multisig_import_transaction)
+        (multisig_sign_transaction)
       )

libraries/wallet/wallet.cpp

@@ -758,6 +758,131 @@ class wallet_api_impl
 
       return true;
    }
+
+   bool multisig_mode(string on_or_off, fc::optional<string> tx_filename)
+   {
+      if (on_or_off == "on")
+      {
+         if (! tx_filename)
+            FC_THROW("Must provide transaction file name");
+         else
+            _tx_filename = *tx_filename;
+
+         _multisig_mode = true;
+      }
+      else
+         _multisig_mode = false;
+
+      return _multisig_mode;
+   }
+
+   optional<signed_transaction> multisig_import_transaction(string tx_filename)
+   {
+      signed_transaction tmp;
+
+      if ( !fc::exists( tx_filename ) )
+      {
+         elog( "Transaction file not exists" );
+         return optional<signed_transaction>();
+      }
+
+      tmp = fc::json::from_file( tx_filename )
+               .as<signed_transaction>( 2 * GRAPHENE_MAX_NESTED_OBJECTS );
+
+      if ( !tmp.ref_block_num || !tmp.ref_block_prefix || tmp.expiration == fc::time_point_sec() )
+      {
+         elog( "Must fill TaPoS and expiration field in online machine" );
+         return optional<signed_transaction>();
+      }
+      else
+      {
+         _multisig_trx = tmp;
+         return _multisig_trx;
+      }
+   }
+
+   signed_transaction multisig_sign_transaction( const vector<string> &wif_keys, bool broadcast )
+   {
+      // use const reference to call the const variant of `sign()`
+      vector<fc::ecc::private_key> private_keys;
+
+      for ( const string &wif_key : wif_keys )
+      {
+         fc::optional<fc::ecc::private_key> optional_private_key = wif_to_key( wif_key );
+
+         if ( !optional_private_key )
+            FC_THROW( "Invalid private key: ${i}", ( "i", wif_key ) );
+
+         private_keys.push_back(*optional_private_key);
+      }
+
+      for ( const fc::ecc::private_key& privkey : private_keys)
+      {
+         signature_type sig = privkey.sign_compact( _multisig_trx.sig_digest( _chain_id ) );
+         const vector<signature_type> &sigs = _multisig_trx.signatures;
+         if ( std::find( sigs.begin(), sigs.end(), sig ) != sigs.end() )
+         {
+            wlog( "signature of ${fn} had already exist, skip", ( "fn", key_to_wif( privkey ) ) );
+         }
+         else
+         {
+            _multisig_trx.sign( privkey, _chain_id );
+         }
+      }
+
+      if ( broadcast )
+      {
+         try
+         {
+            _remote_net_broadcast->broadcast_transaction( _multisig_trx );
+         }
+         catch ( const fc::exception &e )
+         {
+            elog( "Caught exception while broadcasting tx ${id}:  ${e}",
+                  ( "id", _multisig_trx.id().str() )( "e", e.to_detail_string() ) );
+            throw;
+         }
+      }
+
+      return _multisig_trx;
+   }
+
+   void save_transaction_to_file(signed_transaction& tx)
+   {
+      //
+      // Serialize in memory, then save to disk
+      //
+      // This approach lessens the risk of a partially written wallet
+      // if exceptions are thrown in serialization
+      //
+
+      ilog( "saving wallet to file ${fn}", ("fn", _tx_filename) );
+
+      string tx_data = fc::json::to_pretty_string( tx );
+      try
+      {
+         enable_umask_protection();
+         //
+         // Parentheses on the following declaration fails to compile,
+         // due to the Most Vexing Parse.  Thanks, C++
+         //
+         // http://en.wikipedia.org/wiki/Most_vexing_parse
+         //
+         fc::ofstream outfile{ fc::path( _tx_filename ) };
+         outfile.write( tx_data.c_str(), tx_data.length() );
+         outfile.flush();
+         outfile.close();
+         disable_umask_protection();
+      }
+      catch(...)
+      {
+         disable_umask_protection();
+         throw;
+      }
+
+      _multisig_trx = tx;
+   }
+
    void save_wallet_file(string wallet_filename = "")
    {
       //
@@ -1860,6 +1985,11 @@ class wallet_api_impl
          ++expiration_time_offset;
       }
 
+      if (_multisig_mode)
+      {
+         save_transaction_to_file(tx);
+      }
+
       if( broadcast )
       {
          try
@@ -2610,6 +2740,10 @@ class wallet_api_impl
       return it->second;
    }
 
+   bool                    _multisig_mode = false;
+   signed_transaction      _multisig_trx;
+   string                  _tx_filename;
+
    string                  _wallet_filename;
    wallet_data             _wallet;
 
@@ -3587,6 +3721,22 @@ dynamic_global_property_object wallet_api::get_dynamic_global_properties() const
    return my->get_dynamic_global_properties();
 }
 
+bool wallet_api::multisig_mode(string on_or_off, fc::optional<string> tx_filename)
+{
+   return my->multisig_mode(on_or_off, tx_filename);
+}
+
+optional<signed_transaction> wallet_api::multisig_import_transaction( string tx_filename )
+{
+   return my->multisig_import_transaction( tx_filename );
+}
+
+signed_transaction wallet_api::multisig_sign_transaction( const vector<string> &wif_keys,
+                                                          bool broadcast )
+{
+   return my->multisig_sign_transaction( wif_keys, broadcast );
+}
+
 string wallet_api::help()const
 {
    std::vector<std::string> method_names = my->method_documentation.get_method_names();