Page MenuHomePhabricator
Files F12910244

No OneTemporary
Actions

View Options

diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index f3d3f941f..288e072d5 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -1,28 +1,28 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#include "primitives/block.h"
+#include <primitives/block.h>
-#include "crypto/common.h"
-#include "hash.h"
-#include "tinyformat.h"
-#include "utilstrencodings.h"
+#include <crypto/common.h>
+#include <hash.h>
+#include <tinyformat.h>
+#include <utilstrencodings.h>
uint256 CBlockHeader::GetHash() const {
return SerializeHash(*this);
}
std::string CBlock::ToString() const {
std::stringstream s;
s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, "
"hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, "
"vtx=%u)\n",
GetHash().ToString(), nVersion, hashPrevBlock.ToString(),
hashMerkleRoot.ToString(), nTime, nBits, nNonce, vtx.size());
for (const auto &tx : vtx) {
s << " " << tx->ToString() << "\n";
}
return s.str();
}
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 41ac6ff1a..5c06ca0d5 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -1,131 +1,131 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 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 BITCOIN_PRIMITIVES_BLOCK_H
#define BITCOIN_PRIMITIVES_BLOCK_H
-#include "primitives/transaction.h"
-#include "serialize.h"
-#include "uint256.h"
+#include <primitives/transaction.h>
+#include <serialize.h>
+#include <uint256.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) {
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;
int64_t GetBlockTime() const { return (int64_t)nTime; }
};
class CBlock : public CBlockHeader {
public:
// network and disk
std::vector<CTransactionRef> vtx;
// memory only
mutable bool fChecked;
CBlock() { SetNull(); }
CBlock(const CBlockHeader &header) {
SetNull();
*(static_cast<CBlockHeader *>(this)) = header;
}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream &s, Operation ser_action) {
READWRITE(*static_cast<CBlockHeader *>(this));
READWRITE(vtx);
}
void SetNull() {
CBlockHeader::SetNull();
vtx.clear();
fChecked = false;
}
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() {}
explicit 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 nVersion = s.GetVersion();
if (!(s.GetType() & SER_GETHASH)) READWRITE(nVersion);
READWRITE(vHave);
}
void SetNull() { vHave.clear(); }
bool IsNull() const { return vHave.empty(); }
};
#endif // BITCOIN_PRIMITIVES_BLOCK_H
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index f4e58b39a..0c9798ada 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -1,137 +1,137 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#include "primitives/transaction.h"
+#include <primitives/transaction.h>
-#include "hash.h"
-#include "tinyformat.h"
-#include "utilstrencodings.h"
+#include <hash.h>
+#include <tinyformat.h>
+#include <utilstrencodings.h>
std::string COutPoint::ToString() const {
return strprintf("COutPoint(%s, %u)", txid.ToString().substr(0, 10), n);
}
std::string CTxIn::ToString() const {
std::string str;
str += "CTxIn(";
str += prevout.ToString();
if (prevout.IsNull()) {
str += strprintf(", coinbase %s", HexStr(scriptSig));
} else {
str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
}
if (nSequence != SEQUENCE_FINAL) {
str += strprintf(", nSequence=%u", nSequence);
}
str += ")";
return str;
}
std::string CTxOut::ToString() const {
return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN,
(nValue % COIN) / SATOSHI,
HexStr(scriptPubKey).substr(0, 30));
}
CMutableTransaction::CMutableTransaction()
: nVersion(CTransaction::CURRENT_VERSION), nLockTime(0) {}
CMutableTransaction::CMutableTransaction(const CTransaction &tx)
: nVersion(tx.nVersion), vin(tx.vin), vout(tx.vout),
nLockTime(tx.nLockTime) {}
static uint256 ComputeCMutableTransactionHash(const CMutableTransaction &tx) {
return SerializeHash(tx, SER_GETHASH, 0);
}
TxId CMutableTransaction::GetId() const {
return TxId(ComputeCMutableTransactionHash(*this));
}
TxHash CMutableTransaction::GetHash() const {
return TxHash(ComputeCMutableTransactionHash(*this));
}
uint256 CTransaction::ComputeHash() const {
return SerializeHash(*this, SER_GETHASH, 0);
}
/**
* For backward compatibility, the hash is initialized to 0.
* TODO: remove the need for this default constructor entirely.
*/
CTransaction::CTransaction()
: nVersion(CTransaction::CURRENT_VERSION), vin(), vout(), nLockTime(0),
hash() {}
CTransaction::CTransaction(const CMutableTransaction &tx)
: nVersion(tx.nVersion), vin(tx.vin), vout(tx.vout),
nLockTime(tx.nLockTime), hash(ComputeHash()) {}
CTransaction::CTransaction(CMutableTransaction &&tx)
: nVersion(tx.nVersion), vin(std::move(tx.vin)), vout(std::move(tx.vout)),
nLockTime(tx.nLockTime), hash(ComputeHash()) {}
Amount CTransaction::GetValueOut() const {
Amount nValueOut = Amount::zero();
for (const auto &tx_out : vout) {
nValueOut += tx_out.nValue;
if (!MoneyRange(tx_out.nValue) || !MoneyRange(nValueOut)) {
throw std::runtime_error(std::string(__func__) +
": value out of range");
}
}
return nValueOut;
}
double CTransaction::ComputePriority(double dPriorityInputs,
unsigned int nTxSize) const {
nTxSize = CalculateModifiedSize(nTxSize);
if (nTxSize == 0) {
return 0.0;
}
return dPriorityInputs / nTxSize;
}
unsigned int CTransaction::CalculateModifiedSize(unsigned int nTxSize) const {
// In order to avoid disincentivizing cleaning up the UTXO set we don't
// count the constant overhead for each txin and up to 110 bytes of
// scriptSig (which is enough to cover a compressed pubkey p2sh redemption)
// for priority. Providing any more cleanup incentive than making additional
// inputs free would risk encouraging people to create junk outputs to
// redeem later.
if (nTxSize == 0) {
nTxSize = GetTotalSize();
}
for (const auto &nVin : vin) {
unsigned int offset =
41U + std::min(110U, (unsigned int)nVin.scriptSig.size());
if (nTxSize > offset) {
nTxSize -= offset;
}
}
return nTxSize;
}
size_t CTransaction::GetBillableSize() const {
return ::GetSerializeSize(*this, SER_NETWORK, PROTOCOL_VERSION);
}
unsigned int CTransaction::GetTotalSize() const {
return ::GetSerializeSize(*this, SER_NETWORK, PROTOCOL_VERSION);
}
std::string CTransaction::ToString() const {
std::string str;
str += strprintf("CTransaction(txid=%s, ver=%d, vin.size=%u, vout.size=%u, "
"nLockTime=%u)\n",
GetId().ToString().substr(0, 10), nVersion, vin.size(),
vout.size(), nLockTime);
for (const auto &nVin : vin) {
str += " " + nVin.ToString() + "\n";
}
for (const auto &nVout : vout) {
str += " " + nVout.ToString() + "\n";
}
return str;
}
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index ec4a41482..ea28eedf8 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -1,391 +1,391 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2017-2018 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_PRIMITIVES_TRANSACTION_H
#define BITCOIN_PRIMITIVES_TRANSACTION_H
-#include "amount.h"
-#include "feerate.h"
-#include "primitives/txid.h"
-#include "script/script.h"
-#include "serialize.h"
+#include <amount.h>
+#include <feerate.h>
+#include <primitives/txid.h>
+#include <script/script.h>
+#include <serialize.h>
static const int SERIALIZE_TRANSACTION = 0x00;
/**
* An outpoint - a combination of a transaction hash and an index n into its
* vout.
*/
class COutPoint {
private:
TxId txid;
uint32_t n;
public:
COutPoint() : txid(), n(-1) {}
COutPoint(uint256 txidIn, uint32_t nIn) : txid(TxId(txidIn)), n(nIn) {}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream &s, Operation ser_action) {
READWRITE(txid);
READWRITE(n);
}
bool IsNull() const { return txid.IsNull() && n == uint32_t(-1); }
const TxId &GetTxId() const { return txid; }
uint32_t GetN() const { return n; }
friend bool operator<(const COutPoint &a, const COutPoint &b) {
int cmp = a.txid.Compare(b.txid);
return cmp < 0 || (cmp == 0 && a.n < b.n);
}
friend bool operator==(const COutPoint &a, const COutPoint &b) {
return (a.txid == b.txid && a.n == b.n);
}
friend bool operator!=(const COutPoint &a, const COutPoint &b) {
return !(a == b);
}
std::string ToString() const;
};
/**
* 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;
uint32_t nSequence;
/**
* Setting nSequence to this value for every input in a transaction disables
* nLockTime.
*/
static const uint32_t SEQUENCE_FINAL = 0xffffffff;
/* Below flags apply in the context of BIP 68*/
/**
* If this flag set, CTxIn::nSequence is NOT interpreted as a relative
* lock-time.
*/
static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = (1 << 31);
/**
* If CTxIn::nSequence encodes a relative lock-time and this flag is set,
* the relative lock-time has units of 512 seconds, otherwise it specifies
* blocks with a granularity of 1.
*/
static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22);
/**
* If CTxIn::nSequence encodes a relative lock-time, this mask is applied to
* extract that lock-time from the sequence field.
*/
static const uint32_t SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
/**
* In order to use the same number of bits to encode roughly the same
* wall-clock duration, and because blocks are naturally limited to occur
* every 600s on average, the minimum granularity for time-based relative
* lock-time is fixed at 512 seconds. Converting from CTxIn::nSequence to
* seconds is performed by multiplying by 512 = 2^9, or equivalently
* shifting up by 9 bits.
*/
static const int SEQUENCE_LOCKTIME_GRANULARITY = 9;
CTxIn() { nSequence = SEQUENCE_FINAL; }
explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn = CScript(),
uint32_t nSequenceIn = SEQUENCE_FINAL)
: prevout(prevoutIn), scriptSig(scriptSigIn), nSequence(nSequenceIn) {}
CTxIn(TxId prevTxId, uint32_t nOut, CScript scriptSigIn = CScript(),
uint32_t nSequenceIn = SEQUENCE_FINAL)
: CTxIn(COutPoint(prevTxId, nOut), scriptSigIn, nSequenceIn) {}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream &s, Operation ser_action) {
READWRITE(prevout);
READWRITE(scriptSig);
READWRITE(nSequence);
}
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;
};
/**
* 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:
Amount nValue;
CScript scriptPubKey;
CTxOut() { SetNull(); }
CTxOut(Amount nValueIn, CScript scriptPubKeyIn)
: nValue(nValueIn), scriptPubKey(scriptPubKeyIn) {}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream &s, Operation ser_action) {
READWRITE(nValue);
READWRITE(scriptPubKey);
}
void SetNull() {
nValue = -SATOSHI;
scriptPubKey.clear();
}
bool IsNull() const { return nValue == -SATOSHI; }
Amount GetDustThreshold(const CFeeRate &minRelayTxFee) const {
/**
* "Dust" is defined in terms of CTransaction::minRelayTxFee, 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 spendable
* non-segwit txout is 34 bytes big, and will need a CTxIn of at least
* 148 bytes to spend: so dust is a spendable txout less than
* 546*minRelayTxFee/1000 (in satoshis). A typical spendable segwit
* txout is 31 bytes big, and will need a CTxIn of at least 67 bytes to
* spend: so dust is a spendable txout less than 294*minRelayTxFee/1000
* (in satoshis).
*/
if (scriptPubKey.IsUnspendable()) {
return Amount::zero();
}
size_t nSize = GetSerializeSize(*this, SER_DISK, 0);
// the 148 mentioned above
nSize += (32 + 4 + 1 + 107 + 4);
return 3 * minRelayTxFee.GetFee(nSize);
}
bool IsDust(const CFeeRate &minRelayTxFee) const {
return (nValue < GetDustThreshold(minRelayTxFee));
}
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;
};
class CMutableTransaction;
/**
* Basic transaction serialization format:
* - int32_t nVersion
* - std::vector<CTxIn> vin
* - std::vector<CTxOut> vout
* - uint32_t nLockTime
*/
template <typename Stream, typename TxType>
inline void UnserializeTransaction(TxType &tx, Stream &s) {
s >> tx.nVersion;
tx.vin.clear();
tx.vout.clear();
/* Try to read the vin. In case the dummy is there, this will be read as an
* empty vector. */
s >> tx.vin;
/* We read a non-empty vin. Assume a normal vout follows. */
s >> tx.vout;
s >> tx.nLockTime;
}
template <typename Stream, typename TxType>
inline void SerializeTransaction(const TxType &tx, Stream &s) {
s << tx.nVersion;
s << tx.vin;
s << tx.vout;
s << tx.nLockTime;
}
/**
* The basic transaction that is broadcasted on the network and contained in
* blocks. A transaction can contain multiple inputs and outputs.
*/
class CTransaction {
public:
// Default transaction version.
static const int32_t CURRENT_VERSION = 2;
// Changing the default transaction version requires a two step process:
// first adapting relay policy by bumping MAX_STANDARD_VERSION, and then
// later date bumping the default CURRENT_VERSION at which point both
// CURRENT_VERSION and MAX_STANDARD_VERSION will be equal.
static const int32_t MAX_STANDARD_VERSION = 2;
// The local variables are made const to prevent unintended modification
// without updating the cached hash value. However, CTransaction is not
// actually immutable; deserialization and assignment are implemented,
// and bypass the constness. This is safe, as they update the entire
// structure, including the hash.
const int32_t nVersion;
const std::vector<CTxIn> vin;
const std::vector<CTxOut> vout;
const uint32_t nLockTime;
private:
/** Memory only. */
const uint256 hash;
uint256 ComputeHash() const;
public:
/** Construct a CTransaction that qualifies as IsNull() */
CTransaction();
/** Convert a CMutableTransaction into a CTransaction. */
explicit CTransaction(const CMutableTransaction &tx);
explicit CTransaction(CMutableTransaction &&tx);
template <typename Stream> inline void Serialize(Stream &s) const {
SerializeTransaction(*this, s);
}
/**
* This deserializing constructor is provided instead of an Unserialize
* method. Unserialize is not possible, since it would require overwriting
* const fields.
*/
template <typename Stream>
CTransaction(deserialize_type, Stream &s)
: CTransaction(CMutableTransaction(deserialize, s)) {}
bool IsNull() const { return vin.empty() && vout.empty(); }
const TxId GetId() const { return TxId(hash); }
const TxHash GetHash() const { return TxHash(hash); }
// Return sum of txouts.
Amount GetValueOut() const;
// GetValueIn() is a method on CCoinsViewCache, because
// inputs must be known to compute value in.
// Compute priority, given priority of inputs and (optionally) tx size
double ComputePriority(double dPriorityInputs,
unsigned int nTxSize = 0) const;
// Compute modified tx size for priority calculation (optionally given tx
// size)
unsigned int CalculateModifiedSize(unsigned int nTxSize = 0) const;
// Computes an adjusted tx size so that the UTXIs are billed partially
// upfront.
size_t GetBillableSize() const;
/**
* Get the total transaction size in bytes.
* @return Total transaction size in bytes
*/
unsigned int GetTotalSize() const;
bool IsCoinBase() const {
return (vin.size() == 1 && vin[0].prevout.IsNull());
}
friend bool operator==(const CTransaction &a, const CTransaction &b) {
return a.hash == b.hash;
}
friend bool operator!=(const CTransaction &a, const CTransaction &b) {
return a.hash != b.hash;
}
std::string ToString() const;
};
/**
* A mutable version of CTransaction.
*/
class CMutableTransaction {
public:
int32_t nVersion;
std::vector<CTxIn> vin;
std::vector<CTxOut> vout;
uint32_t nLockTime;
CMutableTransaction();
CMutableTransaction(const CTransaction &tx);
template <typename Stream> inline void Serialize(Stream &s) const {
SerializeTransaction(*this, s);
}
template <typename Stream> inline void Unserialize(Stream &s) {
UnserializeTransaction(*this, s);
}
template <typename Stream>
CMutableTransaction(deserialize_type, Stream &s) {
Unserialize(s);
}
/**
* Compute the id and hash of this CMutableTransaction. This is computed on
* the fly, as opposed to GetId() and GetHash() in CTransaction, which uses
* a cached result.
*/
TxId GetId() const;
TxHash GetHash() const;
friend bool operator==(const CMutableTransaction &a,
const CMutableTransaction &b) {
return a.GetId() == b.GetId();
}
};
typedef std::shared_ptr<const CTransaction> CTransactionRef;
static inline CTransactionRef MakeTransactionRef() {
return std::make_shared<const CTransaction>();
}
template <typename Tx>
static inline CTransactionRef MakeTransactionRef(Tx &&txIn) {
return std::make_shared<const CTransaction>(std::forward<Tx>(txIn));
}
/** Precompute sighash midstate to avoid quadratic hashing */
struct PrecomputedTransactionData {
uint256 hashPrevouts, hashSequence, hashOutputs;
PrecomputedTransactionData()
: hashPrevouts(), hashSequence(), hashOutputs() {}
PrecomputedTransactionData(const PrecomputedTransactionData &txdata)
: hashPrevouts(txdata.hashPrevouts), hashSequence(txdata.hashSequence),
hashOutputs(txdata.hashOutputs) {}
explicit PrecomputedTransactionData(const CTransaction &tx);
};
#endif // BITCOIN_PRIMITIVES_TRANSACTION_H
diff --git a/src/primitives/txid.h b/src/primitives/txid.h
index bf1e0ad1e..638c53008 100644
--- a/src/primitives/txid.h
+++ b/src/primitives/txid.h
@@ -1,26 +1,26 @@
// Copyright (c) 2018 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_PRIMITIVES_TXID_H
#define BITCOIN_PRIMITIVES_TXID_H
-#include "uint256.h"
+#include <uint256.h>
/**
* A TxId is the identifier of a transaction. Currently identical to TxHash but
* differentiated for type safety.
*/
struct TxId : public uint256 {
explicit TxId() : uint256() {}
explicit TxId(const uint256 &b) : uint256(b) {}
};
/**
* A TxHash is the double sha256 hash of the full transaction data.
*/
struct TxHash : public uint256 {
explicit TxHash(const uint256 &b) : uint256(b) {}
};
#endif // BITCOIN_PRIMITIVES_TXID_H

File Metadata

Mime Type
text/x-diff
Expires
Wed, Jan 29, 16:54 (10 h, 56 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5053340
Default Alt Text
(23 KB)

Event Timeline