core.h
No OneTemporary
Actions

Size

19 KB

Subscribers

None

core.h
View Options

	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.
	#ifndef BITCOIN_CORE_H
	#define BITCOIN_CORE_H

	#include "uint256.h"
	#include "serialize.h"
	#include "script.h"

	#include <stdio.h>

	class CTransaction;

	/** An outpoint - a combination of a transaction hash and an index n into its vout */
	class COutPoint
	{
	public:
	uint256 hash;
	unsigned int n;

	COutPoint() { SetNull(); }
	COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
	IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
	void SetNull() { hash = 0; n = (unsigned int) -1; }
	bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }

	friend bool operator<(const COutPoint& a, const COutPoint& b)
	{
	return (a.hash < b.hash \|\| (a.hash == b.hash && a.n < b.n));
	}

	friend bool operator==(const COutPoint& a, const COutPoint& b)
	{
	return (a.hash == b.hash && a.n == b.n);
	}

	friend bool operator!=(const COutPoint& a, const COutPoint& b)
	{
	return !(a == b);
	}

	std::string ToString() const;
	void print() const;
	};

	/** An inpoint - a combination of a transaction and an index n into its vin */
	class CInPoint
	{
	public:
	CTransaction* ptx;
	unsigned int n;

	CInPoint() { SetNull(); }
	CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
	void SetNull() { ptx = NULL; n = (unsigned int) -1; }
	bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
	};

	/** An input of a transaction. It contains the location of the previous
	* transaction's output that it claims and a signature that matches the
	* output's public key.
	*/
	class CTxIn
	{
	public:
	COutPoint prevout;
	CScript scriptSig;
	unsigned int nSequence;

	CTxIn()
	{
	nSequence = std::numeric_limits<unsigned int>::max();
	}

	explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max());
	CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max());

	IMPLEMENT_SERIALIZE
	(
	READWRITE(prevout);
	READWRITE(scriptSig);
	READWRITE(nSequence);
	)

	bool IsFinal() const
	{
	return (nSequence == std::numeric_limits<unsigned int>::max());
	}

	friend bool operator==(const CTxIn& a, const CTxIn& b)
	{
	return (a.prevout == b.prevout &&
	a.scriptSig == b.scriptSig &&
	a.nSequence == b.nSequence);
	}

	friend bool operator!=(const CTxIn& a, const CTxIn& b)
	{
	return !(a == b);
	}

	std::string ToString() const;
	void print() const;
	};




	/** An output of a transaction. It contains the public key that the next input
	* must be able to sign with to claim it.
	*/
	class CTxOut
	{
	public:
	int64 nValue;
	CScript scriptPubKey;

	CTxOut()
	{
	SetNull();
	}

	CTxOut(int64 nValueIn, CScript scriptPubKeyIn);

	IMPLEMENT_SERIALIZE
	(
	READWRITE(nValue);
	READWRITE(scriptPubKey);
	)

	void SetNull()
	{
	nValue = -1;
	scriptPubKey.clear();
	}

	bool IsNull() const
	{
	return (nValue == -1);
	}

	uint256 GetHash() const;

	bool IsDust(int64 nMinRelayTxFee) const
	{
	// "Dust" is defined in terms of CTransaction::nMinRelayTxFee,
	// which has units satoshis-per-kilobyte.
	// If you'd pay more than 1/3 in fees
	// to spend something, then we consider it dust.
	// A typical txout is 34 bytes big, and will
	// need a CTxIn of at least 148 bytes to spend,
	// so dust is a txout less than 54 uBTC
	// (5460 satoshis) with default nMinRelayTxFee
	return ((nValue1000)/(3((int)GetSerializeSize(SER_DISK,0)+148)) < nMinRelayTxFee);
	}

	friend bool operator==(const CTxOut& a, const CTxOut& b)
	{
	return (a.nValue == b.nValue &&
	a.scriptPubKey == b.scriptPubKey);
	}

	friend bool operator!=(const CTxOut& a, const CTxOut& b)
	{
	return !(a == b);
	}

	std::string ToString() const;
	void print() const;
	};


	/** The basic transaction that is broadcasted on the network and contained in
	* blocks. A transaction can contain multiple inputs and outputs.
	*/
	class CTransaction
	{
	public:
	static int64 nMinTxFee;
	static int64 nMinRelayTxFee;
	static const int CURRENT_VERSION=1;
	int nVersion;
	std::vector<CTxIn> vin;
	std::vector<CTxOut> vout;
	unsigned int nLockTime;

	CTransaction()
	{
	SetNull();
	}

	IMPLEMENT_SERIALIZE
	(
	READWRITE(this->nVersion);
	nVersion = this->nVersion;
	READWRITE(vin);
	READWRITE(vout);
	READWRITE(nLockTime);
	)

	void SetNull()
	{
	nVersion = CTransaction::CURRENT_VERSION;
	vin.clear();
	vout.clear();
	nLockTime = 0;
	}

	bool IsNull() const
	{
	return (vin.empty() && vout.empty());
	}

	uint256 GetHash() const;
	bool IsNewerThan(const CTransaction& old) const;

	bool IsCoinBase() const
	{
	return (vin.size() == 1 && vin[0].prevout.IsNull());
	}

	friend bool operator==(const CTransaction& a, const CTransaction& b)
	{
	return (a.nVersion == b.nVersion &&
	a.vin == b.vin &&
	a.vout == b.vout &&
	a.nLockTime == b.nLockTime);
	}

	friend bool operator!=(const CTransaction& a, const CTransaction& b)
	{
	return !(a == b);
	}


	std::string ToString() const;
	void print() const;
	};

	/** wrapper for CTxOut that provides a more compact serialization */
	class CTxOutCompressor
	{
	private:
	CTxOut &txout;

	public:
	static uint64 CompressAmount(uint64 nAmount);
	static uint64 DecompressAmount(uint64 nAmount);

	CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }

	IMPLEMENT_SERIALIZE(({
	if (!fRead) {
	uint64 nVal = CompressAmount(txout.nValue);
	READWRITE(VARINT(nVal));
	} else {
	uint64 nVal = 0;
	READWRITE(VARINT(nVal));
	txout.nValue = DecompressAmount(nVal);
	}
	CScriptCompressor cscript(REF(txout.scriptPubKey));
	READWRITE(cscript);
	});)
	};

	/** Undo information for a CTxIn
	*
	* Contains the prevout's CTxOut being spent, and if this was the
	* last output of the affected transaction, its metadata as well
	* (coinbase or not, height, transaction version)
	*/
	class CTxInUndo
	{
	public:
	CTxOut txout; // the txout data before being spent
	bool fCoinBase; // if the outpoint was the last unspent: whether it belonged to a coinbase
	unsigned int nHeight; // if the outpoint was the last unspent: its height
	int nVersion; // if the outpoint was the last unspent: its version

	CTxInUndo() : txout(), fCoinBase(false), nHeight(0), nVersion(0) {}
	CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn), nVersion(nVersionIn) { }

	unsigned int GetSerializeSize(int nType, int nVersion) const {
	return ::GetSerializeSize(VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion) +
	(nHeight > 0 ? ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion) : 0) +
	::GetSerializeSize(CTxOutCompressor(REF(txout)), nType, nVersion);
	}

	template<typename Stream>
	void Serialize(Stream &s, int nType, int nVersion) const {
	::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion);
	if (nHeight > 0)
	::Serialize(s, VARINT(this->nVersion), nType, nVersion);
	::Serialize(s, CTxOutCompressor(REF(txout)), nType, nVersion);
	}

	template<typename Stream>
	void Unserialize(Stream &s, int nType, int nVersion) {
	unsigned int nCode = 0;
	::Unserialize(s, VARINT(nCode), nType, nVersion);
	nHeight = nCode / 2;
	fCoinBase = nCode & 1;
	if (nHeight > 0)
	::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
	::Unserialize(s, REF(CTxOutCompressor(REF(txout))), nType, nVersion);
	}
	};

	/** Undo information for a CTransaction */
	class CTxUndo
	{
	public:
	// undo information for all txins
	std::vector<CTxInUndo> vprevout;

	IMPLEMENT_SERIALIZE(
	READWRITE(vprevout);
	)
	};


	/** pruned version of CTransaction: only retains metadata and unspent transaction outputs
	*
	* Serialized format:
	* - VARINT(nVersion)
	* - VARINT(nCode)
	* - unspentness bitvector, for vout[2] and further; least significant byte first
	* - the non-spent CTxOuts (via CTxOutCompressor)
	* - VARINT(nHeight)
	*
	* The nCode value consists of:
	* - bit 1: IsCoinBase()
	* - bit 2: vout[0] is not spent
	* - bit 4: vout[1] is not spent
	* - The higher bits encode N, the number of non-zero bytes in the following bitvector.
	* - In case both bit 2 and bit 4 are unset, they encode N-1, as there must be at
	* least one non-spent output).
	*
	* Example: 0104835800816115944e077fe7c803cfa57f29b36bf87c1d358bb85e
	* <><><--------------------------------------------><---->
	* \| \ \| /
	* version code vout[1] height
	*
	* - version = 1
	* - code = 4 (vout[1] is not spent, and 0 non-zero bytes of bitvector follow)
	* - unspentness bitvector: as 0 non-zero bytes follow, it has length 0
	* - vout[1]: 835800816115944e077fe7c803cfa57f29b36bf87c1d35
	* * 8358: compact amount representation for 60000000000 (600 BTC)
	* * 00: special txout type pay-to-pubkey-hash
	* * 816115944e077fe7c803cfa57f29b36bf87c1d35: address uint160
	* - height = 203998
	*
	*
	* Example: 0109044086ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4eebbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa486af3b
	* <><><--><--------------------------------------------------><----------------------------------------------><---->
	* / \ \ \| \| /
	* version code unspentness vout[4] vout[16] height
	*
	* - version = 1
	* - code = 9 (coinbase, neither vout[0] or vout[1] are unspent,
	* 2 (1, +1 because both bit 2 and bit 4 are unset) non-zero bitvector bytes follow)
	* - unspentness bitvector: bits 2 (0x04) and 14 (0x4000) are set, so vout[2+2] and vout[14+2] are unspent
	* - vout[4]: 86ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4ee
	* * 86ef97d579: compact amount representation for 234925952 (2.35 BTC)
	* * 00: special txout type pay-to-pubkey-hash
	* * 61b01caab50f1b8e9c50a5057eb43c2d9563a4ee: address uint160
	* - vout[16]: bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4
	* * bbd123: compact amount representation for 110397 (0.001 BTC)
	* * 00: special txout type pay-to-pubkey-hash
	* * 8c988f1a4a4de2161e0f50aac7f17e7f9555caa4: address uint160
	* - height = 120891
	*/
	class CCoins
	{
	public:
	// whether transaction is a coinbase
	bool fCoinBase;

	// unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are dropped
	std::vector<CTxOut> vout;

	// at which height this transaction was included in the active block chain
	int nHeight;

	// version of the CTransaction; accesses to this value should probably check for nHeight as well,
	// as new tx version will probably only be introduced at certain heights
	int nVersion;

	// construct a CCoins from a CTransaction, at a given height
	CCoins(const CTransaction &tx, int nHeightIn) : fCoinBase(tx.IsCoinBase()), vout(tx.vout), nHeight(nHeightIn), nVersion(tx.nVersion) { }

	// empty constructor
	CCoins() : fCoinBase(false), vout(0), nHeight(0), nVersion(0) { }

	// remove spent outputs at the end of vout
	void Cleanup() {
	while (vout.size() > 0 && vout.back().IsNull())
	vout.pop_back();
	if (vout.empty())
	std::vector<CTxOut>().swap(vout);
	}

	void swap(CCoins &to) {
	std::swap(to.fCoinBase, fCoinBase);
	to.vout.swap(vout);
	std::swap(to.nHeight, nHeight);
	std::swap(to.nVersion, nVersion);
	}

	// equality test
	friend bool operator==(const CCoins &a, const CCoins &b) {
	return a.fCoinBase == b.fCoinBase &&
	a.nHeight == b.nHeight &&
	a.nVersion == b.nVersion &&
	a.vout == b.vout;
	}
	friend bool operator!=(const CCoins &a, const CCoins &b) {
	return !(a == b);
	}

	void CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const;

	bool IsCoinBase() const {
	return fCoinBase;
	}

	unsigned int GetSerializeSize(int nType, int nVersion) const {
	unsigned int nSize = 0;
	unsigned int nMaskSize = 0, nMaskCode = 0;
	CalcMaskSize(nMaskSize, nMaskCode);
	bool fFirst = vout.size() > 0 && !vout[0].IsNull();
	bool fSecond = vout.size() > 1 && !vout[1].IsNull();
	assert(fFirst \|\| fSecond \|\| nMaskCode);
	unsigned int nCode = 8*(nMaskCode - (fFirst \|\| fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
	// version
	nSize += ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion);
	// size of header code
	nSize += ::GetSerializeSize(VARINT(nCode), nType, nVersion);
	// spentness bitmask
	nSize += nMaskSize;
	// txouts themself
	for (unsigned int i = 0; i < vout.size(); i++)
	if (!vout[i].IsNull())
	nSize += ::GetSerializeSize(CTxOutCompressor(REF(vout[i])), nType, nVersion);
	// height
	nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
	return nSize;
	}

	template<typename Stream>
	void Serialize(Stream &s, int nType, int nVersion) const {
	unsigned int nMaskSize = 0, nMaskCode = 0;
	CalcMaskSize(nMaskSize, nMaskCode);
	bool fFirst = vout.size() > 0 && !vout[0].IsNull();
	bool fSecond = vout.size() > 1 && !vout[1].IsNull();
	assert(fFirst \|\| fSecond \|\| nMaskCode);
	unsigned int nCode = 8*(nMaskCode - (fFirst \|\| fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
	// version
	::Serialize(s, VARINT(this->nVersion), nType, nVersion);
	// header code
	::Serialize(s, VARINT(nCode), nType, nVersion);
	// spentness bitmask
	for (unsigned int b = 0; b<nMaskSize; b++) {
	unsigned char chAvail = 0;
	for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++)
	if (!vout[2+b*8+i].IsNull())
	chAvail \|= (1 << i);
	::Serialize(s, chAvail, nType, nVersion);
	}
	// txouts themself
	for (unsigned int i = 0; i < vout.size(); i++) {
	if (!vout[i].IsNull())
	::Serialize(s, CTxOutCompressor(REF(vout[i])), nType, nVersion);
	}
	// coinbase height
	::Serialize(s, VARINT(nHeight), nType, nVersion);
	}

	template<typename Stream>
	void Unserialize(Stream &s, int nType, int nVersion) {
	unsigned int nCode = 0;
	// version
	::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
	// header code
	::Unserialize(s, VARINT(nCode), nType, nVersion);
	fCoinBase = nCode & 1;
	std::vector<bool> vAvail(2, false);
	vAvail[0] = nCode & 2;
	vAvail[1] = nCode & 4;
	unsigned int nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
	// spentness bitmask
	while (nMaskCode > 0) {
	unsigned char chAvail = 0;
	::Unserialize(s, chAvail, nType, nVersion);
	for (unsigned int p = 0; p < 8; p++) {
	bool f = (chAvail & (1 << p)) != 0;
	vAvail.push_back(f);
	}
	if (chAvail != 0)
	nMaskCode--;
	}
	// txouts themself
	vout.assign(vAvail.size(), CTxOut());
	for (unsigned int i = 0; i < vAvail.size(); i++) {
	if (vAvail[i])
	::Unserialize(s, REF(CTxOutCompressor(vout[i])), nType, nVersion);
	}
	// coinbase height
	::Unserialize(s, VARINT(nHeight), nType, nVersion);
	Cleanup();
	}

	// mark an outpoint spent, and construct undo information
	bool Spend(const COutPoint &out, CTxInUndo &undo);

	// mark a vout spent
	bool Spend(int nPos);

	// check whether a particular output is still available
	bool IsAvailable(unsigned int nPos) const {
	return (nPos < vout.size() && !vout[nPos].IsNull());
	}

	// check whether the entire CCoins is spent
	// note that only !IsPruned() CCoins can be serialized
	bool IsPruned() const {
	BOOST_FOREACH(const CTxOut &out, vout)
	if (!out.IsNull())
	return false;
	return true;
	}
	};


	/** 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
	static const int CURRENT_VERSION=2;
	int nVersion;
	uint256 hashPrevBlock;
	uint256 hashMerkleRoot;
	unsigned int nTime;
	unsigned int nBits;
	unsigned int nNonce;

	CBlockHeader()
	{
	SetNull();
	}

	IMPLEMENT_SERIALIZE
	(
	READWRITE(this->nVersion);
	nVersion = this->nVersion;
	READWRITE(hashPrevBlock);
	READWRITE(hashMerkleRoot);
	READWRITE(nTime);
	READWRITE(nBits);
	READWRITE(nNonce);
	)

	void SetNull()
	{
	nVersion = CBlockHeader::CURRENT_VERSION;
	hashPrevBlock = 0;
	hashMerkleRoot = 0;
	nTime = 0;
	nBits = 0;
	nNonce = 0;
	}

	bool IsNull() const
	{
	return (nBits == 0);
	}

	uint256 GetHash() const;

	int64 GetBlockTime() const
	{
	return (int64)nTime;
	}
	};


	class CBlock : public CBlockHeader
	{
	public:
	// network and disk
	std::vector<CTransaction> vtx;

	// memory only
	mutable std::vector<uint256> vMerkleTree;

	CBlock()
	{
	SetNull();
	}

	CBlock(const CBlockHeader &header)
	{
	SetNull();
	((CBlockHeader)this) = header;
	}

	IMPLEMENT_SERIALIZE
	(
	READWRITE((CBlockHeader)this);
	READWRITE(vtx);
	)

	void SetNull()
	{
	CBlockHeader::SetNull();
	vtx.clear();
	vMerkleTree.clear();
	}

	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;
	}

	uint256 BuildMerkleTree() const;

	const uint256 &GetTxHash(unsigned int nIndex) const {
	assert(vMerkleTree.size() > 0); // BuildMerkleTree must have been called first
	assert(nIndex < vtx.size());
	return vMerkleTree[nIndex];
	}

	std::vector<uint256> GetMerkleBranch(int nIndex) const;
	static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex);
	void print() const;
	};

	#endif

File Metadata

Mime Type: text/x-c++
Expires: Mon, Nov 25, 07:58 (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4530781
Default Alt Text: core.h (19 KB)

core.hNo OneTemporaryActions

core.hView Options

File Metadata

Event Timeline

core.h
No OneTemporary
Actions

core.h
View Options