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) ) }
public_key_type wallet_db::generate_new_account( const fc::sha512& password, const string& account_name,
const private_key_type& owner_private_key )
{ try {
FC_ASSERT( is_open() );
owallet_account_record account_record = lookup_account( account_name );
FC_ASSERT( !account_record.valid(), "Wallet already contains an account with that name!" );
const public_key_type owner_public_key = owner_private_key.get_public_key();
const address owner_address = address( owner_public_key );
const private_key_type active_private_key = get_account_child_key( owner_private_key, 0 );
const public_key_type active_public_key = active_private_key.get_public_key();
const address active_address = address( active_public_key );
account_record = lookup_account( owner_address );
FC_ASSERT( !account_record.valid(), "Wallet already contains an account with that key!" );
account_record = lookup_account( active_address );
FC_ASSERT( !account_record.valid(), "Wallet already contains an account with the new derived active key!" );
owallet_key_record key_record = lookup_key( owner_address );
FC_ASSERT( !key_record.valid() || !key_record->has_private_key(), "Wallet already contains that key!" );
key_record = lookup_key( active_address );
FC_ASSERT( !key_record.valid() || !key_record->has_private_key(), "Wallet already contains the new derived active key!" );
key_data active_key;
active_key.account_address = owner_address;
active_key.public_key = active_public_key;
active_key.encrypt_private_key( password, active_private_key );
key_data owner_key;
owner_key.account_address = owner_address;
owner_key.public_key = owner_public_key;
owner_key.encrypt_private_key( password, owner_private_key );
account_data account;
account.name = account_name;
account.owner_key = owner_public_key;
account.set_active_key( blockchain::now(), active_public_key );
account.last_update = blockchain::now();
store_key( active_key );
store_key( owner_key );
store_account( account );
return owner_public_key;
} FC_CAPTURE_AND_RETHROW( (account_name) ) }
public_key_type wallet_db::generate_new_account( const fc::sha512& password, const string& account_name, const variant& private_data )
{ try {
FC_ASSERT( is_open() );
owallet_account_record account_record = lookup_account( account_name );
FC_ASSERT( !account_record.valid(), "Wallet already contains an account with that name!" );
uint32_t key_index = get_last_wallet_child_key_index();
private_key_type account_private_key;
public_key_type account_public_key;
address account_address;
while( true )
{
++key_index;
FC_ASSERT( key_index != 0, "Overflow!" );
account_private_key = get_wallet_child_key( password, key_index );
account_public_key = account_private_key.get_public_key();
account_address = address( account_public_key );
account_record = lookup_account( account_address );
if( account_record.valid() ) continue;
owallet_key_record key_record = lookup_key( account_address );
if( key_record.valid() && key_record->has_private_key() ) continue;
break;
}
key_data key;
key.account_address = account_address;
key.public_key = account_public_key;
key.encrypt_private_key( password, account_private_key );
key.gen_seq_number = key_index;
account_data account;
account.name = account_name;
account.owner_key = account_public_key;
account.set_active_key( blockchain::now(), account_public_key );
account.private_data = private_data;
account.is_my_account = true;
set_last_wallet_child_key_index( key_index );
store_key( key );
store_account( account );
return account_public_key;
} FC_CAPTURE_AND_RETHROW( (account_name) ) }
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::remove_contact_account( const string& account_name )
{
const owallet_account_record account_record = lookup_account( account_name );
FC_ASSERT( account_record.valid() );
FC_ASSERT( !account_record->is_my_account );
const int32_t& record_index = account_record->wallet_record_index;
accounts.erase( record_index );
address_to_account_wallet_record_index.erase( address( account_record->owner_key ) );
for( const auto& item : account_record->active_key_history )
{
const public_key_type& active_key = item.second;
address_to_account_wallet_record_index.erase( address( active_key ) );
}
if( account_record->is_delegate() )
{
for( const auto& item : account_record->delegate_info->signing_key_history )
{
const public_key_type& signing_key = item.second;
address_to_account_wallet_record_index.erase( address( signing_key ) );
}
}
name_to_account_wallet_record_index.erase( account_record->name );
account_id_to_wallet_record_index.erase( account_record->id );
// TODO: Remove key records and indexes
}
void WalletDb::remove_contact_account( const string& account_name )
{
const oWalletAccountEntry account_entry = lookup_account( account_name );
FC_ASSERT( account_entry.valid() );
FC_ASSERT( !account_entry->is_my_account );
const int32_t& entry_index = account_entry->wallet_entry_index;
accounts.erase( entry_index );
address_to_account_wallet_entry_index.erase( Address( account_entry->owner_key ) );
for( const auto& item : account_entry->active_key_history )
{
const PublicKeyType& active_key = item.second;
address_to_account_wallet_entry_index.erase( Address( active_key ) );
}
if( account_entry->is_delegate() )
{
for( const auto& item : account_entry->delegate_info->signing_key_history )
{
const PublicKeyType& signing_key = item.second;
address_to_account_wallet_entry_index.erase( Address( signing_key ) );
}
}
name_to_account_wallet_entry_index.erase( account_entry->name );
account_id_to_wallet_entry_index.erase( account_entry->id );
// TODO: Remove key entrys and indexes
}
void WalletDb::store_account( const AccountData& account )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
FC_ASSERT( account.name != string() );
FC_ASSERT( account.owner_key != PublicKeyType() );
oWalletAccountEntry account_entry = lookup_account( account.owner_address() );
if( !account_entry.valid() )
account_entry = WalletAccountEntry();
AccountData& temp = *account_entry;
temp = account;
store_and_reload_entry( *account_entry );
set<PublicKeyType> account_public_keys;
account_public_keys.insert( account_entry->owner_key );
for( const auto& active_key_item : account_entry->active_key_history )
{
const PublicKeyType& active_key = active_key_item.second;
if( active_key == PublicKeyType() ) continue;
account_public_keys.insert( active_key );
}
if( account.is_delegate() )
{
for( const auto& item : account.delegate_info->signing_key_history )
{
const PublicKeyType& signing_key = item.second;
if( signing_key == PublicKeyType() ) continue;
account_public_keys.insert( signing_key );
}
}
for( const PublicKeyType& account_public_key : account_public_keys )
{
const Address account_address = Address( account_public_key );
oWalletKeyEntry key_entry = lookup_key( account_address );
if( !key_entry.valid() )
{
KeyData key;
key.account_address = account_address;
key.public_key = account_public_key;
store_key( key );
}
else if( key_entry->has_private_key() )
{
if( !account_entry->is_my_account )
{
account_entry->is_my_account = true;
store_and_reload_entry( *account_entry );
}
if( key_entry->account_address != account_entry->owner_address() )
{
key_entry->account_address = account_entry->owner_address();
store_key( *key_entry );
}
}
}
} FC_CAPTURE_AND_RETHROW( (account) ) }
void WalletDb::store_account( const blockchain::AccountEntry& blockchain_account_entry )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
oWalletAccountEntry account_entry = lookup_account( blockchain_account_entry.owner_address() );
if( !account_entry.valid() )
account_entry = WalletAccountEntry();
blockchain::AccountEntry& temp = *account_entry;
temp = blockchain_account_entry;
store_account( *account_entry );
} FC_CAPTURE_AND_RETHROW( (blockchain_account_entry) ) }
void wallet_db::store_account( const blockchain::account_record& blockchain_account_record )
{ try {
FC_ASSERT( is_open() );
owallet_account_record account_record = lookup_account( blockchain_account_record.owner_address() );
if( !account_record.valid() )
account_record = wallet_account_record();
blockchain::account_record& temp = *account_record;
temp = blockchain_account_record;
store_account( *account_record );
} FC_CAPTURE_AND_RETHROW( (blockchain_account_record) ) }
void wallet_db::store_key( const key_data& key_to_store )
{
auto key_itr = keys.find( key_to_store.get_address() );
if( key_itr != keys.end() )
{
key_data& old_data = key_itr->second;
old_data = key_to_store;
if( key_to_store.has_private_key())
{
auto oacct = lookup_account( key_to_store.account_address );
FC_ASSERT(oacct.valid(), "expecting an account to existing at this point");
oacct->is_my_account = true;
store_record( *oacct );
cache_account( *oacct );
ilog( "WALLET: storing private key for ${key} under account '${account_name}' address: (${account})",
("key",key_to_store.public_key)
("account",key_to_store.account_address)
("account_name",get_account_name(key_to_store.account_address)) );
}
else
{
/*
ilog( "WALLET: storing public key ${key} under account named '${account_name}' address: (${account})",
("key",key_to_store.public_key)
("account",key_to_store.account_address)
("account_name",get_account_name(key_to_store.account_address)) );
*/
}
ilog( "storing key" );
store_record( key_itr->second, true );
}
else
{
auto r = wallet_key_record( key_to_store, new_wallet_record_index() );
store_record( keys[key_to_store.get_address()] = r, true );
auto key = key_to_store.public_key;
auto bts_addr = key_to_store.get_address();
btc_to_bts_address[ address(key) ] = bts_addr;
btc_to_bts_address[ address(pts_address(key,false,56) )] = bts_addr;
btc_to_bts_address[ address(pts_address(key,true,56) ) ] = bts_addr;
btc_to_bts_address[ address(pts_address(key,false,0) ) ] = bts_addr;
btc_to_bts_address[ address(pts_address(key,true,0) ) ] = bts_addr;
ilog( "indexing key ${k}", ("k",address(pts_address(key,false,56) ) ) );
ilog( "indexing key ${k}", ("k",address(pts_address(key,true,56) ) ) );
}
}
void WalletDb::store_key( const KeyData& key )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
FC_ASSERT( key.public_key != PublicKeyType() );
oWalletKeyEntry key_entry = lookup_key( key.get_address() );
if( !key_entry.valid() )
key_entry = WalletKeyEntry();
KeyData& temp = *key_entry;
temp = key;
store_and_reload_entry( *key_entry, true );
if( key_entry->has_private_key() )
{
oWalletAccountEntry account_entry = lookup_account( key.public_key );
if( !account_entry.valid() )
account_entry = lookup_account( key.account_address );
if( account_entry.valid() )
{
if( key_entry->account_address != account_entry->owner_address() )
{
key_entry->account_address = account_entry->owner_address();
store_and_reload_entry( *key_entry, true );
}
if( !account_entry->is_my_account )
{
account_entry->is_my_account = true;
store_account( *account_entry );
}
}
}
} FC_CAPTURE_AND_RETHROW( (key) ) }
PrivateKeyType WalletDb::generate_new_account_child_key( const fc::sha512& password, const string& account_name )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
oWalletAccountEntry account_entry = lookup_account( account_name );
FC_ASSERT( account_entry.valid(), "Account not found!" );
FC_ASSERT( !account_entry->is_retracted(), "Account has been retracted!" );
FC_ASSERT( account_entry->is_my_account, "Not my account!" );
const oWalletKeyEntry key_entry = lookup_key( Address( account_entry->active_key() ) );
FC_ASSERT( key_entry.valid(), "Active key not found!" );
FC_ASSERT( key_entry->has_private_key(), "Active private key not found!" );
const PrivateKeyType active_private_key = key_entry->decrypt_private_key( password );
uint32_t seq_num = account_entry->last_used_gen_sequence;
PrivateKeyType account_child_private_key;
PublicKeyType account_child_public_key;
Address account_child_address;
while( true )
{
++seq_num;
FC_ASSERT( seq_num != 0, "Overflow!" );
account_child_private_key = get_account_child_key( active_private_key, seq_num );
account_child_public_key = account_child_private_key.get_public_key();
account_child_address = Address( account_child_public_key );
oWalletKeyEntry key_entry = lookup_key( account_child_address );
if( key_entry.valid() && key_entry->has_private_key() ) continue;
break;
}
account_entry->last_used_gen_sequence = seq_num;
KeyData key;
key.account_address = account_entry->owner_address();
key.public_key = account_child_public_key;
key.encrypt_private_key( password, account_child_private_key );
key.gen_seq_number = seq_num;
store_account( *account_entry );
store_key( key );
return account_child_private_key;
} FC_CAPTURE_AND_RETHROW( (account_name) ) }
void wallet_db::add_contact_account( const account_record& blockchain_account_record, const variant& private_data )
{ try {
FC_ASSERT( is_open() );
owallet_account_record record = lookup_account( blockchain_account_record.name );
FC_ASSERT( !record.valid(), "Wallet already contains an account with that name!" );
const public_key_type account_address = blockchain_account_record.owner_key;
owallet_key_record key_record = lookup_key( account_address );
FC_ASSERT( !key_record.valid(), "Wallet already contains that key" );
record = wallet_account_record();
account_record& temp_record = *record;
temp_record = blockchain_account_record;
record->private_data = private_data;
store_account( *record );
} FC_CAPTURE_AND_RETHROW( (blockchain_account_record) ) }
void wallet_db::remove_contact_account( const string& account_name )
{
auto opt_account = lookup_account( account_name );
FC_ASSERT( opt_account.valid() );
auto acct = *opt_account;
FC_ASSERT( ! has_private_key(address(acct.owner_key)), "you can only remove contact accounts");
accounts.erase( acct.wallet_record_index );
remove_item( acct.wallet_record_index );
keys.erase( address(acct.owner_key) );
address_to_account_wallet_record_index.erase( address(acct.owner_key) );
for( const auto& time_key_pair : acct.active_key_history )
{
keys.erase( address(time_key_pair.second) );
address_to_account_wallet_record_index.erase( address(time_key_pair.second) );
}
name_to_account_wallet_record_index.erase( account_name );
}
void WalletDb::add_contact_account( const AccountEntry& blockchain_account_entry, const variant& private_data )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
oWalletAccountEntry entry = lookup_account( blockchain_account_entry.name );
FC_ASSERT( !entry.valid(), "Wallet already contains an account with that name!" );
const PublicKeyType account_address = blockchain_account_entry.owner_key;
oWalletKeyEntry key_entry = lookup_key( account_address );
FC_ASSERT( !key_entry.valid(), "Wallet already contains that key" );
entry = WalletAccountEntry();
AccountEntry& temp_entry = *entry;
temp_entry = blockchain_account_entry;
entry->private_data = private_data;
store_account( *entry );
} FC_CAPTURE_AND_RETHROW( (blockchain_account_entry) ) }
vector<wallet_balance_record> wallet_db::get_all_balances( const string& account_name, uint32_t limit )
{
auto ret = vector<wallet_balance_record>();
auto count = 0;
for( auto item : balances )
{
if (count == limit && limit != -1)
break;
auto okey = lookup_key(item.second.owner());
FC_ASSERT(okey.valid(), "expect a key record to exist at this point");
auto oacct = lookup_account( okey->account_address );
if ( oacct.valid() && oacct->name == account_name )
{
ret.push_back(item.second);
count++;
}
}
return ret;
}
void WalletDb::import_key( const fc::sha512& password, const string& account_name, const PrivateKeyType& private_key,
bool move_existing )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
oWalletAccountEntry account_entry = lookup_account( account_name );
FC_ASSERT( account_entry.valid(), "Account name not found!" );
const PublicKeyType public_key = private_key.get_public_key();
oWalletKeyEntry key_entry = lookup_key( Address( public_key ) );
if( !key_entry.valid() )
key_entry = WalletKeyEntry();
else if( !move_existing )
FC_ASSERT( key_entry->account_address == account_entry->owner_address() );
key_entry->account_address = account_entry->owner_address();
key_entry->public_key = public_key;
key_entry->encrypt_private_key( password, private_key );
store_key( *key_entry );
} FC_CAPTURE_AND_RETHROW( (account_name)(move_existing) ) }
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) ) }
void wallet_db::import_key( const fc::sha512& password, const string& account_name, const private_key_type& private_key,
bool move_existing )
{ try {
FC_ASSERT( is_open() );
owallet_account_record account_record = lookup_account( account_name );
FC_ASSERT( account_record.valid(), "Account name not found!" );
const public_key_type public_key = private_key.get_public_key();
owallet_key_record key_record = lookup_key( address( public_key ) );
if( !key_record.valid() )
key_record = wallet_key_record();
else if( !move_existing )
FC_ASSERT( key_record->account_address == account_record->owner_address() );
key_record->account_address = account_record->owner_address();
key_record->public_key = public_key;
key_record->encrypt_private_key( password, private_key );
store_key( *key_record );
} FC_CAPTURE_AND_RETHROW( (account_name)(move_existing) ) }
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_record( acct );
}
int32_t wallet_db::new_key_child_index( const address& account_address )
{
owallet_account_record account_rec = lookup_account( account_address );
if( account_rec )
{
account_rec->last_used_gen_sequence++;
cache_account( *account_rec );
return account_rec->last_used_gen_sequence;
}
auto next_child_idx = get_property( next_child_key_index );
int32_t next_child_index = 0;
if( next_child_idx.is_null() )
{
next_child_index = 1;
}
else
{
next_child_index = next_child_idx.as<int32_t>();
}
set_property( property_enum::next_child_key_index, next_child_index + 1 );
return next_child_index;
}
private_key_type wallet_db::generate_new_account_child_key( const fc::sha512& password, const string& account_name,
const account_key_type parent_key_type )
{ try {
FC_ASSERT( is_open() );
owallet_account_record account_record = lookup_account( account_name );
FC_ASSERT( account_record.valid(), "Account not found!" );
FC_ASSERT( !account_record->is_retracted(), "Account has been retracted!" );
public_key_type parent_public_key;
switch( parent_key_type )
{
case account_key_type::owner_key:
parent_public_key = account_record->owner_key;
break;
case account_key_type::active_key:
parent_public_key = account_record->active_key();
break;
case account_key_type::signing_key:
FC_ASSERT( account_record->is_delegate() );
parent_public_key = account_record->signing_key();
break;
// No default to force compiler warning
}
const owallet_key_record parent_key_record = lookup_key( address( parent_public_key ) );
FC_ASSERT( parent_key_record.valid(), "Parent key not found!" );
FC_ASSERT( parent_key_record->has_private_key(), "Parent private key not found!" );
const private_key_type parent_private_key = parent_key_record->decrypt_private_key( password );
uint32_t child_key_index = account_record->last_child_key_index;
private_key_type account_child_private_key;
public_key_type account_child_public_key;
address account_child_address;
while( true )
{
++child_key_index;
FC_ASSERT( child_key_index != 0, "Overflow!" );
account_child_private_key = get_account_child_key( parent_private_key, child_key_index );
account_child_public_key = account_child_private_key.get_public_key();
account_child_address = address( account_child_public_key );
owallet_key_record child_key_record = lookup_key( account_child_address );
if( child_key_record.valid() && child_key_record->has_private_key() ) continue;
break;
}
account_record->last_child_key_index = child_key_index;
key_data child_key;
child_key.account_address = account_record->owner_address();
child_key.child_key_index = child_key_index;
child_key.public_key = account_child_public_key;
child_key.encrypt_private_key( password, account_child_private_key );
store_account( *account_record );
store_key( child_key );
return account_child_private_key;
} FC_CAPTURE_AND_RETHROW( (account_name) ) }
string wallet_db::get_account_name( const address& account_address )const
{
auto opt = lookup_account( account_address );
if( opt ) return opt->name;
return "?";
}
PublicKeyType WalletDb::generate_new_account( const fc::sha512& password, const string& account_name, const variant& private_data )
{ try {
FC_ASSERT( is_open() ,"Wallet not open!");
oWalletAccountEntry account_entry = lookup_account( account_name );
FC_ASSERT( !account_entry.valid(), "Wallet already contains an account with that name!" );
uint32_t key_index = get_last_wallet_child_key_index();
PrivateKeyType owner_private_key, active_private_key;
PublicKeyType owner_public_key, active_public_key;
Address owner_address, active_address;
while( true )
{
++key_index;
FC_ASSERT( key_index != 0, "Overflow!" );
owner_private_key = get_wallet_child_key( password, key_index );
owner_public_key = owner_private_key.get_public_key();
owner_address = Address( owner_public_key );
account_entry = lookup_account( owner_address );
if( account_entry.valid() ) continue;
oWalletKeyEntry key_entry = lookup_key( owner_address );
if( key_entry.valid() && key_entry->has_private_key() ) continue;
active_private_key = get_account_child_key( owner_private_key, 0 );
active_public_key = active_private_key.get_public_key();
active_address = Address( active_public_key );
account_entry = lookup_account( active_address );
if( account_entry.valid() ) continue;
key_entry = lookup_key( active_address );
if( key_entry.valid() && key_entry->has_private_key() ) continue;
break;
}
KeyData active_key;
active_key.account_address = owner_address;
active_key.public_key = active_public_key;
active_key.encrypt_private_key( password, active_private_key );
KeyData owner_key;
owner_key.account_address = owner_address;
owner_key.public_key = owner_public_key;
owner_key.encrypt_private_key( password, owner_private_key );
owner_key.gen_seq_number = key_index;
AccountData account;
account.name = account_name;
account.owner_key = owner_public_key;
account.set_active_key( blockchain::now(), active_public_key );
account.last_update = blockchain::now();
account.is_my_account = true;
account.private_data = private_data;
store_key( active_key );
set_last_wallet_child_key_index( key_index );
store_key( owner_key );
store_account( account );
return owner_public_key;
} FC_CAPTURE_AND_RETHROW( (account_name) ) }
void WalletDb::remove_account(const string& accountname)
{
try{
oWalletAccountEntry accRec = lookup_account(accountname);
if (!accRec.valid())
{
return;
}
const int32_t& entry_index = accRec->wallet_entry_index;
accounts.erase(entry_index);
address_to_account_wallet_entry_index.erase(Address(accRec->owner_key));
for (const auto& item : accRec->active_key_history)
{
const PublicKeyType& active_key = item.second;
address_to_account_wallet_entry_index.erase(Address(active_key));
}
if (accRec->is_delegate())
{
for (const auto& item : accRec->delegate_info->signing_key_history)
{
const PublicKeyType& signing_key = item.second;
address_to_account_wallet_entry_index.erase(Address(signing_key));
}
}
name_to_account_wallet_entry_index.erase(accRec->name);
account_id_to_wallet_entry_index.erase(accRec->id);
GenericWalletEntry entry(*accRec);
my->remove_generic_wallet_entry(entry);
//从当前运行时数据中将账号纪录删除
address_to_account_wallet_entry_index.erase(Address(accRec->owner_key));
name_to_account_wallet_entry_index.erase(accRec->name);
account_id_to_wallet_entry_index.erase(accRec->id);
btc_to_gop_address.erase(accRec->owner_address());
btc_to_gop_address.erase(Address(PtsAddress(accRec->owner_key, false, 0)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->owner_key, true, 0)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->owner_key, false, 56)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->owner_key, true, 56)));
if (accRec->is_delegate())
{
btc_to_gop_address.erase(accRec->signing_address());
btc_to_gop_address.erase(Address(PtsAddress(accRec->signing_key(), false, 0)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->signing_key(), true, 0)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->signing_key(), false, 56)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->signing_key(), true, 56)));
}
btc_to_gop_address.erase(Address(accRec->active_key()));
btc_to_gop_address.erase(Address(PtsAddress(accRec->active_key(), false, 0)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->active_key(), true, 0)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->active_key(), false, 56)));
btc_to_gop_address.erase(Address(PtsAddress(accRec->active_key(), true, 56)));
//从db中将key删除,如果不删除,scan_accounts时会将与key相关的账号存入钱包
oWalletKeyEntry tmpRec= lookup_key(accRec->owner_address());
if (tmpRec.valid())
{
my->remove_generic_wallet_entry(GenericWalletEntry(*tmpRec));
}
tmpRec = lookup_key(accRec->active_address());
if (tmpRec.valid())
{
my->remove_generic_wallet_entry(GenericWalletEntry(*tmpRec));
}
if (accRec->is_delegate())
{
tmpRec = lookup_key(accRec->signing_address());
if (tmpRec.valid())
{
my->remove_generic_wallet_entry(GenericWalletEntry(*tmpRec));
}
}
auto keyit_owner= keys.find(accRec->owner_address());
if (keyit_owner != keys.end())
{
GenericWalletEntry rec(keyit_owner->second);
my->remove_generic_wallet_entry(rec);
keys.erase(accRec->owner_address());
}
auto keyit_activekey = keys.find(Address(accRec->active_key()));
if (keyit_activekey != keys.end())
{
GenericWalletEntry rec(keyit_activekey->second);
my->remove_generic_wallet_entry(rec);
keys.erase(accRec->active_address());
}
if (accRec->is_delegate())
{
auto keyit_sign = keys.find(accRec->signing_address());
if (keyit_sign != keys.end())
{
GenericWalletEntry rec(keyit_sign->second);
my->remove_generic_wallet_entry(rec);
}
keys.erase(accRec->signing_address());
accounts.erase(accRec->wallet_entry_index);
}
//删除对应的交易记录
unordered_map<TransactionIdType, WalletTransactionEntry>::iterator mapit = transactions.begin();
unordered_map<TransactionIdType, WalletTransactionEntry>::iterator tmpit;
while (mapit != transactions.end())
{
tmpit = mapit;
GenericWalletEntry rec(tmpit->second);
my->remove_generic_wallet_entry(rec);
mapit = transactions.erase(tmpit);
}
}FC_CAPTURE_AND_RETHROW((accountname))}
