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;
}
void domain_transfer_operation::titan_transfer( 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();
auto secret = one_time_private_key.get_shared_secret( to_public_key );
auto ext_to_public_key = extended_public_key(to_public_key);
auto secret_ext_public_key = ext_to_public_key.child( fc::sha256::hash(secret) );
auto secret_public_key = secret_ext_public_key.get_pub_key();
owner = address( secret_public_key );
auto 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();
FC_ASSERT( memo.valid() );
memo->encrypted_memo_data = fc::aes_encrypt( secret, fc::raw::pack( memo_content ) );
}
void start(const fc::ip::endpoint& endpoint_to_probe,
const fc::ecc::private_key& my_node_id,
const graphene::chain::chain_id_type& chain_id)
{
_remote = endpoint_to_probe;
fc::future<void> connect_task = fc::async([this](){ _connection->connect_to(_remote); }, "connect_task");
try
{
connect_task.wait(fc::seconds(10));
}
catch (const fc::timeout_exception&)
{
ilog("timeout connecting to node ${endpoint}", ("endpoint", endpoint_to_probe));
connect_task.cancel(__FUNCTION__);
throw;
}
fc::sha256::encoder shared_secret_encoder;
fc::sha512 shared_secret = _connection->get_shared_secret();
shared_secret_encoder.write(shared_secret.data(), sizeof(shared_secret));
fc::ecc::compact_signature signature = my_node_id.sign_compact(shared_secret_encoder.result());
graphene::net::hello_message hello("network_mapper",
GRAPHENE_NET_PROTOCOL_VERSION,
fc::ip::address(), 0, 0,
my_node_id.get_public_key(),
signature,
chain_id,
fc::variant_object());
_connection->send_message(hello);
}
void start(const fc::ip::endpoint& endpoint_to_probe,
const fc::ecc::private_key& my_node_id,
const bts::blockchain::digest_type& chain_id)
{
fc::future<void> connect_task = fc::async([=](){ _connection->connect_to(endpoint_to_probe); }, "connect_task");
try
{
connect_task.wait(fc::seconds(10));
}
catch (const fc::timeout_exception&)
{
ilog("timeout connecting to node ${endpoint}", ("endpoint", endpoint_to_probe));
connect_task.cancel();
throw;
}
fc::sha256::encoder shared_secret_encoder;
fc::sha512 shared_secret = _connection->get_shared_secret();
shared_secret_encoder.write(shared_secret.data(), sizeof(shared_secret));
fc::ecc::compact_signature signature = my_node_id.sign_compact(shared_secret_encoder.result());
bts::net::hello_message hello("map_bts_network",
BTS_NET_PROTOCOL_VERSION,
fc::ip::address(), 0, 0,
my_node_id.get_public_key(),
signature,
chain_id,
fc::variant_object());
_connection->send_message(hello);
}
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;
}
encrypted_message message::encrypt( const fc::ecc::private_key& onetimekey,
const fc::ecc::public_key& receiver_public_key )const
{
auto shared_secret = onetimekey.get_shared_secret( receiver_public_key );
encrypted_message result;
result.onetimekey = onetimekey.get_public_key();
result.data = fc::aes_encrypt( shared_secret, fc::raw::pack( *this ) );
return result;
}
void wallet_db::cache_memo( const memo_status& memo,
const fc::ecc::private_key& account_key,
const fc::sha512& password )
{
key_data data;
data.account_address = address(account_key.get_public_key());
//data.memo = memo_data(memo);
data.valid_from_signature = memo.has_valid_signature;
data.encrypt_private_key( password, memo.owner_private_key );
store_key( data );
}
bts_server_process_info_ptr launch_bts_server_process(const genesis_block_config& genesis_block,
const fc::ecc::private_key& trustee_key)
{
bts_server_process_info_ptr server_process_info = std::make_shared<bts_server_process_info>();
server_process_info->server_process = std::make_shared<fc::process>();
std::vector<std::string> options;
options.push_back("--trustee-address");
options.push_back(bts::blockchain::address(trustee_key.get_public_key()));
fc::path server_config_dir = bts_xt_client_test_config::config_directory / "BitSharesX_Server";
fc::remove_all(server_config_dir);
fc::create_directories(server_config_dir);
fc::json::save_to_file(genesis_block, server_config_dir / "genesis.json", true);
server_process_info->server_process->exec(bts_xt_client_test_config::bts_server_exe, options, server_config_dir);
std::shared_ptr<std::ofstream> stdouterrfile = std::make_shared<std::ofstream>((server_config_dir / "stdouterr.txt").string().c_str());
fc::buffered_istream_ptr out_stream = server_process_info->server_process->out_stream();
fc::buffered_istream_ptr err_stream = server_process_info->server_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);
}
});
return server_process_info;
}
signed_block database::_generate_block(
fc::time_point_sec when,
witness_id_type witness_id,
const fc::ecc::private_key& block_signing_private_key
)
{
try {
uint32_t skip = get_node_properties().skip_flags;
uint32_t slot_num = get_slot_at_time( when );
FC_ASSERT( slot_num > 0 );
witness_id_type scheduled_witness = get_scheduled_witness( slot_num );
FC_ASSERT( scheduled_witness == witness_id );
const auto& witness_obj = witness_id(*this);
if( !(skip & skip_witness_signature) )
FC_ASSERT( witness_obj.signing_key == block_signing_private_key.get_public_key() );
static const size_t max_block_header_size = fc::raw::pack_size( signed_block_header() ) + 4;
auto maximum_block_size = get_global_properties().parameters.maximum_block_size;
size_t total_block_size = max_block_header_size;
signed_block pending_block;
//
// The following code throws away existing pending_tx_session and
// rebuilds it by re-applying pending transactions.
//
// This rebuild is necessary because pending transactions' validity
// and semantics may have changed since they were received, because
// time-based semantics are evaluated based on the current block
// time. These changes can only be reflected in the database when
// the value of the "when" variable is known, which means we need to
// re-apply pending transactions in this method.
//
_pending_tx_session.reset();
_pending_tx_session = _undo_db.start_undo_session();
uint64_t postponed_tx_count = 0;
// pop pending state (reset to head block state)
for( const processed_transaction& tx : _pending_tx )
{
size_t new_total_size = total_block_size + fc::raw::pack_size( tx );
// postpone transaction if it would make block too big
if( new_total_size >= maximum_block_size )
{
postponed_tx_count++;
continue;
}
try
{
auto temp_session = _undo_db.start_undo_session();
processed_transaction ptx = _apply_transaction( tx );
temp_session.merge();
// We have to recompute pack_size(ptx) because it may be different
// than pack_size(tx) (i.e. if one or more results increased
// their size)
total_block_size += fc::raw::pack_size( ptx );
pending_block.transactions.push_back( ptx );
}
catch ( const fc::exception& e )
{
// Do nothing, transaction will not be re-applied
wlog( "Transaction was not processed while generating block due to ${e}", ("e", e) );
wlog( "The transaction was ${t}", ("t", tx) );
}
}
if( postponed_tx_count > 0 )
{
wlog( "Postponed ${n} transactions due to block size limit", ("n", postponed_tx_count) );
}
_pending_tx_session.reset();
// We have temporarily broken the invariant that
// _pending_tx_session is the result of applying _pending_tx, as
// _pending_tx now consists of the set of postponed transactions.
// However, the push_block() call below will re-create the
// _pending_tx_session.
pending_block.previous = head_block_id();
pending_block.timestamp = when;
pending_block.transaction_merkle_root = pending_block.calculate_merkle_root();
pending_block.witness = witness_id;
if( !(skip & skip_witness_signature) )
pending_block.sign( block_signing_private_key );
// TODO: Move this to _push_block() so session is restored.
if( !(skip & skip_block_size_check) )
{
FC_ASSERT( fc::raw::pack_size(pending_block) <= get_global_properties().parameters.maximum_block_size );
}
push_block( pending_block, skip );
return pending_block;
} FC_CAPTURE_AND_RETHROW( (witness_id) ) }
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="******"--rpcpassword="******"--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;
}