// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2012 The Bitcoin developers

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

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

#include "alert.h"

#include "checkpoints.h"

#include "db.h"

#include "txdb.h"

#include "net.h"

#include "init.h"

#include "ui_interface.h"

#include "kernel.h"

#include "zerocoin/Zerocoin.h"

#include <boost/algorithm/string/replace.hpp>

#include <boost/filesystem.hpp>

#include <boost/filesystem/fstream.hpp>

using namespace std;

using namespace boost;

//

// Global state

//

CCriticalSection cs_setpwalletRegistered;

set<CWallet*> setpwalletRegistered;

CCriticalSection cs_main;

CTxMemPool mempool;

unsigned int nTransactionsUpdated = 0;

map<uint256, CBlockIndex*> mapBlockIndex;

set<pair<COutPoint, unsigned int> > setStakeSeen;

libzerocoin::Params* ZCParams;

CBigNum bnProofOfWorkLimit(~uint256(0) >> 20); // "standard" scrypt target limit for proof of work, results with 0,000244140625 proof-of-work difficulty

CBigNum bnProofOfStakeLimit(~uint256(0) >> 20);

CBigNum bnProofOfWorkLimitTestNet(~uint256(0) >> 16);

unsigned int nTargetSpacing = 2 * 60; //Block spacing 2 minute

unsigned int nStakeMinAge = 24 * 60 * 60 * 15; //Minimum stake age 15days

unsigned int nStakeMaxAge = 24 * 60 * 60 * 90; //Maximum stake age 90days

unsigned int nModifierInterval = 10 * 60; // time to elapse before new modifier is computed

int nCoinbaseMaturity = 50; //Coin Base Maturity

CBlockIndex* pindexGenesisBlock = NULL;

int nBestHeight = -1;

uint256 nBestChainTrust = 0;

uint256 nBestInvalidTrust = 0;

uint256 hashBestChain = 0;

CBlockIndex* pindexBest = NULL;

int64_t nTimeBestReceived = 0;

CMedianFilter<int> cPeerBlockCounts(5, 0); // Amount of blocks that other nodes claim to have

map<uint256, CBlock*> mapOrphanBlocks;

multimap<uint256, CBlock*> mapOrphanBlocksByPrev;

set<pair<COutPoint, unsigned int> > setStakeSeenOrphan;

map<uint256, CTransaction> mapOrphanTransactions;

map<uint256, set<uint256> > mapOrphanTransactionsByPrev;

// Constant stuff for coinbase transactions we create:

CScript COINBASE_FLAGS;

const string strMessageMagic = "bitconnect Signed Message:\n";

// Settings

int64_t nTransactionFee = MIN_TX_FEE;

int64_t nReserveBalance = 0;

int64_t nMinimumInputValue = 0;

extern enum Checkpoints::CPMode CheckpointsMode;

//////////////////////////////////////////////////////////////////////////////

//

// dispatching functions

//

// These functions dispatch to one or all registered wallets

void RegisterWallet(CWallet* pwalletIn)

}

void UnregisterWallet(CWallet* pwalletIn)

}

// check whether the passed transaction is from us

bool static IsFromMe(CTransaction& tx)

}

// get the wallet transaction with the given hash (if it exists)

bool static GetTransaction(const uint256& hashTx, CWalletTx& wtx)

}

// erases transaction with the given hash from all wallets

void static EraseFromWallets(uint256 hash)

}

// make sure all wallets know about the given transaction, in the given block

void SyncWithWallets(const CTransaction& tx, const CBlock* pblock, bool fUpdate, bool fConnect)

}

// notify wallets about a new best chain

void static SetBestChain(const CBlockLocator& loc)

}

// notify wallets about an updated transaction

void static UpdatedTransaction(const uint256& hashTx)

}

// dump all wallets

void static PrintWallets(const CBlock& block)

}

// notify wallets about an incoming inventory (for request counts)

