#include "main.h"
using namespace std;
-
-
-bool fCoinsDataActual;
+extern int64_t nReserveBalance;
//////////////////////////////////////////////////////////////////////////////
//
{
int64_t nStartTime = GetTimeMillis();
crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
- pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));
+ double nFirstMultiplier = 1e2 / (GetTimeMillis() - nStartTime);
+ pMasterKey.second.nDeriveIterations = (uint32_t)(pMasterKey.second.nDeriveIterations *nFirstMultiplier);
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;
+ double nSecondMultiplier = 1e2 / (GetTimeMillis() - nStartTime);
+ pMasterKey.second.nDeriveIterations = (uint32_t)((pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * nSecondMultiplier) / 2);
if (pMasterKey.second.nDeriveIterations < 25000)
pMasterKey.second.nDeriveIterations = 25000;
CCrypter crypter;
int64_t nStartTime = GetTimeMillis();
crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
- kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));
+ int64_t nDivider = GetTimeMillis() - nStartTime;
+ kMasterKey.nDeriveIterations = (uint32_t)(25e5 / (double)(nDivider));
nStartTime = GetTimeMillis();
crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
- kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
+ double nMultiplier = 1e2 / (GetTimeMillis() - nStartTime);
+ kMasterKey.nDeriveIterations = (uint32_t)((kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * nMultiplier) / 2);
if (kMasterKey.nDeriveIterations < 25000)
kMasterKey.nDeriveIterations = 25000;
uint256 hash = tx.GetHash();
{
LOCK(cs_wallet);
- bool fExisted = mapWallet.count(hash);
+ bool fExisted = mapWallet.count(hash) != 0;
if (fExisted && !fUpdate) return false;
if (fExisted || IsMine(tx) || IsFromMe(tx))
{
{
// Do this infrequently and randomly to avoid giving away
// that these are our transactions.
- static int64_t nNextTime;
+ static int64_t nNextTime = GetRand(GetTime() + 30 * 60);
if (GetTime() < nNextTime)
return;
bool fFirst = (nNextTime == 0);
return;
// Only do it if there's been a new block since last time
- static int64_t nLastTime;
+ static int64_t nLastTime = 0;
if (nTimeBestReceived < nLastTime)
return;
nLastTime = GetTime();
return;
}
- CBigNum bnCoinDayWeight = CBigNum(nValue) * nTimeWeight / COIN / (24 * 60 * 60);
+ CBigNum bnCoinDayWeight = CBigNum(nValue) * nTimeWeight / COIN / nOneDay;
nWeight = bnCoinDayWeight.getuint64();
}
-
-// NovaCoin: get current stake miner statistics
-void CWallet::GetStakeStats(float &nKernelsRate, float &nCoinDaysRate)
-{
- static uint64_t nLastKernels = 0, nLastCoinDays = 0;
- static float nLastKernelsRate = 0, nLastCoinDaysRate = 0;
- static int64_t nLastTime = GetTime();
-
- if (nKernelsTried < nLastKernels)
- {
- nLastKernels = 0;
- nLastCoinDays = 0;
-
- nLastTime = GetTime();
- }
-
- int64_t nInterval = GetTime() - nLastTime;
- //if (nKernelsTried > 1000 && nInterval > 5)
- if (nInterval > 10)
- {
- nKernelsRate = nLastKernelsRate = ( nKernelsTried - nLastKernels ) / (float) nInterval;
- nCoinDaysRate = nLastCoinDaysRate = ( nCoinDaysTried - nLastCoinDays ) / (float) nInterval;
-
- nLastKernels = nKernelsTried;
- nLastCoinDays = nCoinDaysTried;
- nLastTime = GetTime();
- }
- else
- {
- nKernelsRate = nLastKernelsRate;
- nCoinDaysRate = nLastCoinDaysRate;
- }
-}
-
bool CWallet::MergeCoins(const int64_t& nAmount, const int64_t& nMinValue, const int64_t& nOutputValue, list<uint256>& listMerged)
{
int64_t nBalance = GetBalance();
return true;
}
-
-bool CWallet::CreateCoinStake(const CKeyStore& keystore, unsigned int nBits, uint32_t nSearchInterval, CTransaction& txNew, CKey& key)
+bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerationTime, uint32_t nBits, CTransaction &txNew, CKey& key)
{
- // The following combine threshold is important to security
- // Should not be adjusted if you don't understand the consequences
- int64_t nCombineThreshold = GetProofOfWorkReward(GetLastBlockIndex(pindexBest, false)->nBits) / 3;
-
- CBigNum bnTargetPerCoinDay;
- bnTargetPerCoinDay.SetCompact(nBits);
-
- txNew.vin.clear();
- txNew.vout.clear();
+ CWalletTx wtx;
+ if (!GetTransaction(hashTx, wtx))
+ return error("Transaction %s is not found\n", hashTx.GetHex().c_str());
- // Mark coin stake transaction
- CScript scriptEmpty;
- scriptEmpty.clear();
- txNew.vout.push_back(CTxOut(0, scriptEmpty));
-
- // Choose coins to use
- int64_t nBalance = GetBalance();
- int64_t nReserveBalance = 0;
-
- if (mapArgs.count("-reservebalance") && !ParseMoney(mapArgs["-reservebalance"], nReserveBalance))
- return error("CreateCoinStake : invalid reserve balance amount");
+ vector<valtype> vSolutions;
+ txnouttype whichType;
+ CScript scriptPubKeyOut;
+ CScript scriptPubKeyKernel = wtx.vout[nOut].scriptPubKey;
+ if (!Solver(scriptPubKeyKernel, whichType, vSolutions))
+ return error("CreateCoinStake : failed to parse kernel\n");
- if (nBalance <= nReserveBalance)
- return false;
+ if (fDebug && GetBoolArg("-printcoinstake"))
+ printf("CreateCoinStake : parsed kernel type=%d\n", whichType);
- vector<const CWalletTx*> vwtxPrev;
+ if (whichType != TX_PUBKEY && whichType != TX_PUBKEYHASH)
+ return error("CreateCoinStake : no support for kernel type=%d\n", whichType);
- CTxDB txdb("r");
+ if (whichType == TX_PUBKEYHASH) // pay to address type
{
- LOCK2(cs_main, cs_wallet);
- // Cache outputs unless best block or wallet transaction set changed
- if (!fCoinsDataActual)
- {
- mapMeta.clear();
- int64_t nValueIn = 0;
- CoinsSet setCoins;
- if (!SelectCoinsSimple(nBalance - nReserveBalance, MIN_TX_FEE, MAX_MONEY, txNew.nTime, nCoinbaseMaturity * 10, setCoins, nValueIn))
- return false;
+ // convert to pay to public key type
+ if (!GetKey(uint160(vSolutions[0]), key))
+ return error("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
- if (setCoins.empty())
- return false;
-
- {
- CTxIndex txindex;
- CBlock block;
- for(CoinsSet::iterator pcoin = setCoins.begin(); pcoin != setCoins.end(); pcoin++)
- {
- // Load transaction index item
- if (!txdb.ReadTxIndex(pcoin->first->GetHash(), txindex))
- continue;
-
- // Read block header
- if (!block.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos, false))
- continue;
-
- uint64_t nStakeModifier = 0;
- if (!GetKernelStakeModifier(block.GetHash(), nStakeModifier))
- continue;
-
- // Add meta record
- // (txid, vout.n) => ((txindex, (tx, vout.n)), (block, modifier))
- mapMeta[make_pair(pcoin->first->GetHash(), pcoin->second)] = make_pair(make_pair(txindex, *pcoin), make_pair(block, nStakeModifier));
-
- if (fDebug)
- printf("Load coin: %s\n", pcoin->first->GetHash().GetHex().c_str());
- }
- }
+ scriptPubKeyOut << key.GetPubKey() << OP_CHECKSIG;
+ }
+ if (whichType == TX_PUBKEY)
+ {
+ valtype& vchPubKey = vSolutions[0];
+ if (!GetKey(Hash160(vchPubKey), key))
+ return error("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
+ if (key.GetPubKey() != vchPubKey)
+ return error("CreateCoinStake : invalid key for kernel type=%d\n", whichType); // keys mismatch
+ scriptPubKeyOut = scriptPubKeyKernel;
+ }
- if (fDebug)
- printf("Stake miner: %" PRIszu " meta items loaded for %" PRIszu " coins\n", mapMeta.size(), setCoins.size());
+ // The following combine threshold is important to security
+ // Should not be adjusted if you don't understand the consequences
+ int64_t nCombineThreshold = GetProofOfWorkReward(GetLastBlockIndex(pindexBest, false)->nBits) / 3;
- fCoinsDataActual = true;
- nKernelsTried = 0;
- nCoinDaysTried = 0;
- }
- }
+ int64_t nBalance = GetBalance();
+ int64_t nCredit = wtx.vout[nOut].nValue;
- int64_t nCredit = 0;
- CScript scriptPubKeyKernel;
+ txNew.vin.clear();
+ txNew.vout.clear();
- unsigned int nTimeTx, nBlockTime;
- COutPoint prevoutStake;
- CoinsSet::value_type kernelcoin;
+ // List of constake dependencies
+ vector<const CWalletTx*> vwtxPrev;
+ vwtxPrev.push_back(&wtx);
- if (ScanForStakeKernelHash(mapMeta, nBits, txNew.nTime, nSearchInterval, kernelcoin, nTimeTx, nBlockTime, nKernelsTried, nCoinDaysTried))
- {
- // Found a kernel
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : kernel found\n");
- vector<valtype> vSolutions;
- txnouttype whichType;
- CScript scriptPubKeyOut;
- scriptPubKeyKernel = kernelcoin.first->vout[kernelcoin.second].scriptPubKey;
- if (!Solver(scriptPubKeyKernel, whichType, vSolutions))
- {
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : failed to parse kernel\n");
- return false;
- }
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : parsed kernel type=%d\n", whichType);
- if (whichType != TX_PUBKEY && whichType != TX_PUBKEYHASH)
- {
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : no support for kernel type=%d\n", whichType);
- return false; // only support pay to public key and pay to address
- }
- if (whichType == TX_PUBKEYHASH) // pay to address type
- {
- // convert to pay to public key type
- if (!keystore.GetKey(uint160(vSolutions[0]), key))
- {
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
- return false; // unable to find corresponding public key
- }
- scriptPubKeyOut << key.GetPubKey() << OP_CHECKSIG;
- }
- if (whichType == TX_PUBKEY)
- {
- valtype& vchPubKey = vSolutions[0];
- if (!keystore.GetKey(Hash160(vchPubKey), key))
- {
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
- return false; // unable to find corresponding public key
- }
- if (key.GetPubKey() != vchPubKey)
- {
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : invalid key for kernel type=%d\n", whichType);
- return false; // keys mismatch
- }
+ // Set generation time, and kernel input
+ txNew.nTime = nGenerationTime;
+ txNew.vin.push_back(CTxIn(hashTx, nOut));
- scriptPubKeyOut = scriptPubKeyKernel;
- }
+ // Mark coin stake transaction with empty vout[0]
+ CScript scriptEmpty;
+ scriptEmpty.clear();
+ txNew.vout.push_back(CTxOut(0, scriptEmpty));
- txNew.nTime = nTimeTx;
- txNew.vin.push_back(CTxIn(kernelcoin.first->GetHash(), kernelcoin.second));
- nCredit += kernelcoin.first->vout[kernelcoin.second].nValue;
- vwtxPrev.push_back(kernelcoin.first);
- txNew.vout.push_back(CTxOut(0, scriptPubKeyOut));
+ if (fDebug && GetBoolArg("-printcoinstake"))
+ printf("CreateCoinStake : added kernel type=%d\n", whichType);
- if (GetWeight((int64_t)nBlockTime, (int64_t)txNew.nTime) < nStakeMaxAge)
- txNew.vout.push_back(CTxOut(0, scriptPubKeyOut)); //split stake
- if (fDebug && GetBoolArg("-printcoinstake"))
- printf("CreateCoinStake : added kernel type=%d\n", whichType);
- }
+ int64_t nValueIn = 0;
+ CoinsSet setCoins;
+ if (!SelectCoinsSimple(nBalance - nReserveBalance, MIN_TX_FEE, MAX_MONEY, nGenerationTime, nCoinbaseMaturity * 10, setCoins, nValueIn))
+ return false;
- if (nCredit == 0 || nCredit > nBalance - nReserveBalance)
+ if (setCoins.empty())
return false;
- // (txid, vout.n) => ((txindex, (tx, vout.n)), (block, modifier))
- for(MetaMap::const_iterator meta_item = mapMeta.begin(); meta_item != mapMeta.end(); meta_item++)
+ bool fMaxTimeWeight = false;
+ if (GetWeight((int64_t)wtx.nTime, (int64_t)nGenerationTime) == nStakeMaxAge)
{
- // Get coin
- CoinsSet::value_type pcoin = meta_item->second.first.second;
+ // Only one output for old kernel inputs
+ txNew.vout.push_back(CTxOut(0, scriptPubKeyOut));
- // Attempt to add more inputs
- // Only add coins of the same key/address as kernel
- if (txNew.vout.size() == 2 && ((pcoin.first->vout[pcoin.second].scriptPubKey == scriptPubKeyKernel || pcoin.first->vout[pcoin.second].scriptPubKey == txNew.vout[1].scriptPubKey))
- && pcoin.first->GetHash() != txNew.vin[0].prevout.hash)
+ // Iterate through set of (wtx*, nout) in order to find some additional inputs for our new coinstake transaction.
+ //
+ // * Value is higher than 0.01 NVC;
+ // * Only add inputs of the same key/address as kernel;
+ // * Input hash and kernel parent hash should be different.
+ for(CoinsSet::iterator pcoin = setCoins.begin(); pcoin != setCoins.end(); pcoin++)
{
- int64_t nTimeWeight = GetWeight((int64_t)pcoin.first->nTime, (int64_t)txNew.nTime);
-
// Stop adding more inputs if already too many inputs
if (txNew.vin.size() >= 100)
break;
if (nCredit > nCombineThreshold)
break;
// Stop adding inputs if reached reserve limit
- if (nCredit + pcoin.first->vout[pcoin.second].nValue > nBalance - nReserveBalance)
+ if (nCredit + pcoin->first->vout[pcoin->second].nValue > nBalance - nReserveBalance)
break;
- // Do not add additional significant input
- if (pcoin.first->vout[pcoin.second].nValue > nCombineThreshold)
- continue;
+
+ int64_t nTimeWeight = GetWeight((int64_t)pcoin->first->nTime, (int64_t)nGenerationTime);
+
// Do not add input that is still too young
if (nTimeWeight < nStakeMaxAge)
continue;
+ // Do not add input if key/address is not the same as kernel
+ if (pcoin->first->vout[pcoin->second].scriptPubKey != scriptPubKeyKernel && pcoin->first->vout[pcoin->second].scriptPubKey != txNew.vout[1].scriptPubKey)
+ continue;
+ // Do not add input if parents are the same
+ if (pcoin->first->GetHash() != txNew.vin[0].prevout.hash)
+ continue;
+ // Do not add additional significant input
+ if (pcoin->first->vout[pcoin->second].nValue > nCombineThreshold)
+ continue;
- txNew.vin.push_back(CTxIn(pcoin.first->GetHash(), pcoin.second));
- nCredit += pcoin.first->vout[pcoin.second].nValue;
- vwtxPrev.push_back(pcoin.first);
+ txNew.vin.push_back(CTxIn(pcoin->first->GetHash(), pcoin->second));
+ nCredit += pcoin->first->vout[pcoin->second].nValue;
+ vwtxPrev.push_back(pcoin->first);
}
- }
- // Calculate coin age reward
+ fMaxTimeWeight = true;
+ }
+ else
{
- uint64_t nCoinAge;
- CTxDB txdb("r");
- if (!txNew.GetCoinAge(txdb, nCoinAge))
- return error("CreateCoinStake : failed to calculate coin age");
-
- int64_t nReward = GetProofOfStakeReward(nCoinAge, nBits, txNew.nTime);
- // Refuse to create mint that has zero or negative reward
- if(nReward <= 0)
- return false;
-
- nCredit += nReward;
+ // Split stake input if maximum weight isn't reached yet
+ txNew.vout.push_back(CTxOut(0, scriptPubKeyOut));
+ txNew.vout.push_back(CTxOut(0, scriptPubKeyOut));
+
+ if (fDebug && GetBoolArg("-printcoinstake"))
+ printf("CreateCoinStake : maximum time weight isn't reached, splitting coinstake\n");
}
+ // Calculate coin age reward
+ uint64_t nCoinAge;
+ CTxDB txdb("r");
+ if (!txNew.GetCoinAge(txdb, nCoinAge))
+ return error("CreateCoinStake : failed to calculate coin age\n");
+ nCredit += GetProofOfStakeReward(nCoinAge, nBits, nGenerationTime);
+
int64_t nMinFee = 0;
while (true)
{
// Set output amount
- if (txNew.vout.size() == 3)
+ if (fMaxTimeWeight)
+ txNew.vout[1].nValue = nCredit - nMinFee;
+ else
{
txNew.vout[1].nValue = ((nCredit - nMinFee) / 2 / CENT) * CENT;
txNew.vout[2].nValue = nCredit - nMinFee - txNew.vout[1].nValue;
}
- else
- txNew.vout[1].nValue = nCredit - nMinFee;
// Sign
int nIn = 0;
BOOST_FOREACH(const CWalletTx* pcoin, vwtxPrev)
{
if (!SignSignature(*this, *pcoin, txNew, nIn++))
- return error("CreateCoinStake : failed to sign coinstake");
+ return error("CreateCoinStake : failed to sign coinstake\n");
}
// Limit size
unsigned int nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION);
if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
- return error("CreateCoinStake : exceeded coinstake size limit");
+ return error("CreateCoinStake : exceeded coinstake size limit\n");
// Check enough fee is paid
if (nMinFee < txNew.GetMinFee(1, false, GMF_BLOCK, nBytes) - CENT)
}
}
- // Successfully generated coinstake
+ // Successfully created coinstake
return true;
}
-
// Call after CreateTransaction unless you want to abort
bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
{
return DB_LOAD_OK;
}
+DBErrors CWallet::ZapWalletTx()
+{
+ if (!fFileBacked)
+ return DB_LOAD_OK;
+ DBErrors nZapWalletTxRet = CWalletDB(strWalletFile,"cr+").ZapWalletTx(this);
+ if (nZapWalletTxRet == DB_NEED_REWRITE)
+ {
+ if (CDB::Rewrite(strWalletFile, "\x04pool"))
+ {
+ 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
+ // the requires a new key.
+ }
+ }
+
+ if (nZapWalletTxRet != DB_LOAD_OK)
+ return nZapWalletTxRet;
+
+ return DB_LOAD_OK;
+}
bool CWallet::SetAddressBookName(const CTxDestination& address, const string& strName)
{
std::map<CTxDestination, std::string>::iterator mi = mapAddressBook.find(address);
mapAddressBook[address] = strName;
- NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address), (mi == mapAddressBook.end()) ? CT_NEW : CT_UPDATED);
+ NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address) != MINE_NO, (mi == mapAddressBook.end()) ? CT_NEW : CT_UPDATED);
if (!fFileBacked)
return false;
return CWalletDB(strWalletFile).WriteName(CBitcoinAddress(address).ToString(), strName);
bool CWallet::DelAddressBookName(const CTxDestination& address)
{
mapAddressBook.erase(address);
- NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address), CT_DELETED);
+ NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address) != MINE_NO, CT_DELETED);
if (!fFileBacked)
return false;
return CWalletDB(strWalletFile).EraseName(CBitcoinAddress(address).ToString());
{
if (IsMine(pcoin->vout[n]) && pcoin->IsSpent(n) && (txindex.vSpent.size() <= n || txindex.vSpent[n].IsNull()))
{
- printf("FixSpentCoins found lost coin %sppc %s[%d], %s\n",
+ printf("FixSpentCoins found lost coin %sppc %s[%u], %s\n",
FormatMoney(pcoin->vout[n].nValue).c_str(), pcoin->GetHash().ToString().c_str(), n, fCheckOnly? "repair not attempted" : "repairing");
nMismatchFound++;
nBalanceInQuestion += pcoin->vout[n].nValue;
}
else if (IsMine(pcoin->vout[n]) && !pcoin->IsSpent(n) && (txindex.vSpent.size() > n && !txindex.vSpent[n].IsNull()))
{
- printf("FixSpentCoins found spent coin %sppc %s[%d], %s\n",
+ printf("FixSpentCoins found spent coin %sppc %s[%u], %s\n",
FormatMoney(pcoin->vout[n].nValue).c_str(), pcoin->GetHash().ToString().c_str(), n, fCheckOnly? "repair not attempted" : "repairing");
nMismatchFound++;
nBalanceInQuestion += pcoin->vout[n].nValue;
git://git.novaco.in / novacoin.git / blobdiff