2011-08-09 13:27:58 +02:00
// Copyright (c) 2009-2010 Satoshi Nakamoto
2016-12-31 19:01:21 +01:00
// Copyright (c) 2009-2016 The Bitcoin Core developers
2014-10-26 08:03:12 +01:00
// Distributed under the MIT software license, see the accompanying
2012-05-18 16:02:28 +02:00
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
2011-06-26 19:23:24 +02:00
2015-02-03 21:09:47 +01:00
# include "wallet/wallet.h"
2013-04-13 07:13:08 +02:00
2012-05-14 23:44:52 +02:00
# include "base58.h"
2014-05-05 20:54:00 +02:00
# include "checkpoints.h"
2015-07-05 14:17:46 +02:00
# include "chain.h"
2016-10-21 11:47:10 +02:00
# include "wallet/coincontrol.h"
2015-01-24 15:29:29 +01:00
# include "consensus/consensus.h"
2015-01-24 15:57:12 +01:00
# include "consensus/validation.h"
2015-07-05 14:30:07 +02:00
# include "key.h"
# include "keystore.h"
2016-12-02 01:06:41 +01:00
# include "validation.h"
2013-11-16 17:37:31 +01:00
# include "net.h"
2015-06-24 07:25:30 +02:00
# include "policy/policy.h"
2015-07-05 14:30:07 +02:00
# include "primitives/block.h"
# include "primitives/transaction.h"
2014-08-27 17:22:33 +02:00
# include "script/script.h"
# include "script/sign.h"
2017-02-08 19:19:18 +01:00
# include "scheduler.h"
2014-06-19 15:08:37 +02:00
# include "timedata.h"
2015-07-05 14:17:46 +02:00
# include "txmempool.h"
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
# include "util.h"
2016-03-21 18:29:17 +01:00
# include "ui_interface.h"
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
# include "utilmoneystr.h"
2013-04-13 07:13:08 +02:00
2014-10-01 08:50:24 +02:00
# include <assert.h>
2012-11-03 15:58:41 +01:00
# include <boost/algorithm/string/replace.hpp>
2015-02-04 21:19:27 +01:00
# include <boost/filesystem.hpp>
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
# include <boost/thread.hpp>
2011-06-26 19:23:24 +02:00
2016-03-15 10:30:37 +01:00
CWallet * pwalletMain = NULL ;
2015-12-19 14:27:15 +01:00
/** Transaction fee set by the user */
2014-04-10 20:14:18 +02:00
CFeeRate payTxFee ( DEFAULT_TRANSACTION_FEE ) ;
2015-05-18 08:51:16 +02:00
unsigned int nTxConfirmTarget = DEFAULT_TX_CONFIRM_TARGET ;
2015-11-09 19:16:38 +01:00
bool bSpendZeroConfChange = DEFAULT_SPEND_ZEROCONF_CHANGE ;
2016-09-01 15:24:45 +02:00
bool fWalletRbf = DEFAULT_WALLET_RBF ;
2011-06-26 19:23:24 +02:00
2016-02-22 10:48:44 +01:00
const char * DEFAULT_WALLET_DAT = " wallet.dat " ;
2016-06-01 20:29:39 +02:00
const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000 ;
2016-02-22 10:48:44 +01:00
2015-04-28 16:48:28 +02:00
/**
* Fees smaller than this ( in satoshi ) are considered zero fee ( for transaction creation )
2014-10-26 08:03:12 +01:00
* Override with - mintxfee
*/
2015-09-13 23:23:59 +02:00
CFeeRate CWallet : : minTxFee = CFeeRate ( DEFAULT_TRANSACTION_MINFEE ) ;
2016-01-05 19:11:34 +01:00
/**
* If fee estimation does not have enough data to provide estimates , use this fee instead .
* Has no effect if not using fee estimation
* Override with - fallbackfee
*/
CFeeRate CWallet : : fallbackFee = CFeeRate ( DEFAULT_FALLBACK_FEE ) ;
2014-07-03 20:25:32 +02:00
2016-01-07 22:31:27 +01:00
const uint256 CMerkleTx : : ABANDON_HASH ( uint256S ( " 0000000000000000000000000000000000000000000000000000000000000001 " ) ) ;
2014-10-26 08:03:12 +01:00
/** @defgroup mapWallet
*
* @ {
*/
2011-06-26 19:23:24 +02:00
2012-04-07 21:45:39 +02:00
struct CompareValueOnly
{
2017-01-27 02:33:45 +01:00
bool operator ( ) ( const std : : pair < CAmount , std : : pair < const CWalletTx * , unsigned int > > & t1 ,
const std : : pair < CAmount , std : : pair < const CWalletTx * , unsigned int > > & t2 ) const
2012-04-07 21:45:39 +02:00
{
return t1 . first < t2 . first ;
}
} ;
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
std : : string COutput : : ToString ( ) const
{
2016-11-12 01:54:51 +01:00
return strprintf ( " COutput(%s, %d, %d) [ % s ] " , tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->tx->vout[i].nValue)) ;
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
}
2014-02-15 22:38:28 +01:00
const CWalletTx * CWallet : : GetWalletTx ( const uint256 & hash ) const
{
LOCK ( cs_wallet ) ;
std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . find ( hash ) ;
if ( it = = mapWallet . end ( ) )
return NULL ;
return & ( it - > second ) ;
}
2017-01-10 16:45:30 +01:00
CPubKey CWallet : : GenerateNewKey ( bool internal )
2012-02-18 15:02:36 +01:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // mapKeyMetadata
2012-03-22 03:56:31 +01:00
bool fCompressed = CanSupportFeature ( FEATURE_COMPRPUBKEY ) ; // default to compressed public keys if we want 0.6.0 wallets
2012-02-18 15:06:32 +01:00
2013-05-01 06:52:05 +02:00
CKey secret ;
2016-01-02 12:34:08 +01:00
// Create new metadata
int64_t nCreationTime = GetTime ( ) ;
CKeyMetadata metadata ( nCreationTime ) ;
// use HD key derivation if HD was enabled during wallet creation
2016-08-17 14:09:47 +02:00
if ( IsHDEnabled ( ) ) {
2017-01-10 16:45:30 +01:00
DeriveNewChildKey ( metadata , secret , ( CanSupportFeature ( FEATURE_HD_SPLIT ) ? internal : false ) ) ;
2016-01-02 12:34:08 +01:00
} else {
secret . MakeNewKey ( fCompressed ) ;
}
2012-02-18 15:06:32 +01:00
// Compressed public keys were introduced in version 0.6.0
if ( fCompressed )
2012-03-22 03:56:31 +01:00
SetMinVersion ( FEATURE_COMPRPUBKEY ) ;
2012-02-18 15:06:32 +01:00
2013-05-01 06:52:05 +02:00
CPubKey pubkey = secret . GetPubKey ( ) ;
2014-11-06 10:17:48 +01:00
assert ( secret . VerifyPubKey ( pubkey ) ) ;
2013-06-20 01:13:55 +02:00
2016-01-02 12:34:08 +01:00
mapKeyMetadata [ pubkey . GetID ( ) ] = metadata ;
2016-11-08 22:28:20 +01:00
UpdateTimeFirstKey ( nCreationTime ) ;
2013-06-20 01:13:55 +02:00
2013-05-01 06:52:05 +02:00
if ( ! AddKeyPubKey ( secret , pubkey ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : AddKey failed " ) ;
2013-05-01 06:52:05 +02:00
return pubkey ;
2012-02-18 15:02:36 +01:00
}
2011-06-26 19:23:24 +02:00
2017-01-10 16:45:30 +01:00
void CWallet : : DeriveNewChildKey ( CKeyMetadata & metadata , CKey & secret , bool internal )
2016-07-20 01:43:11 +02:00
{
// for now we use a fixed keypath scheme of m/0'/0'/k
CKey key ; //master key seed (256bit)
CExtKey masterKey ; //hd master key
CExtKey accountKey ; //key at m/0'
2017-01-10 16:45:30 +01:00
CExtKey chainChildKey ; //key at m/0'/0' (external) or m/0'/1' (internal)
2016-07-20 01:43:11 +02:00
CExtKey childKey ; //key at m/0'/0'/<n>'
// try to get the master key
if ( ! GetKey ( hdChain . masterKeyID , key ) )
throw std : : runtime_error ( std : : string ( __func__ ) + " : Master key not found " ) ;
masterKey . SetMaster ( key . begin ( ) , key . size ( ) ) ;
// derive m/0'
// use hardened derivation (child keys >= 0x80000000 are hardened after bip32)
masterKey . Derive ( accountKey , BIP32_HARDENED_KEY_LIMIT ) ;
2017-01-10 16:45:30 +01:00
// derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
accountKey . Derive ( chainChildKey , BIP32_HARDENED_KEY_LIMIT + ( internal ? 1 : 0 ) ) ;
2016-07-20 01:43:11 +02:00
// derive child key at next index, skip keys already known to the wallet
do {
// always derive hardened keys
// childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened child-index-range
// example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
2017-01-10 16:45:30 +01:00
chainChildKey . Derive ( childKey , ( internal ? hdChain . nInternalChainCounter : hdChain . nExternalChainCounter ) | BIP32_HARDENED_KEY_LIMIT ) ;
metadata . hdKeypath = " m/0'/ " + std : : string ( internal ? " 1'/ " + std : : to_string ( hdChain . nInternalChainCounter ) : " 0'/ " + std : : to_string ( hdChain . nExternalChainCounter ) ) + " ' " ;
2016-07-20 01:43:11 +02:00
metadata . hdMasterKeyID = hdChain . masterKeyID ;
// increment childkey index
2017-01-10 16:45:30 +01:00
if ( internal )
hdChain . nInternalChainCounter + + ;
else
hdChain . nExternalChainCounter + + ;
2016-07-20 01:43:11 +02:00
} while ( HaveKey ( childKey . key . GetPubKey ( ) . GetID ( ) ) ) ;
secret = childKey . key ;
// update the chain model in the database
if ( ! CWalletDB ( strWalletFile ) . WriteHDChain ( hdChain ) )
throw std : : runtime_error ( std : : string ( __func__ ) + " : Writing HD chain model failed " ) ;
}
2013-06-20 01:13:55 +02:00
bool CWallet : : AddKeyPubKey ( const CKey & secret , const CPubKey & pubkey )
2011-06-26 19:23:24 +02:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // mapKeyMetadata
2013-05-01 06:52:05 +02:00
if ( ! CCryptoKeyStore : : AddKeyPubKey ( secret , pubkey ) )
2011-06-25 14:57:32 +02:00
return false ;
2014-07-26 21:05:11 +02:00
// check if we need to remove from watch-only
CScript script ;
script = GetScriptForDestination ( pubkey . GetID ( ) ) ;
2015-06-10 09:03:08 +02:00
if ( HaveWatchOnly ( script ) )
RemoveWatchOnly ( script ) ;
script = GetScriptForRawPubKey ( pubkey ) ;
2014-07-26 21:05:11 +02:00
if ( HaveWatchOnly ( script ) )
RemoveWatchOnly ( script ) ;
2011-06-26 19:23:24 +02:00
if ( ! fFileBacked )
return true ;
2013-05-01 06:52:05 +02:00
if ( ! IsCrypted ( ) ) {
2013-06-10 15:36:29 +02:00
return CWalletDB ( strWalletFile ) . WriteKey ( pubkey ,
secret . GetPrivKey ( ) ,
2013-06-20 01:13:55 +02:00
mapKeyMetadata [ pubkey . GetID ( ) ] ) ;
2013-05-01 06:52:05 +02:00
}
2011-07-13 13:43:50 +02:00
return true ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
}
2013-06-10 15:36:29 +02:00
bool CWallet : : AddCryptedKey ( const CPubKey & vchPubKey ,
2017-01-27 02:33:45 +01:00
const std : : vector < unsigned char > & vchCryptedSecret )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
if ( ! CCryptoKeyStore : : AddCryptedKey ( vchPubKey , vchCryptedSecret ) )
return false ;
if ( ! fFileBacked )
return true ;
2011-07-08 15:08:27 +02:00
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
2011-07-08 15:08:27 +02:00
if ( pwalletdbEncryption )
2013-06-10 15:36:29 +02:00
return pwalletdbEncryption - > WriteCryptedKey ( vchPubKey ,
vchCryptedSecret ,
2013-06-20 01:13:55 +02:00
mapKeyMetadata [ vchPubKey . GetID ( ) ] ) ;
2011-07-08 15:08:27 +02:00
else
2013-06-10 15:36:29 +02:00
return CWalletDB ( strWalletFile ) . WriteCryptedKey ( vchPubKey ,
vchCryptedSecret ,
2013-06-20 01:13:55 +02:00
mapKeyMetadata [ vchPubKey . GetID ( ) ] ) ;
2011-07-08 15:08:27 +02:00
}
2011-10-10 21:51:07 +02:00
return false ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
}
2016-11-08 22:55:02 +01:00
bool CWallet : : LoadKeyMetadata ( const CTxDestination & keyID , const CKeyMetadata & meta )
2013-06-20 01:13:55 +02:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // mapKeyMetadata
2016-11-08 22:28:20 +01:00
UpdateTimeFirstKey ( meta . nCreateTime ) ;
2016-11-08 22:55:02 +01:00
mapKeyMetadata [ keyID ] = meta ;
2013-06-20 01:13:55 +02:00
return true ;
}
2013-05-02 18:43:07 +02:00
bool CWallet : : LoadCryptedKey ( const CPubKey & vchPubKey , const std : : vector < unsigned char > & vchCryptedSecret )
{
return CCryptoKeyStore : : AddCryptedKey ( vchPubKey , vchCryptedSecret ) ;
}
2016-11-08 22:28:20 +01:00
void CWallet : : UpdateTimeFirstKey ( int64_t nCreateTime )
{
AssertLockHeld ( cs_wallet ) ;
if ( nCreateTime < = 1 ) {
// Cannot determine birthday information, so set the wallet birthday to
// the beginning of time.
nTimeFirstKey = 1 ;
} else if ( ! nTimeFirstKey | | nCreateTime < nTimeFirstKey ) {
nTimeFirstKey = nCreateTime ;
}
}
2012-01-05 03:40:52 +01:00
bool CWallet : : AddCScript ( const CScript & redeemScript )
2011-10-03 19:05:43 +02:00
{
2012-01-05 03:40:52 +01:00
if ( ! CCryptoKeyStore : : AddCScript ( redeemScript ) )
2011-10-03 19:05:43 +02:00
return false ;
if ( ! fFileBacked )
return true ;
2012-01-05 03:40:52 +01:00
return CWalletDB ( strWalletFile ) . WriteCScript ( Hash160 ( redeemScript ) , redeemScript ) ;
2011-10-03 19:05:43 +02:00
}
2014-06-10 09:42:42 +02:00
bool CWallet : : LoadCScript ( const CScript & redeemScript )
{
/* A sanity check was added in pull #3843 to avoid adding redeemScripts
* that never can be redeemed . However , old wallets may still contain
* these . Do not add them to the wallet and warn . */
if ( redeemScript . size ( ) > MAX_SCRIPT_ELEMENT_SIZE )
{
2014-09-25 04:24:46 +02:00
std : : string strAddr = CBitcoinAddress ( CScriptID ( redeemScript ) ) . ToString ( ) ;
2014-06-10 09:42:42 +02:00
LogPrintf ( " %s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s. \n " ,
__func__ , redeemScript . size ( ) , MAX_SCRIPT_ELEMENT_SIZE , strAddr ) ;
return true ;
}
return CCryptoKeyStore : : AddCScript ( redeemScript ) ;
}
2016-11-08 22:55:02 +01:00
bool CWallet : : AddWatchOnly ( const CScript & dest )
2013-07-26 01:06:01 +02:00
{
if ( ! CCryptoKeyStore : : AddWatchOnly ( dest ) )
return false ;
2016-11-08 22:55:02 +01:00
const CKeyMetadata & meta = mapKeyMetadata [ CScriptID ( dest ) ] ;
UpdateTimeFirstKey ( meta . nCreateTime ) ;
2014-07-26 21:05:11 +02:00
NotifyWatchonlyChanged ( true ) ;
2013-07-26 01:06:01 +02:00
if ( ! fFileBacked )
return true ;
2016-11-08 22:55:02 +01:00
return CWalletDB ( strWalletFile ) . WriteWatchOnly ( dest , meta ) ;
}
bool CWallet : : AddWatchOnly ( const CScript & dest , int64_t nCreateTime )
{
mapKeyMetadata [ CScriptID ( dest ) ] . nCreateTime = nCreateTime ;
return AddWatchOnly ( dest ) ;
2013-07-26 01:06:01 +02:00
}
2014-07-26 21:05:11 +02:00
bool CWallet : : RemoveWatchOnly ( const CScript & dest )
{
AssertLockHeld ( cs_wallet ) ;
if ( ! CCryptoKeyStore : : RemoveWatchOnly ( dest ) )
return false ;
if ( ! HaveWatchOnly ( ) )
NotifyWatchonlyChanged ( false ) ;
if ( fFileBacked )
if ( ! CWalletDB ( strWalletFile ) . EraseWatchOnly ( dest ) )
return false ;
return true ;
}
2014-06-09 21:11:59 +02:00
bool CWallet : : LoadWatchOnly ( const CScript & dest )
2013-07-26 01:06:01 +02:00
{
return CCryptoKeyStore : : AddWatchOnly ( dest ) ;
}
2011-11-26 07:02:04 +01:00
bool CWallet : : Unlock ( const SecureString & strWalletPassphrase )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
2011-08-26 20:37:23 +02:00
CCrypter crypter ;
2016-11-10 08:00:05 +01:00
CKeyingMaterial _vMasterKey ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2012-04-06 18:39:12 +02:00
{
LOCK ( cs_wallet ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
BOOST_FOREACH ( const MasterKeyMap : : value_type & pMasterKey , mapMasterKeys )
{
if ( ! crypter . SetKeyFromPassphrase ( strWalletPassphrase , pMasterKey . second . vchSalt , pMasterKey . second . nDeriveIterations , pMasterKey . second . nDerivationMethod ) )
return false ;
2016-11-10 08:00:05 +01:00
if ( ! crypter . Decrypt ( pMasterKey . second . vchCryptedKey , _vMasterKey ) )
2013-05-07 16:47:00 +02:00
continue ; // try another master key
2016-11-10 08:00:05 +01:00
if ( CCryptoKeyStore : : Unlock ( _vMasterKey ) )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return true ;
}
2012-04-06 18:39:12 +02:00
}
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return false ;
}
2011-11-26 07:02:04 +01:00
bool CWallet : : ChangeWalletPassphrase ( const SecureString & strOldWalletPassphrase , const SecureString & strNewWalletPassphrase )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
2011-08-26 20:37:23 +02:00
bool fWasLocked = IsLocked ( ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2011-08-26 20:37:23 +02:00
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
Lock ( ) ;
CCrypter crypter ;
2016-11-10 08:00:05 +01:00
CKeyingMaterial _vMasterKey ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
BOOST_FOREACH ( MasterKeyMap : : value_type & pMasterKey , mapMasterKeys )
{
if ( ! crypter . SetKeyFromPassphrase ( strOldWalletPassphrase , pMasterKey . second . vchSalt , pMasterKey . second . nDeriveIterations , pMasterKey . second . nDerivationMethod ) )
return false ;
2016-11-10 08:00:05 +01:00
if ( ! crypter . Decrypt ( pMasterKey . second . vchCryptedKey , _vMasterKey ) )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return false ;
2016-11-10 08:00:05 +01:00
if ( CCryptoKeyStore : : Unlock ( _vMasterKey ) )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
2013-04-13 07:13:08 +02:00
int64_t nStartTime = GetTimeMillis ( ) ;
2011-06-28 15:31:09 +02:00
crypter . SetKeyFromPassphrase ( strNewWalletPassphrase , pMasterKey . second . vchSalt , pMasterKey . second . nDeriveIterations , pMasterKey . second . nDerivationMethod ) ;
pMasterKey . second . nDeriveIterations = pMasterKey . second . nDeriveIterations * ( 100 / ( ( double ) ( GetTimeMillis ( ) - nStartTime ) ) ) ;
nStartTime = GetTimeMillis ( ) ;
crypter . SetKeyFromPassphrase ( strNewWalletPassphrase , pMasterKey . second . vchSalt , pMasterKey . second . nDeriveIterations , pMasterKey . second . nDerivationMethod ) ;
pMasterKey . second . nDeriveIterations = ( pMasterKey . second . nDeriveIterations + pMasterKey . second . nDeriveIterations * 100 / ( ( double ) ( GetTimeMillis ( ) - nStartTime ) ) ) / 2 ;
if ( pMasterKey . second . nDeriveIterations < 25000 )
pMasterKey . second . nDeriveIterations = 25000 ;
2013-09-18 12:38:08 +02:00
LogPrintf ( " Wallet passphrase changed to an nDeriveIterations of %i \n " , pMasterKey . second . nDeriveIterations ) ;
2011-06-28 15:31:09 +02:00
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
if ( ! crypter . SetKeyFromPassphrase ( strNewWalletPassphrase , pMasterKey . second . vchSalt , pMasterKey . second . nDeriveIterations , pMasterKey . second . nDerivationMethod ) )
return false ;
2016-11-10 08:00:05 +01:00
if ( ! crypter . Encrypt ( _vMasterKey , pMasterKey . second . vchCryptedKey ) )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return false ;
CWalletDB ( strWalletFile ) . WriteMasterKey ( pMasterKey . first , pMasterKey . second ) ;
if ( fWasLocked )
Lock ( ) ;
return true ;
}
}
}
2011-08-26 20:37:23 +02:00
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return false ;
}
2012-04-15 22:10:54 +02:00
void CWallet : : SetBestChain ( const CBlockLocator & loc )
{
CWalletDB walletdb ( strWalletFile ) ;
walletdb . WriteBestBlock ( loc ) ;
}
2011-07-10 16:07:22 +02:00
2012-03-22 03:56:31 +01:00
bool CWallet : : SetMinVersion ( enum WalletFeature nVersion , CWalletDB * pwalletdbIn , bool fExplicit )
2012-02-18 14:55:02 +01:00
{
2014-02-18 18:11:46 +01:00
LOCK ( cs_wallet ) ; // nWalletVersion
2012-02-18 14:55:02 +01:00
if ( nWalletVersion > = nVersion )
return true ;
2012-03-22 03:56:31 +01:00
// when doing an explicit upgrade, if we pass the max version permitted, upgrade all the way
if ( fExplicit & & nVersion > nWalletMaxVersion )
nVersion = FEATURE_LATEST ;
2012-02-18 14:55:02 +01:00
nWalletVersion = nVersion ;
2012-03-22 03:56:31 +01:00
if ( nVersion > nWalletMaxVersion )
nWalletMaxVersion = nVersion ;
2012-02-18 14:55:02 +01:00
if ( fFileBacked )
{
CWalletDB * pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB ( strWalletFile ) ;
if ( nWalletVersion > 40000 )
pwalletdb - > WriteMinVersion ( nWalletVersion ) ;
if ( ! pwalletdbIn )
delete pwalletdb ;
}
return true ;
}
2012-03-22 03:56:31 +01:00
bool CWallet : : SetMaxVersion ( int nVersion )
{
2014-02-18 18:11:46 +01:00
LOCK ( cs_wallet ) ; // nWalletVersion, nWalletMaxVersion
2012-03-22 03:56:31 +01:00
// cannot downgrade below current version
if ( nWalletVersion > nVersion )
return false ;
nWalletMaxVersion = nVersion ;
return true ;
}
2017-01-27 02:33:45 +01:00
std : : set < uint256 > CWallet : : GetConflicts ( const uint256 & txid ) const
2014-02-14 02:12:51 +01:00
{
2017-01-27 02:33:45 +01:00
std : : set < uint256 > result ;
2014-02-14 02:12:51 +01:00
AssertLockHeld ( cs_wallet ) ;
std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . find ( txid ) ;
if ( it = = mapWallet . end ( ) )
return result ;
const CWalletTx & wtx = it - > second ;
2014-02-15 22:38:28 +01:00
std : : pair < TxSpends : : const_iterator , TxSpends : : const_iterator > range ;
2014-02-14 02:12:51 +01:00
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , wtx . tx - > vin )
2014-02-14 02:12:51 +01:00
{
2014-02-15 22:38:28 +01:00
if ( mapTxSpends . count ( txin . prevout ) < = 1 )
continue ; // No conflict if zero or one spends
range = mapTxSpends . equal_range ( txin . prevout ) ;
2016-09-02 18:19:01 +02:00
for ( TxSpends : : const_iterator _it = range . first ; _it ! = range . second ; + + _it )
result . insert ( _it - > second ) ;
2014-02-14 02:12:51 +01:00
}
return result ;
}
2016-12-09 19:45:27 +01:00
bool CWallet : : HasWalletSpend ( const uint256 & txid ) const
{
AssertLockHeld ( cs_wallet ) ;
auto iter = mapTxSpends . lower_bound ( COutPoint ( txid , 0 ) ) ;
return ( iter ! = mapTxSpends . end ( ) & & iter - > first . hash = = txid ) ;
}
2015-02-04 21:19:27 +01:00
void CWallet : : Flush ( bool shutdown )
{
bitdb . Flush ( shutdown ) ;
}
2016-03-15 10:30:37 +01:00
bool CWallet : : Verify ( )
{
2016-09-21 12:15:18 +02:00
if ( GetBoolArg ( " -disablewallet " , DEFAULT_DISABLE_WALLET ) )
2016-09-19 16:09:38 +02:00
return true ;
2016-03-15 10:30:37 +01:00
uiInterface . InitMessage ( _ ( " Verifying wallet... " ) ) ;
2016-08-24 09:57:23 +02:00
std : : string walletFile = GetArg ( " -wallet " , DEFAULT_WALLET_DAT ) ;
2016-03-15 10:30:37 +01:00
2016-08-24 09:57:23 +02:00
std : : string strError ;
if ( ! CWalletDB : : VerifyEnvironment ( walletFile , GetDataDir ( ) . string ( ) , strError ) )
return InitError ( strError ) ;
2016-03-15 10:30:37 +01:00
2015-02-04 21:19:27 +01:00
if ( GetBoolArg ( " -salvagewallet " , false ) )
{
// Recover readable keypairs:
2016-08-24 09:57:23 +02:00
CWallet dummyWallet ;
if ( ! CWalletDB : : Recover ( walletFile , ( void * ) & dummyWallet , CWalletDB : : RecoverKeysOnlyFilter ) )
2015-02-04 21:19:27 +01:00
return false ;
}
2016-08-24 09:57:23 +02:00
std : : string strWarning ;
bool dbV = CWalletDB : : VerifyDatabaseFile ( walletFile , GetDataDir ( ) . string ( ) , strWarning , strError ) ;
if ( ! strWarning . empty ( ) )
InitWarning ( strWarning ) ;
if ( ! dbV )
2015-02-04 21:19:27 +01:00
{
2016-08-24 09:57:23 +02:00
InitError ( strError ) ;
return false ;
2015-02-04 21:19:27 +01:00
}
return true ;
}
2017-01-27 02:33:45 +01:00
void CWallet : : SyncMetaData ( std : : pair < TxSpends : : iterator , TxSpends : : iterator > range )
2014-02-14 02:12:51 +01:00
{
// We want all the wallet transactions in range to have the same metadata as
// the oldest (smallest nOrderPos).
// So: find smallest nOrderPos:
int nMinOrderPos = std : : numeric_limits < int > : : max ( ) ;
const CWalletTx * copyFrom = NULL ;
2014-02-15 22:38:28 +01:00
for ( TxSpends : : iterator it = range . first ; it ! = range . second ; + + it )
2014-02-14 02:12:51 +01:00
{
const uint256 & hash = it - > second ;
int n = mapWallet [ hash ] . nOrderPos ;
if ( n < nMinOrderPos )
{
nMinOrderPos = n ;
copyFrom = & mapWallet [ hash ] ;
}
}
// Now copy data from copyFrom to rest:
2014-02-15 22:38:28 +01:00
for ( TxSpends : : iterator it = range . first ; it ! = range . second ; + + it )
2014-02-14 02:12:51 +01:00
{
const uint256 & hash = it - > second ;
CWalletTx * copyTo = & mapWallet [ hash ] ;
if ( copyFrom = = copyTo ) continue ;
2015-03-12 00:48:53 +01:00
if ( ! copyFrom - > IsEquivalentTo ( * copyTo ) ) continue ;
2014-02-14 02:12:51 +01:00
copyTo - > mapValue = copyFrom - > mapValue ;
copyTo - > vOrderForm = copyFrom - > vOrderForm ;
// fTimeReceivedIsTxTime not copied on purpose
// nTimeReceived not copied on purpose
copyTo - > nTimeSmart = copyFrom - > nTimeSmart ;
copyTo - > fFromMe = copyFrom - > fFromMe ;
copyTo - > strFromAccount = copyFrom - > strFromAccount ;
// nOrderPos not copied on purpose
// cached members not copied on purpose
}
}
2014-10-26 08:03:12 +01:00
/**
* Outpoint is spent if any non - conflicted transaction
* spends it :
*/
2014-02-15 22:38:28 +01:00
bool CWallet : : IsSpent ( const uint256 & hash , unsigned int n ) const
2014-02-14 02:12:51 +01:00
{
2014-02-15 22:38:28 +01:00
const COutPoint outpoint ( hash , n ) ;
2017-01-27 02:33:45 +01:00
std : : pair < TxSpends : : const_iterator , TxSpends : : const_iterator > range ;
2014-02-15 22:38:28 +01:00
range = mapTxSpends . equal_range ( outpoint ) ;
2014-02-14 02:12:51 +01:00
2014-02-15 22:38:28 +01:00
for ( TxSpends : : const_iterator it = range . first ; it ! = range . second ; + + it )
2014-02-14 02:12:51 +01:00
{
2014-02-15 22:38:28 +01:00
const uint256 & wtxid = it - > second ;
std : : map < uint256 , CWalletTx > : : const_iterator mit = mapWallet . find ( wtxid ) ;
2016-01-07 22:31:27 +01:00
if ( mit ! = mapWallet . end ( ) ) {
int depth = mit - > second . GetDepthInMainChain ( ) ;
if ( depth > 0 | | ( depth = = 0 & & ! mit - > second . isAbandoned ( ) ) )
return true ; // Spent
}
2014-02-14 02:12:51 +01:00
}
2014-02-15 22:38:28 +01:00
return false ;
}
void CWallet : : AddToSpends ( const COutPoint & outpoint , const uint256 & wtxid )
{
2017-01-27 02:33:45 +01:00
mapTxSpends . insert ( std : : make_pair ( outpoint , wtxid ) ) ;
2014-02-15 22:38:28 +01:00
2017-01-27 02:33:45 +01:00
std : : pair < TxSpends : : iterator , TxSpends : : iterator > range ;
2014-02-15 22:38:28 +01:00
range = mapTxSpends . equal_range ( outpoint ) ;
SyncMetaData ( range ) ;
}
void CWallet : : AddToSpends ( const uint256 & wtxid )
{
assert ( mapWallet . count ( wtxid ) ) ;
CWalletTx & thisTx = mapWallet [ wtxid ] ;
if ( thisTx . IsCoinBase ( ) ) // Coinbases don't spend anything!
return ;
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , thisTx . tx - > vin )
2014-02-15 22:38:28 +01:00
AddToSpends ( txin . prevout , wtxid ) ;
2014-02-14 02:12:51 +01:00
}
2011-11-26 07:02:04 +01:00
bool CWallet : : EncryptWallet ( const SecureString & strWalletPassphrase )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
2011-08-26 20:37:23 +02:00
if ( IsCrypted ( ) )
return false ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2016-11-10 08:00:05 +01:00
CKeyingMaterial _vMasterKey ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2016-11-10 08:00:05 +01:00
_vMasterKey . resize ( WALLET_CRYPTO_KEY_SIZE ) ;
GetStrongRandBytes ( & _vMasterKey [ 0 ] , WALLET_CRYPTO_KEY_SIZE ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2011-08-26 20:37:23 +02:00
CMasterKey kMasterKey ;
2014-06-24 14:27:32 +02:00
2011-08-26 20:37:23 +02:00
kMasterKey . vchSalt . resize ( WALLET_CRYPTO_SALT_SIZE ) ;
2016-04-16 12:25:12 +02:00
GetStrongRandBytes ( & kMasterKey . vchSalt [ 0 ] , WALLET_CRYPTO_SALT_SIZE ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2011-08-26 20:37:23 +02:00
CCrypter crypter ;
2013-04-13 07:13:08 +02:00
int64_t nStartTime = GetTimeMillis ( ) ;
2011-08-26 20:37:23 +02:00
crypter . SetKeyFromPassphrase ( strWalletPassphrase , kMasterKey . vchSalt , 25000 , kMasterKey . nDerivationMethod ) ;
kMasterKey . nDeriveIterations = 2500000 / ( ( double ) ( GetTimeMillis ( ) - nStartTime ) ) ;
2011-06-28 15:31:09 +02:00
2011-08-26 20:37:23 +02:00
nStartTime = GetTimeMillis ( ) ;
crypter . SetKeyFromPassphrase ( strWalletPassphrase , kMasterKey . vchSalt , kMasterKey . nDeriveIterations , kMasterKey . nDerivationMethod ) ;
kMasterKey . nDeriveIterations = ( kMasterKey . nDeriveIterations + kMasterKey . nDeriveIterations * 100 / ( ( double ) ( GetTimeMillis ( ) - nStartTime ) ) ) / 2 ;
2011-06-28 15:31:09 +02:00
2011-08-26 20:37:23 +02:00
if ( kMasterKey . nDeriveIterations < 25000 )
kMasterKey . nDeriveIterations = 25000 ;
2011-06-28 15:31:09 +02:00
2013-09-18 12:38:08 +02:00
LogPrintf ( " Encrypting Wallet with an nDeriveIterations of %i \n " , kMasterKey . nDeriveIterations ) ;
2011-06-28 15:31:09 +02:00
2011-08-26 20:37:23 +02:00
if ( ! crypter . SetKeyFromPassphrase ( strWalletPassphrase , kMasterKey . vchSalt , kMasterKey . nDeriveIterations , kMasterKey . nDerivationMethod ) )
return false ;
2016-11-10 08:00:05 +01:00
if ( ! crypter . Encrypt ( _vMasterKey , kMasterKey . vchCryptedKey ) )
2011-08-26 20:37:23 +02:00
return false ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2011-08-26 20:37:23 +02:00
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
mapMasterKeys [ + + nMasterKeyMaxID ] = kMasterKey ;
if ( fFileBacked )
{
2014-09-28 16:11:17 +02:00
assert ( ! pwalletdbEncryption ) ;
2011-07-08 15:08:27 +02:00
pwalletdbEncryption = new CWalletDB ( strWalletFile ) ;
2014-09-28 16:11:17 +02:00
if ( ! pwalletdbEncryption - > TxnBegin ( ) ) {
delete pwalletdbEncryption ;
pwalletdbEncryption = NULL ;
2012-05-14 07:11:11 +02:00
return false ;
2014-09-28 16:11:17 +02:00
}
2011-07-08 15:08:27 +02:00
pwalletdbEncryption - > WriteMasterKey ( nMasterKeyMaxID , kMasterKey ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
}
2016-11-10 08:00:05 +01:00
if ( ! EncryptKeys ( _vMasterKey ) )
2011-07-08 15:08:27 +02:00
{
2014-09-28 16:11:17 +02:00
if ( fFileBacked ) {
2011-07-08 15:08:27 +02:00
pwalletdbEncryption - > TxnAbort ( ) ;
2014-09-28 16:11:17 +02:00
delete pwalletdbEncryption ;
}
// We now probably have half of our keys encrypted in memory, and half not...
2015-04-28 16:48:28 +02:00
// die and let the user reload the unencrypted wallet.
2014-10-01 08:50:24 +02:00
assert ( false ) ;
2011-07-08 15:08:27 +02:00
}
2012-02-18 14:55:02 +01:00
// Encryption was introduced in version 0.4.0
2012-03-22 03:56:31 +01:00
SetMinVersion ( FEATURE_WALLETCRYPT , pwalletdbEncryption , true ) ;
2012-02-18 14:55:02 +01:00
2011-07-08 15:08:27 +02:00
if ( fFileBacked )
{
2014-09-28 16:11:17 +02:00
if ( ! pwalletdbEncryption - > TxnCommit ( ) ) {
delete pwalletdbEncryption ;
2014-10-26 08:03:12 +01:00
// We now have keys encrypted in memory, but not on disk...
2015-04-28 16:48:28 +02:00
// die to avoid confusion and let the user reload the unencrypted wallet.
2014-10-01 08:50:24 +02:00
assert ( false ) ;
2014-09-28 16:11:17 +02:00
}
2011-07-08 15:08:27 +02:00
2012-02-18 15:36:40 +01:00
delete pwalletdbEncryption ;
2011-07-08 15:08:27 +02:00
pwalletdbEncryption = NULL ;
}
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
2011-11-17 20:01:25 +01:00
Lock ( ) ;
Unlock ( strWalletPassphrase ) ;
2016-07-21 21:19:02 +02:00
// if we are using HD, replace the HD master key (seed) with a new one
2016-08-17 14:09:47 +02:00
if ( IsHDEnabled ( ) ) {
2016-07-21 21:19:02 +02:00
CKey key ;
CPubKey masterPubKey = GenerateNewHDMasterKey ( ) ;
if ( ! SetHDMasterKey ( masterPubKey ) )
return false ;
}
2011-11-17 20:01:25 +01:00
NewKeyPool ( ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
Lock ( ) ;
2011-08-26 20:37:23 +02:00
2011-11-11 03:12:46 +01:00
// Need to completely rewrite the wallet file; if we don't, bdb might keep
// bits of the unencrypted private key in slack space in the database file.
2011-11-20 16:39:01 +01:00
CDB : : Rewrite ( strWalletFile ) ;
2012-05-05 16:07:14 +02:00
2011-11-11 03:12:46 +01:00
}
2012-05-06 19:40:58 +02:00
NotifyStatusChanged ( this ) ;
2011-11-10 21:29:23 +01:00
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return true ;
2011-06-26 19:23:24 +02:00
}
2016-09-10 04:21:44 +02:00
DBErrors CWallet : : ReorderTransactions ( )
{
2016-09-28 17:57:25 +02:00
LOCK ( cs_wallet ) ;
2016-09-10 04:21:44 +02:00
CWalletDB walletdb ( strWalletFile ) ;
2016-09-28 17:57:25 +02:00
// Old wallets didn't have any defined order for transactions
// Probably a bad idea to change the output of this
// First: get all CWalletTx and CAccountingEntry into a sorted-by-time multimap.
2017-01-27 02:33:45 +01:00
typedef std : : pair < CWalletTx * , CAccountingEntry * > TxPair ;
typedef std : : multimap < int64_t , TxPair > TxItems ;
2016-09-28 17:57:25 +02:00
TxItems txByTime ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2016-09-28 17:57:25 +02:00
{
CWalletTx * wtx = & ( ( * it ) . second ) ;
2017-01-27 02:33:45 +01:00
txByTime . insert ( std : : make_pair ( wtx - > nTimeReceived , TxPair ( wtx , ( CAccountingEntry * ) 0 ) ) ) ;
2016-09-28 17:57:25 +02:00
}
2017-01-27 02:33:45 +01:00
std : : list < CAccountingEntry > acentries ;
2016-09-28 17:57:25 +02:00
walletdb . ListAccountCreditDebit ( " " , acentries ) ;
BOOST_FOREACH ( CAccountingEntry & entry , acentries )
{
2017-01-27 02:33:45 +01:00
txByTime . insert ( std : : make_pair ( entry . nTime , TxPair ( ( CWalletTx * ) 0 , & entry ) ) ) ;
2016-09-28 17:57:25 +02:00
}
nOrderPosNext = 0 ;
std : : vector < int64_t > nOrderPosOffsets ;
for ( TxItems : : iterator it = txByTime . begin ( ) ; it ! = txByTime . end ( ) ; + + it )
{
CWalletTx * const pwtx = ( * it ) . second . first ;
CAccountingEntry * const pacentry = ( * it ) . second . second ;
int64_t & nOrderPos = ( pwtx ! = 0 ) ? pwtx - > nOrderPos : pacentry - > nOrderPos ;
if ( nOrderPos = = - 1 )
{
nOrderPos = nOrderPosNext + + ;
nOrderPosOffsets . push_back ( nOrderPos ) ;
if ( pwtx )
{
if ( ! walletdb . WriteTx ( * pwtx ) )
return DB_LOAD_FAIL ;
}
else
if ( ! walletdb . WriteAccountingEntry ( pacentry - > nEntryNo , * pacentry ) )
return DB_LOAD_FAIL ;
}
else
{
int64_t nOrderPosOff = 0 ;
BOOST_FOREACH ( const int64_t & nOffsetStart , nOrderPosOffsets )
{
if ( nOrderPos > = nOffsetStart )
+ + nOrderPosOff ;
}
nOrderPos + = nOrderPosOff ;
nOrderPosNext = std : : max ( nOrderPosNext , nOrderPos + 1 ) ;
if ( ! nOrderPosOff )
continue ;
// Since we're changing the order, write it back
if ( pwtx )
{
if ( ! walletdb . WriteTx ( * pwtx ) )
return DB_LOAD_FAIL ;
}
else
if ( ! walletdb . WriteAccountingEntry ( pacentry - > nEntryNo , * pacentry ) )
return DB_LOAD_FAIL ;
}
}
walletdb . WriteOrderPosNext ( nOrderPosNext ) ;
return DB_LOAD_OK ;
2016-09-10 04:21:44 +02:00
}
2013-04-13 07:13:08 +02:00
int64_t CWallet : : IncOrderPosNext ( CWalletDB * pwalletdb )
2012-09-08 06:55:36 +02:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // nOrderPosNext
2013-04-13 07:13:08 +02:00
int64_t nRet = nOrderPosNext + + ;
2012-11-13 23:52:37 +01:00
if ( pwalletdb ) {
pwalletdb - > WriteOrderPosNext ( nOrderPosNext ) ;
} else {
CWalletDB ( strWalletFile ) . WriteOrderPosNext ( nOrderPosNext ) ;
}
2012-09-08 06:55:36 +02:00
return nRet ;
}
2016-06-02 15:00:59 +02:00
bool CWallet : : AccountMove ( std : : string strFrom , std : : string strTo , CAmount nAmount , std : : string strComment )
{
CWalletDB walletdb ( strWalletFile ) ;
if ( ! walletdb . TxnBegin ( ) )
return false ;
int64_t nNow = GetAdjustedTime ( ) ;
// Debit
CAccountingEntry debit ;
debit . nOrderPos = IncOrderPosNext ( & walletdb ) ;
debit . strAccount = strFrom ;
debit . nCreditDebit = - nAmount ;
debit . nTime = nNow ;
debit . strOtherAccount = strTo ;
debit . strComment = strComment ;
2016-09-10 04:22:59 +02:00
AddAccountingEntry ( debit , & walletdb ) ;
2016-06-02 15:00:59 +02:00
// Credit
CAccountingEntry credit ;
credit . nOrderPos = IncOrderPosNext ( & walletdb ) ;
credit . strAccount = strTo ;
credit . nCreditDebit = nAmount ;
credit . nTime = nNow ;
credit . strOtherAccount = strFrom ;
credit . strComment = strComment ;
2016-09-10 04:22:59 +02:00
AddAccountingEntry ( credit , & walletdb ) ;
2016-06-02 15:00:59 +02:00
if ( ! walletdb . TxnCommit ( ) )
return false ;
return true ;
}
2016-06-03 08:16:42 +02:00
bool CWallet : : GetAccountPubkey ( CPubKey & pubKey , std : : string strAccount , bool bForceNew )
{
CWalletDB walletdb ( strWalletFile ) ;
CAccount account ;
walletdb . ReadAccount ( strAccount , account ) ;
if ( ! bForceNew ) {
if ( ! account . vchPubKey . IsValid ( ) )
bForceNew = true ;
else {
// Check if the current key has been used
CScript scriptPubKey = GetScriptForDestination ( account . vchPubKey . GetID ( ) ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : iterator it = mapWallet . begin ( ) ;
2016-06-03 08:16:42 +02:00
it ! = mapWallet . end ( ) & & account . vchPubKey . IsValid ( ) ;
+ + it )
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxOut & txout , ( * it ) . second . tx - > vout )
2016-06-03 08:16:42 +02:00
if ( txout . scriptPubKey = = scriptPubKey ) {
bForceNew = true ;
break ;
}
}
}
// Generate a new key
if ( bForceNew ) {
2017-01-10 16:45:30 +01:00
if ( ! GetKeyFromPool ( account . vchPubKey , false ) )
2016-06-03 08:16:42 +02:00
return false ;
SetAddressBook ( account . vchPubKey . GetID ( ) , strAccount , " receive " ) ;
walletdb . WriteAccount ( strAccount , account ) ;
}
pubKey = account . vchPubKey ;
return true ;
}
2011-07-13 11:56:38 +02:00
void CWallet : : MarkDirty ( )
{
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
2011-07-13 11:56:38 +02:00
BOOST_FOREACH ( PAIRTYPE ( const uint256 , CWalletTx ) & item , mapWallet )
item . second . MarkDirty ( ) ;
}
}
2016-12-09 19:45:27 +01:00
bool CWallet : : MarkReplaced ( const uint256 & originalHash , const uint256 & newHash )
{
LOCK ( cs_wallet ) ;
auto mi = mapWallet . find ( originalHash ) ;
// There is a bug if MarkReplaced is not called on an existing wallet transaction.
assert ( mi ! = mapWallet . end ( ) ) ;
CWalletTx & wtx = ( * mi ) . second ;
// Ensure for now that we're not overwriting data
assert ( wtx . mapValue . count ( " replaced_by_txid " ) = = 0 ) ;
wtx . mapValue [ " replaced_by_txid " ] = newHash . ToString ( ) ;
CWalletDB walletdb ( strWalletFile , " r+ " ) ;
bool success = true ;
if ( ! walletdb . WriteTx ( wtx ) ) {
LogPrintf ( " %s: Updating walletdb tx %s failed " , __func__ , wtx . GetHash ( ) . ToString ( ) ) ;
success = false ;
}
NotifyTransactionChanged ( this , originalHash , CT_UPDATED ) ;
return success ;
}
2016-06-08 06:41:03 +02:00
bool CWallet : : AddToWallet ( const CWalletTx & wtxIn , bool fFlushOnClose )
2011-06-26 19:23:24 +02:00
{
2016-06-08 06:41:03 +02:00
LOCK ( cs_wallet ) ;
CWalletDB walletdb ( strWalletFile , " r+ " , fFlushOnClose ) ;
2011-06-26 19:23:24 +02:00
uint256 hash = wtxIn . GetHash ( ) ;
2014-02-14 02:12:51 +01:00
2016-06-08 06:25:31 +02:00
// Inserts only if not already there, returns tx inserted or tx found
2017-01-27 02:33:45 +01:00
std : : pair < std : : map < uint256 , CWalletTx > : : iterator , bool > ret = mapWallet . insert ( std : : make_pair ( hash , wtxIn ) ) ;
2016-06-08 06:25:31 +02:00
CWalletTx & wtx = ( * ret . first ) . second ;
wtx . BindWallet ( this ) ;
bool fInsertedNew = ret . second ;
if ( fInsertedNew )
{
wtx . nTimeReceived = GetAdjustedTime ( ) ;
2016-06-08 06:41:03 +02:00
wtx . nOrderPos = IncOrderPosNext ( & walletdb ) ;
2017-01-27 02:33:45 +01:00
wtxOrdered . insert ( std : : make_pair ( wtx . nOrderPos , TxPair ( & wtx , ( CAccountingEntry * ) 0 ) ) ) ;
2016-12-16 16:00:26 +01:00
wtx . nTimeSmart = ComputeTimeSmart ( wtx ) ;
2016-06-08 06:25:31 +02:00
AddToSpends ( hash ) ;
}
2011-06-26 19:23:24 +02:00
2016-06-08 06:25:31 +02:00
bool fUpdated = false ;
if ( ! fInsertedNew )
{
// Merge
if ( ! wtxIn . hashUnset ( ) & & wtxIn . hashBlock ! = wtx . hashBlock )
2011-06-26 19:23:24 +02:00
{
2016-06-08 06:25:31 +02:00
wtx . hashBlock = wtxIn . hashBlock ;
fUpdated = true ;
}
// If no longer abandoned, update
if ( wtxIn . hashBlock . IsNull ( ) & & wtx . isAbandoned ( ) )
{
wtx . hashBlock = wtxIn . hashBlock ;
fUpdated = true ;
}
if ( wtxIn . nIndex ! = - 1 & & ( wtxIn . nIndex ! = wtx . nIndex ) )
{
wtx . nIndex = wtxIn . nIndex ;
fUpdated = true ;
2011-06-26 19:23:24 +02:00
}
2016-06-08 06:25:31 +02:00
if ( wtxIn . fFromMe & & wtxIn . fFromMe ! = wtx . fFromMe )
{
wtx . fFromMe = wtxIn . fFromMe ;
fUpdated = true ;
}
}
2011-06-26 19:23:24 +02:00
2016-06-08 06:25:31 +02:00
//// debug print
LogPrintf ( " AddToWallet %s %s%s \n " , wtxIn . GetHash ( ) . ToString ( ) , ( fInsertedNew ? " new " : " " ) , ( fUpdated ? " update " : " " ) ) ;
2011-06-26 19:23:24 +02:00
2016-06-08 06:25:31 +02:00
// Write to disk
if ( fInsertedNew | | fUpdated )
2016-06-08 06:41:03 +02:00
if ( ! walletdb . WriteTx ( wtx ) )
2016-06-08 06:25:31 +02:00
return false ;
2013-05-26 20:17:18 +02:00
2016-06-08 06:25:31 +02:00
// Break debit/credit balance caches:
wtx . MarkDirty ( ) ;
2011-06-26 19:23:24 +02:00
2016-06-08 06:25:31 +02:00
// Notify UI of new or updated transaction
NotifyTransactionChanged ( this , hash , fInsertedNew ? CT_NEW : CT_UPDATED ) ;
2012-11-03 15:58:41 +01:00
2016-06-08 06:25:31 +02:00
// notify an external script when a wallet transaction comes in or is updated
std : : string strCmd = GetArg ( " -walletnotify " , " " ) ;
2012-11-03 15:58:41 +01:00
2016-06-08 06:25:31 +02:00
if ( ! strCmd . empty ( ) )
{
boost : : replace_all ( strCmd , " %s " , wtxIn . GetHash ( ) . GetHex ( ) ) ;
boost : : thread t ( runCommand , strCmd ) ; // thread runs free
}
return true ;
}
bool CWallet : : LoadToWallet ( const CWalletTx & wtxIn )
{
uint256 hash = wtxIn . GetHash ( ) ;
2012-11-03 15:58:41 +01:00
2016-06-08 06:25:31 +02:00
mapWallet [ hash ] = wtxIn ;
CWalletTx & wtx = mapWallet [ hash ] ;
wtx . BindWallet ( this ) ;
2017-01-27 02:33:45 +01:00
wtxOrdered . insert ( std : : make_pair ( wtx . nOrderPos , TxPair ( & wtx , ( CAccountingEntry * ) 0 ) ) ) ;
2016-06-08 06:25:31 +02:00
AddToSpends ( hash ) ;
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , wtx . tx - > vin ) {
2016-06-08 06:25:31 +02:00
if ( mapWallet . count ( txin . prevout . hash ) ) {
CWalletTx & prevtx = mapWallet [ txin . prevout . hash ] ;
if ( prevtx . nIndex = = - 1 & & ! prevtx . hashUnset ( ) ) {
MarkConflicted ( prevtx . hashBlock , wtx . GetHash ( ) ) ;
}
}
2012-05-05 16:07:14 +02:00
}
2016-06-08 06:25:31 +02:00
2011-06-26 19:23:24 +02:00
return true ;
}
2014-10-26 08:03:12 +01:00
/**
2016-12-16 20:17:13 +01:00
* Add a transaction to the wallet , or update it . pIndex and posInBlock should
* be set when the transaction was known to be included in a block . When
* posInBlock = SYNC_TRANSACTION_NOT_IN_BLOCK ( - 1 ) , then wallet state is not
* updated in AddToWallet , but notifications happen and cached balances are
* marked dirty .
2014-10-26 08:03:12 +01:00
* If fUpdate is true , existing transactions will be updated .
2016-12-16 20:17:13 +01:00
* TODO : One exception to this is that the abandoned state is cleared under the
* assumption that any further notification of a transaction that was considered
* abandoned is an indication that it is not safe to be considered abandoned .
2017-02-06 15:16:18 +01:00
* Abandoned state should probably be more carefully tracked via different
2016-12-16 20:17:13 +01:00
* posInBlock signals or by checking mempool presence when necessary .
2014-10-26 08:03:12 +01:00
*/
2016-04-26 13:55:13 +02:00
bool CWallet : : AddToWalletIfInvolvingMe ( const CTransaction & tx , const CBlockIndex * pIndex , int posInBlock , bool fUpdate )
2011-06-26 19:23:24 +02:00
{
{
2014-03-09 12:41:22 +01:00
AssertLockHeld ( cs_wallet ) ;
2015-11-26 18:42:07 +01:00
2016-04-26 13:55:13 +02:00
if ( posInBlock ! = - 1 ) {
2015-11-26 18:42:07 +01:00
BOOST_FOREACH ( const CTxIn & txin , tx . vin ) {
std : : pair < TxSpends : : const_iterator , TxSpends : : const_iterator > range = mapTxSpends . equal_range ( txin . prevout ) ;
while ( range . first ! = range . second ) {
if ( range . first - > second ! = tx . GetHash ( ) ) {
2016-04-26 13:55:13 +02:00
LogPrintf ( " Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i) \n " , tx . GetHash ( ) . ToString ( ) , pIndex - > GetBlockHash ( ) . ToString ( ) , range . first - > second . ToString ( ) , range . first - > first . hash . ToString ( ) , range . first - > first . n ) ;
MarkConflicted ( pIndex - > GetBlockHash ( ) , range . first - > second ) ;
2015-11-26 18:42:07 +01:00
}
range . first + + ;
}
}
}
2014-09-06 21:59:59 +02:00
bool fExisted = mapWallet . count ( tx . GetHash ( ) ) ! = 0 ;
2011-08-26 20:37:23 +02:00
if ( fExisted & & ! fUpdate ) return false ;
2014-07-17 14:09:46 +02:00
if ( fExisted | | IsMine ( tx ) | | IsFromMe ( tx ) )
2011-08-26 20:37:23 +02:00
{
2016-11-12 01:54:51 +01:00
CWalletTx wtx ( this , MakeTransactionRef ( tx ) ) ;
2014-08-31 05:55:27 +02:00
2011-08-26 20:37:23 +02:00
// Get merkle branch if transaction was found in a block
2016-04-26 13:55:13 +02:00
if ( posInBlock ! = - 1 )
wtx . SetMerkleBranch ( pIndex , posInBlock ) ;
2014-08-31 05:55:27 +02:00
2016-06-08 06:41:03 +02:00
return AddToWallet ( wtx , false ) ;
2011-08-26 20:37:23 +02:00
}
2011-06-26 19:23:24 +02:00
}
return false ;
}
2016-01-07 22:31:27 +01:00
bool CWallet : : AbandonTransaction ( const uint256 & hashTx )
{
LOCK2 ( cs_main , cs_wallet ) ;
2016-12-09 19:36:42 +01:00
CWalletDB walletdb ( strWalletFile , " r+ " ) ;
2016-01-07 22:31:27 +01:00
std : : set < uint256 > todo ;
std : : set < uint256 > done ;
// Can't mark abandoned if confirmed or in mempool
assert ( mapWallet . count ( hashTx ) ) ;
CWalletTx & origtx = mapWallet [ hashTx ] ;
if ( origtx . GetDepthInMainChain ( ) > 0 | | origtx . InMempool ( ) ) {
return false ;
}
todo . insert ( hashTx ) ;
while ( ! todo . empty ( ) ) {
uint256 now = * todo . begin ( ) ;
todo . erase ( now ) ;
done . insert ( now ) ;
assert ( mapWallet . count ( now ) ) ;
CWalletTx & wtx = mapWallet [ now ] ;
int currentconfirm = wtx . GetDepthInMainChain ( ) ;
// If the orig tx was not in block, none of its spends can be
assert ( currentconfirm < = 0 ) ;
// if (currentconfirm < 0) {Tx and spends are already conflicted, no need to abandon}
if ( currentconfirm = = 0 & & ! wtx . isAbandoned ( ) ) {
// If the orig tx was not in block/mempool, none of its spends can be in mempool
assert ( ! wtx . InMempool ( ) ) ;
wtx . nIndex = - 1 ;
wtx . setAbandoned ( ) ;
wtx . MarkDirty ( ) ;
2016-05-09 09:15:12 +02:00
walletdb . WriteTx ( wtx ) ;
2016-01-11 11:15:41 +01:00
NotifyTransactionChanged ( this , wtx . GetHash ( ) , CT_UPDATED ) ;
2016-01-07 22:31:27 +01:00
// Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too
TxSpends : : const_iterator iter = mapTxSpends . lower_bound ( COutPoint ( hashTx , 0 ) ) ;
while ( iter ! = mapTxSpends . end ( ) & & iter - > first . hash = = now ) {
if ( ! done . count ( iter - > second ) ) {
todo . insert ( iter - > second ) ;
}
iter + + ;
}
// If a transaction changes 'conflicted' state, that changes the balance
// available of the outputs it spends. So force those to be recomputed
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , wtx . tx - > vin )
2016-01-07 22:31:27 +01:00
{
if ( mapWallet . count ( txin . prevout . hash ) )
mapWallet [ txin . prevout . hash ] . MarkDirty ( ) ;
}
}
}
return true ;
}
2015-11-26 18:42:07 +01:00
void CWallet : : MarkConflicted ( const uint256 & hashBlock , const uint256 & hashTx )
{
LOCK2 ( cs_main , cs_wallet ) ;
int conflictconfirms = 0 ;
2016-02-09 20:23:09 +01:00
if ( mapBlockIndex . count ( hashBlock ) ) {
CBlockIndex * pindex = mapBlockIndex [ hashBlock ] ;
if ( chainActive . Contains ( pindex ) ) {
conflictconfirms = - ( chainActive . Height ( ) - pindex - > nHeight + 1 ) ;
}
2015-11-26 18:42:07 +01:00
}
2016-02-09 20:23:09 +01:00
// If number of conflict confirms cannot be determined, this means
// that the block is still unknown or not yet part of the main chain,
// for example when loading the wallet during a reindex. Do nothing in that
// case.
if ( conflictconfirms > = 0 )
return ;
2015-11-26 18:42:07 +01:00
// Do not flush the wallet here for performance reasons
CWalletDB walletdb ( strWalletFile , " r+ " , false ) ;
2016-01-07 22:31:12 +01:00
std : : set < uint256 > todo ;
2015-11-26 18:42:07 +01:00
std : : set < uint256 > done ;
2016-01-07 22:31:12 +01:00
todo . insert ( hashTx ) ;
2015-11-26 18:42:07 +01:00
while ( ! todo . empty ( ) ) {
2016-01-07 22:31:12 +01:00
uint256 now = * todo . begin ( ) ;
todo . erase ( now ) ;
2015-11-26 18:42:07 +01:00
done . insert ( now ) ;
assert ( mapWallet . count ( now ) ) ;
CWalletTx & wtx = mapWallet [ now ] ;
int currentconfirm = wtx . GetDepthInMainChain ( ) ;
if ( conflictconfirms < currentconfirm ) {
// Block is 'more conflicted' than current confirm; update.
// Mark transaction as conflicted with this block.
wtx . nIndex = - 1 ;
wtx . hashBlock = hashBlock ;
wtx . MarkDirty ( ) ;
2016-05-09 09:15:12 +02:00
walletdb . WriteTx ( wtx ) ;
2015-11-26 18:42:07 +01:00
// Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too
TxSpends : : const_iterator iter = mapTxSpends . lower_bound ( COutPoint ( now , 0 ) ) ;
while ( iter ! = mapTxSpends . end ( ) & & iter - > first . hash = = now ) {
if ( ! done . count ( iter - > second ) ) {
2016-01-07 22:31:12 +01:00
todo . insert ( iter - > second ) ;
2015-11-26 18:42:07 +01:00
}
iter + + ;
}
2016-01-06 23:24:30 +01:00
// If a transaction changes 'conflicted' state, that changes the balance
// available of the outputs it spends. So force those to be recomputed
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , wtx . tx - > vin )
2016-01-06 23:24:30 +01:00
{
if ( mapWallet . count ( txin . prevout . hash ) )
mapWallet [ txin . prevout . hash ] . MarkDirty ( ) ;
}
2015-11-26 18:42:07 +01:00
}
}
}
2016-04-26 13:55:13 +02:00
void CWallet : : SyncTransaction ( const CTransaction & tx , const CBlockIndex * pindex , int posInBlock )
2014-02-15 22:38:28 +01:00
{
2014-04-15 17:38:25 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2015-11-26 18:42:07 +01:00
2016-04-26 13:55:13 +02:00
if ( ! AddToWalletIfInvolvingMe ( tx , pindex , posInBlock , true ) )
2014-02-15 22:38:28 +01:00
return ; // Not one of ours
// If a transaction changes 'conflicted' state, that changes the balance
// available of the outputs it spends. So force those to be
// recomputed, also:
BOOST_FOREACH ( const CTxIn & txin , tx . vin )
{
if ( mapWallet . count ( txin . prevout . hash ) )
mapWallet [ txin . prevout . hash ] . MarkDirty ( ) ;
}
2013-10-19 18:34:06 +02:00
}
2011-06-26 19:23:24 +02:00
2013-07-26 01:06:01 +02:00
isminetype CWallet : : IsMine ( const CTxIn & txin ) const
2011-06-26 19:23:24 +02:00
{
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
2017-01-27 02:33:45 +01:00
std : : map < uint256 , CWalletTx > : : const_iterator mi = mapWallet . find ( txin . prevout . hash ) ;
2011-06-26 19:23:24 +02:00
if ( mi ! = mapWallet . end ( ) )
{
const CWalletTx & prev = ( * mi ) . second ;
2016-11-12 01:54:51 +01:00
if ( txin . prevout . n < prev . tx - > vout . size ( ) )
return IsMine ( prev . tx - > vout [ txin . prevout . n ] ) ;
2011-06-26 19:23:24 +02:00
}
}
2014-07-01 11:00:22 +02:00
return ISMINE_NO ;
2011-06-26 19:23:24 +02:00
}
2016-12-09 21:31:06 +01:00
// Note that this function doesn't distinguish between a 0-valued input,
// and a not-"is mine" (according to the filter) input.
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetDebit ( const CTxIn & txin , const isminefilter & filter ) const
2011-06-26 19:23:24 +02:00
{
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
2017-01-27 02:33:45 +01:00
std : : map < uint256 , CWalletTx > : : const_iterator mi = mapWallet . find ( txin . prevout . hash ) ;
2011-06-26 19:23:24 +02:00
if ( mi ! = mapWallet . end ( ) )
{
const CWalletTx & prev = ( * mi ) . second ;
2016-11-12 01:54:51 +01:00
if ( txin . prevout . n < prev . tx - > vout . size ( ) )
if ( IsMine ( prev . tx - > vout [ txin . prevout . n ] ) & filter )
return prev . tx - > vout [ txin . prevout . n ] . nValue ;
2011-06-26 19:23:24 +02:00
}
}
return 0 ;
}
2015-02-04 23:19:29 +01:00
isminetype CWallet : : IsMine ( const CTxOut & txout ) const
{
return : : IsMine ( * this , txout . scriptPubKey ) ;
}
CAmount CWallet : : GetCredit ( const CTxOut & txout , const isminefilter & filter ) const
{
if ( ! MoneyRange ( txout . nValue ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : value out of range " ) ;
2015-02-04 23:19:29 +01:00
return ( ( IsMine ( txout ) & filter ) ? txout . nValue : 0 ) ;
}
2011-10-03 19:05:43 +02:00
bool CWallet : : IsChange ( const CTxOut & txout ) const
{
2011-11-08 19:20:29 +01:00
// TODO: fix handling of 'change' outputs. The assumption is that any
2014-06-09 21:11:59 +02:00
// payment to a script that is ours, but is not in the address book
2011-11-08 19:20:29 +01:00
// is change. That assumption is likely to break when we implement multisignature
// wallets that return change back into a multi-signature-protected address;
// a better way of identifying which outputs are 'the send' and which are
// 'the change' will need to be implemented (maybe extend CWalletTx to remember
// which output, if any, was change).
2014-06-09 21:11:59 +02:00
if ( : : IsMine ( * this , txout . scriptPubKey ) )
2012-04-06 18:39:12 +02:00
{
2014-06-09 21:11:59 +02:00
CTxDestination address ;
if ( ! ExtractDestination ( txout . scriptPubKey , address ) )
return true ;
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
if ( ! mapAddressBook . count ( address ) )
return true ;
}
2011-10-03 19:05:43 +02:00
return false ;
}
2015-02-04 23:19:29 +01:00
CAmount CWallet : : GetChange ( const CTxOut & txout ) const
{
if ( ! MoneyRange ( txout . nValue ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : value out of range " ) ;
2015-02-04 23:19:29 +01:00
return ( IsChange ( txout ) ? txout . nValue : 0 ) ;
}
bool CWallet : : IsMine ( const CTransaction & tx ) const
{
BOOST_FOREACH ( const CTxOut & txout , tx . vout )
if ( IsMine ( txout ) )
return true ;
return false ;
}
bool CWallet : : IsFromMe ( const CTransaction & tx ) const
{
return ( GetDebit ( tx , ISMINE_ALL ) > 0 ) ;
}
CAmount CWallet : : GetDebit ( const CTransaction & tx , const isminefilter & filter ) const
{
CAmount nDebit = 0 ;
BOOST_FOREACH ( const CTxIn & txin , tx . vin )
{
nDebit + = GetDebit ( txin , filter ) ;
if ( ! MoneyRange ( nDebit ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : value out of range " ) ;
2015-02-04 23:19:29 +01:00
}
return nDebit ;
}
2016-12-09 21:31:06 +01:00
bool CWallet : : IsAllFromMe ( const CTransaction & tx , const isminefilter & filter ) const
{
LOCK ( cs_wallet ) ;
BOOST_FOREACH ( const CTxIn & txin , tx . vin )
{
auto mi = mapWallet . find ( txin . prevout . hash ) ;
if ( mi = = mapWallet . end ( ) )
return false ; // any unknown inputs can't be from us
const CWalletTx & prev = ( * mi ) . second ;
if ( txin . prevout . n > = prev . tx - > vout . size ( ) )
return false ; // invalid input!
if ( ! ( IsMine ( prev . tx - > vout [ txin . prevout . n ] ) & filter ) )
return false ;
}
return true ;
}
2015-02-04 23:19:29 +01:00
CAmount CWallet : : GetCredit ( const CTransaction & tx , const isminefilter & filter ) const
{
CAmount nCredit = 0 ;
BOOST_FOREACH ( const CTxOut & txout , tx . vout )
{
nCredit + = GetCredit ( txout , filter ) ;
if ( ! MoneyRange ( nCredit ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : value out of range " ) ;
2015-02-04 23:19:29 +01:00
}
return nCredit ;
}
CAmount CWallet : : GetChange ( const CTransaction & tx ) const
{
CAmount nChange = 0 ;
BOOST_FOREACH ( const CTxOut & txout , tx . vout )
{
nChange + = GetChange ( txout ) ;
if ( ! MoneyRange ( nChange ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : value out of range " ) ;
2015-02-04 23:19:29 +01:00
}
return nChange ;
}
2016-07-21 21:19:02 +02:00
CPubKey CWallet : : GenerateNewHDMasterKey ( )
{
CKey key ;
key . MakeNewKey ( true ) ;
int64_t nCreationTime = GetTime ( ) ;
CKeyMetadata metadata ( nCreationTime ) ;
// calculate the pubkey
CPubKey pubkey = key . GetPubKey ( ) ;
assert ( key . VerifyPubKey ( pubkey ) ) ;
// set the hd keypath to "m" -> Master, refers the masterkeyid to itself
metadata . hdKeypath = " m " ;
metadata . hdMasterKeyID = pubkey . GetID ( ) ;
{
LOCK ( cs_wallet ) ;
// mem store the metadata
mapKeyMetadata [ pubkey . GetID ( ) ] = metadata ;
// write the key&metadata to the database
if ( ! AddKeyPubKey ( key , pubkey ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : AddKeyPubKey failed " ) ;
2016-07-21 21:19:02 +02:00
}
return pubkey ;
}
bool CWallet : : SetHDMasterKey ( const CPubKey & pubkey )
2016-01-02 12:34:08 +01:00
{
LOCK ( cs_wallet ) ;
// store the keyid (hash160) together with
// the child index counter in the database
// as a hdchain object
CHDChain newHdChain ;
newHdChain . masterKeyID = pubkey . GetID ( ) ;
SetHDChain ( newHdChain , false ) ;
return true ;
}
bool CWallet : : SetHDChain ( const CHDChain & chain , bool memonly )
{
LOCK ( cs_wallet ) ;
if ( ! memonly & & ! CWalletDB ( strWalletFile ) . WriteHDChain ( chain ) )
2017-01-27 02:33:45 +01:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : writing chain failed " ) ;
2016-01-02 12:34:08 +01:00
hdChain = chain ;
return true ;
}
2017-03-09 03:32:02 +01:00
bool CWallet : : IsHDEnabled ( ) const
2016-08-17 14:09:47 +02:00
{
return ! hdChain . masterKeyID . IsNull ( ) ;
}
2013-04-13 07:13:08 +02:00
int64_t CWalletTx : : GetTxTime ( ) const
2011-06-26 19:23:24 +02:00
{
2013-04-13 07:13:08 +02:00
int64_t n = nTimeSmart ;
2012-05-28 20:45:12 +02:00
return n ? n : nTimeReceived ;
2011-06-26 19:23:24 +02:00
}
int CWalletTx : : GetRequestCount ( ) const
{
// Returns -1 if it wasn't being tracked
int nRequests = - 1 ;
{
2012-04-06 18:39:12 +02:00
LOCK ( pwallet - > cs_wallet ) ;
2011-06-26 19:23:24 +02:00
if ( IsCoinBase ( ) )
{
// Generated block
2016-01-07 22:31:27 +01:00
if ( ! hashUnset ( ) )
2011-06-26 19:23:24 +02:00
{
2017-01-27 02:33:45 +01:00
std : : map < uint256 , int > : : const_iterator mi = pwallet - > mapRequestCount . find ( hashBlock ) ;
2011-06-26 19:23:24 +02:00
if ( mi ! = pwallet - > mapRequestCount . end ( ) )
nRequests = ( * mi ) . second ;
}
}
else
{
// Did anyone request this transaction?
2017-01-27 02:33:45 +01:00
std : : map < uint256 , int > : : const_iterator mi = pwallet - > mapRequestCount . find ( GetHash ( ) ) ;
2011-06-26 19:23:24 +02:00
if ( mi ! = pwallet - > mapRequestCount . end ( ) )
{
nRequests = ( * mi ) . second ;
// How about the block it's in?
2016-01-07 22:31:27 +01:00
if ( nRequests = = 0 & & ! hashUnset ( ) )
2011-06-26 19:23:24 +02:00
{
2017-01-27 02:33:45 +01:00
std : : map < uint256 , int > : : const_iterator _mi = pwallet - > mapRequestCount . find ( hashBlock ) ;
2016-09-02 18:19:01 +02:00
if ( _mi ! = pwallet - > mapRequestCount . end ( ) )
nRequests = ( * _mi ) . second ;
2011-06-26 19:23:24 +02:00
else
nRequests = 1 ; // If it's in someone else's block it must have got out
}
}
}
}
return nRequests ;
}
2017-01-27 02:33:45 +01:00
void CWalletTx : : GetAmounts ( std : : list < COutputEntry > & listReceived ,
std : : list < COutputEntry > & listSent , CAmount & nFee , std : : string & strSentAccount , const isminefilter & filter ) const
2011-06-26 19:23:24 +02:00
{
2012-06-02 04:33:28 +02:00
nFee = 0 ;
2011-06-26 19:23:24 +02:00
listReceived . clear ( ) ;
listSent . clear ( ) ;
strSentAccount = strFromAccount ;
// Compute fee:
2014-04-23 00:46:19 +02:00
CAmount nDebit = GetDebit ( filter ) ;
2011-06-26 19:23:24 +02:00
if ( nDebit > 0 ) // debit>0 means we signed/sent this transaction
{
2016-11-12 01:54:51 +01:00
CAmount nValueOut = tx - > GetValueOut ( ) ;
2011-06-26 19:23:24 +02:00
nFee = nDebit - nValueOut ;
}
2011-10-03 19:05:43 +02:00
// Sent/received.
2016-11-12 01:54:51 +01:00
for ( unsigned int i = 0 ; i < tx - > vout . size ( ) ; + + i )
2011-06-26 19:23:24 +02:00
{
2016-11-12 01:54:51 +01:00
const CTxOut & txout = tx - > vout [ i ] ;
2014-04-29 19:39:01 +02:00
isminetype fIsMine = pwallet - > IsMine ( txout ) ;
2012-09-22 05:20:14 +02:00
// Only need to handle txouts if AT LEAST one of these is true:
// 1) they debit from us (sent)
// 2) the output is to us (received)
if ( nDebit > 0 )
{
// Don't report 'change' txouts
if ( pwallet - > IsChange ( txout ) )
continue ;
}
2014-04-29 19:39:01 +02:00
else if ( ! ( fIsMine & filter ) )
2012-09-22 05:20:14 +02:00
continue ;
// In either case, we need to get the destination address
2012-05-14 23:44:52 +02:00
CTxDestination address ;
2015-12-12 03:07:11 +01:00
2015-12-12 19:45:53 +01:00
if ( ! ExtractDestination ( txout . scriptPubKey , address ) & & ! txout . scriptPubKey . IsUnspendable ( ) )
2011-06-26 19:23:24 +02:00
{
2013-09-18 12:38:08 +02:00
LogPrintf ( " CWalletTx::GetAmounts: Unknown transaction type found, txid %s \n " ,
2014-01-16 16:15:27 +01:00
this - > GetHash ( ) . ToString ( ) ) ;
2012-09-22 05:20:14 +02:00
address = CNoDestination ( ) ;
2011-06-26 19:23:24 +02:00
}
2014-07-18 13:24:38 +02:00
COutputEntry output = { address , txout . nValue , ( int ) i } ;
2014-05-30 00:54:00 +02:00
2012-09-22 05:20:14 +02:00
// If we are debited by the transaction, add the output as a "sent" entry
2011-06-26 19:23:24 +02:00
if ( nDebit > 0 )
2014-05-30 00:54:00 +02:00
listSent . push_back ( output ) ;
2011-06-26 19:23:24 +02:00
2012-09-22 05:20:14 +02:00
// If we are receiving the output, add it as a "received" entry
2014-07-12 17:15:17 +02:00
if ( fIsMine & filter )
2014-05-30 00:54:00 +02:00
listReceived . push_back ( output ) ;
2011-06-26 19:23:24 +02:00
}
}
2017-01-27 02:33:45 +01:00
void CWalletTx : : GetAccountAmounts ( const std : : string & strAccount , CAmount & nReceived ,
2014-04-23 00:46:19 +02:00
CAmount & nSent , CAmount & nFee , const isminefilter & filter ) const
2011-06-26 19:23:24 +02:00
{
2012-06-02 04:33:28 +02:00
nReceived = nSent = nFee = 0 ;
2011-06-26 19:23:24 +02:00
2014-04-23 00:46:19 +02:00
CAmount allFee ;
2017-01-27 02:33:45 +01:00
std : : string strSentAccount ;
std : : list < COutputEntry > listReceived ;
std : : list < COutputEntry > listSent ;
2014-04-08 15:23:50 +02:00
GetAmounts ( listReceived , listSent , allFee , strSentAccount , filter ) ;
2011-06-26 19:23:24 +02:00
if ( strAccount = = strSentAccount )
{
2014-05-30 00:54:00 +02:00
BOOST_FOREACH ( const COutputEntry & s , listSent )
nSent + = s . amount ;
2011-06-26 19:23:24 +02:00
nFee = allFee ;
}
{
2012-04-06 18:39:12 +02:00
LOCK ( pwallet - > cs_wallet ) ;
2014-05-30 00:54:00 +02:00
BOOST_FOREACH ( const COutputEntry & r , listReceived )
2011-06-26 19:23:24 +02:00
{
2014-05-30 00:54:00 +02:00
if ( pwallet - > mapAddressBook . count ( r . destination ) )
2011-06-26 19:23:24 +02:00
{
2017-01-27 02:33:45 +01:00
std : : map < CTxDestination , CAddressBookData > : : const_iterator mi = pwallet - > mapAddressBook . find ( r . destination ) ;
2013-07-15 07:20:50 +02:00
if ( mi ! = pwallet - > mapAddressBook . end ( ) & & ( * mi ) . second . name = = strAccount )
2014-05-30 00:54:00 +02:00
nReceived + = r . amount ;
2011-06-26 19:23:24 +02:00
}
else if ( strAccount . empty ( ) )
{
2014-05-30 00:54:00 +02:00
nReceived + = r . amount ;
2011-06-26 19:23:24 +02:00
}
}
}
}
2014-10-26 08:03:12 +01:00
/**
* Scan the block chain ( starting in pindexStart ) for transactions
* from or to us . If fUpdate is true , found transactions that already
* exist in the wallet will be updated .
2017-02-16 16:49:03 +01:00
*
* Returns pointer to the first block in the last contiguous range that was
* successfully scanned .
*
2014-10-26 08:03:12 +01:00
*/
2017-02-16 16:49:03 +01:00
CBlockIndex * CWallet : : ScanForWalletTransactions ( CBlockIndex * pindexStart , bool fUpdate )
2011-06-26 19:23:24 +02:00
{
2017-02-16 16:49:03 +01:00
CBlockIndex * ret = nullptr ;
2014-02-18 01:35:37 +01:00
int64_t nNow = GetTime ( ) ;
2015-04-23 00:19:11 +02:00
const CChainParams & chainParams = Params ( ) ;
2011-06-26 19:23:24 +02:00
CBlockIndex * pindex = pindexStart ;
{
2014-04-15 17:38:25 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2014-03-19 00:26:14 +01:00
// no need to read and scan block, if block was created before
// our wallet birthday (as adjusted for block time variability)
2017-03-02 18:20:34 +01:00
while ( pindex & & nTimeFirstKey & & ( pindex - > GetBlockTime ( ) < ( nTimeFirstKey - TIMESTAMP_WINDOW ) ) )
2014-03-19 00:26:14 +01:00
pindex = chainActive . Next ( pindex ) ;
ShowProgress ( _ ( " Rescanning... " ) , 0 ) ; // show rescan progress in GUI as dialog or on splashscreen, if -rescan on startup
2017-01-04 22:09:20 +01:00
double dProgressStart = GuessVerificationProgress ( chainParams . TxData ( ) , pindex ) ;
double dProgressTip = GuessVerificationProgress ( chainParams . TxData ( ) , chainActive . Tip ( ) ) ;
2011-06-26 19:23:24 +02:00
while ( pindex )
{
2014-03-19 00:26:14 +01:00
if ( pindex - > nHeight % 100 = = 0 & & dProgressTip - dProgressStart > 0.0 )
2017-01-04 22:09:20 +01:00
ShowProgress ( _ ( " Rescanning... " ) , std : : max ( 1 , std : : min ( 99 , ( int ) ( ( GuessVerificationProgress ( chainParams . TxData ( ) , pindex ) - dProgressStart ) / ( dProgressTip - dProgressStart ) * 100 ) ) ) ) ;
2013-06-10 15:38:13 +02:00
2011-06-26 19:23:24 +02:00
CBlock block ;
2017-02-16 16:49:03 +01:00
if ( ReadBlockFromDisk ( block , pindex , Params ( ) . GetConsensus ( ) ) ) {
for ( size_t posInBlock = 0 ; posInBlock < block . vtx . size ( ) ; + + posInBlock ) {
AddToWalletIfInvolvingMe ( * block . vtx [ posInBlock ] , pindex , posInBlock , fUpdate ) ;
}
if ( ! ret ) {
ret = pindex ;
}
} else {
ret = nullptr ;
2011-06-26 19:23:24 +02:00
}
2013-10-10 23:07:44 +02:00
pindex = chainActive . Next ( pindex ) ;
2014-02-18 01:35:37 +01:00
if ( GetTime ( ) > = nNow + 60 ) {
nNow = GetTime ( ) ;
2017-01-04 16:31:56 +01:00
LogPrintf ( " Still rescanning. At block %d. Progress=%f \n " , pindex - > nHeight , GuessVerificationProgress ( chainParams . TxData ( ) , pindex ) ) ;
2014-02-18 01:35:37 +01:00
}
2011-06-26 19:23:24 +02:00
}
2014-03-19 00:26:14 +01:00
ShowProgress ( _ ( " Rescanning... " ) , 100 ) ; // hide progress dialog in GUI
2011-06-26 19:23:24 +02:00
}
return ret ;
}
void CWallet : : ReacceptWalletTransactions ( )
{
2015-04-28 16:48:28 +02:00
// If transactions aren't being broadcasted, don't let them into local mempool either
2015-03-27 10:34:48 +01:00
if ( ! fBroadcastTransactions )
return ;
2014-04-15 17:38:25 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2014-12-19 06:59:16 +01:00
std : : map < int64_t , CWalletTx * > mapSorted ;
// Sort pending wallet transactions based on their initial wallet insertion order
2014-02-15 22:38:28 +01:00
BOOST_FOREACH ( PAIRTYPE ( const uint256 , CWalletTx ) & item , mapWallet )
2011-06-26 19:23:24 +02:00
{
2014-02-15 22:38:28 +01:00
const uint256 & wtxid = item . first ;
CWalletTx & wtx = item . second ;
assert ( wtx . GetHash ( ) = = wtxid ) ;
2011-06-26 19:23:24 +02:00
2014-02-15 22:38:28 +01:00
int nDepth = wtx . GetDepthInMainChain ( ) ;
2016-01-07 22:31:27 +01:00
if ( ! wtx . IsCoinBase ( ) & & ( nDepth = = 0 & & ! wtx . isAbandoned ( ) ) ) {
2014-12-19 06:59:16 +01:00
mapSorted . insert ( std : : make_pair ( wtx . nOrderPos , & wtx ) ) ;
2011-06-26 19:23:24 +02:00
}
}
2014-12-19 06:59:16 +01:00
// Try to add wallet transactions to memory pool
BOOST_FOREACH ( PAIRTYPE ( const int64_t , CWalletTx * ) & item , mapSorted )
{
CWalletTx & wtx = * ( item . second ) ;
LOCK ( mempool . cs ) ;
2016-10-25 20:27:04 +02:00
CValidationState state ;
wtx . AcceptToMemoryPool ( maxTxFee , state ) ;
2014-12-19 06:59:16 +01:00
}
2011-06-26 19:23:24 +02:00
}
2016-05-25 02:56:17 +02:00
bool CWalletTx : : RelayWalletTransaction ( CConnman * connman )
2011-06-26 19:23:24 +02:00
{
2015-03-27 10:34:48 +01:00
assert ( pwallet - > GetBroadcastTransactions ( ) ) ;
2016-12-06 07:39:14 +01:00
if ( ! IsCoinBase ( ) & & ! isAbandoned ( ) & & GetDepthInMainChain ( ) = = 0 )
2011-06-26 19:23:24 +02:00
{
2016-12-06 07:39:14 +01:00
CValidationState state ;
/* GetDepthInMainChain already catches known conflicts. */
if ( InMempool ( ) | | AcceptToMemoryPool ( maxTxFee , state ) ) {
2014-06-09 10:02:00 +02:00
LogPrintf ( " Relaying wtx %s \n " , GetHash ( ) . ToString ( ) ) ;
2016-04-17 01:13:12 +02:00
if ( connman ) {
CInv inv ( MSG_TX , GetHash ( ) ) ;
connman - > ForEachNode ( [ & inv ] ( CNode * pnode )
{
pnode - > PushInventory ( inv ) ;
} ) ;
return true ;
}
2011-06-26 19:23:24 +02:00
}
}
2015-03-23 18:47:18 +01:00
return false ;
2011-06-26 19:23:24 +02:00
}
2017-01-27 02:33:45 +01:00
std : : set < uint256 > CWalletTx : : GetConflicts ( ) const
2014-02-14 02:12:51 +01:00
{
2017-01-27 02:33:45 +01:00
std : : set < uint256 > result ;
2014-02-14 02:12:51 +01:00
if ( pwallet ! = NULL )
{
uint256 myHash = GetHash ( ) ;
2014-07-17 14:09:46 +02:00
result = pwallet - > GetConflicts ( myHash ) ;
2014-02-14 02:12:51 +01:00
result . erase ( myHash ) ;
}
return result ;
}
2014-12-19 02:00:01 +01:00
CAmount CWalletTx : : GetDebit ( const isminefilter & filter ) const
{
2016-11-12 01:54:51 +01:00
if ( tx - > vin . empty ( ) )
2014-12-19 02:00:01 +01:00
return 0 ;
CAmount debit = 0 ;
if ( filter & ISMINE_SPENDABLE )
{
if ( fDebitCached )
debit + = nDebitCached ;
else
{
nDebitCached = pwallet - > GetDebit ( * this , ISMINE_SPENDABLE ) ;
fDebitCached = true ;
debit + = nDebitCached ;
}
}
if ( filter & ISMINE_WATCH_ONLY )
{
if ( fWatchDebitCached )
debit + = nWatchDebitCached ;
else
{
nWatchDebitCached = pwallet - > GetDebit ( * this , ISMINE_WATCH_ONLY ) ;
fWatchDebitCached = true ;
debit + = nWatchDebitCached ;
}
}
return debit ;
}
CAmount CWalletTx : : GetCredit ( const isminefilter & filter ) const
{
// Must wait until coinbase is safely deep enough in the chain before valuing it
if ( IsCoinBase ( ) & & GetBlocksToMaturity ( ) > 0 )
return 0 ;
2016-11-15 15:19:23 +01:00
CAmount credit = 0 ;
2014-12-19 02:00:01 +01:00
if ( filter & ISMINE_SPENDABLE )
{
// GetBalance can assume transactions in mapWallet won't change
if ( fCreditCached )
credit + = nCreditCached ;
else
{
nCreditCached = pwallet - > GetCredit ( * this , ISMINE_SPENDABLE ) ;
fCreditCached = true ;
credit + = nCreditCached ;
}
}
if ( filter & ISMINE_WATCH_ONLY )
{
if ( fWatchCreditCached )
credit + = nWatchCreditCached ;
else
{
nWatchCreditCached = pwallet - > GetCredit ( * this , ISMINE_WATCH_ONLY ) ;
fWatchCreditCached = true ;
credit + = nWatchCreditCached ;
}
}
return credit ;
}
CAmount CWalletTx : : GetImmatureCredit ( bool fUseCache ) const
{
if ( IsCoinBase ( ) & & GetBlocksToMaturity ( ) > 0 & & IsInMainChain ( ) )
{
if ( fUseCache & & fImmatureCreditCached )
return nImmatureCreditCached ;
nImmatureCreditCached = pwallet - > GetCredit ( * this , ISMINE_SPENDABLE ) ;
fImmatureCreditCached = true ;
return nImmatureCreditCached ;
}
return 0 ;
}
CAmount CWalletTx : : GetAvailableCredit ( bool fUseCache ) const
{
if ( pwallet = = 0 )
return 0 ;
// Must wait until coinbase is safely deep enough in the chain before valuing it
if ( IsCoinBase ( ) & & GetBlocksToMaturity ( ) > 0 )
return 0 ;
if ( fUseCache & & fAvailableCreditCached )
return nAvailableCreditCached ;
CAmount nCredit = 0 ;
uint256 hashTx = GetHash ( ) ;
2016-11-12 01:54:51 +01:00
for ( unsigned int i = 0 ; i < tx - > vout . size ( ) ; i + + )
2014-12-19 02:00:01 +01:00
{
if ( ! pwallet - > IsSpent ( hashTx , i ) )
{
2016-11-12 01:54:51 +01:00
const CTxOut & txout = tx - > vout [ i ] ;
2014-12-19 02:00:01 +01:00
nCredit + = pwallet - > GetCredit ( txout , ISMINE_SPENDABLE ) ;
if ( ! MoneyRange ( nCredit ) )
throw std : : runtime_error ( " CWalletTx::GetAvailableCredit() : value out of range " ) ;
}
}
nAvailableCreditCached = nCredit ;
fAvailableCreditCached = true ;
return nCredit ;
}
CAmount CWalletTx : : GetImmatureWatchOnlyCredit ( const bool & fUseCache ) const
{
if ( IsCoinBase ( ) & & GetBlocksToMaturity ( ) > 0 & & IsInMainChain ( ) )
{
if ( fUseCache & & fImmatureWatchCreditCached )
return nImmatureWatchCreditCached ;
nImmatureWatchCreditCached = pwallet - > GetCredit ( * this , ISMINE_WATCH_ONLY ) ;
fImmatureWatchCreditCached = true ;
return nImmatureWatchCreditCached ;
}
return 0 ;
}
CAmount CWalletTx : : GetAvailableWatchOnlyCredit ( const bool & fUseCache ) const
{
if ( pwallet = = 0 )
return 0 ;
// Must wait until coinbase is safely deep enough in the chain before valuing it
if ( IsCoinBase ( ) & & GetBlocksToMaturity ( ) > 0 )
return 0 ;
if ( fUseCache & & fAvailableWatchCreditCached )
return nAvailableWatchCreditCached ;
CAmount nCredit = 0 ;
2016-11-12 01:54:51 +01:00
for ( unsigned int i = 0 ; i < tx - > vout . size ( ) ; i + + )
2014-12-19 02:00:01 +01:00
{
if ( ! pwallet - > IsSpent ( GetHash ( ) , i ) )
{
2016-11-12 01:54:51 +01:00
const CTxOut & txout = tx - > vout [ i ] ;
2014-12-19 02:00:01 +01:00
nCredit + = pwallet - > GetCredit ( txout , ISMINE_WATCH_ONLY ) ;
if ( ! MoneyRange ( nCredit ) )
throw std : : runtime_error ( " CWalletTx::GetAvailableCredit() : value out of range " ) ;
}
}
nAvailableWatchCreditCached = nCredit ;
fAvailableWatchCreditCached = true ;
return nCredit ;
}
CAmount CWalletTx : : GetChange ( ) const
{
if ( fChangeCached )
return nChangeCached ;
nChangeCached = pwallet - > GetChange ( * this ) ;
fChangeCached = true ;
return nChangeCached ;
}
2015-11-30 16:15:15 +01:00
bool CWalletTx : : InMempool ( ) const
{
LOCK ( mempool . cs ) ;
if ( mempool . exists ( GetHash ( ) ) ) {
return true ;
}
return false ;
}
2014-12-19 02:00:01 +01:00
bool CWalletTx : : IsTrusted ( ) const
{
// Quick answer in most cases
2015-05-25 06:48:33 +02:00
if ( ! CheckFinalTx ( * this ) )
2014-12-19 02:00:01 +01:00
return false ;
int nDepth = GetDepthInMainChain ( ) ;
if ( nDepth > = 1 )
return true ;
if ( nDepth < 0 )
return false ;
if ( ! bSpendZeroConfChange | | ! IsFromMe ( ISMINE_ALL ) ) // using wtx's cached debit
return false ;
2015-11-26 18:42:07 +01:00
// Don't trust unconfirmed transactions from us unless they are in the mempool.
2015-11-30 16:15:15 +01:00
if ( ! InMempool ( ) )
return false ;
2015-11-26 18:42:07 +01:00
2014-12-19 02:00:01 +01:00
// Trusted if all inputs are from us and are in the mempool:
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , tx - > vin )
2014-12-19 02:00:01 +01:00
{
// Transactions not sent by us: not trusted
const CWalletTx * parent = pwallet - > GetWalletTx ( txin . prevout . hash ) ;
if ( parent = = NULL )
return false ;
2016-11-12 01:54:51 +01:00
const CTxOut & parentOut = parent - > tx - > vout [ txin . prevout . n ] ;
2014-12-19 02:00:01 +01:00
if ( pwallet - > IsMine ( parentOut ) ! = ISMINE_SPENDABLE )
return false ;
}
return true ;
}
2016-11-12 01:54:51 +01:00
bool CWalletTx : : IsEquivalentTo ( const CWalletTx & _tx ) const
2015-07-02 20:57:39 +02:00
{
2016-11-12 01:54:51 +01:00
CMutableTransaction tx1 = * this - > tx ;
CMutableTransaction tx2 = * _tx . tx ;
2015-07-02 20:57:39 +02:00
for ( unsigned int i = 0 ; i < tx1 . vin . size ( ) ; i + + ) tx1 . vin [ i ] . scriptSig = CScript ( ) ;
for ( unsigned int i = 0 ; i < tx2 . vin . size ( ) ; i + + ) tx2 . vin [ i ] . scriptSig = CScript ( ) ;
return CTransaction ( tx1 ) = = CTransaction ( tx2 ) ;
}
2016-05-25 02:56:17 +02:00
std : : vector < uint256 > CWallet : : ResendWalletTransactionsBefore ( int64_t nTime , CConnman * connman )
2015-03-23 18:47:18 +01:00
{
std : : vector < uint256 > result ;
LOCK ( cs_wallet ) ;
// Sort them in chronological order
2017-01-27 02:33:45 +01:00
std : : multimap < unsigned int , CWalletTx * > mapSorted ;
2015-03-23 18:47:18 +01:00
BOOST_FOREACH ( PAIRTYPE ( const uint256 , CWalletTx ) & item , mapWallet )
{
CWalletTx & wtx = item . second ;
// Don't rebroadcast if newer than nTime:
if ( wtx . nTimeReceived > nTime )
continue ;
2017-01-27 02:33:45 +01:00
mapSorted . insert ( std : : make_pair ( wtx . nTimeReceived , & wtx ) ) ;
2015-03-23 18:47:18 +01:00
}
BOOST_FOREACH ( PAIRTYPE ( const unsigned int , CWalletTx * ) & item , mapSorted )
{
CWalletTx & wtx = * item . second ;
2016-05-25 02:56:17 +02:00
if ( wtx . RelayWalletTransaction ( connman ) )
2015-03-23 18:47:18 +01:00
result . push_back ( wtx . GetHash ( ) ) ;
}
return result ;
}
2016-05-25 02:56:17 +02:00
void CWallet : : ResendWalletTransactions ( int64_t nBestBlockTime , CConnman * connman )
2011-06-26 19:23:24 +02:00
{
// Do this infrequently and randomly to avoid giving away
// that these are our transactions.
2015-03-27 10:34:48 +01:00
if ( GetTime ( ) < nNextResend | | ! fBroadcastTransactions )
2011-06-26 19:23:24 +02:00
return ;
2013-04-19 23:28:25 +02:00
bool fFirst = ( nNextResend = = 0 ) ;
nNextResend = GetTime ( ) + GetRand ( 30 * 60 ) ;
2011-06-26 19:23:24 +02:00
if ( fFirst )
return ;
// Only do it if there's been a new block since last time
2015-03-23 18:47:18 +01:00
if ( nBestBlockTime < nLastResend )
2011-06-26 19:23:24 +02:00
return ;
2013-04-19 23:28:25 +02:00
nLastResend = GetTime ( ) ;
2011-06-26 19:23:24 +02:00
2015-03-23 18:47:18 +01:00
// Rebroadcast unconfirmed txes older than 5 minutes before the last
// block was found:
2016-05-25 02:56:17 +02:00
std : : vector < uint256 > relayed = ResendWalletTransactionsBefore ( nBestBlockTime - 5 * 60 , connman ) ;
2015-03-23 18:47:18 +01:00
if ( ! relayed . empty ( ) )
LogPrintf ( " %s: rebroadcast %u unconfirmed transactions \n " , __func__ , relayed . size ( ) ) ;
2011-06-26 19:23:24 +02:00
}
2014-10-26 08:03:12 +01:00
/** @} */ // end of mapWallet
2011-06-26 19:23:24 +02:00
2014-10-26 08:03:12 +01:00
/** @defgroup Actions
*
* @ {
*/
2011-06-26 19:23:24 +02:00
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetBalance ( ) const
2011-06-26 19:23:24 +02:00
{
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2011-06-26 19:23:24 +02:00
{
2014-04-15 17:38:25 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2011-06-26 19:23:24 +02:00
{
const CWalletTx * pcoin = & ( * it ) . second ;
2014-02-13 01:23:06 +01:00
if ( pcoin - > IsTrusted ( ) )
2012-02-14 12:08:00 +01:00
nTotal + = pcoin - > GetAvailableCredit ( ) ;
2011-06-26 19:23:24 +02:00
}
}
return nTotal ;
}
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetUnconfirmedBalance ( ) const
2011-07-11 20:42:10 +02:00
{
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2011-07-11 20:42:10 +02:00
{
2014-04-15 17:38:25 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2011-07-11 20:42:10 +02:00
{
const CWalletTx * pcoin = & ( * it ) . second ;
2016-03-17 17:48:05 +01:00
if ( ! pcoin - > IsTrusted ( ) & & pcoin - > GetDepthInMainChain ( ) = = 0 & & pcoin - > InMempool ( ) )
2012-02-14 12:08:00 +01:00
nTotal + = pcoin - > GetAvailableCredit ( ) ;
}
}
return nTotal ;
}
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetImmatureBalance ( ) const
2012-02-14 12:08:00 +01:00
{
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2012-02-14 12:08:00 +01:00
{
2014-04-15 17:38:25 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2012-02-14 12:08:00 +01:00
{
2012-06-18 08:32:33 +02:00
const CWalletTx * pcoin = & ( * it ) . second ;
nTotal + = pcoin - > GetImmatureCredit ( ) ;
2011-07-11 20:42:10 +02:00
}
}
return nTotal ;
}
2011-06-26 19:23:24 +02:00
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetWatchOnlyBalance ( ) const
2014-03-29 05:15:28 +01:00
{
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2014-03-29 05:15:28 +01:00
{
2014-07-13 09:33:45 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2014-03-29 05:15:28 +01:00
{
const CWalletTx * pcoin = & ( * it ) . second ;
if ( pcoin - > IsTrusted ( ) )
nTotal + = pcoin - > GetAvailableWatchOnlyCredit ( ) ;
}
}
2014-09-28 16:11:17 +02:00
2014-03-29 05:15:28 +01:00
return nTotal ;
}
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetUnconfirmedWatchOnlyBalance ( ) const
2014-03-29 05:15:28 +01:00
{
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2014-03-29 05:15:28 +01:00
{
2014-07-13 09:33:45 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2014-03-29 05:15:28 +01:00
{
const CWalletTx * pcoin = & ( * it ) . second ;
2016-03-17 17:48:05 +01:00
if ( ! pcoin - > IsTrusted ( ) & & pcoin - > GetDepthInMainChain ( ) = = 0 & & pcoin - > InMempool ( ) )
2014-03-29 05:15:28 +01:00
nTotal + = pcoin - > GetAvailableWatchOnlyCredit ( ) ;
}
}
return nTotal ;
}
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetImmatureWatchOnlyBalance ( ) const
2014-03-29 05:15:28 +01:00
{
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2014-03-29 05:15:28 +01:00
{
2014-07-13 09:33:45 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2014-03-29 05:15:28 +01:00
{
const CWalletTx * pcoin = & ( * it ) . second ;
nTotal + = pcoin - > GetImmatureWatchOnlyCredit ( ) ;
}
}
return nTotal ;
}
2017-02-23 17:20:16 +01:00
void CWallet : : AvailableCoins ( std : : vector < COutput > & vCoins , bool fOnlySafe , const CCoinControl * coinControl , bool fIncludeZeroValue ) const
2012-02-27 13:19:32 +01:00
{
vCoins . clear ( ) ;
{
2014-06-20 14:32:57 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2012-02-27 13:19:32 +01:00
{
2014-02-15 22:38:28 +01:00
const uint256 & wtxid = it - > first ;
2012-02-27 13:19:32 +01:00
const CWalletTx * pcoin = & ( * it ) . second ;
2015-05-25 06:48:33 +02:00
if ( ! CheckFinalTx ( * pcoin ) )
2012-05-31 22:01:16 +02:00
continue ;
2012-02-27 13:19:32 +01:00
if ( pcoin - > IsCoinBase ( ) & & pcoin - > GetBlocksToMaturity ( ) > 0 )
continue ;
2014-02-12 19:43:07 +01:00
int nDepth = pcoin - > GetDepthInMainChain ( ) ;
if ( nDepth < 0 )
continue ;
2016-03-17 17:48:05 +01:00
// We should not consider coins which aren't at least in our mempool
// It's possible for these to be conflicted via ancestors which we may never be able to detect
if ( nDepth = = 0 & & ! pcoin - > InMempool ( ) )
continue ;
2017-02-23 17:20:16 +01:00
bool safeTx = pcoin - > IsTrusted ( ) ;
2016-12-09 19:45:27 +01:00
// We should not consider coins from transactions that are replacing
// other transactions.
//
// Example: There is a transaction A which is replaced by bumpfee
// transaction B. In this case, we want to prevent creation of
// a transaction B' which spends an output of B.
//
// Reason: If transaction A were initially confirmed, transactions B
// and B' would no longer be valid, so the user would have to create
// a new transaction C to replace B'. However, in the case of a
// one-block reorg, transactions B' and C might BOTH be accepted,
// when the user only wanted one of them. Specifically, there could
// be a 1-block reorg away from the chain where transactions A and C
// were accepted to another chain where B, B', and C were all
// accepted.
2017-02-23 17:20:16 +01:00
if ( nDepth = = 0 & & pcoin - > mapValue . count ( " replaces_txid " ) ) {
safeTx = false ;
2016-12-09 19:45:27 +01:00
}
// Similarly, we should not consider coins from transactions that
// have been replaced. In the example above, we would want to prevent
// creation of a transaction A' spending an output of A, because if
// transaction B were initially confirmed, conflicting with A and
// A', we wouldn't want to the user to create a transaction D
// intending to replace A', but potentially resulting in a scenario
// where A, A', and D could all be accepted (instead of just B and
// D, or just A and A' like the user would want).
2017-02-23 17:20:16 +01:00
if ( nDepth = = 0 & & pcoin - > mapValue . count ( " replaced_by_txid " ) ) {
safeTx = false ;
}
if ( fOnlySafe & & ! safeTx ) {
2016-12-09 19:45:27 +01:00
continue ;
}
2016-11-12 01:54:51 +01:00
for ( unsigned int i = 0 ; i < pcoin - > tx - > vout . size ( ) ; i + + ) {
isminetype mine = IsMine ( pcoin - > tx - > vout [ i ] ) ;
2014-07-01 11:00:22 +02:00
if ( ! ( IsSpent ( wtxid , i ) ) & & mine ! = ISMINE_NO & &
2016-11-12 01:54:51 +01:00
! IsLockedCoin ( ( * it ) . first , i ) & & ( pcoin - > tx - > vout [ i ] . nValue > 0 | | fIncludeZeroValue ) & &
2016-02-11 02:07:22 +01:00
( ! coinControl | | ! coinControl - > HasSelected ( ) | | coinControl - > fAllowOtherInputs | | coinControl - > IsSelected ( COutPoint ( ( * it ) . first , i ) ) ) )
2015-04-24 06:42:49 +02:00
vCoins . push_back ( COutput ( pcoin , i , nDepth ,
( ( mine & ISMINE_SPENDABLE ) ! = ISMINE_NO ) | |
2016-03-14 19:22:11 +01:00
( coinControl & & coinControl - > fAllowWatchOnly & & ( mine & ISMINE_WATCH_SOLVABLE ) ! = ISMINE_NO ) ,
2017-02-23 17:20:16 +01:00
( mine & ( ISMINE_SPENDABLE | ISMINE_WATCH_SOLVABLE ) ) ! = ISMINE_NO , safeTx ) ) ;
2012-09-27 19:52:09 +02:00
}
2012-02-27 13:19:32 +01:00
}
}
}
2017-01-27 02:33:45 +01:00
static void ApproximateBestSubset ( std : : vector < std : : pair < CAmount , std : : pair < const CWalletTx * , unsigned int > > > vValue , const CAmount & nTotalLower , const CAmount & nTargetValue ,
std : : vector < char > & vfBest , CAmount & nBest , int iterations = 1000 )
2012-04-13 01:22:15 +02:00
{
2017-01-27 02:33:45 +01:00
std : : vector < char > vfIncluded ;
2012-04-13 01:22:15 +02:00
vfBest . assign ( vValue . size ( ) , true ) ;
nBest = nTotalLower ;
2016-10-13 16:19:20 +02:00
FastRandomContext insecure_rand ;
2013-02-16 00:27:57 +01:00
2012-04-13 01:22:15 +02:00
for ( int nRep = 0 ; nRep < iterations & & nBest ! = nTargetValue ; nRep + + )
{
vfIncluded . assign ( vValue . size ( ) , false ) ;
2014-04-23 00:46:19 +02:00
CAmount nTotal = 0 ;
2012-04-13 01:22:15 +02:00
bool fReachedTarget = false ;
for ( int nPass = 0 ; nPass < 2 & & ! fReachedTarget ; nPass + + )
{
2015-12-07 00:15:36 +01:00
for ( unsigned int i = 0 ; i < vValue . size ( ) ; i + + )
2012-04-13 01:22:15 +02:00
{
2013-02-16 00:27:57 +01:00
//The solver here uses a randomized algorithm,
//the randomness serves no real security purpose but is just
//needed to prevent degenerate behavior and it is important
2014-10-26 08:03:12 +01:00
//that the rng is fast. We do not use a constant random sequence,
2013-02-16 00:27:57 +01:00
//because there may be some privacy improvement by making
//the selection random.
2016-10-13 16:19:20 +02:00
if ( nPass = = 0 ? insecure_rand . rand32 ( ) & 1 : ! vfIncluded [ i ] )
2012-04-13 01:22:15 +02:00
{
nTotal + = vValue [ i ] . first ;
vfIncluded [ i ] = true ;
if ( nTotal > = nTargetValue )
{
fReachedTarget = true ;
if ( nTotal < nBest )
{
nBest = nTotal ;
vfBest = vfIncluded ;
}
2015-12-07 00:15:36 +01:00
nTotal - = vValue [ i ] . first ;
vfIncluded [ i ] = false ;
2012-04-13 01:22:15 +02:00
}
}
}
}
}
}
2017-01-27 02:33:45 +01:00
bool CWallet : : SelectCoinsMinConf ( const CAmount & nTargetValue , const int nConfMine , const int nConfTheirs , const uint64_t nMaxAncestors , std : : vector < COutput > vCoins ,
std : : set < std : : pair < const CWalletTx * , unsigned int > > & setCoinsRet , CAmount & nValueRet ) const
2011-06-26 19:23:24 +02:00
{
setCoinsRet . clear ( ) ;
nValueRet = 0 ;
// List of values less than target
2017-01-27 02:33:45 +01:00
std : : pair < CAmount , std : : pair < const CWalletTx * , unsigned int > > coinLowestLarger ;
2014-04-23 00:46:19 +02:00
coinLowestLarger . first = std : : numeric_limits < CAmount > : : max ( ) ;
2011-06-26 19:23:24 +02:00
coinLowestLarger . second . first = NULL ;
2017-01-27 02:33:45 +01:00
std : : vector < std : : pair < CAmount , std : : pair < const CWalletTx * , unsigned int > > > vValue ;
2014-04-23 00:46:19 +02:00
CAmount nTotalLower = 0 ;
2011-06-26 19:23:24 +02:00
2012-04-07 19:52:40 +02:00
random_shuffle ( vCoins . begin ( ) , vCoins . end ( ) , GetRandInt ) ;
2013-07-26 01:06:01 +02:00
BOOST_FOREACH ( const COutput & output , vCoins )
2011-06-26 19:23:24 +02:00
{
2013-07-26 01:06:01 +02:00
if ( ! output . fSpendable )
continue ;
2012-02-27 13:19:32 +01:00
const CWalletTx * pcoin = output . tx ;
2011-06-26 19:23:24 +02:00
2014-07-01 11:00:22 +02:00
if ( output . nDepth < ( pcoin - > IsFromMe ( ISMINE_ALL ) ? nConfMine : nConfTheirs ) )
2012-02-27 13:19:32 +01:00
continue ;
2011-06-26 19:23:24 +02:00
2016-12-02 21:29:20 +01:00
if ( ! mempool . TransactionWithinChainLimit ( pcoin - > GetHash ( ) , nMaxAncestors ) )
continue ;
2012-02-27 13:19:32 +01:00
int i = output . i ;
2016-11-12 01:54:51 +01:00
CAmount n = pcoin - > tx - > vout [ i ] . nValue ;
2011-06-26 19:23:24 +02:00
2017-01-27 02:33:45 +01:00
std : : pair < CAmount , std : : pair < const CWalletTx * , unsigned int > > coin = std : : make_pair ( n , std : : make_pair ( pcoin , i ) ) ;
2011-06-26 19:23:24 +02:00
2012-02-27 13:19:32 +01:00
if ( n = = nTargetValue )
{
setCoinsRet . insert ( coin . second ) ;
nValueRet + = coin . first ;
return true ;
}
2015-09-13 23:23:59 +02:00
else if ( n < nTargetValue + MIN_CHANGE )
2012-02-27 13:19:32 +01:00
{
vValue . push_back ( coin ) ;
nTotalLower + = n ;
}
else if ( n < coinLowestLarger . first )
{
coinLowestLarger = coin ;
2011-06-26 19:23:24 +02:00
}
}
2012-04-13 01:22:15 +02:00
if ( nTotalLower = = nTargetValue )
2011-06-26 19:23:24 +02:00
{
2012-04-15 22:52:09 +02:00
for ( unsigned int i = 0 ; i < vValue . size ( ) ; + + i )
2011-06-26 19:23:24 +02:00
{
setCoinsRet . insert ( vValue [ i ] . second ) ;
nValueRet + = vValue [ i ] . first ;
}
return true ;
}
2012-04-13 01:22:15 +02:00
if ( nTotalLower < nTargetValue )
2011-06-26 19:23:24 +02:00
{
if ( coinLowestLarger . second . first = = NULL )
return false ;
setCoinsRet . insert ( coinLowestLarger . second ) ;
nValueRet + = coinLowestLarger . first ;
return true ;
}
// Solve subset sum by stochastic approximation
2015-12-07 18:35:29 +01:00
std : : sort ( vValue . begin ( ) , vValue . end ( ) , CompareValueOnly ( ) ) ;
std : : reverse ( vValue . begin ( ) , vValue . end ( ) ) ;
2017-01-27 02:33:45 +01:00
std : : vector < char > vfBest ;
2014-04-23 00:46:19 +02:00
CAmount nBest ;
2011-06-26 19:23:24 +02:00
2015-09-13 23:23:59 +02:00
ApproximateBestSubset ( vValue , nTotalLower , nTargetValue , vfBest , nBest ) ;
if ( nBest ! = nTargetValue & & nTotalLower > = nTargetValue + MIN_CHANGE )
ApproximateBestSubset ( vValue , nTotalLower , nTargetValue + MIN_CHANGE , vfBest , nBest ) ;
2011-06-26 19:23:24 +02:00
2012-04-13 01:22:15 +02:00
// If we have a bigger coin and (either the stochastic approximation didn't find a good solution,
// or the next bigger coin is closer), return the bigger coin
if ( coinLowestLarger . second . first & &
2015-09-13 23:23:59 +02:00
( ( nBest ! = nTargetValue & & nBest < nTargetValue + MIN_CHANGE ) | | coinLowestLarger . first < = nBest ) )
2011-06-26 19:23:24 +02:00
{
setCoinsRet . insert ( coinLowestLarger . second ) ;
nValueRet + = coinLowestLarger . first ;
}
else {
2012-04-15 22:52:09 +02:00
for ( unsigned int i = 0 ; i < vValue . size ( ) ; i + + )
2011-06-26 19:23:24 +02:00
if ( vfBest [ i ] )
{
setCoinsRet . insert ( vValue [ i ] . second ) ;
nValueRet + = vValue [ i ] . first ;
}
2013-09-19 14:47:21 +02:00
LogPrint ( " selectcoins " , " SelectCoins() best subset: " ) ;
2012-04-15 22:52:09 +02:00
for ( unsigned int i = 0 ; i < vValue . size ( ) ; i + + )
2011-06-26 19:23:24 +02:00
if ( vfBest [ i ] )
2014-01-16 16:15:27 +01:00
LogPrint ( " selectcoins " , " %s " , FormatMoney ( vValue [ i ] . first ) ) ;
LogPrint ( " selectcoins " , " total %s \n " , FormatMoney ( nBest ) ) ;
2011-06-26 19:23:24 +02:00
}
return true ;
}
2017-01-27 02:33:45 +01:00
bool CWallet : : SelectCoins ( const std : : vector < COutput > & vAvailableCoins , const CAmount & nTargetValue , std : : set < std : : pair < const CWalletTx * , unsigned int > > & setCoinsRet , CAmount & nValueRet , const CCoinControl * coinControl ) const
2011-06-26 19:23:24 +02:00
{
2017-01-27 02:33:45 +01:00
std : : vector < COutput > vCoins ( vAvailableCoins ) ;
2013-08-12 17:03:03 +02:00
// coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
2015-04-25 03:29:00 +02:00
if ( coinControl & & coinControl - > HasSelected ( ) & & ! coinControl - > fAllowOtherInputs )
2013-08-12 17:03:03 +02:00
{
BOOST_FOREACH ( const COutput & out , vCoins )
{
2015-04-25 03:29:00 +02:00
if ( ! out . fSpendable )
continue ;
2016-11-12 01:54:51 +01:00
nValueRet + = out . tx - > tx - > vout [ out . i ] . nValue ;
2017-01-27 02:33:45 +01:00
setCoinsRet . insert ( std : : make_pair ( out . tx , out . i ) ) ;
2013-08-12 17:03:03 +02:00
}
return ( nValueRet > = nTargetValue ) ;
}
2012-02-27 13:19:32 +01:00
2015-04-25 03:29:00 +02:00
// calculate value from preset inputs and store them
2017-01-27 02:33:45 +01:00
std : : set < std : : pair < const CWalletTx * , uint32_t > > setPresetCoins ;
2015-04-25 03:29:00 +02:00
CAmount nValueFromPresetInputs = 0 ;
std : : vector < COutPoint > vPresetInputs ;
if ( coinControl )
coinControl - > ListSelected ( vPresetInputs ) ;
BOOST_FOREACH ( const COutPoint & outpoint , vPresetInputs )
{
2017-01-27 02:33:45 +01:00
std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . find ( outpoint . hash ) ;
2015-04-25 03:29:00 +02:00
if ( it ! = mapWallet . end ( ) )
{
const CWalletTx * pcoin = & it - > second ;
// Clearly invalid input, fail
2016-11-12 01:54:51 +01:00
if ( pcoin - > tx - > vout . size ( ) < = outpoint . n )
2015-04-25 03:29:00 +02:00
return false ;
2016-11-12 01:54:51 +01:00
nValueFromPresetInputs + = pcoin - > tx - > vout [ outpoint . n ] . nValue ;
2017-01-27 02:33:45 +01:00
setPresetCoins . insert ( std : : make_pair ( pcoin , outpoint . n ) ) ;
2015-04-25 03:29:00 +02:00
} else
return false ; // TODO: Allow non-wallet inputs
}
// remove preset inputs from vCoins
2017-01-27 02:33:45 +01:00
for ( std : : vector < COutput > : : iterator it = vCoins . begin ( ) ; it ! = vCoins . end ( ) & & coinControl & & coinControl - > HasSelected ( ) ; )
2015-04-25 03:29:00 +02:00
{
2017-01-27 02:33:45 +01:00
if ( setPresetCoins . count ( std : : make_pair ( it - > tx , it - > i ) ) )
2015-04-25 03:29:00 +02:00
it = vCoins . erase ( it ) ;
else
+ + it ;
}
2016-12-02 21:29:20 +01:00
size_t nMaxChainLength = std : : min ( GetArg ( " -limitancestorcount " , DEFAULT_ANCESTOR_LIMIT ) , GetArg ( " -limitdescendantcount " , DEFAULT_DESCENDANT_LIMIT ) ) ;
bool fRejectLongChains = GetBoolArg ( " -walletrejectlongchains " , DEFAULT_WALLET_REJECT_LONG_CHAINS ) ;
2015-04-25 03:29:00 +02:00
bool res = nTargetValue < = nValueFromPresetInputs | |
2016-12-02 21:29:20 +01:00
SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 1 , 6 , 0 , vCoins , setCoinsRet , nValueRet ) | |
SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 1 , 1 , 0 , vCoins , setCoinsRet , nValueRet ) | |
( bSpendZeroConfChange & & SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 0 , 1 , 2 , vCoins , setCoinsRet , nValueRet ) ) | |
( bSpendZeroConfChange & & SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 0 , 1 , std : : min ( ( size_t ) 4 , nMaxChainLength / 3 ) , vCoins , setCoinsRet , nValueRet ) ) | |
( bSpendZeroConfChange & & SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 0 , 1 , nMaxChainLength / 2 , vCoins , setCoinsRet , nValueRet ) ) | |
( bSpendZeroConfChange & & SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 0 , 1 , nMaxChainLength , vCoins , setCoinsRet , nValueRet ) ) | |
( bSpendZeroConfChange & & ! fRejectLongChains & & SelectCoinsMinConf ( nTargetValue - nValueFromPresetInputs , 0 , 1 , std : : numeric_limits < uint64_t > : : max ( ) , vCoins , setCoinsRet , nValueRet ) ) ;
2015-04-25 03:29:00 +02:00
// because SelectCoinsMinConf clears the setCoinsRet, we now add the possible inputs to the coinset
setCoinsRet . insert ( setPresetCoins . begin ( ) , setPresetCoins . end ( ) ) ;
// add preset inputs to the total value selected
nValueRet + = nValueFromPresetInputs ;
return res ;
2011-06-26 19:23:24 +02:00
}
2016-12-19 09:04:05 +01:00
bool CWallet : : FundTransaction ( CMutableTransaction & tx , CAmount & nFeeRet , bool overrideEstimatedFeeRate , const CFeeRate & specificFeeRate , int & nChangePosInOut , std : : string & strFailReason , bool includeWatching , bool lockUnspents , const std : : set < int > & setSubtractFeeFromOutputs , bool keepReserveKey , const CTxDestination & destChange )
2015-04-25 03:29:00 +02:00
{
2017-01-27 02:33:45 +01:00
std : : vector < CRecipient > vecSend ;
2015-04-25 03:29:00 +02:00
// Turn the txout set into a CRecipient vector
2016-12-13 22:36:23 +01:00
for ( size_t idx = 0 ; idx < tx . vout . size ( ) ; idx + + )
2015-04-25 03:29:00 +02:00
{
2016-12-13 22:36:23 +01:00
const CTxOut & txOut = tx . vout [ idx ] ;
CRecipient recipient = { txOut . scriptPubKey , txOut . nValue , setSubtractFeeFromOutputs . count ( idx ) = = 1 } ;
2015-04-25 03:29:00 +02:00
vecSend . push_back ( recipient ) ;
}
CCoinControl coinControl ;
2016-03-30 03:04:22 +02:00
coinControl . destChange = destChange ;
2015-04-25 03:29:00 +02:00
coinControl . fAllowOtherInputs = true ;
2015-04-24 06:42:49 +02:00
coinControl . fAllowWatchOnly = includeWatching ;
2016-05-06 11:01:50 +02:00
coinControl . fOverrideFeeRate = overrideEstimatedFeeRate ;
2016-04-28 22:04:07 +02:00
coinControl . nFeeRate = specificFeeRate ;
2015-04-25 03:29:00 +02:00
BOOST_FOREACH ( const CTxIn & txin , tx . vin )
coinControl . Select ( txin . prevout ) ;
CReserveKey reservekey ( this ) ;
CWalletTx wtx ;
2016-03-30 03:04:22 +02:00
if ( ! CreateTransaction ( vecSend , wtx , reservekey , nFeeRet , nChangePosInOut , strFailReason , & coinControl , false ) )
2015-04-25 03:29:00 +02:00
return false ;
2016-03-30 03:04:22 +02:00
if ( nChangePosInOut ! = - 1 )
2016-11-12 01:54:51 +01:00
tx . vout . insert ( tx . vout . begin ( ) + nChangePosInOut , wtx . tx - > vout [ nChangePosInOut ] ) ;
2015-04-25 03:29:00 +02:00
2016-12-13 22:36:23 +01:00
// Copy output sizes from new transaction; they may have had the fee subtracted from them
for ( unsigned int idx = 0 ; idx < tx . vout . size ( ) ; idx + + )
tx . vout [ idx ] . nValue = wtx . tx - > vout [ idx ] . nValue ;
2015-04-25 03:29:00 +02:00
// Add new txins (keeping original txin scriptSig/order)
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , wtx . tx - > vin )
2015-04-25 03:29:00 +02:00
{
2016-02-11 02:07:22 +01:00
if ( ! coinControl . IsSelected ( txin . prevout ) )
2016-04-06 16:56:14 +02:00
{
2015-04-25 03:29:00 +02:00
tx . vin . push_back ( txin ) ;
2016-04-06 16:56:14 +02:00
if ( lockUnspents )
{
LOCK2 ( cs_main , cs_wallet ) ;
LockCoin ( txin . prevout ) ;
}
}
2015-04-25 03:29:00 +02:00
}
2016-12-19 09:04:05 +01:00
// optionally keep the change output key
if ( keepReserveKey )
reservekey . KeepKey ( ) ;
2015-04-25 03:29:00 +02:00
return true ;
}
2017-01-27 02:33:45 +01:00
bool CWallet : : CreateTransaction ( const std : : vector < CRecipient > & vecSend , CWalletTx & wtxNew , CReserveKey & reservekey , CAmount & nFeeRet ,
2016-03-30 03:04:22 +02:00
int & nChangePosInOut , std : : string & strFailReason , const CCoinControl * coinControl , bool sign )
2011-06-26 19:23:24 +02:00
{
2014-04-23 00:46:19 +02:00
CAmount nValue = 0 ;
2016-03-30 03:04:22 +02:00
int nChangePosRequest = nChangePosInOut ;
2014-07-23 14:34:36 +02:00
unsigned int nSubtractFeeFromAmount = 0 ;
2017-01-04 09:51:14 +01:00
for ( const auto & recipient : vecSend )
2011-06-26 19:23:24 +02:00
{
2014-07-23 14:34:36 +02:00
if ( nValue < 0 | | recipient . nAmount < 0 )
2013-04-25 23:31:22 +02:00
{
2016-11-22 18:48:01 +01:00
strFailReason = _ ( " Transaction amounts must not be negative " ) ;
2011-06-26 19:23:24 +02:00
return false ;
2013-04-25 23:31:22 +02:00
}
2014-07-23 14:34:36 +02:00
nValue + = recipient . nAmount ;
if ( recipient . fSubtractFeeFromAmount )
nSubtractFeeFromAmount + + ;
2011-06-26 19:23:24 +02:00
}
2016-11-22 18:48:01 +01:00
if ( vecSend . empty ( ) )
2013-04-25 23:31:22 +02:00
{
2016-11-22 18:48:01 +01:00
strFailReason = _ ( " Transaction must have at least one recipient " ) ;
2011-06-26 19:23:24 +02:00
return false ;
2013-04-25 23:31:22 +02:00
}
2011-06-26 19:23:24 +02:00
2014-05-27 21:44:57 +02:00
wtxNew . fTimeReceivedIsTxTime = true ;
2011-06-28 23:45:22 +02:00
wtxNew . BindWallet ( this ) ;
2014-06-07 13:53:27 +02:00
CMutableTransaction txNew ;
2011-06-26 19:23:24 +02:00
2013-08-25 20:13:25 +02:00
// Discourage fee sniping.
//
2015-06-01 21:03:51 +02:00
// For a large miner the value of the transactions in the best block and
2015-12-02 15:28:24 +01:00
// the mempool can exceed the cost of deliberately attempting to mine two
2015-06-01 21:03:51 +02:00
// blocks to orphan the current best block. By setting nLockTime such that
// only the next block can include the transaction, we discourage this
// practice as the height restricted and limited blocksize gives miners
// considering fee sniping fewer options for pulling off this attack.
//
// A simple way to think about this is from the wallet's point of view we
// always want the blockchain to move forward. By setting nLockTime this
// way we're basically making the statement that we only want this
// transaction to appear in the next block; we don't want to potentially
// encourage reorgs by allowing transactions to appear at lower heights
// than the next block in forks of the best chain.
//
// Of course, the subsidy is high enough, and transaction volume low
// enough, that fee sniping isn't a problem yet, but by implementing a fix
// now we ensure code won't be written that makes assumptions about
// nLockTime that preclude a fix later.
txNew . nLockTime = chainActive . Height ( ) ;
2013-08-25 20:13:25 +02:00
// Secondly occasionally randomly pick a nLockTime even further back, so
// that transactions that are delayed after signing for whatever reason,
// e.g. high-latency mix networks and some CoinJoin implementations, have
// better privacy.
if ( GetRandInt ( 10 ) = = 0 )
txNew . nLockTime = std : : max ( 0 , ( int ) txNew . nLockTime - GetRandInt ( 100 ) ) ;
assert ( txNew . nLockTime < = ( unsigned int ) chainActive . Height ( ) ) ;
assert ( txNew . nLockTime < LOCKTIME_THRESHOLD ) ;
2011-06-26 19:23:24 +02:00
{
2017-01-27 02:33:45 +01:00
std : : set < std : : pair < const CWalletTx * , unsigned int > > setCoins ;
2012-04-06 18:39:12 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2011-06-26 19:23:24 +02:00
{
2016-03-08 01:15:17 +01:00
std : : vector < COutput > vAvailableCoins ;
AvailableCoins ( vAvailableCoins , true , coinControl ) ;
2014-11-02 00:14:47 +01:00
nFeeRet = 0 ;
2015-09-14 14:49:59 +02:00
// Start with no fee and loop until there is enough fee
2013-07-31 06:06:44 +02:00
while ( true )
2011-06-26 19:23:24 +02:00
{
2016-03-30 03:04:22 +02:00
nChangePosInOut = nChangePosRequest ;
2014-06-07 13:53:27 +02:00
txNew . vin . clear ( ) ;
txNew . vout . clear ( ) ;
2011-06-26 19:23:24 +02:00
wtxNew . fFromMe = true ;
2014-07-23 14:34:36 +02:00
bool fFirst = true ;
2011-06-26 19:23:24 +02:00
2015-03-18 19:22:49 +01:00
CAmount nValueToSelect = nValue ;
2014-07-23 14:34:36 +02:00
if ( nSubtractFeeFromAmount = = 0 )
2015-03-18 19:22:49 +01:00
nValueToSelect + = nFeeRet ;
2011-06-26 19:23:24 +02:00
// vouts to the payees
2017-01-04 09:51:14 +01:00
for ( const auto & recipient : vecSend )
2013-04-25 00:27:00 +02:00
{
2014-07-23 14:34:36 +02:00
CTxOut txout ( recipient . nAmount , recipient . scriptPubKey ) ;
if ( recipient . fSubtractFeeFromAmount )
{
txout . nValue - = nFeeRet / nSubtractFeeFromAmount ; // Subtract fee equally from each selected recipient
if ( fFirst ) // first receiver pays the remainder not divisible by output count
{
fFirst = false ;
txout . nValue - = nFeeRet % nSubtractFeeFromAmount ;
}
}
2016-12-13 22:19:17 +01:00
if ( txout . IsDust ( dustRelayFee ) )
2013-04-25 23:31:22 +02:00
{
2014-07-23 14:34:36 +02:00
if ( recipient . fSubtractFeeFromAmount & & nFeeRet > 0 )
{
if ( txout . nValue < 0 )
strFailReason = _ ( " The transaction amount is too small to pay the fee " ) ;
else
strFailReason = _ ( " The transaction amount is too small to send after the fee has been deducted " ) ;
}
else
strFailReason = _ ( " Transaction amount too small " ) ;
2013-04-25 00:27:00 +02:00
return false ;
2013-04-25 23:31:22 +02:00
}
2014-06-07 13:53:27 +02:00
txNew . vout . push_back ( txout ) ;
2013-04-25 00:27:00 +02:00
}
2011-06-26 19:23:24 +02:00
// Choose coins to use
2014-04-23 00:46:19 +02:00
CAmount nValueIn = 0 ;
2017-01-04 09:51:14 +01:00
setCoins . clear ( ) ;
2016-03-08 01:15:17 +01:00
if ( ! SelectCoins ( vAvailableCoins , nValueToSelect , setCoins , nValueIn , coinControl ) )
2013-04-25 23:31:22 +02:00
{
strFailReason = _ ( " Insufficient funds " ) ;
2011-06-26 19:23:24 +02:00
return false ;
2013-04-25 23:31:22 +02:00
}
2011-06-26 19:23:24 +02:00
2015-03-18 19:22:49 +01:00
const CAmount nChange = nValueIn - nValueToSelect ;
2011-07-24 16:37:09 +02:00
if ( nChange > 0 )
2011-06-26 19:23:24 +02:00
{
2011-09-28 18:30:06 +02:00
// Fill a vout to ourself
// TODO: pass in scriptChange instead of reservekey so
// change transaction isn't always pay-to-bitcoin-address
2011-06-26 19:23:24 +02:00
CScript scriptChange ;
2013-08-12 17:03:03 +02:00
// coin control: send change to custom address
if ( coinControl & & ! boost : : get < CNoDestination > ( & coinControl - > destChange ) )
2014-09-11 19:15:29 +02:00
scriptChange = GetScriptForDestination ( coinControl - > destChange ) ;
2013-08-12 17:03:03 +02:00
// no coin control: send change to newly generated address
else
{
// Note: We use a new key here to keep it from being obvious which side is the change.
// The drawback is that by not reusing a previous key, the change may be lost if a
// backup is restored, if the backup doesn't have the new private key for the change.
// If we reused the old key, it would be possible to add code to look for and
// rediscover unknown transactions that were written with keys of ours to recover
// post-backup change.
// Reserve a new key pair from key pool
CPubKey vchPubKey ;
2013-12-02 20:33:44 +01:00
bool ret ;
2017-01-10 16:45:30 +01:00
ret = reservekey . GetReservedKey ( vchPubKey , true ) ;
2016-12-06 13:45:56 +01:00
if ( ! ret )
{
strFailReason = _ ( " Keypool ran out, please call keypoolrefill first " ) ;
return false ;
}
2013-08-12 17:03:03 +02:00
2014-09-11 19:15:29 +02:00
scriptChange = GetScriptForDestination ( vchPubKey . GetID ( ) ) ;
2013-08-12 17:03:03 +02:00
}
2011-06-26 19:23:24 +02:00
2013-04-25 00:27:00 +02:00
CTxOut newTxOut ( nChange , scriptChange ) ;
2014-07-23 14:34:36 +02:00
// We do not move dust-change to fees, because the sender would end up paying more than requested.
// This would be against the purpose of the all-inclusive feature.
// So instead we raise the change and deduct from the recipient.
2016-12-13 22:19:17 +01:00
if ( nSubtractFeeFromAmount > 0 & & newTxOut . IsDust ( dustRelayFee ) )
2014-07-23 14:34:36 +02:00
{
2016-12-13 22:19:17 +01:00
CAmount nDust = newTxOut . GetDustThreshold ( dustRelayFee ) - newTxOut . nValue ;
2014-07-23 14:34:36 +02:00
newTxOut . nValue + = nDust ; // raise change until no more dust
for ( unsigned int i = 0 ; i < vecSend . size ( ) ; i + + ) // subtract from first recipient
{
if ( vecSend [ i ] . fSubtractFeeFromAmount )
{
txNew . vout [ i ] . nValue - = nDust ;
2016-12-13 22:19:17 +01:00
if ( txNew . vout [ i ] . IsDust ( dustRelayFee ) )
2014-07-23 14:34:36 +02:00
{
strFailReason = _ ( " The transaction amount is too small to send after the fee has been deducted " ) ;
return false ;
}
break ;
}
}
}
2013-04-25 00:27:00 +02:00
// Never create dust outputs; if we would, just
// add the dust to the fee.
2016-12-13 22:19:17 +01:00
if ( newTxOut . IsDust ( dustRelayFee ) )
2013-04-25 00:27:00 +02:00
{
2016-03-30 03:04:22 +02:00
nChangePosInOut = - 1 ;
2013-04-25 00:27:00 +02:00
nFeeRet + = nChange ;
reservekey . ReturnKey ( ) ;
}
else
{
2016-03-30 03:04:22 +02:00
if ( nChangePosInOut = = - 1 )
{
// Insert change txn at random position:
nChangePosInOut = GetRandInt ( txNew . vout . size ( ) + 1 ) ;
}
2016-06-08 15:34:18 +02:00
else if ( ( unsigned int ) nChangePosInOut > txNew . vout . size ( ) )
2016-03-30 03:04:22 +02:00
{
strFailReason = _ ( " Change index out of range " ) ;
return false ;
}
2017-01-27 02:33:45 +01:00
std : : vector < CTxOut > : : iterator position = txNew . vout . begin ( ) + nChangePosInOut ;
2014-06-07 13:53:27 +02:00
txNew . vout . insert ( position , newTxOut ) ;
2013-04-25 00:27:00 +02:00
}
2011-06-26 19:23:24 +02:00
}
else
reservekey . ReturnKey ( ) ;
// Fill vin
2013-08-25 20:13:25 +02:00
//
2015-11-30 06:11:18 +01:00
// Note how the sequence number is set to non-maxint so that
// the nLockTime set above actually works.
2016-08-26 12:13:48 +02:00
//
// BIP125 defines opt-in RBF as any nSequence < maxint-1, so
// we use the highest possible value in that range (maxint-2)
// to avoid conflicting with other possible uses of nSequence,
2017-01-18 16:15:37 +01:00
// and in the spirit of "smallest possible change from prior
2016-08-26 12:13:48 +02:00
// behavior."
2015-12-03 09:53:23 +01:00
bool rbf = coinControl ? coinControl - > signalRbf : fWalletRbf ;
2017-01-04 09:51:14 +01:00
for ( const auto & coin : setCoins )
2013-08-25 20:13:25 +02:00
txNew . vin . push_back ( CTxIn ( coin . first - > GetHash ( ) , coin . second , CScript ( ) ,
2015-12-03 09:53:23 +01:00
std : : numeric_limits < unsigned int > : : max ( ) - ( rbf ? 2 : 1 ) ) ) ;
2011-06-26 19:23:24 +02:00
2017-01-04 09:51:14 +01:00
// Fill in dummy signatures for fee calculation.
2017-01-26 18:57:04 +01:00
if ( ! DummySignTx ( txNew , setCoins ) ) {
strFailReason = _ ( " Signing transaction failed " ) ;
return false ;
2015-04-25 03:29:00 +02:00
}
2016-01-03 18:54:50 +01:00
unsigned int nBytes = GetVirtualTransactionSize ( txNew ) ;
2015-04-25 03:29:00 +02:00
2017-01-04 09:51:14 +01:00
CTransaction txNewConst ( txNew ) ;
2014-06-07 13:53:27 +02:00
2017-01-04 09:51:14 +01:00
// Remove scriptSigs to eliminate the fee calculation dummy signatures
for ( auto & vin : txNew . vin ) {
vin . scriptSig = CScript ( ) ;
vin . scriptWitness . SetNull ( ) ;
2013-04-25 23:31:22 +02:00
}
2015-04-25 03:29:00 +02:00
2016-10-21 10:09:02 +02:00
// Allow to override the default confirmation target over the CoinControl instance
int currentConfirmationTarget = nTxConfirmTarget ;
if ( coinControl & & coinControl - > nConfirmTarget > 0 )
currentConfirmationTarget = coinControl - > nConfirmTarget ;
CAmount nFeeNeeded = GetMinimumFee ( nBytes , currentConfirmationTarget , mempool ) ;
2015-11-25 13:04:52 +01:00
if ( coinControl & & nFeeNeeded > 0 & & coinControl - > nMinimumTotalFee > nFeeNeeded ) {
nFeeNeeded = coinControl - > nMinimumTotalFee ;
}
2016-05-06 11:01:50 +02:00
if ( coinControl & & coinControl - > fOverrideFeeRate )
2016-04-28 22:04:07 +02:00
nFeeNeeded = coinControl - > nFeeRate . GetFee ( nBytes ) ;
2014-05-27 21:44:57 +02:00
2014-12-16 10:43:40 +01:00
// If we made it here and we aren't even able to meet the relay fee on the next pass, give up
// because we must be at the maximum allowed fee.
if ( nFeeNeeded < : : minRelayTxFee . GetFee ( nBytes ) )
2011-06-26 19:23:24 +02:00
{
2014-12-16 10:43:40 +01:00
strFailReason = _ ( " Transaction too large for fee policy " ) ;
return false ;
2011-06-26 19:23:24 +02:00
}
2017-01-05 15:12:48 +01:00
if ( nFeeRet > = nFeeNeeded ) {
// Reduce fee to only the needed amount if we have change
// output to increase. This prevents potential overpayment
// in fees if the coins selected to meet nFeeNeeded result
// in a transaction that requires less fee than the prior
// iteration.
// TODO: The case where nSubtractFeeFromAmount > 0 remains
// to be addressed because it requires returning the fee to
// the payees and not the change output.
// TODO: The case where there is no change output remains
// to be addressed so we avoid creating too small an output.
if ( nFeeRet > nFeeNeeded & & nChangePosInOut ! = - 1 & & nSubtractFeeFromAmount = = 0 ) {
CAmount extraFeePaid = nFeeRet - nFeeNeeded ;
2017-01-27 02:33:45 +01:00
std : : vector < CTxOut > : : iterator change_position = txNew . vout . begin ( ) + nChangePosInOut ;
2017-01-05 15:12:48 +01:00
change_position - > nValue + = extraFeePaid ;
nFeeRet - = extraFeePaid ;
}
2014-12-16 10:43:40 +01:00
break ; // Done, enough fee included.
2017-01-05 15:12:48 +01:00
}
2014-05-27 21:44:57 +02:00
2017-01-05 15:10:08 +01:00
// Try to reduce change to include necessary fee
if ( nChangePosInOut ! = - 1 & & nSubtractFeeFromAmount = = 0 ) {
CAmount additionalFeeNeeded = nFeeNeeded - nFeeRet ;
2017-01-27 02:33:45 +01:00
std : : vector < CTxOut > : : iterator change_position = txNew . vout . begin ( ) + nChangePosInOut ;
2017-01-05 15:10:08 +01:00
// Only reduce change if remaining amount is still a large enough output.
if ( change_position - > nValue > = MIN_FINAL_CHANGE + additionalFeeNeeded ) {
change_position - > nValue - = additionalFeeNeeded ;
nFeeRet + = additionalFeeNeeded ;
break ; // Done, able to increase fee from change
}
}
2014-05-27 21:44:57 +02:00
// Include more fee and try again.
nFeeRet = nFeeNeeded ;
continue ;
2011-06-26 19:23:24 +02:00
}
}
2017-01-04 09:51:14 +01:00
if ( sign )
{
CTransaction txNewConst ( txNew ) ;
int nIn = 0 ;
for ( const auto & coin : setCoins )
{
const CScript & scriptPubKey = coin . first - > tx - > vout [ coin . second ] . scriptPubKey ;
SignatureData sigdata ;
if ( ! ProduceSignature ( TransactionSignatureCreator ( this , & txNewConst , nIn , coin . first - > tx - > vout [ coin . second ] . nValue , SIGHASH_ALL ) , scriptPubKey , sigdata ) )
{
strFailReason = _ ( " Signing transaction failed " ) ;
return false ;
} else {
UpdateTransaction ( txNew , nIn , sigdata ) ;
}
nIn + + ;
}
}
// Embed the constructed transaction data in wtxNew.
wtxNew . SetTx ( MakeTransactionRef ( std : : move ( txNew ) ) ) ;
// Limit size
if ( GetTransactionWeight ( wtxNew ) > = MAX_STANDARD_TX_WEIGHT )
{
strFailReason = _ ( " Transaction too large " ) ;
return false ;
}
2011-06-26 19:23:24 +02:00
}
2016-12-02 21:45:43 +01:00
if ( GetBoolArg ( " -walletrejectlongchains " , DEFAULT_WALLET_REJECT_LONG_CHAINS ) ) {
// Lastly, ensure this tx will pass the mempool's chain limits
LockPoints lp ;
2017-01-20 15:24:35 +01:00
CTxMemPoolEntry entry ( wtxNew . tx , 0 , 0 , 0 , false , 0 , lp ) ;
2016-12-02 21:45:43 +01:00
CTxMemPool : : setEntries setAncestors ;
size_t nLimitAncestors = GetArg ( " -limitancestorcount " , DEFAULT_ANCESTOR_LIMIT ) ;
size_t nLimitAncestorSize = GetArg ( " -limitancestorsize " , DEFAULT_ANCESTOR_SIZE_LIMIT ) * 1000 ;
size_t nLimitDescendants = GetArg ( " -limitdescendantcount " , DEFAULT_DESCENDANT_LIMIT ) ;
size_t nLimitDescendantSize = GetArg ( " -limitdescendantsize " , DEFAULT_DESCENDANT_SIZE_LIMIT ) * 1000 ;
std : : string errString ;
if ( ! mempool . CalculateMemPoolAncestors ( entry , setAncestors , nLimitAncestors , nLimitAncestorSize , nLimitDescendants , nLimitDescendantSize , errString ) ) {
strFailReason = _ ( " Transaction has too long of a mempool chain " ) ;
return false ;
}
}
2014-07-23 14:34:36 +02:00
return true ;
2011-06-26 19:23:24 +02:00
}
2014-10-26 08:03:12 +01:00
/**
* Call after CreateTransaction unless you want to abort
*/
2016-10-25 20:27:04 +02:00
bool CWallet : : CommitTransaction ( CWalletTx & wtxNew , CReserveKey & reservekey , CConnman * connman , CValidationState & state )
2011-06-26 19:23:24 +02:00
{
{
2012-04-06 18:39:12 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2016-11-12 01:54:51 +01:00
LogPrintf ( " CommitTransaction: \n %s " , wtxNew . tx - > ToString ( ) ) ;
2011-06-26 19:23:24 +02:00
{
// Take key pair from key pool so it won't be used again
reservekey . KeepKey ( ) ;
// Add tx to wallet, because if it has change it's also ours,
// otherwise just for transaction history.
2016-06-08 06:41:03 +02:00
AddToWallet ( wtxNew ) ;
2011-06-26 19:23:24 +02:00
2014-02-15 22:38:28 +01:00
// Notify that old coins are spent
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxIn & txin , wtxNew . tx - > vin )
2011-06-26 19:23:24 +02:00
{
CWalletTx & coin = mapWallet [ txin . prevout . hash ] ;
2011-06-28 23:45:22 +02:00
coin . BindWallet ( this ) ;
2012-05-05 16:07:14 +02:00
NotifyTransactionChanged ( this , coin . GetHash ( ) , CT_UPDATED ) ;
2011-06-26 19:23:24 +02:00
}
}
// Track how many getdata requests our transaction gets
2011-08-26 20:37:23 +02:00
mapRequestCount [ wtxNew . GetHash ( ) ] = 0 ;
2011-06-26 19:23:24 +02:00
2015-03-27 10:34:48 +01:00
if ( fBroadcastTransactions )
2011-06-26 19:23:24 +02:00
{
2015-03-27 10:34:48 +01:00
// Broadcast
2016-10-25 20:27:04 +02:00
if ( ! wtxNew . AcceptToMemoryPool ( maxTxFee , state ) ) {
2016-12-08 20:49:28 +01:00
LogPrintf ( " CommitTransaction(): Transaction cannot be broadcast immediately, %s \n " , state . GetRejectReason ( ) ) ;
// TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
} else {
wtxNew . RelayWalletTransaction ( connman ) ;
2015-03-27 10:34:48 +01:00
}
2011-06-26 19:23:24 +02:00
}
}
return true ;
}
2016-09-10 03:53:23 +02:00
void CWallet : : ListAccountCreditDebit ( const std : : string & strAccount , std : : list < CAccountingEntry > & entries ) {
CWalletDB walletdb ( strWalletFile ) ;
return walletdb . ListAccountCreditDebit ( strAccount , entries ) ;
}
2016-09-10 04:22:59 +02:00
bool CWallet : : AddAccountingEntry ( const CAccountingEntry & acentry )
2015-10-19 11:19:38 +02:00
{
2016-09-10 04:22:59 +02:00
CWalletDB walletdb ( strWalletFile ) ;
return AddAccountingEntry ( acentry , & walletdb ) ;
}
bool CWallet : : AddAccountingEntry ( const CAccountingEntry & acentry , CWalletDB * pwalletdb )
2015-10-19 11:19:38 +02:00
{
2016-09-10 04:22:59 +02:00
if ( ! pwalletdb - > WriteAccountingEntry_Backend ( acentry ) )
2015-10-19 11:19:38 +02:00
return false ;
laccentries . push_back ( acentry ) ;
CAccountingEntry & entry = laccentries . back ( ) ;
2017-01-27 02:33:45 +01:00
wtxOrdered . insert ( std : : make_pair ( entry . nOrderPos , TxPair ( ( CWalletTx * ) 0 , & entry ) ) ) ;
2015-10-19 11:19:38 +02:00
return true ;
}
2015-10-25 02:47:04 +02:00
CAmount CWallet : : GetRequiredFee ( unsigned int nTxBytes )
{
return std : : max ( minTxFee . GetFee ( nTxBytes ) , : : minRelayTxFee . GetFee ( nTxBytes ) ) ;
}
2014-04-23 00:46:19 +02:00
CAmount CWallet : : GetMinimumFee ( unsigned int nTxBytes , unsigned int nConfirmTarget , const CTxMemPool & pool )
2014-05-27 21:44:57 +02:00
{
2017-01-26 04:20:02 +01:00
// payTxFee is the user-set global for desired feerate
return GetMinimumFee ( nTxBytes , nConfirmTarget , pool , payTxFee . GetFee ( nTxBytes ) ) ;
}
CAmount CWallet : : GetMinimumFee ( unsigned int nTxBytes , unsigned int nConfirmTarget , const CTxMemPool & pool , CAmount targetFee )
{
CAmount nFeeNeeded = targetFee ;
2014-05-27 21:44:57 +02:00
// User didn't set: use -txconfirmtarget to estimate...
2015-11-16 21:15:32 +01:00
if ( nFeeNeeded = = 0 ) {
int estimateFoundTarget = nConfirmTarget ;
nFeeNeeded = pool . estimateSmartFee ( nConfirmTarget , & estimateFoundTarget ) . GetFee ( nTxBytes ) ;
2016-01-05 19:11:34 +01:00
// ... unless we don't have enough mempool data for estimatefee, then use fallbackFee
if ( nFeeNeeded = = 0 )
nFeeNeeded = fallbackFee . GetFee ( nTxBytes ) ;
2016-01-05 19:10:19 +01:00
}
// prevent user from paying a fee below minRelayTxFee or minTxFee
nFeeNeeded = std : : max ( nFeeNeeded , GetRequiredFee ( nTxBytes ) ) ;
2014-12-16 10:43:40 +01:00
// But always obey the maximum
if ( nFeeNeeded > maxTxFee )
nFeeNeeded = maxTxFee ;
2014-05-27 21:44:57 +02:00
return nFeeNeeded ;
}
2011-06-26 19:23:24 +02:00
2012-09-18 20:30:47 +02:00
DBErrors CWallet : : LoadWallet ( bool & fFirstRunRet )
2011-06-26 19:23:24 +02:00
{
if ( ! fFileBacked )
2012-09-05 10:32:13 +02:00
return DB_LOAD_OK ;
2011-06-26 19:23:24 +02:00
fFirstRunRet = false ;
2012-09-18 20:30:47 +02:00
DBErrors nLoadWalletRet = CWalletDB ( strWalletFile , " cr+ " ) . LoadWallet ( this ) ;
2011-11-11 03:12:46 +01:00
if ( nLoadWalletRet = = DB_NEED_REWRITE )
2011-11-10 21:29:23 +01:00
{
2011-11-11 03:12:46 +01:00
if ( CDB : : Rewrite ( strWalletFile , " \x04 pool " ) )
{
2013-12-19 09:58:06 +01:00
LOCK ( cs_wallet ) ;
2011-11-11 03:12:46 +01:00
setKeyPool . clear ( ) ;
// Note: can't top-up keypool here, because wallet is locked.
// User will be prompted to unlock wallet the next operation
2015-04-08 14:24:46 +02:00
// that requires a new key.
2011-11-11 03:12:46 +01:00
}
2011-11-10 21:29:23 +01:00
}
2011-07-05 03:06:19 +02:00
if ( nLoadWalletRet ! = DB_LOAD_OK )
return nLoadWalletRet ;
2012-05-14 19:07:52 +02:00
fFirstRunRet = ! vchDefaultKey . IsValid ( ) ;
2011-06-26 19:23:24 +02:00
2014-03-19 00:26:14 +01:00
uiInterface . LoadWallet ( this ) ;
2011-07-13 07:07:49 +02:00
return DB_LOAD_OK ;
2011-06-26 19:23:24 +02:00
}
2017-01-27 02:33:45 +01:00
DBErrors CWallet : : ZapSelectTx ( std : : vector < uint256 > & vHashIn , std : : vector < uint256 > & vHashOut )
2016-03-07 14:51:06 +01:00
{
if ( ! fFileBacked )
return DB_LOAD_OK ;
2016-11-12 10:53:18 +01:00
AssertLockHeld ( cs_wallet ) ; // mapWallet
vchDefaultKey = CPubKey ( ) ;
DBErrors nZapSelectTxRet = CWalletDB ( strWalletFile , " cr+ " ) . ZapSelectTx ( vHashIn , vHashOut ) ;
for ( uint256 hash : vHashOut )
mapWallet . erase ( hash ) ;
2016-03-07 14:51:06 +01:00
if ( nZapSelectTxRet = = DB_NEED_REWRITE )
{
if ( CDB : : Rewrite ( strWalletFile , " \x04 pool " ) )
{
setKeyPool . clear ( ) ;
// Note: can't top-up keypool here, because wallet is locked.
// User will be prompted to unlock wallet the next operation
// that requires a new key.
}
}
if ( nZapSelectTxRet ! = DB_LOAD_OK )
return nZapSelectTxRet ;
MarkDirty ( ) ;
return DB_LOAD_OK ;
}
2011-07-07 15:22:54 +02:00
2014-02-14 18:27:15 +01:00
DBErrors CWallet : : ZapWalletTx ( std : : vector < CWalletTx > & vWtx )
2014-02-14 17:33:07 +01:00
{
if ( ! fFileBacked )
return DB_LOAD_OK ;
2016-11-12 10:53:18 +01:00
vchDefaultKey = CPubKey ( ) ;
DBErrors nZapWalletTxRet = CWalletDB ( strWalletFile , " cr+ " ) . ZapWalletTx ( vWtx ) ;
2014-02-14 17:33:07 +01:00
if ( nZapWalletTxRet = = DB_NEED_REWRITE )
{
if ( CDB : : Rewrite ( strWalletFile , " \x04 pool " ) )
{
LOCK ( cs_wallet ) ;
setKeyPool . clear ( ) ;
// Note: can't top-up keypool here, because wallet is locked.
// User will be prompted to unlock wallet the next operation
2014-10-26 08:03:12 +01:00
// that requires a new key.
2014-02-14 17:33:07 +01:00
}
}
if ( nZapWalletTxRet ! = DB_LOAD_OK )
return nZapWalletTxRet ;
return DB_LOAD_OK ;
}
2017-01-27 02:33:45 +01:00
bool CWallet : : SetAddressBook ( const CTxDestination & address , const std : : string & strName , const std : : string & strPurpose )
2011-07-07 15:22:54 +02:00
{
2014-02-18 18:11:46 +01:00
bool fUpdated = false ;
{
LOCK ( cs_wallet ) ; // mapAddressBook
std : : map < CTxDestination , CAddressBookData > : : iterator mi = mapAddressBook . find ( address ) ;
fUpdated = mi ! = mapAddressBook . end ( ) ;
mapAddressBook [ address ] . name = strName ;
if ( ! strPurpose . empty ( ) ) /* update purpose only if requested */
mapAddressBook [ address ] . purpose = strPurpose ;
}
2014-09-06 21:59:59 +02:00
NotifyAddressBookChanged ( this , address , strName , : : IsMine ( * this , address ) ! = ISMINE_NO ,
2014-02-18 18:11:46 +01:00
strPurpose , ( fUpdated ? CT_UPDATED : CT_NEW ) ) ;
2011-07-07 15:22:54 +02:00
if ( ! fFileBacked )
return false ;
2013-07-22 08:50:39 +02:00
if ( ! strPurpose . empty ( ) & & ! CWalletDB ( strWalletFile ) . WritePurpose ( CBitcoinAddress ( address ) . ToString ( ) , strPurpose ) )
return false ;
2012-05-14 23:44:52 +02:00
return CWalletDB ( strWalletFile ) . WriteName ( CBitcoinAddress ( address ) . ToString ( ) , strName ) ;
2011-07-07 15:22:54 +02:00
}
2013-07-22 08:50:39 +02:00
bool CWallet : : DelAddressBook ( const CTxDestination & address )
2011-07-07 15:22:54 +02:00
{
2013-11-18 16:55:54 +01:00
{
2014-02-18 18:11:46 +01:00
LOCK ( cs_wallet ) ; // mapAddressBook
if ( fFileBacked )
2013-11-18 16:55:54 +01:00
{
2014-02-18 18:11:46 +01:00
// Delete destdata tuples associated with address
std : : string strAddress = CBitcoinAddress ( address ) . ToString ( ) ;
2017-01-27 02:33:45 +01:00
BOOST_FOREACH ( const PAIRTYPE ( std : : string , std : : string ) & item , mapAddressBook [ address ] . destdata )
2014-02-18 18:11:46 +01:00
{
CWalletDB ( strWalletFile ) . EraseDestData ( strAddress , item . first ) ;
}
2013-11-18 16:55:54 +01:00
}
2014-02-18 18:11:46 +01:00
mapAddressBook . erase ( address ) ;
2013-11-18 16:55:54 +01:00
}
2014-09-06 21:59:59 +02:00
NotifyAddressBookChanged ( this , address , " " , : : IsMine ( * this , address ) ! = ISMINE_NO , " " , CT_DELETED ) ;
2014-02-18 18:11:46 +01:00
2011-07-07 15:22:54 +02:00
if ( ! fFileBacked )
return false ;
2013-07-22 08:50:39 +02:00
CWalletDB ( strWalletFile ) . ErasePurpose ( CBitcoinAddress ( address ) . ToString ( ) ) ;
2012-05-14 23:44:52 +02:00
return CWalletDB ( strWalletFile ) . EraseName ( CBitcoinAddress ( address ) . ToString ( ) ) ;
2011-07-07 15:22:54 +02:00
}
2012-05-14 19:07:52 +02:00
bool CWallet : : SetDefaultKey ( const CPubKey & vchPubKey )
2011-07-07 15:22:54 +02:00
{
if ( fFileBacked )
{
if ( ! CWalletDB ( strWalletFile ) . WriteDefaultKey ( vchPubKey ) )
return false ;
}
vchDefaultKey = vchPubKey ;
return true ;
}
2014-10-26 08:03:12 +01:00
/**
* Mark old keypool keys as used ,
* and generate all new keys
*/
2011-11-17 20:01:25 +01:00
bool CWallet : : NewKeyPool ( )
{
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
2011-11-17 20:01:25 +01:00
CWalletDB walletdb ( strWalletFile ) ;
2013-04-13 07:13:08 +02:00
BOOST_FOREACH ( int64_t nIndex , setKeyPool )
2011-11-17 20:01:25 +01:00
walletdb . ErasePool ( nIndex ) ;
setKeyPool . clear ( ) ;
2017-01-16 08:57:31 +01:00
if ( ! TopUpKeyPool ( ) ) {
2011-11-17 20:01:25 +01:00
return false ;
2017-01-16 08:57:31 +01:00
}
2017-01-10 16:45:30 +01:00
LogPrintf ( " CWallet::NewKeyPool rewrote keypool \n " ) ;
2011-11-17 20:01:25 +01:00
}
return true ;
}
2017-01-10 16:45:30 +01:00
size_t CWallet : : KeypoolCountExternalKeys ( )
{
AssertLockHeld ( cs_wallet ) ; // setKeyPool
2017-01-16 08:56:37 +01:00
// immediately return setKeyPool's size if HD or HD_SPLIT is disabled or not supported
if ( ! IsHDEnabled ( ) | | ! CanSupportFeature ( FEATURE_HD_SPLIT ) )
return setKeyPool . size ( ) ;
2017-01-10 16:45:30 +01:00
CWalletDB walletdb ( strWalletFile ) ;
// count amount of external keys
size_t amountE = 0 ;
for ( const int64_t & id : setKeyPool )
{
CKeyPool tmpKeypool ;
if ( ! walletdb . ReadPool ( id , tmpKeypool ) )
throw std : : runtime_error ( std : : string ( __func__ ) + " : read failed " ) ;
amountE + = ! tmpKeypool . fInternal ;
}
return amountE ;
}
2013-06-25 22:07:29 +02:00
bool CWallet : : TopUpKeyPool ( unsigned int kpSize )
2011-06-26 19:23:24 +02:00
{
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
if ( IsLocked ( ) )
return false ;
2011-06-26 19:23:24 +02:00
// Top up key pool
2013-06-25 22:07:29 +02:00
unsigned int nTargetSize ;
if ( kpSize > 0 )
nTargetSize = kpSize ;
else
2017-01-27 02:33:45 +01:00
nTargetSize = std : : max ( GetArg ( " -keypool " , DEFAULT_KEYPOOL_SIZE ) , ( int64_t ) 0 ) ;
2013-06-25 22:07:29 +02:00
2017-01-10 16:45:30 +01:00
// count amount of available keys (internal, external)
2017-01-17 08:55:30 +01:00
// make sure the keypool of external and internal keys fits the user selected target (-keypool)
2017-01-10 16:45:30 +01:00
int64_t amountExternal = KeypoolCountExternalKeys ( ) ;
int64_t amountInternal = setKeyPool . size ( ) - amountExternal ;
2017-01-16 11:22:30 +01:00
int64_t missingExternal = std : : max ( std : : max ( ( int64_t ) nTargetSize , ( int64_t ) 1 ) - amountExternal , ( int64_t ) 0 ) ;
2017-01-17 08:55:30 +01:00
int64_t missingInternal = std : : max ( std : : max ( ( int64_t ) nTargetSize , ( int64_t ) 1 ) - amountInternal , ( int64_t ) 0 ) ;
2017-01-10 16:45:30 +01:00
if ( ! IsHDEnabled ( ) | | ! CanSupportFeature ( FEATURE_HD_SPLIT ) )
{
// don't create extra internal keys
missingInternal = 0 ;
}
bool internal = false ;
CWalletDB walletdb ( strWalletFile ) ;
for ( int64_t i = missingInternal + missingExternal ; i - - ; )
2011-06-26 19:23:24 +02:00
{
2013-04-13 07:13:08 +02:00
int64_t nEnd = 1 ;
2017-01-10 16:45:30 +01:00
if ( i < missingInternal )
internal = true ;
2011-06-26 19:23:24 +02:00
if ( ! setKeyPool . empty ( ) )
nEnd = * ( - - setKeyPool . end ( ) ) + 1 ;
2017-01-10 16:45:30 +01:00
if ( ! walletdb . WritePool ( nEnd , CKeyPool ( GenerateNewKey ( internal ) , internal ) ) )
2017-01-27 02:33:45 +01:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : writing generated key failed " ) ;
2011-06-26 19:23:24 +02:00
setKeyPool . insert ( nEnd ) ;
2017-01-10 16:45:30 +01:00
LogPrintf ( " keypool added key %d, size=%u, internal=%d \n " , nEnd , setKeyPool . size ( ) , internal ) ;
2011-06-26 19:23:24 +02:00
}
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
}
return true ;
}
2017-01-10 16:45:30 +01:00
void CWallet : : ReserveKeyFromKeyPool ( int64_t & nIndex , CKeyPool & keypool , bool internal )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
nIndex = - 1 ;
2012-05-14 19:07:52 +02:00
keypool . vchPubKey = CPubKey ( ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
if ( ! IsLocked ( ) )
TopUpKeyPool ( ) ;
2011-06-26 19:23:24 +02:00
// Get the oldest key
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
if ( setKeyPool . empty ( ) )
return ;
CWalletDB walletdb ( strWalletFile ) ;
2017-01-10 16:45:30 +01:00
// try to find a key that matches the internal/external filter
for ( const int64_t & id : setKeyPool )
{
CKeyPool tmpKeypool ;
if ( ! walletdb . ReadPool ( id , tmpKeypool ) )
throw std : : runtime_error ( std : : string ( __func__ ) + " : read failed " ) ;
if ( ! HaveKey ( tmpKeypool . vchPubKey . GetID ( ) ) )
throw std : : runtime_error ( std : : string ( __func__ ) + " : unknown key in key pool " ) ;
2017-01-16 11:08:00 +01:00
if ( ! IsHDEnabled ( ) | | ! CanSupportFeature ( FEATURE_HD_SPLIT ) | | tmpKeypool . fInternal = = internal )
2017-01-10 16:45:30 +01:00
{
nIndex = id ;
keypool = tmpKeypool ;
setKeyPool . erase ( id ) ;
assert ( keypool . vchPubKey . IsValid ( ) ) ;
LogPrintf ( " keypool reserve %d \n " , nIndex ) ;
return ;
}
}
2011-06-26 19:23:24 +02:00
}
}
2013-04-13 07:13:08 +02:00
void CWallet : : KeepKey ( int64_t nIndex )
2011-06-26 19:23:24 +02:00
{
// Remove from key pool
if ( fFileBacked )
{
CWalletDB walletdb ( strWalletFile ) ;
2011-08-26 20:37:23 +02:00
walletdb . ErasePool ( nIndex ) ;
2011-06-26 19:23:24 +02:00
}
2014-02-24 09:08:56 +01:00
LogPrintf ( " keypool keep %d \n " , nIndex ) ;
2011-06-26 19:23:24 +02:00
}
2013-04-13 07:13:08 +02:00
void CWallet : : ReturnKey ( int64_t nIndex )
2011-06-26 19:23:24 +02:00
{
// Return to key pool
2012-04-06 18:39:12 +02:00
{
LOCK ( cs_wallet ) ;
2011-06-26 19:23:24 +02:00
setKeyPool . insert ( nIndex ) ;
2012-04-06 18:39:12 +02:00
}
2014-02-24 09:08:56 +01:00
LogPrintf ( " keypool return %d \n " , nIndex ) ;
2011-06-26 19:23:24 +02:00
}
2017-01-10 16:45:30 +01:00
bool CWallet : : GetKeyFromPool ( CPubKey & result , bool internal )
2011-06-26 19:23:24 +02:00
{
2013-04-13 07:13:08 +02:00
int64_t nIndex = 0 ;
2011-06-26 19:23:24 +02:00
CKeyPool keypool ;
2011-08-12 22:32:07 +02:00
{
2012-04-06 18:39:12 +02:00
LOCK ( cs_wallet ) ;
2017-01-10 16:45:30 +01:00
ReserveKeyFromKeyPool ( nIndex , keypool , internal ) ;
2011-09-01 16:58:08 +02:00
if ( nIndex = = - 1 )
2011-08-12 22:32:07 +02:00
{
2011-09-01 16:58:08 +02:00
if ( IsLocked ( ) ) return false ;
2017-01-10 16:45:30 +01:00
result = GenerateNewKey ( internal ) ;
2011-08-12 22:32:07 +02:00
return true ;
}
2011-09-01 16:58:08 +02:00
KeepKey ( nIndex ) ;
result = keypool . vchPubKey ;
2011-08-12 22:32:07 +02:00
}
return true ;
2011-06-26 19:23:24 +02:00
}
2013-04-13 07:13:08 +02:00
int64_t CWallet : : GetOldestKeyPoolTime ( )
2011-06-26 19:23:24 +02:00
{
2016-04-05 10:45:11 +02:00
LOCK ( cs_wallet ) ;
// if the keypool is empty, return <NOW>
if ( setKeyPool . empty ( ) )
Add wallet privkey encryption.
This commit adds support for ckeys, or enCrypted private keys, to the wallet.
All keys are stored in memory in their encrypted form and thus the passphrase
is required from the user to spend coins, or to create new addresses.
Keys are encrypted with AES-256-CBC using OpenSSL's EVP library. The key is
calculated via EVP_BytesToKey using SHA512 with (by default) 25000 rounds and
a random salt.
By default, the user's wallet remains unencrypted until they call the RPC
command encryptwallet <passphrase> or, from the GUI menu, Options->
Encrypt Wallet.
When the user is attempting to call RPC functions which require the password
to unlock the wallet, an error will be returned unless they call
walletpassphrase <passphrase> <time to keep key in memory> first.
A keypoolrefill command has been added which tops up the users keypool
(requiring the passphrase via walletpassphrase first).
keypoolsize has been added to the output of getinfo to show the user the
number of keys left before they need to specify their passphrase (and call
keypoolrefill).
Note that walletpassphrase will automatically fill keypool in a separate
thread which it spawns when the passphrase is set. This could cause some
delays in other threads waiting for locks on the wallet passphrase, including
one which could cause the passphrase to be stored longer than expected,
however it will not allow the passphrase to be used longer than expected as
ThreadCleanWalletPassphrase will attempt to get a lock on the key as soon
as the specified lock time has arrived.
When the keypool runs out (and wallet is locked) GetOrReuseKeyFromPool
returns vchDefaultKey, meaning miners may start to generate many blocks to
vchDefaultKey instead of a new key each time.
A walletpassphrasechange <oldpassphrase> <newpassphrase> has been added to
allow the user to change their password via RPC.
Whenever keying material (unencrypted private keys, the user's passphrase,
the wallet's AES key) is stored unencrypted in memory, any reasonable attempt
is made to mlock/VirtualLock that memory before storing the keying material.
This is not true in several (commented) cases where mlock/VirtualLocking the
memory is not possible.
Although encryption of private keys in memory can be very useful on desktop
systems (as some small amount of protection against stupid viruses), on an
RPC server, the password is entered fairly insecurely. Thus, the only main
advantage encryption has for RPC servers is for RPC servers that do not spend
coins, except in rare cases, eg. a webserver of a merchant which only receives
payment except for cases of manual intervention.
Thanks to jgarzik for the original patch and sipa, gmaxwell and many others
for all their input.
Conflicts:
src/wallet.cpp
2011-07-08 15:47:35 +02:00
return GetTime ( ) ;
2016-04-05 10:45:11 +02:00
CKeyPool keypool ;
CWalletDB walletdb ( strWalletFile ) ;
2017-01-17 09:43:12 +01:00
if ( IsHDEnabled ( ) & & CanSupportFeature ( FEATURE_HD_SPLIT ) )
{
// if HD & HD Chain Split is enabled, response max(oldest-internal-key, oldest-external-key)
int64_t now = GetTime ( ) ;
int64_t oldest_external = now , oldest_internal = now ;
for ( const int64_t & id : setKeyPool )
{
if ( ! walletdb . ReadPool ( id , keypool ) )
throw std : : runtime_error ( std : : string ( __func__ ) + " : read failed " ) ;
if ( keypool . fInternal & & keypool . nTime < oldest_internal )
oldest_internal = keypool . nTime ;
else if ( ! keypool . fInternal & & keypool . nTime < oldest_external )
oldest_external = keypool . nTime ;
}
return std : : max ( oldest_internal , oldest_external ) ;
}
// load oldest key from keypool, get time and return
2016-04-05 10:45:11 +02:00
int64_t nIndex = * ( setKeyPool . begin ( ) ) ;
if ( ! walletdb . ReadPool ( nIndex , keypool ) )
2017-01-27 02:33:45 +01:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : read oldest key in keypool failed " ) ;
2016-04-05 10:45:11 +02:00
assert ( keypool . vchPubKey . IsValid ( ) ) ;
2011-06-26 19:23:24 +02:00
return keypool . nTime ;
}
2014-04-23 00:46:19 +02:00
std : : map < CTxDestination , CAmount > CWallet : : GetAddressBalances ( )
2012-08-01 18:48:42 +02:00
{
2017-01-27 02:33:45 +01:00
std : : map < CTxDestination , CAmount > balances ;
2012-08-01 18:48:42 +02:00
{
LOCK ( cs_wallet ) ;
BOOST_FOREACH ( PAIRTYPE ( uint256 , CWalletTx ) walletEntry , mapWallet )
{
CWalletTx * pcoin = & walletEntry . second ;
2016-11-12 10:05:09 +01:00
if ( ! pcoin - > IsTrusted ( ) )
2012-08-01 18:48:42 +02:00
continue ;
if ( pcoin - > IsCoinBase ( ) & & pcoin - > GetBlocksToMaturity ( ) > 0 )
continue ;
int nDepth = pcoin - > GetDepthInMainChain ( ) ;
2014-07-01 11:00:22 +02:00
if ( nDepth < ( pcoin - > IsFromMe ( ISMINE_ALL ) ? 0 : 1 ) )
2012-08-01 18:48:42 +02:00
continue ;
2016-11-12 01:54:51 +01:00
for ( unsigned int i = 0 ; i < pcoin - > tx - > vout . size ( ) ; i + + )
2012-08-01 18:48:42 +02:00
{
2012-08-20 19:43:33 +02:00
CTxDestination addr ;
2016-11-12 01:54:51 +01:00
if ( ! IsMine ( pcoin - > tx - > vout [ i ] ) )
2012-08-01 18:48:42 +02:00
continue ;
2016-11-12 01:54:51 +01:00
if ( ! ExtractDestination ( pcoin - > tx - > vout [ i ] . scriptPubKey , addr ) )
2012-08-20 19:43:33 +02:00
continue ;
2012-08-01 18:48:42 +02:00
2016-11-12 01:54:51 +01:00
CAmount n = IsSpent ( walletEntry . first , i ) ? 0 : pcoin - > tx - > vout [ i ] . nValue ;
2012-08-01 18:48:42 +02:00
if ( ! balances . count ( addr ) )
balances [ addr ] = 0 ;
balances [ addr ] + = n ;
}
}
}
return balances ;
}
2017-01-27 02:33:45 +01:00
std : : set < std : : set < CTxDestination > > CWallet : : GetAddressGroupings ( )
2012-08-01 18:48:42 +02:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // mapWallet
2017-01-27 02:33:45 +01:00
std : : set < std : : set < CTxDestination > > groupings ;
std : : set < CTxDestination > grouping ;
2012-08-01 18:48:42 +02:00
BOOST_FOREACH ( PAIRTYPE ( uint256 , CWalletTx ) walletEntry , mapWallet )
{
CWalletTx * pcoin = & walletEntry . second ;
2016-11-12 01:54:51 +01:00
if ( pcoin - > tx - > vin . size ( ) > 0 )
2012-08-01 18:48:42 +02:00
{
2012-09-27 19:29:35 +02:00
bool any_mine = false ;
2012-08-01 18:48:42 +02:00
// group all input addresses with each other
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( CTxIn txin , pcoin - > tx - > vin )
2012-08-20 19:43:33 +02:00
{
CTxDestination address ;
2012-09-27 19:29:35 +02:00
if ( ! IsMine ( txin ) ) /* If this input isn't mine, ignore it */
continue ;
2016-11-12 01:54:51 +01:00
if ( ! ExtractDestination ( mapWallet [ txin . prevout . hash ] . tx - > vout [ txin . prevout . n ] . scriptPubKey , address ) )
2012-08-20 19:43:33 +02:00
continue ;
grouping . insert ( address ) ;
2012-09-27 19:29:35 +02:00
any_mine = true ;
2012-08-20 19:43:33 +02:00
}
2012-08-01 18:48:42 +02:00
// group change with input addresses
2012-09-27 19:29:35 +02:00
if ( any_mine )
{
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( CTxOut txout , pcoin - > tx - > vout )
2012-09-27 19:29:35 +02:00
if ( IsChange ( txout ) )
{
CTxDestination txoutAddr ;
if ( ! ExtractDestination ( txout . scriptPubKey , txoutAddr ) )
continue ;
grouping . insert ( txoutAddr ) ;
}
}
if ( grouping . size ( ) > 0 )
{
groupings . insert ( grouping ) ;
grouping . clear ( ) ;
}
2012-08-01 18:48:42 +02:00
}
// group lone addrs by themselves
2016-11-12 01:54:51 +01:00
for ( unsigned int i = 0 ; i < pcoin - > tx - > vout . size ( ) ; i + + )
if ( IsMine ( pcoin - > tx - > vout [ i ] ) )
2012-08-01 18:48:42 +02:00
{
2012-08-20 19:43:33 +02:00
CTxDestination address ;
2016-11-12 01:54:51 +01:00
if ( ! ExtractDestination ( pcoin - > tx - > vout [ i ] . scriptPubKey , address ) )
2012-08-20 19:43:33 +02:00
continue ;
grouping . insert ( address ) ;
2012-08-01 18:48:42 +02:00
groupings . insert ( grouping ) ;
grouping . clear ( ) ;
}
}
2017-01-27 02:33:45 +01:00
std : : set < std : : set < CTxDestination > * > uniqueGroupings ; // a set of pointers to groups of addresses
std : : map < CTxDestination , std : : set < CTxDestination > * > setmap ; // map addresses to the unique group containing it
BOOST_FOREACH ( std : : set < CTxDestination > _grouping , groupings )
2012-08-01 18:48:42 +02:00
{
// make a set of all the groups hit by this new group
2017-01-27 02:33:45 +01:00
std : : set < std : : set < CTxDestination > * > hits ;
std : : map < CTxDestination , std : : set < CTxDestination > * > : : iterator it ;
2016-09-02 18:19:01 +02:00
BOOST_FOREACH ( CTxDestination address , _grouping )
2012-08-01 18:48:42 +02:00
if ( ( it = setmap . find ( address ) ) ! = setmap . end ( ) )
hits . insert ( ( * it ) . second ) ;
// merge all hit groups into a new single group and delete old groups
2017-01-27 02:33:45 +01:00
std : : set < CTxDestination > * merged = new std : : set < CTxDestination > ( _grouping ) ;
BOOST_FOREACH ( std : : set < CTxDestination > * hit , hits )
2012-08-01 18:48:42 +02:00
{
merged - > insert ( hit - > begin ( ) , hit - > end ( ) ) ;
uniqueGroupings . erase ( hit ) ;
delete hit ;
}
uniqueGroupings . insert ( merged ) ;
// update setmap
2012-08-20 19:43:33 +02:00
BOOST_FOREACH ( CTxDestination element , * merged )
2012-08-01 18:48:42 +02:00
setmap [ element ] = merged ;
}
2017-01-27 02:33:45 +01:00
std : : set < std : : set < CTxDestination > > ret ;
BOOST_FOREACH ( std : : set < CTxDestination > * uniqueGrouping , uniqueGroupings )
2012-08-01 18:48:42 +02:00
{
ret . insert ( * uniqueGrouping ) ;
delete uniqueGrouping ;
}
return ret ;
}
2016-05-17 02:11:24 +02:00
CAmount CWallet : : GetAccountBalance ( const std : : string & strAccount , int nMinDepth , const isminefilter & filter )
{
CWalletDB walletdb ( strWalletFile ) ;
return GetAccountBalance ( walletdb , strAccount , nMinDepth , filter ) ;
}
CAmount CWallet : : GetAccountBalance ( CWalletDB & walletdb , const std : : string & strAccount , int nMinDepth , const isminefilter & filter )
{
CAmount nBalance = 0 ;
// Tally wallet transactions
2017-01-27 02:33:45 +01:00
for ( std : : map < uint256 , CWalletTx > : : iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; + + it )
2016-05-17 02:11:24 +02:00
{
const CWalletTx & wtx = ( * it ) . second ;
if ( ! CheckFinalTx ( wtx ) | | wtx . GetBlocksToMaturity ( ) > 0 | | wtx . GetDepthInMainChain ( ) < 0 )
continue ;
CAmount nReceived , nSent , nFee ;
wtx . GetAccountAmounts ( strAccount , nReceived , nSent , nFee , filter ) ;
if ( nReceived ! = 0 & & wtx . GetDepthInMainChain ( ) > = nMinDepth )
nBalance + = nReceived ;
nBalance - = nSent + nFee ;
}
// Tally internal accounting entries
nBalance + = walletdb . GetAccountCreditDebit ( strAccount ) ;
return nBalance ;
}
2015-05-31 15:36:44 +02:00
std : : set < CTxDestination > CWallet : : GetAccountAddresses ( const std : : string & strAccount ) const
2013-07-16 01:01:09 +02:00
{
2014-11-28 19:11:49 +01:00
LOCK ( cs_wallet ) ;
2017-01-27 02:33:45 +01:00
std : : set < CTxDestination > result ;
2013-07-16 01:01:09 +02:00
BOOST_FOREACH ( const PAIRTYPE ( CTxDestination , CAddressBookData ) & item , mapAddressBook )
{
const CTxDestination & address = item . first ;
2017-01-27 02:33:45 +01:00
const std : : string & strName = item . second . name ;
2013-07-16 01:01:09 +02:00
if ( strName = = strAccount )
result . insert ( address ) ;
}
return result ;
}
2017-01-10 16:45:30 +01:00
bool CReserveKey : : GetReservedKey ( CPubKey & pubkey , bool internal )
2011-06-26 19:23:24 +02:00
{
if ( nIndex = = - 1 )
{
CKeyPool keypool ;
2017-01-10 16:45:30 +01:00
pwallet - > ReserveKeyFromKeyPool ( nIndex , keypool , internal ) ;
2011-07-14 03:11:40 +02:00
if ( nIndex ! = - 1 )
vchPubKey = keypool . vchPubKey ;
2013-04-25 19:30:28 +02:00
else {
2014-06-16 14:45:32 +02:00
return false ;
2011-07-14 03:28:31 +02:00
}
2011-06-26 19:23:24 +02:00
}
2012-05-14 19:07:52 +02:00
assert ( vchPubKey . IsValid ( ) ) ;
2013-04-25 19:30:28 +02:00
pubkey = vchPubKey ;
return true ;
2011-06-26 19:23:24 +02:00
}
void CReserveKey : : KeepKey ( )
{
if ( nIndex ! = - 1 )
pwallet - > KeepKey ( nIndex ) ;
nIndex = - 1 ;
2012-05-14 19:07:52 +02:00
vchPubKey = CPubKey ( ) ;
2011-06-26 19:23:24 +02:00
}
void CReserveKey : : ReturnKey ( )
{
if ( nIndex ! = - 1 )
pwallet - > ReturnKey ( nIndex ) ;
nIndex = - 1 ;
2012-05-14 19:07:52 +02:00
vchPubKey = CPubKey ( ) ;
2011-06-26 19:23:24 +02:00
}
2011-07-07 15:22:54 +02:00
2017-01-27 02:33:45 +01:00
void CWallet : : GetAllReserveKeys ( std : : set < CKeyID > & setAddress ) const
2011-07-11 21:49:45 +02:00
{
setAddress . clear ( ) ;
CWalletDB walletdb ( strWalletFile ) ;
2012-04-06 18:39:12 +02:00
LOCK2 ( cs_main , cs_wallet ) ;
2013-04-13 07:13:08 +02:00
BOOST_FOREACH ( const int64_t & id , setKeyPool )
2011-07-11 21:49:45 +02:00
{
CKeyPool keypool ;
if ( ! walletdb . ReadPool ( id , keypool ) )
2017-01-27 02:33:45 +01:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : read failed " ) ;
2012-05-14 19:07:52 +02:00
assert ( keypool . vchPubKey . IsValid ( ) ) ;
2012-05-14 23:44:52 +02:00
CKeyID keyID = keypool . vchPubKey . GetID ( ) ;
if ( ! HaveKey ( keyID ) )
2017-01-27 02:33:45 +01:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : unknown key in key pool " ) ;
2012-05-14 23:44:52 +02:00
setAddress . insert ( keyID ) ;
2011-07-11 21:49:45 +02:00
}
}
2012-05-05 16:07:14 +02:00
void CWallet : : UpdatedTransaction ( const uint256 & hashTx )
{
{
LOCK ( cs_wallet ) ;
// Only notify UI if this transaction is in this wallet
2017-01-27 02:33:45 +01:00
std : : map < uint256 , CWalletTx > : : const_iterator mi = mapWallet . find ( hashTx ) ;
2012-05-05 16:07:14 +02:00
if ( mi ! = mapWallet . end ( ) )
NotifyTransactionChanged ( this , hashTx , CT_UPDATED ) ;
}
}
2012-09-27 19:52:09 +02:00
2015-07-01 08:32:30 +02:00
void CWallet : : GetScriptForMining ( boost : : shared_ptr < CReserveScript > & script )
2015-04-10 12:49:01 +02:00
{
2015-07-01 08:32:30 +02:00
boost : : shared_ptr < CReserveKey > rKey ( new CReserveKey ( this ) ) ;
2015-04-10 12:49:01 +02:00
CPubKey pubkey ;
2015-07-01 08:32:30 +02:00
if ( ! rKey - > GetReservedKey ( pubkey ) )
2015-04-10 12:49:01 +02:00
return ;
2015-07-01 08:32:30 +02:00
script = rKey ;
script - > reserveScript = CScript ( ) < < ToByteVector ( pubkey ) < < OP_CHECKSIG ;
2015-04-10 12:49:01 +02:00
}
2016-03-30 03:04:22 +02:00
void CWallet : : LockCoin ( const COutPoint & output )
2012-09-27 19:52:09 +02:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // setLockedCoins
2012-09-27 19:52:09 +02:00
setLockedCoins . insert ( output ) ;
}
2016-03-30 03:04:22 +02:00
void CWallet : : UnlockCoin ( const COutPoint & output )
2012-09-27 19:52:09 +02:00
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // setLockedCoins
2012-09-27 19:52:09 +02:00
setLockedCoins . erase ( output ) ;
}
void CWallet : : UnlockAllCoins ( )
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // setLockedCoins
2012-09-27 19:52:09 +02:00
setLockedCoins . clear ( ) ;
}
bool CWallet : : IsLockedCoin ( uint256 hash , unsigned int n ) const
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // setLockedCoins
2012-09-27 19:52:09 +02:00
COutPoint outpt ( hash , n ) ;
return ( setLockedCoins . count ( outpt ) > 0 ) ;
}
void CWallet : : ListLockedCoins ( std : : vector < COutPoint > & vOutpts )
{
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // setLockedCoins
2012-09-27 19:52:09 +02:00
for ( std : : set < COutPoint > : : iterator it = setLockedCoins . begin ( ) ;
it ! = setLockedCoins . end ( ) ; it + + ) {
COutPoint outpt = ( * it ) ;
vOutpts . push_back ( outpt ) ;
}
}
2014-10-26 08:03:12 +01:00
/** @} */ // end of Actions
2014-08-27 17:46:30 +02:00
class CAffectedKeysVisitor : public boost : : static_visitor < void > {
private :
const CKeyStore & keystore ;
std : : vector < CKeyID > & vKeys ;
public :
CAffectedKeysVisitor ( const CKeyStore & keystoreIn , std : : vector < CKeyID > & vKeysIn ) : keystore ( keystoreIn ) , vKeys ( vKeysIn ) { }
void Process ( const CScript & script ) {
txnouttype type ;
std : : vector < CTxDestination > vDest ;
int nRequired ;
if ( ExtractDestinations ( script , type , vDest , nRequired ) ) {
BOOST_FOREACH ( const CTxDestination & dest , vDest )
boost : : apply_visitor ( * this , dest ) ;
}
}
void operator ( ) ( const CKeyID & keyId ) {
if ( keystore . HaveKey ( keyId ) )
vKeys . push_back ( keyId ) ;
}
void operator ( ) ( const CScriptID & scriptId ) {
CScript script ;
if ( keystore . GetCScript ( scriptId , script ) )
Process ( script ) ;
}
void operator ( ) ( const CNoDestination & none ) { }
} ;
2016-11-08 22:55:02 +01:00
void CWallet : : GetKeyBirthTimes ( std : : map < CTxDestination , int64_t > & mapKeyBirth ) const {
2013-12-12 08:07:59 +01:00
AssertLockHeld ( cs_wallet ) ; // mapKeyMetadata
2013-04-29 19:50:40 +02:00
mapKeyBirth . clear ( ) ;
// get birth times for keys with metadata
2016-11-08 22:55:02 +01:00
for ( const auto & entry : mapKeyMetadata ) {
if ( entry . second . nCreateTime ) {
mapKeyBirth [ entry . first ] = entry . second . nCreateTime ;
}
}
2013-04-29 19:50:40 +02:00
// map in which we'll infer heights of other keys
2016-08-13 19:21:13 +02:00
CBlockIndex * pindexMax = chainActive [ std : : max ( 0 , chainActive . Height ( ) - 144 ) ] ; // the tip can be reorganized; use a 144-block safety margin
2013-04-29 19:50:40 +02:00
std : : map < CKeyID , CBlockIndex * > mapKeyFirstBlock ;
std : : set < CKeyID > setKeys ;
GetKeys ( setKeys ) ;
BOOST_FOREACH ( const CKeyID & keyid , setKeys ) {
if ( mapKeyBirth . count ( keyid ) = = 0 )
mapKeyFirstBlock [ keyid ] = pindexMax ;
}
setKeys . clear ( ) ;
// if there are no such keys, we're done
if ( mapKeyFirstBlock . empty ( ) )
return ;
// find first block that affects those keys, if there are any left
std : : vector < CKeyID > vAffected ;
for ( std : : map < uint256 , CWalletTx > : : const_iterator it = mapWallet . begin ( ) ; it ! = mapWallet . end ( ) ; it + + ) {
// iterate over all wallet transactions...
const CWalletTx & wtx = ( * it ) . second ;
2014-09-04 02:02:44 +02:00
BlockMap : : const_iterator blit = mapBlockIndex . find ( wtx . hashBlock ) ;
2013-10-10 23:07:44 +02:00
if ( blit ! = mapBlockIndex . end ( ) & & chainActive . Contains ( blit - > second ) ) {
2013-04-29 19:50:40 +02:00
// ... which are already in a block
int nHeight = blit - > second - > nHeight ;
2016-11-12 01:54:51 +01:00
BOOST_FOREACH ( const CTxOut & txout , wtx . tx - > vout ) {
2013-04-29 19:50:40 +02:00
// iterate over all their outputs
2014-08-27 17:46:30 +02:00
CAffectedKeysVisitor ( * this , vAffected ) . Process ( txout . scriptPubKey ) ;
2013-04-29 19:50:40 +02:00
BOOST_FOREACH ( const CKeyID & keyid , vAffected ) {
// ... and all their affected keys
std : : map < CKeyID , CBlockIndex * > : : iterator rit = mapKeyFirstBlock . find ( keyid ) ;
if ( rit ! = mapKeyFirstBlock . end ( ) & & nHeight < rit - > second - > nHeight )
rit - > second = blit - > second ;
}
vAffected . clear ( ) ;
}
}
}
// Extract block timestamps for those keys
for ( std : : map < CKeyID , CBlockIndex * > : : const_iterator it = mapKeyFirstBlock . begin ( ) ; it ! = mapKeyFirstBlock . end ( ) ; it + + )
2017-03-02 18:20:34 +01:00
mapKeyBirth [ it - > first ] = it - > second - > GetBlockTime ( ) - TIMESTAMP_WINDOW ; // block times can be 2h off
2013-04-29 19:50:40 +02:00
}
2013-11-18 16:55:54 +01:00
2016-12-19 16:51:45 +01:00
/**
* Compute smart timestamp for a transaction being added to the wallet .
*
* Logic :
* - If sending a transaction , assign its timestamp to the current time .
* - If receiving a transaction outside a block , assign its timestamp to the
* current time .
* - If receiving a block with a future timestamp , assign all its ( not already
* known ) transactions ' timestamps to the current time .
* - If receiving a block with a past timestamp , before the most recent known
* transaction ( that we care about ) , assign all its ( not already known )
* transactions ' timestamps to the same timestamp as that most - recent - known
* transaction .
* - If receiving a block with a past timestamp , but after the most recent known
* transaction , assign all its ( not already known ) transactions ' timestamps to
* the block time .
*
* For more information see CWalletTx : : nTimeSmart ,
* https : //bitcointalk.org/?topic=54527, or
* https : //github.com/bitcoin/bitcoin/pull/1393.
*/
2016-12-16 16:00:26 +01:00
unsigned int CWallet : : ComputeTimeSmart ( const CWalletTx & wtx ) const
{
unsigned int nTimeSmart = wtx . nTimeReceived ;
2017-02-10 21:00:30 +01:00
if ( ! wtx . hashUnset ( ) ) {
if ( mapBlockIndex . count ( wtx . hashBlock ) ) {
2016-12-16 16:00:26 +01:00
int64_t latestNow = wtx . nTimeReceived ;
int64_t latestEntry = 0 ;
2017-02-10 21:00:30 +01:00
// Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
int64_t latestTolerated = latestNow + 300 ;
const TxItems & txOrdered = wtxOrdered ;
for ( auto it = txOrdered . rbegin ( ) ; it ! = txOrdered . rend ( ) ; + + it ) {
CWalletTx * const pwtx = it - > second . first ;
if ( pwtx = = & wtx ) {
continue ;
}
CAccountingEntry * const pacentry = it - > second . second ;
int64_t nSmartTime ;
if ( pwtx ) {
nSmartTime = pwtx - > nTimeSmart ;
if ( ! nSmartTime ) {
nSmartTime = pwtx - > nTimeReceived ;
2016-12-16 16:00:26 +01:00
}
2017-02-10 21:00:30 +01:00
} else {
nSmartTime = pacentry - > nTime ;
}
if ( nSmartTime < = latestTolerated ) {
latestEntry = nSmartTime ;
if ( nSmartTime > latestNow ) {
latestNow = nSmartTime ;
2016-12-16 16:00:26 +01:00
}
2017-02-10 21:00:30 +01:00
break ;
2016-12-16 16:00:26 +01:00
}
}
int64_t blocktime = mapBlockIndex [ wtx . hashBlock ] - > GetBlockTime ( ) ;
nTimeSmart = std : : max ( latestEntry , std : : min ( blocktime , latestNow ) ) ;
2017-02-10 21:00:30 +01:00
} else {
LogPrintf ( " %s: found %s in block %s not in index \n " , __func__ , wtx . GetHash ( ) . ToString ( ) , wtx . hashBlock . ToString ( ) ) ;
2016-12-16 16:00:26 +01:00
}
}
return nTimeSmart ;
}
2013-11-18 16:55:54 +01:00
bool CWallet : : AddDestData ( const CTxDestination & dest , const std : : string & key , const std : : string & value )
{
2014-01-14 05:05:43 +01:00
if ( boost : : get < CNoDestination > ( & dest ) )
return false ;
2013-11-18 16:55:54 +01:00
mapAddressBook [ dest ] . destdata . insert ( std : : make_pair ( key , value ) ) ;
if ( ! fFileBacked )
return true ;
return CWalletDB ( strWalletFile ) . WriteDestData ( CBitcoinAddress ( dest ) . ToString ( ) , key , value ) ;
}
bool CWallet : : EraseDestData ( const CTxDestination & dest , const std : : string & key )
{
if ( ! mapAddressBook [ dest ] . destdata . erase ( key ) )
return false ;
if ( ! fFileBacked )
return true ;
return CWalletDB ( strWalletFile ) . EraseDestData ( CBitcoinAddress ( dest ) . ToString ( ) , key ) ;
}
bool CWallet : : LoadDestData ( const CTxDestination & dest , const std : : string & key , const std : : string & value )
{
mapAddressBook [ dest ] . destdata . insert ( std : : make_pair ( key , value ) ) ;
return true ;
}
bool CWallet : : GetDestData ( const CTxDestination & dest , const std : : string & key , std : : string * value ) const
{
std : : map < CTxDestination , CAddressBookData > : : const_iterator i = mapAddressBook . find ( dest ) ;
if ( i ! = mapAddressBook . end ( ) )
{
CAddressBookData : : StringMap : : const_iterator j = i - > second . destdata . find ( key ) ;
if ( j ! = i - > second . destdata . end ( ) )
{
if ( value )
* value = j - > second ;
return true ;
}
}
return false ;
}
2014-08-21 05:04:43 +02:00
2016-02-22 10:48:44 +01:00
std : : string CWallet : : GetWalletHelpString ( bool showDebug )
{
std : : string strUsage = HelpMessageGroup ( _ ( " Wallet options: " ) ) ;
strUsage + = HelpMessageOpt ( " -disablewallet " , _ ( " Do not load the wallet and disable wallet RPC calls " ) ) ;
strUsage + = HelpMessageOpt ( " -keypool=<n> " , strprintf ( _ ( " Set key pool size to <n> (default: %u) " ) , DEFAULT_KEYPOOL_SIZE ) ) ;
strUsage + = HelpMessageOpt ( " -fallbackfee=<amt> " , strprintf ( _ ( " A fee rate (in %s/kB) that will be used when fee estimation has insufficient data (default: %s) " ) ,
CURRENCY_UNIT , FormatMoney ( DEFAULT_FALLBACK_FEE ) ) ) ;
strUsage + = HelpMessageOpt ( " -mintxfee=<amt> " , strprintf ( _ ( " Fees (in %s/kB) smaller than this are considered zero fee for transaction creation (default: %s) " ) ,
CURRENCY_UNIT , FormatMoney ( DEFAULT_TRANSACTION_MINFEE ) ) ) ;
strUsage + = HelpMessageOpt ( " -paytxfee=<amt> " , strprintf ( _ ( " Fee (in %s/kB) to add to transactions you send (default: %s) " ) ,
CURRENCY_UNIT , FormatMoney ( payTxFee . GetFeePerK ( ) ) ) ) ;
strUsage + = HelpMessageOpt ( " -rescan " , _ ( " Rescan the block chain for missing wallet transactions on startup " ) ) ;
2016-02-26 12:48:53 +01:00
strUsage + = HelpMessageOpt ( " -salvagewallet " , _ ( " Attempt to recover private keys from a corrupt wallet on startup " ) ) ;
2016-02-22 10:48:44 +01:00
strUsage + = HelpMessageOpt ( " -spendzeroconfchange " , strprintf ( _ ( " Spend unconfirmed change when sending transactions (default: %u) " ) , DEFAULT_SPEND_ZEROCONF_CHANGE ) ) ;
strUsage + = HelpMessageOpt ( " -txconfirmtarget=<n> " , strprintf ( _ ( " If paytxfee is not set, include enough fee so transactions begin confirmation on average within n blocks (default: %u) " ) , DEFAULT_TX_CONFIRM_TARGET ) ) ;
2016-06-23 12:25:04 +02:00
strUsage + = HelpMessageOpt ( " -usehd " , _ ( " Use hierarchical deterministic key generation (HD) after BIP32. Only has effect during wallet creation/first start " ) + " " + strprintf ( _ ( " (default: %u) " ) , DEFAULT_USE_HD_WALLET ) ) ;
2016-09-01 15:24:45 +02:00
strUsage + = HelpMessageOpt ( " -walletrbf " , strprintf ( _ ( " Send transactions with full-RBF opt-in enabled (default: %u) " ) , DEFAULT_WALLET_RBF ) ) ;
2016-02-22 10:48:44 +01:00
strUsage + = HelpMessageOpt ( " -upgradewallet " , _ ( " Upgrade wallet to latest format on startup " ) ) ;
strUsage + = HelpMessageOpt ( " -wallet=<file> " , _ ( " Specify wallet file (within data directory) " ) + " " + strprintf ( _ ( " (default: %s) " ) , DEFAULT_WALLET_DAT ) ) ;
strUsage + = HelpMessageOpt ( " -walletbroadcast " , _ ( " Make the wallet broadcast transactions " ) + " " + strprintf ( _ ( " (default: %u) " ) , DEFAULT_WALLETBROADCAST ) ) ;
strUsage + = HelpMessageOpt ( " -walletnotify=<cmd> " , _ ( " Execute command when a wallet transaction changes (%s in cmd is replaced by TxID) " ) ) ;
strUsage + = HelpMessageOpt ( " -zapwallettxes=<mode> " , _ ( " Delete all wallet transactions and only recover those parts of the blockchain through -rescan on startup " ) +
" " + _ ( " (1 = keep tx meta data e.g. account owner and payment request information, 2 = drop tx meta data) " ) ) ;
if ( showDebug )
{
strUsage + = HelpMessageGroup ( _ ( " Wallet debugging/testing options: " ) ) ;
strUsage + = HelpMessageOpt ( " -dblogsize=<n> " , strprintf ( " Flush wallet database activity from memory to disk log every <n> megabytes (default: %u) " , DEFAULT_WALLET_DBLOGSIZE ) ) ;
strUsage + = HelpMessageOpt ( " -flushwallet " , strprintf ( " Run a thread to flush wallet periodically (default: %u) " , DEFAULT_FLUSHWALLET ) ) ;
strUsage + = HelpMessageOpt ( " -privdb " , strprintf ( " Sets the DB_PRIVATE flag in the wallet db environment (default: %u) " , DEFAULT_WALLET_PRIVDB ) ) ;
2017-01-03 15:01:46 +01:00
strUsage + = HelpMessageOpt ( " -walletrejectlongchains " , strprintf ( _ ( " Wallet will not create transactions that violate mempool chain limits (default: %u) " ) , DEFAULT_WALLET_REJECT_LONG_CHAINS ) ) ;
2016-02-22 10:48:44 +01:00
}
return strUsage ;
}
2016-09-09 10:44:47 +02:00
CWallet * CWallet : : CreateWalletFromFile ( const std : : string walletFile )
2016-02-22 12:07:55 +01:00
{
// needed to restore wallet transaction meta data after -zapwallettxes
std : : vector < CWalletTx > vWtx ;
if ( GetBoolArg ( " -zapwallettxes " , false ) ) {
uiInterface . InitMessage ( _ ( " Zapping all transactions from wallet... " ) ) ;
2016-03-15 10:30:37 +01:00
CWallet * tempWallet = new CWallet ( walletFile ) ;
2016-02-22 12:07:55 +01:00
DBErrors nZapWalletRet = tempWallet - > ZapWalletTx ( vWtx ) ;
if ( nZapWalletRet ! = DB_LOAD_OK ) {
2016-09-09 10:44:47 +02:00
InitError ( strprintf ( _ ( " Error loading %s: Wallet corrupted " ) , walletFile ) ) ;
return NULL ;
2016-02-22 12:07:55 +01:00
}
delete tempWallet ;
tempWallet = NULL ;
}
uiInterface . InitMessage ( _ ( " Loading wallet... " ) ) ;
int64_t nStart = GetTimeMillis ( ) ;
bool fFirstRun = true ;
2016-03-15 10:30:37 +01:00
CWallet * walletInstance = new CWallet ( walletFile ) ;
2016-02-22 12:07:55 +01:00
DBErrors nLoadWalletRet = walletInstance - > LoadWallet ( fFirstRun ) ;
if ( nLoadWalletRet ! = DB_LOAD_OK )
{
2016-09-09 10:44:47 +02:00
if ( nLoadWalletRet = = DB_CORRUPT ) {
InitError ( strprintf ( _ ( " Error loading %s: Wallet corrupted " ) , walletFile ) ) ;
return NULL ;
}
2016-02-22 12:07:55 +01:00
else if ( nLoadWalletRet = = DB_NONCRITICAL_ERROR )
{
2016-03-21 18:29:17 +01:00
InitWarning ( strprintf ( _ ( " Error reading %s! All keys read correctly, but transaction data "
2016-02-26 12:48:53 +01:00
" or address book entries might be missing or incorrect. " ) ,
2016-03-15 10:30:37 +01:00
walletFile ) ) ;
2016-02-22 12:07:55 +01:00
}
2016-09-09 10:44:47 +02:00
else if ( nLoadWalletRet = = DB_TOO_NEW ) {
InitError ( strprintf ( _ ( " Error loading %s: Wallet requires newer version of %s " ) , walletFile , _ ( PACKAGE_NAME ) ) ) ;
return NULL ;
}
2016-02-22 12:07:55 +01:00
else if ( nLoadWalletRet = = DB_NEED_REWRITE )
{
2016-09-09 10:44:47 +02:00
InitError ( strprintf ( _ ( " Wallet needed to be rewritten: restart %s to complete " ) , _ ( PACKAGE_NAME ) ) ) ;
return NULL ;
}
else {
InitError ( strprintf ( _ ( " Error loading %s " ) , walletFile ) ) ;
return NULL ;
2016-02-22 12:07:55 +01:00
}
}
if ( GetBoolArg ( " -upgradewallet " , fFirstRun ) )
{
int nMaxVersion = GetArg ( " -upgradewallet " , 0 ) ;
if ( nMaxVersion = = 0 ) // the -upgradewallet without argument case
{
LogPrintf ( " Performing wallet upgrade to %i \n " , FEATURE_LATEST ) ;
nMaxVersion = CLIENT_VERSION ;
walletInstance - > SetMinVersion ( FEATURE_LATEST ) ; // permanently upgrade the wallet immediately
}
else
LogPrintf ( " Allowing wallet upgrade up to %i \n " , nMaxVersion ) ;
if ( nMaxVersion < walletInstance - > GetVersion ( ) )
2016-03-05 22:08:10 +01:00
{
2016-09-09 10:44:47 +02:00
InitError ( _ ( " Cannot downgrade wallet " ) ) ;
return NULL ;
2016-03-05 22:08:10 +01:00
}
2016-02-22 12:07:55 +01:00
walletInstance - > SetMaxVersion ( nMaxVersion ) ;
}
if ( fFirstRun )
{
// Create new keyUser and set as default key
2016-08-17 14:09:47 +02:00
if ( GetBoolArg ( " -usehd " , DEFAULT_USE_HD_WALLET ) & & ! walletInstance - > IsHDEnabled ( ) ) {
2016-01-02 12:34:08 +01:00
// generate a new master key
2016-07-21 21:19:02 +02:00
CPubKey masterPubKey = walletInstance - > GenerateNewHDMasterKey ( ) ;
if ( ! walletInstance - > SetHDMasterKey ( masterPubKey ) )
2016-08-19 18:31:35 +02:00
throw std : : runtime_error ( std : : string ( __func__ ) + " : Storing master key failed " ) ;
2017-01-17 09:07:48 +01:00
// ensure this wallet.dat can only be opened by clients supporting HD with chain split
walletInstance - > SetMinVersion ( FEATURE_HD_SPLIT ) ;
2016-01-02 12:34:08 +01:00
}
2016-02-22 12:07:55 +01:00
CPubKey newDefaultKey ;
2017-01-10 16:45:30 +01:00
if ( walletInstance - > GetKeyFromPool ( newDefaultKey , false ) ) {
2016-02-22 12:07:55 +01:00
walletInstance - > SetDefaultKey ( newDefaultKey ) ;
2016-09-09 10:44:47 +02:00
if ( ! walletInstance - > SetAddressBook ( walletInstance - > vchDefaultKey . GetID ( ) , " " , " receive " ) ) {
InitError ( _ ( " Cannot write default address " ) + = " \n " ) ;
return NULL ;
}
2016-02-22 12:07:55 +01:00
}
walletInstance - > SetBestChain ( chainActive . GetLocator ( ) ) ;
}
2016-11-30 02:51:30 +01:00
else if ( IsArgSet ( " -usehd " ) ) {
2016-06-13 16:27:41 +02:00
bool useHD = GetBoolArg ( " -usehd " , DEFAULT_USE_HD_WALLET ) ;
2016-09-09 10:44:47 +02:00
if ( walletInstance - > IsHDEnabled ( ) & & ! useHD ) {
InitError ( strprintf ( _ ( " Error loading %s: You can't disable HD on a already existing HD wallet " ) , walletFile ) ) ;
return NULL ;
}
if ( ! walletInstance - > IsHDEnabled ( ) & & useHD ) {
InitError ( strprintf ( _ ( " Error loading %s: You can't enable HD on a already existing non-HD wallet " ) , walletFile ) ) ;
return NULL ;
}
2016-06-13 16:27:41 +02:00
}
2016-02-22 12:07:55 +01:00
LogPrintf ( " wallet %15dms \n " , GetTimeMillis ( ) - nStart ) ;
RegisterValidationInterface ( walletInstance ) ;
2017-01-18 17:59:10 +01:00
CBlockIndex * pindexRescan = chainActive . Genesis ( ) ;
if ( ! GetBoolArg ( " -rescan " , false ) )
2016-02-22 12:07:55 +01:00
{
2016-03-15 10:30:37 +01:00
CWalletDB walletdb ( walletFile ) ;
2016-02-22 12:07:55 +01:00
CBlockLocator locator ;
if ( walletdb . ReadBestBlock ( locator ) )
pindexRescan = FindForkInGlobalIndex ( chainActive , locator ) ;
}
if ( chainActive . Tip ( ) & & chainActive . Tip ( ) ! = pindexRescan )
{
//We can't rescan beyond non-pruned blocks, stop and throw an error
//this might happen if a user uses a old wallet within a pruned node
// or if he ran -disablewallet for a longer time, then decided to re-enable
if ( fPruneMode )
{
CBlockIndex * block = chainActive . Tip ( ) ;
while ( block & & block - > pprev & & ( block - > pprev - > nStatus & BLOCK_HAVE_DATA ) & & block - > pprev - > nTx > 0 & & pindexRescan ! = block )
block = block - > pprev ;
2016-09-09 10:44:47 +02:00
if ( pindexRescan ! = block ) {
InitError ( _ ( " Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of pruned node) " ) ) ;
return NULL ;
}
2016-02-22 12:07:55 +01:00
}
uiInterface . InitMessage ( _ ( " Rescanning... " ) ) ;
LogPrintf ( " Rescanning last %i blocks (from block %i)... \n " , chainActive . Height ( ) - pindexRescan - > nHeight , pindexRescan - > nHeight ) ;
nStart = GetTimeMillis ( ) ;
walletInstance - > ScanForWalletTransactions ( pindexRescan , true ) ;
LogPrintf ( " rescan %15dms \n " , GetTimeMillis ( ) - nStart ) ;
walletInstance - > SetBestChain ( chainActive . GetLocator ( ) ) ;
2016-11-27 04:32:30 +01:00
CWalletDB : : IncrementUpdateCounter ( ) ;
2016-02-22 12:07:55 +01:00
// Restore wallet transaction metadata after -zapwallettxes=1
if ( GetBoolArg ( " -zapwallettxes " , false ) & & GetArg ( " -zapwallettxes " , " 1 " ) ! = " 2 " )
{
2016-03-15 10:30:37 +01:00
CWalletDB walletdb ( walletFile ) ;
2016-02-22 12:07:55 +01:00
BOOST_FOREACH ( const CWalletTx & wtxOld , vWtx )
{
uint256 hash = wtxOld . GetHash ( ) ;
std : : map < uint256 , CWalletTx > : : iterator mi = walletInstance - > mapWallet . find ( hash ) ;
if ( mi ! = walletInstance - > mapWallet . end ( ) )
{
const CWalletTx * copyFrom = & wtxOld ;
CWalletTx * copyTo = & mi - > second ;
copyTo - > mapValue = copyFrom - > mapValue ;
copyTo - > vOrderForm = copyFrom - > vOrderForm ;
copyTo - > nTimeReceived = copyFrom - > nTimeReceived ;
copyTo - > nTimeSmart = copyFrom - > nTimeSmart ;
copyTo - > fFromMe = copyFrom - > fFromMe ;
copyTo - > strFromAccount = copyFrom - > strFromAccount ;
copyTo - > nOrderPos = copyFrom - > nOrderPos ;
2016-05-09 09:15:12 +02:00
walletdb . WriteTx ( * copyTo ) ;
2016-02-22 12:07:55 +01:00
}
}
}
}
walletInstance - > SetBroadcastTransactions ( GetBoolArg ( " -walletbroadcast " , DEFAULT_WALLETBROADCAST ) ) ;
2016-08-20 00:50:48 +02:00
{
LOCK ( walletInstance - > cs_wallet ) ;
LogPrintf ( " setKeyPool.size() = %u \n " , walletInstance - > GetKeyPoolSize ( ) ) ;
LogPrintf ( " mapWallet.size() = %u \n " , walletInstance - > mapWallet . size ( ) ) ;
LogPrintf ( " mapAddressBook.size() = %u \n " , walletInstance - > mapAddressBook . size ( ) ) ;
}
2016-09-09 10:44:47 +02:00
return walletInstance ;
}
bool CWallet : : InitLoadWallet ( )
{
if ( GetBoolArg ( " -disablewallet " , DEFAULT_DISABLE_WALLET ) ) {
pwalletMain = NULL ;
LogPrintf ( " Wallet disabled! \n " ) ;
return true ;
}
std : : string walletFile = GetArg ( " -wallet " , DEFAULT_WALLET_DAT ) ;
2017-01-08 21:41:30 +01:00
if ( walletFile . find_first_of ( " / \\ " ) ! = std : : string : : npos ) {
return InitError ( _ ( " -wallet parameter must only specify a filename (not a path) " )) ;
} else if ( SanitizeString ( walletFile , SAFE_CHARS_FILENAME ) ! = walletFile ) {
return InitError ( _ ( " Invalid characters in -wallet filename " ) ) ;
}
2016-09-09 10:44:47 +02:00
CWallet * const pwallet = CreateWalletFromFile ( walletFile ) ;
if ( ! pwallet ) {
return false ;
}
pwalletMain = pwallet ;
2016-08-20 00:50:48 +02:00
2016-03-15 10:30:37 +01:00
return true ;
}
2017-02-08 19:19:18 +01:00
std : : atomic < bool > CWallet : : fFlushScheduled ( false ) ;
2016-09-09 10:15:01 +02:00
2017-02-08 19:19:18 +01:00
void CWallet : : postInitProcess ( CScheduler & scheduler )
2016-10-20 09:22:13 +02:00
{
// Add wallet transactions that aren't already in a block to mempool
// Do this here as mempool requires genesis block to be loaded
ReacceptWalletTransactions ( ) ;
// Run a thread to flush wallet periodically
2017-02-08 19:19:18 +01:00
if ( ! CWallet : : fFlushScheduled . exchange ( true ) ) {
2017-01-23 15:27:59 +01:00
scheduler . scheduleEvery ( MaybeCompactWalletDB , 500 ) ;
2016-09-09 10:15:01 +02:00
}
2016-10-20 09:22:13 +02:00
}
2016-03-15 10:30:37 +01:00
bool CWallet : : ParameterInteraction ( )
{
2016-09-21 12:15:18 +02:00
if ( GetBoolArg ( " -disablewallet " , DEFAULT_DISABLE_WALLET ) )
2016-09-19 16:09:38 +02:00
return true ;
2016-09-19 15:52:48 +02:00
if ( GetBoolArg ( " -blocksonly " , DEFAULT_BLOCKSONLY ) & & SoftSetBoolArg ( " -walletbroadcast " , false ) ) {
LogPrintf ( " %s: parameter interaction: -blocksonly=1 -> setting -walletbroadcast=0 \n " , __func__ ) ;
}
2016-11-12 10:23:57 +01:00
if ( GetBoolArg ( " -salvagewallet " , false ) & & SoftSetBoolArg ( " -rescan " , true ) ) {
// Rewrite just private keys: rescan to find transactions
LogPrintf ( " %s: parameter interaction: -salvagewallet=1 -> setting -rescan=1 \n " , __func__ ) ;
}
// -zapwallettx implies a rescan
if ( GetBoolArg ( " -zapwallettxes " , false ) & & SoftSetBoolArg ( " -rescan " , true ) ) {
LogPrintf ( " %s: parameter interaction: -zapwallettxes=<mode> -> setting -rescan=1 \n " , __func__ ) ;
}
2016-09-19 15:52:48 +02:00
if ( GetBoolArg ( " -sysperms " , false ) )
return InitError ( " -sysperms is not allowed in combination with enabled wallet functionality " ) ;
if ( GetArg ( " -prune " , 0 ) & & GetBoolArg ( " -rescan " , false ) )
return InitError ( _ ( " Rescans are not possible in pruned mode. You will need to use -reindex which will download the whole blockchain again. " ) ) ;
2016-01-08 01:14:09 +01:00
if ( : : minRelayTxFee . GetFeePerK ( ) > HIGH_TX_FEE_PER_KB )
InitWarning ( AmountHighWarn ( " -minrelaytxfee " ) + " " +
_ ( " The wallet will avoid paying less than the minimum relay fee. " ) ) ;
2016-11-30 02:51:30 +01:00
if ( IsArgSet ( " -mintxfee " ) )
2016-03-15 10:30:37 +01:00
{
CAmount n = 0 ;
2016-11-30 03:45:24 +01:00
if ( ! ParseMoney ( GetArg ( " -mintxfee " , " " ) , n ) | | 0 = = n )
return InitError ( AmountErrMsg ( " mintxfee " , GetArg ( " -mintxfee " , " " ) ) ) ;
2016-01-08 01:14:09 +01:00
if ( n > HIGH_TX_FEE_PER_KB )
InitWarning ( AmountHighWarn ( " -mintxfee " ) + " " +
_ ( " This is the minimum transaction fee you pay on every transaction. " ) ) ;
CWallet : : minTxFee = CFeeRate ( n ) ;
2016-03-15 10:30:37 +01:00
}
2016-11-30 02:51:30 +01:00
if ( IsArgSet ( " -fallbackfee " ) )
2016-03-15 10:30:37 +01:00
{
CAmount nFeePerK = 0 ;
2016-11-30 03:45:24 +01:00
if ( ! ParseMoney ( GetArg ( " -fallbackfee " , " " ) , nFeePerK ) )
return InitError ( strprintf ( _ ( " Invalid amount for -fallbackfee=<amount>: '%s' " ) , GetArg ( " -fallbackfee " , " " ) ) ) ;
2016-03-15 10:30:37 +01:00
if ( nFeePerK > HIGH_TX_FEE_PER_KB )
2016-01-08 01:14:09 +01:00
InitWarning ( AmountHighWarn ( " -fallbackfee " ) + " " +
_ ( " This is the transaction fee you may pay when fee estimates are not available. " ) ) ;
2016-03-15 10:30:37 +01:00
CWallet : : fallbackFee = CFeeRate ( nFeePerK ) ;
}
2016-11-30 02:51:30 +01:00
if ( IsArgSet ( " -paytxfee " ) )
2016-03-15 10:30:37 +01:00
{
CAmount nFeePerK = 0 ;
2016-11-30 03:45:24 +01:00
if ( ! ParseMoney ( GetArg ( " -paytxfee " , " " ) , nFeePerK ) )
return InitError ( AmountErrMsg ( " paytxfee " , GetArg ( " -paytxfee " , " " ) ) ) ;
2016-03-15 10:30:37 +01:00
if ( nFeePerK > HIGH_TX_FEE_PER_KB )
2016-01-08 01:14:09 +01:00
InitWarning ( AmountHighWarn ( " -paytxfee " ) + " " +
_ ( " This is the transaction fee you will pay if you send a transaction. " ) ) ;
2016-03-15 10:30:37 +01:00
payTxFee = CFeeRate ( nFeePerK , 1000 ) ;
if ( payTxFee < : : minRelayTxFee )
{
2016-03-21 18:29:17 +01:00
return InitError ( strprintf ( _ ( " Invalid amount for -paytxfee=<amount>: '%s' (must be at least %s) " ) ,
2016-11-30 03:45:24 +01:00
GetArg ( " -paytxfee " , " " ) , : : minRelayTxFee . ToString ( ) ) ) ;
2016-03-15 10:30:37 +01:00
}
}
2016-11-30 02:51:30 +01:00
if ( IsArgSet ( " -maxtxfee " ) )
2016-03-15 10:30:37 +01:00
{
CAmount nMaxFee = 0 ;
2016-11-30 03:45:24 +01:00
if ( ! ParseMoney ( GetArg ( " -maxtxfee " , " " ) , nMaxFee ) )
return InitError ( AmountErrMsg ( " maxtxfee " , GetArg ( " -maxtxfee " , " " ) ) ) ;
2016-03-15 10:30:37 +01:00
if ( nMaxFee > HIGH_MAX_TX_FEE )
2016-03-21 18:29:17 +01:00
InitWarning ( _ ( " -maxtxfee is set very high! Fees this large could be paid on a single transaction. " ) ) ;
2016-03-15 10:30:37 +01:00
maxTxFee = nMaxFee ;
if ( CFeeRate ( maxTxFee , 1000 ) < : : minRelayTxFee )
{
2016-03-21 18:29:17 +01:00
return InitError ( strprintf ( _ ( " Invalid amount for -maxtxfee=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions) " ) ,
2016-11-30 03:45:24 +01:00
GetArg ( " -maxtxfee " , " " ) , : : minRelayTxFee . ToString ( ) ) ) ;
2016-03-15 10:30:37 +01:00
}
}
nTxConfirmTarget = GetArg ( " -txconfirmtarget " , DEFAULT_TX_CONFIRM_TARGET ) ;
bSpendZeroConfChange = GetBoolArg ( " -spendzeroconfchange " , DEFAULT_SPEND_ZEROCONF_CHANGE ) ;
2016-09-01 15:24:45 +02:00
fWalletRbf = GetBoolArg ( " -walletrbf " , DEFAULT_WALLET_RBF ) ;
2016-03-15 10:30:37 +01:00
return true ;
2016-02-22 12:07:55 +01:00
}
2016-05-17 02:31:16 +02:00
bool CWallet : : BackupWallet ( const std : : string & strDest )
{
if ( ! fFileBacked )
return false ;
while ( true )
{
{
LOCK ( bitdb . cs_db ) ;
if ( ! bitdb . mapFileUseCount . count ( strWalletFile ) | | bitdb . mapFileUseCount [ strWalletFile ] = = 0 )
{
// Flush log data to the dat file
bitdb . CloseDb ( strWalletFile ) ;
bitdb . CheckpointLSN ( strWalletFile ) ;
bitdb . mapFileUseCount . erase ( strWalletFile ) ;
// Copy wallet file
boost : : filesystem : : path pathSrc = GetDataDir ( ) / strWalletFile ;
boost : : filesystem : : path pathDest ( strDest ) ;
if ( boost : : filesystem : : is_directory ( pathDest ) )
pathDest / = strWalletFile ;
try {
boost : : filesystem : : copy_file ( pathSrc , pathDest , boost : : filesystem : : copy_option : : overwrite_if_exists ) ;
LogPrintf ( " copied %s to %s \n " , strWalletFile , pathDest . string ( ) ) ;
return true ;
} catch ( const boost : : filesystem : : filesystem_error & e ) {
LogPrintf ( " error copying %s to %s - %s \n " , strWalletFile , pathDest . string ( ) , e . what ( ) ) ;
return false ;
}
}
}
MilliSleep ( 100 ) ;
}
return false ;
}
2014-08-21 05:04:43 +02:00
CKeyPool : : CKeyPool ( )
{
nTime = GetTime ( ) ;
2017-01-16 11:10:12 +01:00
fInternal = false ;
2014-08-21 05:04:43 +02:00
}
2017-01-10 16:45:30 +01:00
CKeyPool : : CKeyPool ( const CPubKey & vchPubKeyIn , bool internalIn )
2014-08-21 05:04:43 +02:00
{
nTime = GetTime ( ) ;
vchPubKey = vchPubKeyIn ;
2017-01-10 16:45:30 +01:00
fInternal = internalIn ;
2014-08-21 05:04:43 +02:00
}
CWalletKey : : CWalletKey ( int64_t nExpires )
{
nTimeCreated = ( nExpires ? GetTime ( ) : 0 ) ;
nTimeExpires = nExpires ;
}
2014-08-28 17:15:21 +02:00
2016-12-30 10:35:43 +01:00
void CMerkleTx : : SetMerkleBranch ( const CBlockIndex * pindex , int posInBlock )
2014-08-28 17:15:21 +02:00
{
2014-08-29 20:24:16 +02:00
// Update the tx's hashBlock
2016-04-26 13:55:13 +02:00
hashBlock = pindex - > GetBlockHash ( ) ;
2014-08-28 17:15:21 +02:00
2016-04-26 13:55:13 +02:00
// set the position of the transaction in the block
nIndex = posInBlock ;
2014-08-28 17:15:21 +02:00
}
2015-11-26 18:42:07 +01:00
int CMerkleTx : : GetDepthInMainChain ( const CBlockIndex * & pindexRet ) const
2014-08-28 17:15:21 +02:00
{
2016-01-07 22:31:27 +01:00
if ( hashUnset ( ) )
2014-08-28 17:15:21 +02:00
return 0 ;
2016-01-07 22:31:27 +01:00
2014-08-28 17:15:21 +02:00
AssertLockHeld ( cs_main ) ;
// Find the block it claims to be in
2014-09-04 02:02:44 +02:00
BlockMap : : iterator mi = mapBlockIndex . find ( hashBlock ) ;
2014-08-28 17:15:21 +02:00
if ( mi = = mapBlockIndex . end ( ) )
return 0 ;
CBlockIndex * pindex = ( * mi ) . second ;
if ( ! pindex | | ! chainActive . Contains ( pindex ) )
return 0 ;
pindexRet = pindex ;
2015-11-26 18:42:07 +01:00
return ( ( nIndex = = - 1 ) ? ( - 1 ) : 1 ) * ( chainActive . Height ( ) - pindex - > nHeight + 1 ) ;
2014-08-28 17:15:21 +02:00
}
int CMerkleTx : : GetBlocksToMaturity ( ) const
{
if ( ! IsCoinBase ( ) )
return 0 ;
2017-01-27 02:33:45 +01:00
return std : : max ( 0 , ( COINBASE_MATURITY + 1 ) - GetDepthInMainChain ( ) ) ;
2014-08-28 17:15:21 +02:00
}
2016-10-25 20:27:04 +02:00
bool CMerkleTx : : AcceptToMemoryPool ( const CAmount & nAbsurdFee , CValidationState & state )
2014-08-28 17:15:21 +02:00
{
2016-12-05 03:53:26 +01:00
return : : AcceptToMemoryPool ( mempool , state , tx , true , NULL , NULL , false , nAbsurdFee ) ;
2014-08-28 17:15:21 +02:00
}