auxpow.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2016 Daniel Kraft
// Distributed under the MIT/X11 software license, see the accompanying
// file license.txt or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_AUXPOW_H
#define BITCOIN_AUXPOW_H
 
#include "consensus/params.h"
#include "consensus/validation.h"
#include "primitives/pureheader.h"
#include "primitives/transaction.h"
#include "serialize.h"
#include "uint256.h"
 
#include <vector>
 
class CBlock;
class CBlockHeader;
class CBlockIndex;
 
static const unsigned char pchMergedMiningHeader[] = { 0xfa, 0xbe, 'm', 'm' };
 
/* Because it is needed for auxpow, the definition of CMerkleTx is moved
   here from wallet.h.  */
 
class CMerkleTx
{
private:
    static const uint256 ABANDON_HASH;
 
public:
    CTransactionRef tx;
    uint256 hashBlock;
    // Dogecoin TODO: Is this used? If not remove. If it is, I don't think it's actually set
    // anywhere. Check with Namecore
    std::vector<uint256> vMerkleBranch;
 
    /* An nIndex == -1 means that hashBlock (in nonzero) refers to the earliest
     * block in the chain we know this or any in-wallet dependency conflicts
     * with. Older clients interpret nIndex == -1 as unconfirmed for backward
     * compatibility.
     */
    int nIndex;
 
    CMerkleTx()
    {
        SetTx(MakeTransactionRef());
        Init();
    }
 
    CMerkleTx(CTransactionRef arg)
    {
        SetTx(std::move(arg));
        Init();
    }
 
    operator const CTransaction&() const { return *tx; }
 
    void Init()
    {
        hashBlock = uint256();
        nIndex = -1;
    }
 
    void SetTx(CTransactionRef arg)
    {
        tx = std::move(arg);
    }
 
    ADD_SERIALIZE_METHODS;
 
    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action) {
        READWRITE(tx);
        READWRITE(hashBlock);
        READWRITE(vMerkleBranch);
        READWRITE(nIndex);
    }
 
    void InitMerkleBranch(const CBlock& block, int posInBlock);
 
    void SetMerkleBranch(const CBlockIndex* pindex, int posInBlock);
 
    int GetDepthInMainChain(const CBlockIndex* &pindexRet) const;
    int GetDepthInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
    bool IsInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet) > 0; }
    int GetBlocksToMaturity() const;
    bool AcceptToMemoryPool(const CAmount& nAbsurdFee, CValidationState& state);
    bool hashUnset() const { return (hashBlock.IsNull() || hashBlock == ABANDON_HASH); }
    bool isAbandoned() const { return (hashBlock == ABANDON_HASH); }
    void setAbandoned() { hashBlock = ABANDON_HASH; }
 
    const uint256& GetHash() const { return tx->GetHash(); }
    bool IsCoinBase() const { return tx->IsCoinBase(); }
};
 
class CAuxPow : public CMerkleTx
{
 
/* Public for the unit tests.  */
public:
 
  std::vector<uint256> vChainMerkleBranch;
 
  int nChainIndex;
 
  CPureBlockHeader parentBlock;
 
public:
 
  /* Prevent accidental conversion.  */
  inline explicit CAuxPow(CTransactionRef txIn)
    : CMerkleTx(txIn)
  {
  }
 
  inline CAuxPow()
    : CMerkleTx()
  {
  }
 
  ADD_SERIALIZE_METHODS;
 
  template<typename Stream, typename Operation>
    inline void
    SerializationOp (Stream& s, Operation ser_action)
  {
    READWRITE (*static_cast<CMerkleTx*> (this));
    READWRITE (vChainMerkleBranch);
    READWRITE (nChainIndex);
    READWRITE (parentBlock);
  }
 
  bool check(const uint256& hashAuxBlock, int nChainId, const Consensus::Params& params) const;
 
  inline uint256
  getParentBlockPoWHash() const
  {
    return parentBlock.GetPoWHash ();
  }
 
  /* FIXME: Remove after the hardfork.  */
  inline const CPureBlockHeader&
  getParentBlock() const
  {
    return parentBlock;
  }
 
  static int getExpectedIndex(uint32_t nNonce, int nChainId, unsigned h);
 
  static uint256 CheckMerkleBranch(uint256 hash,
                                   const std::vector<uint256>& vMerkleBranch,
                                   int nIndex);
 
  static void initAuxPow(CBlockHeader& header);
 
};
 
#endif // BITCOIN_AUXPOW_H