C++ private_key::get_secret方法代码示例

        PublicKeyType withdraw_with_escrow::encrypt_memo_data(
            const fc::ecc::private_key& one_time_private_key,
            const fc::ecc::public_key&  to_public_key,
            const fc::ecc::private_key& from_private_key,
            const std::string& memo_message,
            const fc::ecc::public_key&  memo_pub_key,
            MemoFlagsEnum memo_type)
        {
            memo = TransferMemo();
            const auto secret = one_time_private_key.get_shared_secret(to_public_key);
            const auto ext_to_public_key = ExtendedPublicKey(to_public_key);
            const auto secret_ext_public_key = ext_to_public_key.child(fc::sha256::hash(secret));
            const auto secret_public_key = secret_ext_public_key.get_pub_key();

            sender = Address(one_time_private_key.get_public_key());
            receiver = Address(secret_public_key);

            fc::sha512 check_secret;
            if (from_private_key.get_secret() != fc::ecc::private_key().get_secret())
                check_secret = from_private_key.get_shared_secret(secret_public_key);

            MemoData memo_content;
            memo_content.set_message(memo_message);
            memo_content.from = memo_pub_key;
            memo_content.from_signature = check_secret._hash[0];
            memo_content.memo_flags = memo_type;

            memo->one_time_key = one_time_private_key.get_public_key();

            encrypt_memo_data(secret, memo_content);
            return secret_public_key;
        }

   public_key_type withdraw_with_signature::encrypt_memo_data(
           const fc::ecc::private_key& one_time_private_key,
           const fc::ecc::public_key&  to_public_key,
           const fc::ecc::private_key& from_private_key,
           const std::string& memo_message,
           const fc::ecc::public_key&  memo_pub_key,
           memo_flags_enum memo_type )
   {
      memo = titan_memo();
      const auto secret = one_time_private_key.get_shared_secret( to_public_key );
      const auto ext_to_public_key = extended_public_key( to_public_key );
      const auto secret_ext_public_key = ext_to_public_key.child( fc::sha256::hash( secret ) );
      const auto secret_public_key = secret_ext_public_key.get_pub_key();
      owner = address( secret_public_key );

      fc::sha512 check_secret;
      if( from_private_key.get_secret() != fc::ecc::private_key().get_secret() )
        check_secret = from_private_key.get_shared_secret( secret_public_key );

      memo_data memo_content;
      memo_content.set_message( memo_message );
      memo_content.from = memo_pub_key;
      memo_content.from_signature = check_secret._hash[0];
      memo_content.memo_flags = memo_type;

      memo->one_time_key = one_time_private_key.get_public_key();

      encrypt_memo_data( secret, memo_content );
      return secret_public_key;
   }

std::string key_to_wif(const fc::ecc::private_key& key)
{
  fc::sha256 secret = key.get_secret();
  const size_t size_of_data_to_hash = sizeof(secret) + 1;
  const size_t size_of_hash_bytes = 4;
  char data[size_of_data_to_hash + size_of_hash_bytes];
  data[0] = (char)0x80;
  memcpy(&data[1], (char*)&secret, sizeof(secret));
  fc::sha256 digest = fc::sha256::hash(data, size_of_data_to_hash);
  digest = fc::sha256::hash(digest);
  memcpy(data + size_of_data_to_hash, (char*)&digest, size_of_hash_bytes);
  return fc::to_base58(data, sizeof(data));
}

 void pack( Stream& s, const fc::ecc::private_key& pk)
 {
     fc::raw::pack( s, pk.get_secret() );
 }

 extended_private_key( const fc::ecc::private_key& k ):priv_key(k.get_secret()){}

 void pack( Stream& s, const fc::ecc::private_key& pk, uint32_t _max_depth )
 {
     FC_ASSERT( _max_depth > 0 );
     fc::raw::pack( s, pk.get_secret(), _max_depth - 1 );
 }

std::string key_to_wif(const fc::ecc::private_key& key)
{
  return key_to_wif( key.get_secret() );
}

fc::process_ptr launch_bts_client_process(uint32_t process_number, uint16_t rpc_port, 
                                          const fc::ecc::private_key& trustee_key, 
                                          bool act_as_trustee)
{
  fc::process_ptr bts_client_process(std::make_shared<fc::process>());
  std::vector<std::string> options;

  std::ostringstream numbered_config_dir_name;
  numbered_config_dir_name << "BitSharesX_" << std::setw(3) << std::setfill('0') << process_number;
  fc::path numbered_config_dir = bts_xt_client_test_config::config_directory / numbered_config_dir_name.str();
  fc::remove_all(numbered_config_dir);
  fc::create_directories(numbered_config_dir);

  // create a wallet in that directory
  // we could (and probably should) make bts_xt_client create the wallet, 
  // but if we ask it to create the wallet
  // it will interactively prompt for passwords which is a big hassle.
  // here we explicitly create one with a blank password
  {
    bts::wallet::wallet_ptr wallet = std::make_shared<bts::wallet::wallet>();
    wallet->set_data_directory(numbered_config_dir);
    fc::path wallet_data_filename = wallet->get_wallet_file();
    wallet->create(wallet_data_filename, "", WALLET_PASPHRASE);
  }

  options.push_back("--data-dir");
  options.push_back(numbered_config_dir.string());

  options.push_back("--server");
  options.push_back("--rpcuser=" RPC_USERNAME);
  options.push_back("--rpcpassword=" RPC_PASSWORD);
  options.push_back("--rpcport");
  options.push_back(boost::lexical_cast<std::string>(rpc_port));
  options.push_back("--trustee-address");
  options.push_back(bts::blockchain::address(trustee_key.get_public_key()));
  if (act_as_trustee)
  {
    options.push_back("--trustee-private-key");
    options.push_back(trustee_key.get_secret());
  }

  bts_client_process->exec(bts_xt_client_test_config::bts_client_exe, options, numbered_config_dir);

#if 0
  std::shared_ptr<std::ofstream> stdouterrfile = std::make_shared<std::ofstream>((numbered_config_dir / "stdouterr.txt").string().c_str());
  fc::buffered_istream_ptr out_stream = bts_client_process->out_stream();
  fc::buffered_istream_ptr err_stream = bts_client_process->err_stream();
  server_process_info->stdout_reader_done = fc::async([out_stream,stdouterrfile]()
    {
      char buf[1024];
      for (;;)
      {
        size_t bytes_read = out_stream->readsome(buf, sizeof(buf));
        if (!bytes_read)
          break;
        stdouterrfile->write(buf, bytes_read);
      }
    });
  server_process_info->stderr_reader_done = fc::async([err_stream,stdouterrfile]()
    {
      char buf[1024];
      for (;;)
      {
        size_t bytes_read = err_stream->readsome(buf, sizeof(buf));
        if (!bytes_read)
          break;
        stdouterrfile->write(buf, bytes_read);
      }
    });
#endif
  return bts_client_process;
}