void static Inventory(const uint256& hash)

}

// ask wallets to resend their transactions

void ResendWalletTransactions(bool fForce)

}

//////////////////////////////////////////////////////////////////////////////

//

// mapOrphanTransactions

//

bool AddOrphanTx(const CTransaction& tx)

}

void static EraseOrphanTx(uint256 hash)

}

unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans)

}

//////////////////////////////////////////////////////////////////////////////

//

// CTransaction and CTxIndex

//

bool CTransaction::ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet)

}

bool CTransaction::ReadFromDisk(CTxDB& txdb, COutPoint prevout)

}

bool CTransaction::ReadFromDisk(COutPoint prevout)

}

bool IsStandardTx(const CTransaction& tx)

}

bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)

}

//

// Check transaction inputs, and make sure any

// pay-to-script-hash transactions are evaluating IsStandard scripts

//

// Why bother? To avoid denial-of-service attacks; an attacker

// can submit a standard HASH... OP_EQUAL transaction,

// which will get accepted into blocks. The redemption

// script can be anything; an attacker could use a very

// expensive-to-check-upon-redemption script like:

// DUP CHECKSIG DROP ... repeated 100 times... OP_1

//

bool CTransaction::AreInputsStandard(const MapPrevTx& mapInputs) const

}

unsigned int

CTransaction::GetLegacySigOpCount() const

}

int CMerkleTx::SetMerkleBranch(const CBlock* pblock)

}

bool CTransaction::CheckTransaction() const

}

int64_t CTransaction::GetMinFee(unsigned int nBlockSize, enum GetMinFee_mode mode, unsigned int nBytes) const

}

bool AcceptToMemoryPool(CTxMemPool& pool, CTransaction &tx,

}

bool CTxMemPool::addUnchecked(const uint256& hash, CTransaction &tx)

}

bool CTxMemPool::remove(const CTransaction &tx, bool fRecursive)

}

bool CTxMemPool::removeConflicts(const CTransaction &tx)

}

void CTxMemPool::clear()

}

void CTxMemPool::queryHashes(std::vector<uint256>& vtxid)

}

int CMerkleTx::GetDepthInMainChainINTERNAL(CBlockIndex* &pindexRet) const

}

int CMerkleTx::GetDepthInMainChain(CBlockIndex* &pindexRet) const

}

int CMerkleTx::GetBlocksToMaturity() const

}

bool CMerkleTx::AcceptToMemoryPool()

{

return ::AcceptToMemoryPool(mempool, *this, NULL);

}

bool CWalletTx::AcceptWalletTransaction(CTxDB& txdb)

}

bool CWalletTx::AcceptWalletTransaction()

}

int CTxIndex::GetDepthInMainChain() const

}

// Return transaction in tx, and if it was found inside a block, its hash is placed in hashBlock

bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock)

}

//////////////////////////////////////////////////////////////////////////////

//

// CBlock and CBlockIndex

//

static CBlockIndex* pblockindexFBBHLast;

CBlockIndex* FindBlockByHeight(int nHeight)

{

CBlockIndex *pblockindex;

if (nHeight < nBestHeight / 2)

pblockindex = pindexGenesisBlock;

else

pblockindex = pindexBest;

if (pblockindexFBBHLast && abs(nHeight - pblockindex->nHeight) > abs(nHeight - pblockindexFBBHLast->nHeight))

pblockindex = pblockindexFBBHLast;

while (pblockindex->nHeight > nHeight)

pblockindex = pblockindex->pprev;

while (pblockindex->nHeight < nHeight)

pblockindex = pblockindex->pnext;

pblockindexFBBHLast = pblockindex;

return pblockindex;

}

bool CBlock::ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions)

}

uint256 static GetOrphanRoot(const CBlock* pblock)

}

// ppcoin: find block wanted by given orphan block

uint256 WantedByOrphan(const CBlock* pblockOrphan)

}

// miner's coin base reward