// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2015 The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef NAVCOIN_PRIMITIVES_BLOCK_H

#define NAVCOIN_PRIMITIVES_BLOCK_H

#include "primitives/transaction.h"

#include "serialize.h"

#include "uint256.h"

#include "arith_uint256.h"

#include "hash.h"

/** Nodes collect new transactions into a block, hash them into a hash tree,

* and scan through nonce values to make the block's hash satisfy proof-of-work

* requirements. When they solve the proof-of-work, they broadcast the block

* to everyone and the block is added to the block chain. The first transaction

* in the block is a special one that creates a new coin owned by the creator

* of the block.

*/

class CBlockHeader

{

public:

// header

int32_t nVersion;

uint256 hashPrevBlock;

uint256 hashMerkleRoot;

uint32_t nTime;

uint32_t nBits;

uint32_t nNonce;

CBlockHeader()

{

SetNull();

}

ADD_SERIALIZE_METHODS;

template <typename Stream, typename Operation>

inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {

READWRITE(this->nVersion);

READWRITE(hashPrevBlock);

READWRITE(hashMerkleRoot);

READWRITE(nTime);

READWRITE(nBits);

READWRITE(nNonce);

}

void SetNull()

{

nVersion = 0;

hashPrevBlock.SetNull();

hashMerkleRoot.SetNull();

nTime = 0;

nBits = 0;

nNonce = 0;

}

bool IsNull() const

{

return (nBits == 0);

}

uint256 GetHash() const;

uint256 GetPoWHash() const;

unsigned int GetStakeEntropyBit() const

{

// Take last bit of block hash as entropy bit

unsigned int nEntropyBit = ((UintToArith256(GetHash()).GetLow64()) & 1llu);

return nEntropyBit;

}

int64_t GetBlockTime() const

{

return (int64_t)nTime;

}

std::string ToString() const;

};

class CBlock : public CBlockHeader

{

public:

// network and disk

std::vector<CTransaction> vtx;

// ppcoin: block signature - signed by one of the coin base txout[N]'s owner

std::vector<unsigned char> vchBlockSig;

// memory only

mutable bool fChecked;

mutable std::vector<uint256> vMerkleTree;

CBlock()

{

SetNull();

}

CBlock(const CBlockHeader &header)

{

SetNull();

*((CBlockHeader*)this) = header;

}

ADD_SERIALIZE_METHODS;

template <typename Stream, typename Operation>

inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {

READWRITE(*(CBlockHeader*)this);

// ConnectBlock depends on vtx following header to generate CDiskTxPos

if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))

{

READWRITE(vtx);

READWRITE(vchBlockSig);

}

else if (ser_action.ForRead())

{

const_cast<CBlock*>(this)->vtx.clear();

const_cast<CBlock*>(this)->vchBlockSig.clear();

}

}

uint256 BuildMerkleTree() const

{

vMerkleTree.clear();

for (std::vector<CTransaction>::const_iterator it(vtx.begin()); it != vtx.end(); ++it)

vMerkleTree.push_back(it->GetHash());

int j = 0;

for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)

{

for (int i = 0; i < nSize; i += 2)

{

int i2 = std::min(i+1, nSize-1);

vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(), vMerkleTree[j+i].end(),

vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));

}

j += nSize;

}

return (vMerkleTree.empty() ? uint256() : vMerkleTree.back());

}

void SetNull()

{

CBlockHeader::SetNull();

vtx.clear();

vchBlockSig.clear();

vMerkleTree.clear();

fChecked = false;

}

bool IsProofOfStake() const

{

return (vtx.size() > 1 && vtx[1].IsCoinStake());

}

bool IsProofOfWork() const

{

return !IsProofOfStake();

}

CBlockHeader GetBlockHeader() const

{

CBlockHeader block;

block.nVersion = nVersion;

block.hashPrevBlock = hashPrevBlock;

block.hashMerkleRoot = hashMerkleRoot;

block.nTime = nTime;

block.nBits = nBits;

block.nNonce = nNonce;

return block;

}

std::string ToString() const;

};

/** Describes a place in the block chain to another node such that if the

* other node doesn't have the same branch, it can find a recent common trunk.

* The further back it is, the further before the fork it may be.

*/

struct CBlockLocator

{

std::vector<uint256> vHave;

CBlockLocator() {}

CBlockLocator(const std::vector<uint256>& vHaveIn)

{

vHave = vHaveIn;

}

ADD_SERIALIZE_METHODS;

template <typename Stream, typename Operation>

inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {

if (!(nType & SER_GETHASH))

READWRITE(nVersion);

READWRITE(vHave);

}

void SetNull()

{

vHave.clear();

}

bool IsNull() const

{

return vHave.empty();

}

};

/** Compute the consensus-critical block weight (see BIP 141). */

int64_t GetBlockWeight(const CBlock& tx);

#endif // NAVCOIN_PRIMITIVES_BLOCK_H