// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2011 The Bitcoin developers
-// Copyright (c) 2011 The PPCoin developers
+// Copyright (c) 2011-2012 The PPCoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file license.txt or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_MAIN_H
extern CCriticalSection cs_main;
extern std::map<uint256, CBlockIndex*> mapBlockIndex;
+extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
extern uint256 hashGenesisBlock;
extern CBlockIndex* pindexGenesisBlock;
extern int nBestHeight;
extern int64 nTimeBestReceived;
extern CCriticalSection cs_setpwalletRegistered;
extern std::set<CWallet*> setpwalletRegistered;
+extern std::map<uint256, CBlock*> mapOrphanBlocks;
// Settings
extern int fGenerateBitcoins;
extern int fMinimizeToTray;
extern int fMinimizeOnClose;
extern int fUseUPnP;
+extern int64 nBalanceReserve;
bool ProcessMessages(CNode* pfrom);
bool SendMessages(CNode* pto, bool fSendTrickle);
void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
-CBlock* CreateNewBlock(CReserveKey& reservekey);
+CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfWorkOnly=false);
void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
bool CheckProofOfWork(uint256 hash, unsigned int nBits);
+int64 GetProofOfStakeReward(int64 nCoinAge);
unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
int GetNumBlocksOfPeers();
bool IsInitialBlockDownload();
std::string GetWarnings(std::string strFor);
-
+bool Reorganize(CTxDB& txdb, CBlockIndex* pindexNew);
+uint256 WantedByOrphan(const CBlock* pblockOrphan);
+const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
return (nValue == -1);
}
+ bool SetEmpty()
+ {
+ nValue = 0;
+ scriptPubKey.clear();
+ }
+
+ bool IsEmpty() const
+ {
+ return (nValue == 0 && scriptPubKey.empty());
+ }
+
uint256 GetHash() const
{
return SerializeHash(*this);
std::string ToString() const
{
+ if (IsEmpty()) return "CTxOut(empty)";
if (scriptPubKey.size() < 6)
return "CTxOut(error)";
return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().substr(0,30).c_str());
bool IsCoinBase() const
{
- return (vin.size() == 1 && vin[0].prevout.IsNull());
+ return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() == 1);
+ }
+
+ bool IsCoinStake() const
+ {
+ // ppcoin: the coin stake transaction is marked with the first output empty
+ return (vin.size() > 0 && vout.size() == 2 && vout[0].IsEmpty());
}
int GetSigOpCount() const
std::string ToString() const
{
std::string str;
- str += strprintf("CTransaction(hash=%s, nTime=%d, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
+ str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
+ str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
GetHash().ToString().substr(0,10).c_str(),
nTime,
nVersion,
bool AddToMemoryPoolUnchecked();
public:
bool RemoveFromMemoryPool();
+ bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
+ bool CheckProofOfStake(unsigned int nBits) const;
};
// network and disk
std::vector<CTransaction> vtx;
+ // ppcoin: block signature - signed by coin base txout[0]'s owner
+ std::vector<unsigned char> vchBlockSig;
+
// memory only
mutable std::vector<uint256> vMerkleTree;
READWRITE(nBits);
READWRITE(nNonce);
- // ConnectBlock depends on vtx being last so it can calculate offset
+ // ConnectBlock depends on vtx following header to generate CDiskTxPos
if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
+ {
READWRITE(vtx);
+ READWRITE(vchBlockSig);
+ }
else if (fRead)
+ {
const_cast<CBlock*>(this)->vtx.clear();
+ const_cast<CBlock*>(this)->vchBlockSig.clear();
+ }
)
void SetNull()
nBits = 0;
nNonce = 0;
vtx.clear();
+ vchBlockSig.clear();
vMerkleTree.clear();
nDoS = 0;
}
return (int64)nTime;
}
+ // ppcoin: two types of block: proof-of-work or proof-of-stake
+ bool IsProofOfStake() const
+ {
+ return (vtx.size() > 1 && vtx[1].IsCoinStake());
+ }
+
+ bool IsProofOfWork() const
+ {
+ return !IsProofOfStake();
+ }
+
+ std::pair<COutPoint, unsigned int> GetProofOfStake() const
+ {
+ return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
+ }
+
// ppcoin: get max transaction timestamp
int64 GetMaxTransactionTime() const
{
filein >> *this;
// Check the header
- if (!CheckProofOfWork(GetHash(), nBits))
+ if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
return error("CBlock::ReadFromDisk() : errors in block header");
return true;
void print() const
{
- printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
+ printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d, vchBlockSig=%s)\n",
GetHash().ToString().substr(0,20).c_str(),
nVersion,
hashPrevBlock.ToString().substr(0,20).c_str(),
hashMerkleRoot.ToString().substr(0,10).c_str(),
nTime, nBits, nNonce,
- vtx.size());
+ vtx.size(),
+ HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
for (int i = 0; i < vtx.size(); i++)
{
printf(" ");
}
+ bool SignBlock(const CKeyStore& keystore)
+ {
+ std::vector<std::pair<opcodetype, valtype> > vSolution;
+ const CTxOut& txout = IsProofOfStake()? vtx[1].vout[1] : vtx[0].vout[0];
+
+ if (!Solver(txout.scriptPubKey, vSolution))
+ return false;
+ BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
+ {
+ if (item.first == OP_PUBKEY)
+ {
+ // Sign
+ const valtype& vchPubKey = item.second;
+ CKey key;
+ if (!keystore.GetKey(Hash160(vchPubKey), key))
+ return false;
+ if (key.GetPubKey() != vchPubKey)
+ return false;
+ return key.Sign(GetHash(), vchBlockSig);
+ }
+ }
+ return false;
+ }
+
+ bool CheckBlockSignature() const
+ {
+ if (GetHash() == hashGenesisBlock)
+ return vchBlockSig.empty();
+
+ std::vector<std::pair<opcodetype, valtype> > vSolution;
+ const CTxOut& txout = IsProofOfStake()? vtx[1].vout[1] : vtx[0].vout[0];
+
+ if (!Solver(txout.scriptPubKey, vSolution))
+ return false;
+ BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
+ {
+ if (item.first == OP_PUBKEY)
+ {
+ const valtype& vchPubKey = item.second;
+ CKey key;
+ if (!key.SetPubKey(vchPubKey))
+ return false;
+ if (vchBlockSig.empty())
+ return false;
+ return key.Verify(GetHash(), vchBlockSig);
+ }
+ }
+ return false;
+ }
+
bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
bool CheckBlock() const;
bool AcceptBlock();
- uint64 GetBlockCoinAge(); // ppcoin: calculate total coin age spent in block
+ bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
};
unsigned int nBlockPos;
uint64 nChainTrust;// ppcoin: trust score of chain, in the unit of coin-days
int nHeight;
- int nCheckpoint; // ppcoin: chain auto checkpoint height
+ bool fProofOfStake; // ppcoin: is the block of proof-of-stake type
+ COutPoint prevoutStake;
+ unsigned int nStakeTime;
// block header
int nVersion;
nBlockPos = 0;
nHeight = 0;
nChainTrust = 0;
- nCheckpoint = 0;
+ fProofOfStake = true;
+ prevoutStake.SetNull();
+ nStakeTime = 0;
nVersion = 0;
hashMerkleRoot = 0;
nBlockPos = nBlockPosIn;
nHeight = 0;
nChainTrust = 0;
- nCheckpoint = 0;
+ fProofOfStake = block.IsProofOfStake();
+ if (fProofOfStake)
+ {
+ prevoutStake = block.vtx[1].vin[0].prevout;
+ nStakeTime = block.vtx[1].nTime;
+ }
+ else
+ {
+ prevoutStake.SetNull();
+ nStakeTime = 0;
+ }
nVersion = block.nVersion;
hashMerkleRoot = block.hashMerkleRoot;
bool CheckIndex() const
{
- return CheckProofOfWork(GetBlockHash(), nBits);
+ return IsProofOfWork() ? CheckProofOfWork(GetBlockHash(), nBits) : true;
}
bool EraseBlockFromDisk()
return pindex->GetMedianTimePast();
}
+ bool IsProofOfWork() const
+ {
+ return !fProofOfStake;
+ }
+ bool IsProofOfStake() const
+ {
+ return fProofOfStake;
+ }
std::string ToString() const
{
- return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nChainTrust=%"PRI64d" nHeight=%d, nCheckpoint=%d, merkle=%s, hashBlock=%s)",
- pprev, pnext, nFile, nBlockPos, nChainTrust, nHeight, nCheckpoint,
+ return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nChainTrust=%"PRI64d" nHeight=%d, fProofOfStake=%d prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
+ pprev, pnext, nFile, nBlockPos, nChainTrust, nHeight,
+ fProofOfStake, prevoutStake.ToString().c_str(), nStakeTime,
hashMerkleRoot.ToString().substr(0,10).c_str(),
GetBlockHash().ToString().substr(0,20).c_str());
}
READWRITE(nBlockPos);
READWRITE(nChainTrust);
READWRITE(nHeight);
- READWRITE(nCheckpoint);
+ READWRITE(fProofOfStake);
+ if (fProofOfStake)
+ {
+ READWRITE(prevoutStake);
+ READWRITE(nStakeTime);
+ }
+ else if (fRead)
+ {
+ const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
+ const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
+ }
// block header
READWRITE(this->nVersion);
bool CheckSignature()
{
CKey key;
- if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
+ if (!key.SetPubKey(ParseHex("0487ca85b6ae9d311f996c7616d20d0c88a5b4f07d25e78f419019f35cce6522acf978b2d99f0e7a58db1f120439e5c1889266927854aa57c93956c2569188a539")))
return error("CAlert::CheckSignature() : SetPubKey failed");
if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
return error("CAlert::CheckSignature() : verify signature failed");
git://git.novaco.in / novacoin.git / blobdiff