Fixed Spacing issues

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

@@ -497,6 +497,11 @@ class wallet_api
        * @ingroup Transaction Builder API
        */
       signed_transaction sign_builder_transaction(transaction_handle_type transaction_handle, bool broadcast = true);
+      /** Broadcast signed transaction
+       * @param tx signed transaction
+       * @returns the transaction ID along with the signed transaction.
+       */
+      pair<transaction_id_type,signed_transaction> broadcast_transaction(signed_transaction tx);
       /**
        * @ingroup Transaction Builder API
        */
@@ -596,6 +601,12 @@ class wallet_api
        */
       bool    load_wallet_file(string wallet_filename = "");
 
+      /** Quitting from Peerplays wallet.
+       * 
+       * The current wallet will be closed.
+       */
+      void    quit();
+
       /** Saves the current wallet to the given filename.
        * 
        * @warning This does not change the wallet filename that will be used for future
@@ -1513,6 +1524,37 @@ class wallet_api
        */
       signed_transaction sign_transaction(signed_transaction tx, bool broadcast = false);
 
+      /** Get transaction signers.
+       *
+       * Returns information about who signed the transaction, specifically,
+       * the corresponding public keys of the private keys used to sign the transaction.
+       * @param tx the signed transaction
+       * @return the set of public_keys
+       */
+      flat_set<public_key_type> get_transaction_signers(const signed_transaction &tx) const;
+
+      /** Get key references.
+       *
+       * Returns accounts related to given public keys.
+       * @param keys public keys to search for related accounts
+       * @return the set of related accounts
+       */
+      vector<vector<account_id_type>> get_key_references(const vector<public_key_type> &keys) const;
+
+      /** Signs a transaction.
+       *
+       * Given a fully-formed transaction with or without signatures, signs
+       * the transaction with the owned keys and optionally broadcasts the
+       * transaction.
+       *
+       * @param tx the unsigned transaction
+       * @param broadcast true if you wish to broadcast the transaction
+       *
+       * @return the signed transaction
+       */
+      signed_transaction add_transaction_signature( signed_transaction tx,
+                                                    bool broadcast = false );
+
       /** Returns an uninitialized object representing a given blockchain operation.
        *
        * This returns a default-initialized object of the given type; it can be used 
@@ -1920,6 +1962,7 @@ FC_API( graphene::wallet::wallet_api,
         (set_fees_on_builder_transaction)
         (preview_builder_transaction)
         (sign_builder_transaction)
+        (broadcast_transaction)
         (propose_builder_transaction)
         (propose_builder_transaction2)
         (remove_builder_transaction)
@@ -2005,6 +2048,9 @@ FC_API( graphene::wallet::wallet_api,
         (save_wallet_file)
         (serialize_transaction)
         (sign_transaction)
+        (get_transaction_signers)
+        (get_key_references)
+        (add_transaction_signature)
         (get_prototype_operation)
         (propose_parameter_change)
         (propose_fee_change)

libraries/wallet/wallet.cpp

@@ -274,6 +274,7 @@ public:
 private:
    void claim_registered_account(const account_object& account)
    {
+      bool import_keys = false;
       auto it = _wallet.pending_account_registrations.find( account.name );
       FC_ASSERT( it != _wallet.pending_account_registrations.end() );
       for (const std::string& wif_key : it->second)
@@ -289,8 +290,13 @@ private:
             //    possibility of migrating to a fork where the
             //    name is available, the user can always
             //    manually re-register)
+         } else {
+            import_keys = true;
          }
       _wallet.pending_account_registrations.erase( it );
+
+      if (import_keys)
+         save_wallet_file();
    }
 
    // after a witness registration succeeds, this saves the private key in the wallet permanently
@@ -599,6 +605,13 @@ public:
       fc::async([this, object]{subscribed_object_changed(object);}, "Object changed");
    }
 
+   void quit()
+   {
+      ilog( "Quitting Cli Wallet ..." );
+
+      throw fc::canceled_exception();
+   }
+   
    bool copy_wallet_file( string destination_filename )
    {
       fc::path src_path = get_wallet_filename();
@@ -1147,6 +1160,20 @@ public:
 
       return _builder_transactions[transaction_handle] = sign_transaction(_builder_transactions[transaction_handle], broadcast);
    }
+
+   pair<transaction_id_type,signed_transaction> broadcast_transaction(signed_transaction tx)
+   {
+       try {
+           _remote_net_broadcast->broadcast_transaction(tx);
+       }
+       catch (const fc::exception& e) {
+           elog("Caught exception while broadcasting tx ${id}:  ${e}",
+                ("id", tx.id().str())("e", e.to_detail_string()));
+           throw;
+       }
+       return std::make_pair(tx.id(),tx);
+   }
+
    signed_transaction propose_builder_transaction(
       transaction_handle_type handle,
       time_point_sec expiration = time_point::now() + fc::minutes(1),
@@ -2250,6 +2277,84 @@ public:
       return tx;
    }
 
+   flat_set<public_key_type> get_transaction_signers(const signed_transaction &tx) const
+   {
+      return tx.get_signature_keys(_chain_id);
+   }
+
+   vector<vector<account_id_type>> get_key_references(const vector<public_key_type> &keys) const
+   {
+       return _remote_db->get_key_references(keys);
+   }
+
+   /**
+    * Get the required public keys to sign the transaction which had been
+    * owned by us
+    *
+    * NOTE, if `erase_existing_sigs` set to true, the original trasaction's
+    * signatures will be erased
+    *
+    * @param tx           The transaction to be signed
+    * @param erase_existing_sigs
+    *        The transaction could have been partially signed already,
+    *        if set to false, the corresponding public key of existing
+    *        signatures won't be returned.
+    *        If set to true, the existing signatures will be erased and
+    *        all required keys returned.
+   */
+   set<public_key_type> get_owned_required_keys( signed_transaction &tx,
+                                                    bool erase_existing_sigs = true)
+   {
+      set<public_key_type> pks = _remote_db->get_potential_signatures( tx );
+      flat_set<public_key_type> owned_keys;
+      owned_keys.reserve( pks.size() );
+      std::copy_if( pks.begin(), pks.end(),
+                    std::inserter( owned_keys, owned_keys.end() ),
+                    [this]( const public_key_type &pk ) {
+                       return _keys.find( pk ) != _keys.end();
+                    } );
+
+      if ( erase_existing_sigs )
+         tx.signatures.clear();
+
+      return _remote_db->get_required_signatures( tx, owned_keys );
+   }
+
+   signed_transaction add_transaction_signature( signed_transaction tx,
+                                                 bool broadcast )
+   {
+      set<public_key_type> approving_key_set = get_owned_required_keys(tx, false);
+
+      if ( ( ( tx.ref_block_num == 0 && tx.ref_block_prefix == 0 ) ||
+             tx.expiration == fc::time_point_sec() ) &&
+           tx.signatures.empty() )
+      {
+         auto dyn_props = get_dynamic_global_properties();
+         auto parameters = get_global_properties().parameters;
+         fc::time_point_sec now = dyn_props.time;
+         tx.set_reference_block( dyn_props.head_block_id );
+         tx.set_expiration( now + parameters.maximum_time_until_expiration );
+      }
+      for ( const public_key_type &key : approving_key_set )
+         tx.sign( get_private_key( key ), _chain_id );
+
+      if ( broadcast )
+      {
+         try
+         {
+            _remote_net_broadcast->broadcast_transaction( tx );
+         }
+         catch ( const fc::exception &e )
+         {
+            elog( "Caught exception while broadcasting tx ${id}:  ${e}",
+                  ( "id", tx.id().str() )( "e", e.to_detail_string() ) );
+            FC_THROW( "Caught exception while broadcasting tx" );
+         }
+      }
+
+      return tx;
+   }
+
    signed_transaction sell_asset(string seller_account,
                                  string amount_to_sell,
                                  string symbol_to_sell,
@@ -3645,6 +3750,11 @@ signed_transaction wallet_api::sign_builder_transaction(transaction_handle_type
    return my->sign_builder_transaction(transaction_handle, broadcast);
 }
 
+pair<transaction_id_type,signed_transaction> wallet_api::broadcast_transaction(signed_transaction tx)
+{
+    return my->broadcast_transaction(tx);
+}
+
 signed_transaction wallet_api::propose_builder_transaction(
    transaction_handle_type handle,
    time_point_sec expiration,
@@ -4117,6 +4227,22 @@ signed_transaction wallet_api::sign_transaction(signed_transaction tx, bool broa
    return my->sign_transaction( tx, broadcast);
 } FC_CAPTURE_AND_RETHROW( (tx) ) }
 
+signed_transaction wallet_api::add_transaction_signature( signed_transaction tx,
+                                                          bool broadcast )
+{
+   return my->add_transaction_signature( tx, broadcast );
+}
+
+flat_set<public_key_type> wallet_api::get_transaction_signers(const signed_transaction &tx) const
+{ try {
+   return my->get_transaction_signers(tx);
+} FC_CAPTURE_AND_RETHROW( (tx) ) }
+
+vector<vector<account_id_type>> wallet_api::get_key_references(const vector<public_key_type> &keys) const
+{ try {
+   return my->get_key_references(keys);
+} FC_CAPTURE_AND_RETHROW( (keys) ) }
+
 operation wallet_api::get_prototype_operation(string operation_name)
 {
    return my->get_prototype_operation( operation_name );
@@ -4304,6 +4430,11 @@ bool wallet_api::load_wallet_file( string wallet_filename )
    return my->load_wallet_file( wallet_filename );
 }
 
+void wallet_api::quit()
+{
+   my->quit();
+}
+
 void wallet_api::save_wallet_file( string wallet_filename )
 {
    my->save_wallet_file( wallet_filename );

tests/cli/main.cpp

@@ -28,6 +28,9 @@
 #include <graphene/utilities/tempdir.hpp>
 #include <graphene/bookie/bookie_plugin.hpp>
 #include <graphene/account_history/account_history_plugin.hpp>
+#include <graphene/witness/witness.hpp>
+#include <graphene/market_history/market_history_plugin.hpp>
+
 #include <graphene/egenesis/egenesis.hpp>
 #include <graphene/wallet/wallet.hpp>
 #include <graphene/chain/config.hpp>
@@ -81,6 +84,9 @@ int sockQuit(void)
 
 #include "../common/genesis_file_util.hpp"
 
+using std::exception;
+using std::cerr;
+
 #define INVOKE(test) ((struct test*)this)->test_method();
 
 //////
@@ -120,6 +126,8 @@ std::shared_ptr<graphene::app::application> start_application(fc::temp_directory
 
    app1->register_plugin< graphene::bookie::bookie_plugin>();
    app1->register_plugin<graphene::account_history::account_history_plugin>();
+   app1->register_plugin< graphene::market_history::market_history_plugin >();
+   app1->register_plugin< graphene::witness_plugin::witness_plugin >();
    app1->startup_plugins();
    boost::program_options::variables_map cfg;
 #ifdef _WIN32
@@ -329,6 +337,16 @@ BOOST_FIXTURE_TEST_CASE( cli_connect, cli_fixture )
    BOOST_TEST_MESSAGE("Testing wallet connection.");
 }
 
+////////////////
+// Start a server and connect using the same calls as the CLI
+// Quit wallet and be sure that file was saved correctly
+////////////////
+BOOST_FIXTURE_TEST_CASE( cli_quit, cli_fixture )
+{
+   BOOST_TEST_MESSAGE("Testing wallet connection and quit command.");
+   BOOST_CHECK_THROW( con.wallet_api_ptr->quit(), fc::canceled_exception );
+}
+
 BOOST_FIXTURE_TEST_CASE( upgrade_nathan_account, cli_fixture )
 {
    try
@@ -380,8 +398,11 @@ BOOST_FIXTURE_TEST_CASE( create_new_account, cli_fixture )
       BOOST_CHECK(con.wallet_api_ptr->import_key("jmjatlanta", bki.wif_priv_key));
       con.wallet_api_ptr->save_wallet_file(con.wallet_filename);
 
-      // attempt to give jmjatlanta some CORE
-      BOOST_TEST_MESSAGE("Transferring CORE from Nathan to jmjatlanta");
+      BOOST_CHECK(generate_block(app1));
+      fc::usleep( fc::seconds(1) );
+      
+      // attempt to give jmjatlanta some peerplays
+      BOOST_TEST_MESSAGE("Transferring peerplays from Nathan to jmjatlanta");
       signed_transaction transfer_tx = con.wallet_api_ptr->transfer(
             "nathan", "jmjatlanta", "10000", "1.3.0", "Here are some CORE token for your new account", true
       );
@@ -401,14 +422,14 @@ BOOST_FIXTURE_TEST_CASE( cli_vote_for_2_witnesses, cli_fixture )
    try
    {
       BOOST_TEST_MESSAGE("Cli Vote Test for 2 Witnesses");
-
-      INVOKE(upgrade_nathan_account); // just to fund nathan
+      
+      INVOKE(create_new_account);
 
       // get the details for init1
       witness_object init1_obj = con.wallet_api_ptr->get_witness("init1");
       int init1_start_votes = init1_obj.total_votes;
       // Vote for a witness
-      signed_transaction vote_witness1_tx = con.wallet_api_ptr->vote_for_witness("nathan", "init1", true, true);
+      signed_transaction vote_witness1_tx = con.wallet_api_ptr->vote_for_witness("jmjatlanta", "init1", true, true);
 
       // generate a block to get things started
       BOOST_CHECK(generate_block(app1));
@@ -423,7 +444,7 @@ BOOST_FIXTURE_TEST_CASE( cli_vote_for_2_witnesses, cli_fixture )
 
       // Vote for a 2nd witness
       int init2_start_votes = init2_obj.total_votes;
-      signed_transaction vote_witness2_tx = con.wallet_api_ptr->vote_for_witness("nathan", "init2", true, true);
+      signed_transaction vote_witness2_tx = con.wallet_api_ptr->vote_for_witness("jmjatlanta", "init2", true, true);
 
       // send another block to trigger maintenance interval
       BOOST_CHECK(generate_maintenance_block(app1));
@@ -442,6 +463,42 @@ BOOST_FIXTURE_TEST_CASE( cli_vote_for_2_witnesses, cli_fixture )
    }
 }
 
+BOOST_FIXTURE_TEST_CASE( cli_get_signed_transaction_signers, cli_fixture )
+{
+   try
+   {
+      INVOKE(upgrade_nathan_account);
+
+      // register account and transfer funds
+      const auto test_bki = con.wallet_api_ptr->suggest_brain_key();
+      con.wallet_api_ptr->register_account(
+         "test", test_bki.pub_key, test_bki.pub_key, "nathan", "nathan", 0, true
+      );
+      con.wallet_api_ptr->transfer("nathan", "test", "1000", "1.3.0", "", true);
+
+      // import key and save wallet
+      BOOST_CHECK(con.wallet_api_ptr->import_key("test", test_bki.wif_priv_key));
+      con.wallet_api_ptr->save_wallet_file(con.wallet_filename);
+
+      // create transaction and check expected result
+      auto signed_trx = con.wallet_api_ptr->transfer("test", "nathan", "10", "1.3.0", "", true);
+
+      const auto &test_acc = con.wallet_api_ptr->get_account("test");
+      flat_set<public_key_type> expected_signers = {test_bki.pub_key};
+      vector<vector<account_id_type> > expected_key_refs{{test_acc.id, test_acc.id}};
+
+      auto signers = con.wallet_api_ptr->get_transaction_signers(signed_trx);
+      BOOST_CHECK(signers == expected_signers);
+
+      auto key_refs = con.wallet_api_ptr->get_key_references({test_bki.pub_key});
+      BOOST_CHECK(key_refs == expected_key_refs);
+
+   } catch( fc::exception& e ) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
 ///////////////////////
 // Check account history pagination
 ///////////////////////
@@ -451,7 +508,7 @@ BOOST_FIXTURE_TEST_CASE( account_history_pagination, cli_fixture )
    {
       INVOKE(create_new_account);
 
-      // attempt to give jmjatlanta some peerplay
+       // attempt to give jmjatlanta some peerplay
       BOOST_TEST_MESSAGE("Transferring peerplay from Nathan to jmjatlanta");
       for(int i = 1; i <= 199; i++)
       {
@@ -461,13 +518,13 @@ BOOST_FIXTURE_TEST_CASE( account_history_pagination, cli_fixture )
 
       BOOST_CHECK(generate_block(app1));
 
-      // now get account history and make sure everything is there (and no duplicates)
+       // now get account history and make sure everything is there (and no duplicates)
       std::vector<graphene::wallet::operation_detail> history = con.wallet_api_ptr->get_account_history("jmjatlanta", 300);
       BOOST_CHECK_EQUAL(201u, history.size() );
 
-      std::set<object_id_type> operation_ids;
+       std::set<object_id_type> operation_ids;
 
-      for(auto& op : history)
+       for(auto& op : history)
       {
          if( operation_ids.find(op.op.id) != operation_ids.end() )
          {
@@ -479,4 +536,288 @@ BOOST_FIXTURE_TEST_CASE( account_history_pagination, cli_fixture )
       edump((e.to_detail_string()));
       throw;
    }
-}
+}
+
+BOOST_FIXTURE_TEST_CASE( cli_get_available_transaction_signers, cli_fixture )
+{
+   try
+   {
+      INVOKE(upgrade_nathan_account);
+
+      // register account
+      const auto test_bki = con.wallet_api_ptr->suggest_brain_key();
+      con.wallet_api_ptr->register_account(
+         "test", test_bki.pub_key, test_bki.pub_key, "nathan", "nathan", 0, true
+      );
+      const auto &test_acc = con.wallet_api_ptr->get_account("test");
+
+      // create and sign transaction
+      signed_transaction trx;
+      trx.operations = {transfer_operation()};
+
+      // sign with test key
+      const auto test_privkey = wif_to_key( test_bki.wif_priv_key );
+      BOOST_REQUIRE( test_privkey );
+      trx.sign( *test_privkey, con.wallet_data.chain_id );
+
+      // sign with other keys
+      const auto privkey_1 = fc::ecc::private_key::generate();
+      trx.sign( privkey_1, con.wallet_data.chain_id );
+
+      const auto privkey_2 = fc::ecc::private_key::generate();
+      trx.sign( privkey_2, con.wallet_data.chain_id );
+
+      // verify expected result
+      flat_set<public_key_type> expected_signers = {test_bki.pub_key, 
+                                                    privkey_1.get_public_key(), 
+                                                    privkey_2.get_public_key()};
+
+      auto signers = con.wallet_api_ptr->get_transaction_signers(trx);
+      BOOST_CHECK(signers == expected_signers);
+
+      // blockchain has no references to unknown accounts (privkey_1, privkey_2)
+      // only test account available
+      vector<vector<account_id_type> > expected_key_refs;
+      expected_key_refs.push_back(vector<account_id_type>());
+      expected_key_refs.push_back(vector<account_id_type>());
+      expected_key_refs.push_back({test_acc.id, test_acc.id});
+
+      auto key_refs = con.wallet_api_ptr->get_key_references({expected_signers.begin(), expected_signers.end()});
+      std::sort(key_refs.begin(), key_refs.end());
+
+      BOOST_CHECK(key_refs == expected_key_refs);
+
+   } catch( fc::exception& e ) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_FIXTURE_TEST_CASE( cli_cant_get_signers_from_modified_transaction, cli_fixture )
+{
+   try
+   {
+      INVOKE(upgrade_nathan_account);
+
+      // register account
+      const auto test_bki = con.wallet_api_ptr->suggest_brain_key();
+      con.wallet_api_ptr->register_account(
+         "test", test_bki.pub_key, test_bki.pub_key, "nathan", "nathan", 0, true
+      );
+
+      // create and sign transaction
+      signed_transaction trx;
+      trx.operations = {transfer_operation()};
+
+      // sign with test key
+      const auto test_privkey = wif_to_key( test_bki.wif_priv_key );
+      BOOST_REQUIRE( test_privkey );
+      trx.sign( *test_privkey, con.wallet_data.chain_id );
+
+      // modify transaction (MITM-attack)
+      trx.operations.clear();
+
+      // verify if transaction has no valid signature of test account 
+      flat_set<public_key_type> expected_signers_of_valid_transaction = {test_bki.pub_key};
+      auto signers = con.wallet_api_ptr->get_transaction_signers(trx);
+      BOOST_CHECK(signers != expected_signers_of_valid_transaction);
+
+   } catch( fc::exception& e ) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+///////////////////
+// Start a server and connect using the same calls as the CLI
+// Set a voting proxy and be assured that it sticks
+///////////////////
+BOOST_FIXTURE_TEST_CASE( cli_set_voting_proxy, cli_fixture )
+{
+   try {
+      INVOKE(create_new_account);
+
+      // grab account for comparison
+      account_object prior_voting_account = con.wallet_api_ptr->get_account("jmjatlanta");
+      // set the voting proxy to nathan
+      BOOST_TEST_MESSAGE("About to set voting proxy.");
+      signed_transaction voting_tx = con.wallet_api_ptr->set_voting_proxy("jmjatlanta", "nathan", true);
+      account_object after_voting_account = con.wallet_api_ptr->get_account("jmjatlanta");
+      // see if it changed
+      BOOST_CHECK(prior_voting_account.options.voting_account != after_voting_account.options.voting_account);
+   } catch( fc::exception& e ) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+
+///////////////////////
+// Create a multi-sig account and verify that only when all signatures are
+// signed, the transaction could be broadcast
+///////////////////////
+BOOST_AUTO_TEST_CASE( cli_multisig_transaction )
+{
+   using namespace graphene::chain;
+   using namespace graphene::app;
+   std::shared_ptr<graphene::app::application> app1;
+   try {
+      fc::temp_directory app_dir( graphene::utilities::temp_directory_path() );
+
+      int server_port_number = 0;
+      app1 = start_application(app_dir, server_port_number);
+
+      // connect to the server
+      client_connection con(app1, app_dir, server_port_number);
+
+      BOOST_TEST_MESSAGE("Setting wallet password");
+      con.wallet_api_ptr->set_password("supersecret");
+      con.wallet_api_ptr->unlock("supersecret");
+
+      // import Nathan account
+      BOOST_TEST_MESSAGE("Importing nathan key");
+      std::vector<std::string> nathan_keys{"5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"};
+      BOOST_CHECK_EQUAL(nathan_keys[0], "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3");
+      BOOST_CHECK(con.wallet_api_ptr->import_key("nathan", nathan_keys[0]));
+
+      BOOST_TEST_MESSAGE("Importing nathan's balance");
+      std::vector<signed_transaction> import_txs = con.wallet_api_ptr->import_balance("nathan", nathan_keys, true);
+      account_object nathan_acct_before_upgrade = con.wallet_api_ptr->get_account("nathan");
+
+      // upgrade nathan
+      BOOST_TEST_MESSAGE("Upgrading Nathan to LTM");
+      signed_transaction upgrade_tx = con.wallet_api_ptr->upgrade_account("nathan", true);
+      account_object nathan_acct_after_upgrade = con.wallet_api_ptr->get_account("nathan");
+
+      // verify that the upgrade was successful
+      BOOST_CHECK_PREDICATE( std::not_equal_to<uint32_t>(), (nathan_acct_before_upgrade.membership_expiration_date.sec_since_epoch())(nathan_acct_after_upgrade.membership_expiration_date.sec_since_epoch()) );
+      BOOST_CHECK(nathan_acct_after_upgrade.is_lifetime_member());
+
+      // create a new multisig account
+      graphene::wallet::brain_key_info bki1 = con.wallet_api_ptr->suggest_brain_key();
+      graphene::wallet::brain_key_info bki2 = con.wallet_api_ptr->suggest_brain_key();
+      graphene::wallet::brain_key_info bki3 = con.wallet_api_ptr->suggest_brain_key();
+      graphene::wallet::brain_key_info bki4 = con.wallet_api_ptr->suggest_brain_key();
+      BOOST_CHECK(!bki1.brain_priv_key.empty());
+      BOOST_CHECK(!bki2.brain_priv_key.empty());
+      BOOST_CHECK(!bki3.brain_priv_key.empty());
+      BOOST_CHECK(!bki4.brain_priv_key.empty());
+
+      signed_transaction create_multisig_acct_tx;
+      account_create_operation account_create_op;
+
+      account_create_op.referrer = nathan_acct_after_upgrade.id;
+      account_create_op.referrer_percent = nathan_acct_after_upgrade.referrer_rewards_percentage;
+      account_create_op.registrar = nathan_acct_after_upgrade.id;
+      account_create_op.name = "cifer.test";
+      account_create_op.owner = authority(1, bki1.pub_key, 1);
+      account_create_op.active = authority(2, bki2.pub_key, 1, bki3.pub_key, 1);
+      account_create_op.options.memo_key = bki4.pub_key;
+      account_create_op.fee = asset(1000000);  // should be enough for creating account
+
+      create_multisig_acct_tx.operations.push_back(account_create_op);
+      con.wallet_api_ptr->sign_transaction(create_multisig_acct_tx, true);
+
+      // attempt to give cifer.test some peerplays
+      BOOST_TEST_MESSAGE("Transferring peerplays from Nathan to cifer.test");
+      signed_transaction transfer_tx1 = con.wallet_api_ptr->transfer("nathan", "cifer.test", "10000", "1.3.0", "Here are some BTS for your new account", true);
+
+      // transfer bts from cifer.test to nathan
+      BOOST_TEST_MESSAGE("Transferring peerplays from cifer.test to nathan");
+      auto dyn_props = app1->chain_database()->get_dynamic_global_properties();
+      account_object cifer_test = con.wallet_api_ptr->get_account("cifer.test");
+
+      // construct a transfer transaction
+      signed_transaction transfer_tx2;
+      transfer_operation xfer_op;
+      xfer_op.from = cifer_test.id;
+      xfer_op.to = nathan_acct_after_upgrade.id;
+      xfer_op.amount = asset(100000000);
+      xfer_op.fee = asset(3000000);  // should be enough for transfer
+      transfer_tx2.operations.push_back(xfer_op);
+
+      // case1: sign a transaction without TaPoS and expiration fields
+      // expect: return a transaction with TaPoS and expiration filled
+      transfer_tx2 =
+         con.wallet_api_ptr->add_transaction_signature( transfer_tx2, false );
+      BOOST_CHECK( ( transfer_tx2.ref_block_num != 0 &&
+                     transfer_tx2.ref_block_prefix != 0 ) ||
+                   ( transfer_tx2.expiration != fc::time_point_sec() ) );
+
+      // case2: broadcast without signature
+      // expect: exception with missing active authority
+      BOOST_CHECK_THROW(con.wallet_api_ptr->broadcast_transaction(transfer_tx2), fc::exception);
+
+      // case3:
+      // import one of the private keys for this new account in the wallet file,
+      // sign and broadcast with partial signatures
+      //
+      // expect: exception with missing active authority
+      BOOST_CHECK(con.wallet_api_ptr->import_key("cifer.test", bki2.wif_priv_key));
+      BOOST_CHECK_THROW(con.wallet_api_ptr->add_transaction_signature(transfer_tx2, true), fc::exception);
+
+      // case4: sign again as signature exists
+      // expect: num of signatures not increase
+      // transfer_tx2 = con.wallet_api_ptr->add_transaction_signature(transfer_tx2, false);
+      // BOOST_CHECK_EQUAL(transfer_tx2.signatures.size(), 1);
+
+      // case5:
+      // import another private key, sign and broadcast without full signatures
+      //
+      // expect: transaction broadcast successfully
+      BOOST_CHECK(con.wallet_api_ptr->import_key("cifer.test", bki3.wif_priv_key));
+      con.wallet_api_ptr->add_transaction_signature(transfer_tx2, true);
+      auto balances = con.wallet_api_ptr->list_account_balances( "cifer.test" );
+      for (auto b : balances) {
+         if (b.asset_id == asset_id_type()) {
+            BOOST_ASSERT(b == asset(900000000 - 3000000));
+         }
+      }
+
+      // wait for everything to finish up
+      fc::usleep(fc::seconds(1));
+   } catch( fc::exception& e ) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+   app1->shutdown();
+}
+
+graphene::wallet::plain_keys decrypt_keys( const std::string& password, const vector<char>& cipher_keys )
+{
+   auto pw = fc::sha512::hash( password.c_str(), password.size() );
+   vector<char> decrypted = fc::aes_decrypt( pw, cipher_keys );
+   return fc::raw::unpack<graphene::wallet::plain_keys>( decrypted );
+}
+
+BOOST_AUTO_TEST_CASE( saving_keys_wallet_test ) 
+{
+   cli_fixture cli;
+
+   cli.con.wallet_api_ptr->import_balance( "nathan", cli.nathan_keys, true );
+   cli.con.wallet_api_ptr->upgrade_account( "nathan", true );
+   std::string brain_key( "FICTIVE WEARY MINIBUS LENS HAWKIE MAIDISH MINTY GLYPH GYTE KNOT COCKSHY LENTIGO PROPS BIFORM KHUTBAH BRAZIL" );
+   cli.con.wallet_api_ptr->create_account_with_brain_key( brain_key, "account1", "nathan", "nathan", true );
+
+   BOOST_CHECK_NO_THROW( cli.con.wallet_api_ptr->transfer( "nathan", "account1", "9000", "1.3.0", "", true ) );
+
+   std::string path( cli.app_dir.path().generic_string() + "/wallet.json" );
+   graphene::wallet::wallet_data wallet = fc::json::from_file( path ).as<graphene::wallet::wallet_data>( 2 * GRAPHENE_MAX_NESTED_OBJECTS );
+   BOOST_CHECK( wallet.extra_keys.size() == 1 ); // nathan
+   BOOST_CHECK( wallet.pending_account_registrations.size() == 1 ); // account1
+   BOOST_CHECK( wallet.pending_account_registrations["account1"].size() == 2 ); // account1 active key + account1 memo key
+
+   graphene::wallet::plain_keys pk = decrypt_keys( "supersecret", wallet.cipher_keys );
+   BOOST_CHECK( pk.keys.size() == 1 ); // nathan key
+
+   BOOST_CHECK( generate_block( cli.app1 ) );
+   fc::usleep( fc::seconds(1) );
+
+   wallet = fc::json::from_file( path ).as<graphene::wallet::wallet_data>( 2 * GRAPHENE_MAX_NESTED_OBJECTS );
+   BOOST_CHECK( wallet.extra_keys.size() == 2 ); // nathan + account1
+   BOOST_CHECK( wallet.pending_account_registrations.empty() );
+   BOOST_CHECK_NO_THROW( cli.con.wallet_api_ptr->transfer( "account1", "nathan", "1000", "1.3.0", "", true ) );
+
+   pk = decrypt_keys( "supersecret", wallet.cipher_keys );
+   BOOST_CHECK( pk.keys.size() == 3 ); // nathan key + account1 active key + account1 memo key
+}