void wallet_db::store_account( const account_data& account )
{ try {
FC_ASSERT( is_open() );
FC_ASSERT( account.name != string() );
FC_ASSERT( account.owner_key != public_key_type() );
owallet_account_record account_record = lookup_account( account.owner_address() );
if( !account_record.valid() )
account_record = wallet_account_record();
account_data& temp = *account_record;
temp = account;
store_and_reload_record( *account_record );
set<public_key_type> account_public_keys;
account_public_keys.insert( account_record->owner_key );
for( const auto& active_key_item : account_record->active_key_history )
{
const public_key_type& active_key = active_key_item.second;
if( active_key == public_key_type() ) continue;
account_public_keys.insert( active_key );
}
if( account.is_delegate() )
{
for( const auto& item : account.delegate_info->signing_key_history )
{
const public_key_type& signing_key = item.second;
if( signing_key == public_key_type() ) continue;
account_public_keys.insert( signing_key );
}
}
for( const public_key_type& account_public_key : account_public_keys )
{
const address account_address = address( account_public_key );
owallet_key_record key_record = lookup_key( account_address );
if( !key_record.valid() )
{
key_data key;
key.account_address = account_address;
key.public_key = account_public_key;
store_key( key );
}
else if( key_record->has_private_key() )
{
if( !account_record->is_my_account )
{
account_record->is_my_account = true;
store_and_reload_record( *account_record );
}
if( key_record->account_address != account_record->owner_address() )
{
key_record->account_address = account_record->owner_address();
store_key( *key_record );
}
}
}
} FC_CAPTURE_AND_RETHROW( (account) ) }
void wallet_db::store_key( const key_data& key )
{ try {
FC_ASSERT( is_open() );
FC_ASSERT( key.public_key != public_key_type() );
owallet_key_record key_record = lookup_key( key.get_address() );
if( !key_record.valid() )
key_record = wallet_key_record();
key_data& temp = *key_record;
temp = key;
store_and_reload_record( *key_record, true );
if( key_record->has_private_key() )
{
owallet_account_record account_record = lookup_account( key.public_key );
if( !account_record.valid() )
account_record = lookup_account( key.account_address );
if( account_record.valid() )
{
if( key_record->account_address != account_record->owner_address() )
{
key_record->account_address = account_record->owner_address();
store_and_reload_record( *key_record, true );
}
}
}
} FC_CAPTURE_AND_RETHROW( (key) ) }
void wallet_db::store_setting(const string& name, const variant& value)
{
auto orec = lookup_setting(name);
if (orec.valid())
{
orec->value = value;
settings[name] = *orec;
store_and_reload_record( *orec );
}
else
{
auto rec = wallet_setting_record( setting(name, value), new_wallet_record_index() );
settings[name] = rec;
store_and_reload_record( rec );
}
}
void wallet_db::set_master_key( const extended_private_key& extended_key,
const fc::sha512& new_password )
{ try {
master_key key;
key.encrypt_key( new_password, extended_key );
auto key_record = wallet_master_key_record( key, -1 );
store_and_reload_record( key_record, true );
} FC_CAPTURE_AND_RETHROW() }
void wallet_db::store_transaction( const transaction_data& transaction )
{ try {
FC_ASSERT( is_open() );
FC_ASSERT( transaction.record_id != transaction_id_type() );
FC_ASSERT( transaction.is_virtual || transaction.trx.id() != signed_transaction().id() );
owallet_transaction_record transaction_record = lookup_transaction( transaction.record_id );
if( !transaction_record.valid() )
transaction_record = wallet_transaction_record();
transaction_data& temp = *transaction_record;
temp = transaction;
store_and_reload_record( *transaction_record );
} FC_CAPTURE_AND_RETHROW( (transaction) ) }
wallet_approval_record wallet_db::store_approval( const approval_data& approval )
{ try {
FC_ASSERT( is_open() );
FC_ASSERT( !approval.name.empty() );
owallet_approval_record approval_record = lookup_approval( approval.name );
if( !approval_record.valid() )
approval_record = wallet_approval_record();
approval_data& temp = *approval_record;
temp = approval;
store_and_reload_record( *approval_record );
return *approval_record;
} FC_CAPTURE_AND_RETHROW( (approval) ) }
void wallet_db::change_password( const fc::sha512& old_password,
const fc::sha512& new_password )
{ try {
FC_ASSERT( is_open() );
const extended_private_key master_private_key = wallet_master_key->decrypt_key( old_password );
set_master_key( master_private_key, new_password );
for( auto key : keys )
{
if( key.second.has_private_key() )
{
auto priv_key = key.second.decrypt_private_key( old_password );
key.second.encrypt_private_key( new_password, priv_key );
store_and_reload_record( key.second, true );
}
}
} FC_CAPTURE_AND_RETHROW() }
void wallet_db::set_property( property_enum property_id, const variant& v )
{
wallet_property_record property_record;
auto property_itr = properties.find( property_id );
if( property_itr != properties.end() )
{
property_record = property_itr->second;
property_record.value = v;
}
else
{
if( property_id == property_enum::next_record_number )
property_record = wallet_property_record( wallet_property(property_id, v), 1 );
else
property_record = wallet_property_record( wallet_property(property_id, v), new_wallet_record_index() );
}
store_and_reload_record( property_record );
}
void wallet_db::cache_balance( const bts::blockchain::balance_record& balance_to_cache )
{
auto balance_id = balance_to_cache.id();
owallet_balance_record current_bal = lookup_balance(balance_id);
wallet_balance_record balance_record;
if( !current_bal.valid() )
{
balance_record = wallet_balance_record( balance_to_cache, new_wallet_record_index() );
}
else
{
blockchain::balance_record& chain_rec = *current_bal;
chain_rec = balance_to_cache;
balance_record = *current_bal;
}
store_and_reload_record( balance_record );
}
wallet_account_record wallet_db::store_account( const account_data& account )
{ try {
FC_ASSERT( is_open() );
FC_ASSERT( account.name != string() );
FC_ASSERT( account.owner_key != public_key_type() );
owallet_account_record account_record = lookup_account( account.owner_address() );
if( !account_record.valid() )
account_record = wallet_account_record();
account_data& temp = *account_record;
temp = account;
store_and_reload_record( *account_record );
const auto index_key = [ & ]( const public_key_type& account_public_key )
{
const address account_address = address( account_public_key );
owallet_key_record key_record = lookup_key( account_address );
if( !key_record.valid() )
{
key_data key;
key.account_address = account_address;
key.public_key = account_public_key;
store_key( key );
}
else if( key_record->has_private_key() )
{
if( key_record->account_address != account_record->owner_address() )
{
key_record->account_address = account_record->owner_address();
store_key( *key_record );
}
}
};
account_record->scan_public_keys( index_key );
return *account_record;
} FC_CAPTURE_AND_RETHROW( (account) ) }
wallet_contact_record wallet_db::store_contact( const contact_data& contact )
{ try {
FC_ASSERT( is_open() );
FC_ASSERT( !contact.data.is_null() );
FC_ASSERT( !contact.label.empty() );
// Check for label collision
owallet_contact_record contact_record = lookup_contact( contact.label );
if( contact_record.valid() && contact_record->data.as_string() != contact.data.as_string() )
FC_CAPTURE_AND_THROW( label_already_in_use, );
contact_record = lookup_contact( contact.data );
if( !contact_record.valid() )
contact_record = wallet_contact_record();
else if( contact_record->label != contact.label )
label_to_account_or_contact.erase( contact_record->label );
contact_data& temp = *contact_record;
temp = contact;
store_and_reload_record( *contact_record );
return *contact_record;
} FC_CAPTURE_AND_RETHROW( (contact) ) }
void wallet_db::rename_account(const public_key_type &old_account_key,
const string& new_account_name )
{
/* Precondition: check that new_account doesn't exist in wallet and that old_account does
*/
FC_ASSERT( is_open() );
auto opt_old_acct = lookup_account( old_account_key );
FC_ASSERT( opt_old_acct.valid() );
auto acct = *opt_old_acct;
auto old_name = acct.name;
acct.name = new_account_name;
name_to_account_wallet_record_index[acct.name] = acct.wallet_record_index;
if( name_to_account_wallet_record_index[old_name] == acct.wallet_record_index )
//Only remove the old name from the map if it pointed to the record we've just renamed
name_to_account_wallet_record_index.erase( old_name );
accounts[acct.wallet_record_index] = acct;
address_to_account_wallet_record_index[address(acct.owner_key)] = acct.wallet_record_index;
for( const auto& time_key_pair : acct.active_key_history )
address_to_account_wallet_record_index[address(time_key_pair.second)] = acct.wallet_record_index;
store_and_reload_record( acct );
}
