#include <string>
#include <vector>
-#include <boost/foreach.hpp>
-
#include "keystore.h"
#include "bignum.h"
+#include "base58.h"
typedef std::vector<uint8_t> valtype;
class CTransaction;
+class CBitcoinAddress;
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520; // bytes
-/** IsMine() return codes */
+// Setting nSequence to this value for every input in a transaction
+// disables nLockTime.
+static const uint32_t SEQUENCE_FINAL = 0xffffffff;
+
+// Threshold for inverted nSequence: below this value it is interpreted
+// as a relative lock-time, otherwise ignored.
+//static const uint32_t SEQUENCE_THRESHOLD = 0x80000000;
+
+// If this flag set, CTxIn::nSequence is NOT interpreted as a
+// relative lock-time.
+static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = 0x80000000;
+
+// 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 = 0x00400000;
+
+// 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;
+
+// IsMine() return codes
enum isminetype
{
MINE_NO = 0,
typedef uint8_t isminefilter;
-/** Signature hash types/flags */
+// Signature hash types/flags
enum
{
SIGHASH_ALL = 1,
SIGHASH_ANYONECANPAY = 0x80
};
-/** Script verification flags */
+// Script verification flags
enum
{
SCRIPT_VERIFY_NONE = 0,
SCRIPT_VERIFY_STRICTENC = (1U << 1), // enforce strict conformance to DER and SEC2 for signatures and pubkeys
SCRIPT_VERIFY_LOW_S = (1U << 2), // enforce low S values in signatures (depends on STRICTENC)
SCRIPT_VERIFY_NOCACHE = (1U << 3), // do not store results in signature cache (but do query it)
- SCRIPT_VERIFY_NULLDUMMY = (1U << 4), // verify dummy stack item consumed by CHECKMULTISIG is of zero-length
- SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY = (1U << 9)
-
+ SCRIPT_VERIFY_NULLDUMMY = (1U << 4), // verify dummy stack item consumed by CHECKMULTISIG is of zero-length
+ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY = (1U << 9),
+ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY = (1U << 10)
};
// Strict verification:
const char* GetTxnOutputType(txnouttype t);
-/** Script opcodes */
-enum opcodetype
+// Script opcodes
+enum opcodetype : uint8_t
{
// push value
OP_0 = 0x00,
OP_VERIFY = 0x69,
OP_RETURN = 0x6a,
OP_CHECKLOCKTIMEVERIFY = 0xb1,
+ OP_CHECKSEQUENCEVERIFY = 0xb2,
// stack ops
OP_TOALTSTACK = 0x6b,
// expansion
OP_NOP1 = 0xb0,
- OP_NOP3 = 0xb2,
OP_NOP4 = 0xb3,
OP_NOP5 = 0xb4,
OP_NOP6 = 0xb5,
OP_NOP9 = 0xb8,
OP_NOP10 = 0xb9,
-
-
// template matching params
OP_SMALLDATA = 0xf9,
OP_SMALLINTEGER = 0xfa,
OP_PUBKEYS = 0xfb,
+ OP_INTEGER = 0xfc,
OP_PUBKEYHASH = 0xfd,
OP_PUBKEY = 0xfe,
inline std::string StackString(const std::vector<std::vector<unsigned char> >& vStack)
{
std::string str;
- BOOST_FOREACH(const std::vector<unsigned char>& vch, vStack)
+ for(const auto& vch : vStack)
{
if (!str.empty())
str += " ";
return str;
}
-/** Serialized script, used inside transaction inputs and outputs */
+// Serialized script, used inside transaction inputs and outputs
class CScript : public std::vector<uint8_t>
{
protected:
- CScript& push_int64(int64_t n)
- {
- if (n == -1 || (n >= 1 && n <= 16))
- {
- push_back((uint8_t)n + (OP_1 - 1));
- }
- else
- {
- CBigNum bn(n);
- *this << bn.getvch();
- }
- return *this;
- }
- CScript& push_uint64(uint64_t n)
- {
- if (n >= 1 && n <= 16)
- {
- push_back((uint8_t)n + (OP_1 - 1));
- }
- else
- {
- CBigNum bn(n);
- *this << bn.getvch();
- }
- return *this;
- }
+ CScript& push_int64(int64_t n);
+ CScript& push_uint64(uint64_t n);
public:
CScript() { }
CScript(const uint8_t* pbegin, const uint8_t* pend) : std::vector<uint8_t>(pbegin, pend) { }
#endif
- CScript& operator+=(const CScript& b)
- {
- insert(end(), b.begin(), b.end());
- return *this;
- }
+ CScript& operator+=(const CScript& b);
friend CScript operator+(const CScript& a, const CScript& b)
{
CScript& operator<<(uint32_t b) { return push_uint64(b); }
CScript& operator<<(uint64_t b) { return push_uint64(b); }
- CScript& operator<<(opcodetype opcode)
- {
- if (opcode < 0 || opcode > 0xff)
- throw std::runtime_error("CScript::operator<<() : invalid opcode");
- insert(end(), (uint8_t)opcode);
- return *this;
- }
+ CScript& operator<<(opcodetype opcode);
+ CScript& operator<<(const uint160& b);
+ CScript& operator<<(const uint256& b);
+ CScript& operator<<(const CPubKey& key);
+ CScript& operator<<(const CBigNum& b);
+ CScript& operator<<(const std::vector<uint8_t>& b);
+ CScript& operator<<(const CScript& b);
- CScript& operator<<(const uint160& b)
- {
- insert(end(), sizeof(b));
- insert(end(), (uint8_t*)&b, (uint8_t*)&b + sizeof(b));
- return *this;
- }
-
- CScript& operator<<(const uint256& b)
- {
- insert(end(), sizeof(b));
- insert(end(), (uint8_t*)&b, (uint8_t*)&b + sizeof(b));
- return *this;
- }
-
- CScript& operator<<(const CPubKey& key)
- {
- std::vector<uint8_t> vchKey = key.Raw();
- return (*this) << vchKey;
- }
-
- CScript& operator<<(const CBigNum& b)
- {
- *this << b.getvch();
- return *this;
- }
-
- CScript& operator<<(const std::vector<uint8_t>& b)
- {
- if (b.size() < OP_PUSHDATA1)
- {
- insert(end(), (uint8_t)b.size());
- }
- else if (b.size() <= 0xff)
- {
- insert(end(), OP_PUSHDATA1);
- insert(end(), (uint8_t)b.size());
- }
- else if (b.size() <= 0xffff)
- {
- insert(end(), OP_PUSHDATA2);
- uint16_t nSize = (uint16_t) b.size();
- insert(end(), (uint8_t*)&nSize, (uint8_t*)&nSize + sizeof(nSize));
- }
- else
- {
- insert(end(), OP_PUSHDATA4);
- uint32_t nSize = (uint32_t) b.size();
- insert(end(), (uint8_t*)&nSize, (uint8_t*)&nSize + sizeof(nSize));
- }
- insert(end(), b.begin(), b.end());
- return *this;
- }
-
- CScript& operator<<(const CScript& b)
- {
- // I'm not sure if this should push the script or concatenate scripts.
- // If there's ever a use for pushing a script onto a script, delete this member fn
- assert(!"Warning: Pushing a CScript onto a CScript with << is probably not intended, use + to concatenate!");
- return *this;
- }
-
-
- bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<uint8_t>& vchRet)
- {
- // Wrapper so it can be called with either iterator or const_iterator
- const_iterator pc2 = pc;
- bool fRet = GetOp2(pc2, opcodeRet, &vchRet);
- pc = begin() + (pc2 - begin());
- return fRet;
- }
-
- bool GetOp(iterator& pc, opcodetype& opcodeRet)
- {
- const_iterator pc2 = pc;
- bool fRet = GetOp2(pc2, opcodeRet, NULL);
- pc = begin() + (pc2 - begin());
- return fRet;
- }
-
- bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<uint8_t>& vchRet) const
- {
- return GetOp2(pc, opcodeRet, &vchRet);
- }
-
- bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
- {
- return GetOp2(pc, opcodeRet, NULL);
- }
-
- bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<uint8_t>* pvchRet) const
- {
- opcodeRet = OP_INVALIDOPCODE;
- if (pvchRet)
- pvchRet->clear();
- if (pc >= end())
- return false;
-
- // Read instruction
- if (end() - pc < 1)
- return false;
- uint32_t opcode = *pc++;
-
- // Immediate operand
- if (opcode <= OP_PUSHDATA4)
- {
- uint32_t nSize = OP_0;
- if (opcode < OP_PUSHDATA1)
- {
- nSize = opcode;
- }
- else if (opcode == OP_PUSHDATA1)
- {
- if (end() - pc < 1)
- return false;
- nSize = *pc++;
- }
- else if (opcode == OP_PUSHDATA2)
- {
- if (end() - pc < 2)
- return false;
- memcpy(&nSize, &pc[0], 2);
- pc += 2;
- }
- else if (opcode == OP_PUSHDATA4)
- {
- if (end() - pc < 4)
- return false;
- memcpy(&nSize, &pc[0], 4);
- pc += 4;
- }
- if (end() - pc < 0 || (uint32_t)(end() - pc) < nSize)
- return false;
- if (pvchRet)
- pvchRet->assign(pc, pc + nSize);
- pc += nSize;
- }
-
- opcodeRet = (opcodetype)opcode;
- return true;
- }
+ bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<uint8_t>& vchRet);
+ bool GetOp(iterator& pc, opcodetype& opcodeRet);
+ bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<uint8_t>& vchRet) const;
+ bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const;
+ bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<uint8_t>* pvchRet) const;
// Encode/decode small integers:
- static int DecodeOP_N(opcodetype opcode)
- {
- if (opcode == OP_0)
- return 0;
- assert(opcode >= OP_1 && opcode <= OP_16);
- return (opcode - (OP_1 - 1));
- }
- static opcodetype EncodeOP_N(int n)
- {
- assert(n >= 0 && n <= 16);
- if (n == 0)
- return OP_0;
- return (opcodetype)(OP_1+n-1);
- }
+ static int DecodeOP_N(opcodetype opcode);
+ static opcodetype EncodeOP_N(int n);
- int FindAndDelete(const CScript& b)
- {
- int nFound = 0;
- if (b.empty())
- return nFound;
- iterator pc = begin();
- opcodetype opcode;
- do
- {
- while (end() - pc >= (long)b.size() && memcmp(&pc[0], &b[0], b.size()) == 0)
- {
- erase(pc, pc + b.size());
- ++nFound;
- }
- }
- while (GetOp(pc, opcode));
- return nFound;
- }
- int Find(opcodetype op) const
- {
- int nFound = 0;
- opcodetype opcode;
- for (const_iterator pc = begin(); pc != end() && GetOp(pc, opcode);)
- if (opcode == op)
- ++nFound;
- return nFound;
- }
+ int FindAndDelete(const CScript& b);
+ int Find(opcodetype op) const;
// Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs
// as 20 sigops. With pay-to-script-hash, that changed:
bool IsPayToScriptHash() const;
+ bool IsPushOnly(const_iterator pc) const;
+
// Called by CTransaction::IsStandard and P2SH VerifyScript (which makes it consensus-critical).
- bool IsPushOnly() const
- {
- const_iterator pc = begin();
- while (pc < end())
- {
- opcodetype opcode;
- if (!GetOp(pc, opcode))
- return false;
- if (opcode > OP_16)
- return false;
- }
- return true;
- }
+ bool IsPushOnly() const;
// Called by CTransaction::IsStandard.
bool HasCanonicalPushes() const;
void SetDestination(const CTxDestination& address);
- void SetDestination(const CPubKey& R, CPubKey& pubKeyVariant);
- void SetMultisig(int nRequired, const std::vector<CKey>& keys);
-
-
- void PrintHex() const
- {
- printf("CScript(%s)\n", HexStr(begin(), end(), true).c_str());
- }
+ void SetAddress(const CBitcoinAddress& dest);
+ void SetMultisig(int nRequired, const std::vector<CPubKey>& keys);
- std::string ToString(bool fShort=false) const
- {
- std::string str;
- opcodetype opcode;
- std::vector<uint8_t> vch;
- const_iterator pc = begin();
- while (pc < end())
- {
- if (!str.empty())
- str += " ";
- if (!GetOp(pc, opcode, vch))
- {
- str += "[error]";
- return str;
- }
- if (0 <= opcode && opcode <= OP_PUSHDATA4)
- str += fShort? ValueString(vch).substr(0, 10) : ValueString(vch);
- else
- str += GetOpName(opcode);
- }
- return str;
- }
-
- void print() const
- {
- printf("%s\n", ToString().c_str());
- }
-
- CScriptID GetID() const
- {
- return CScriptID(Hash160(*this));
- }
+ void PrintHex() const;
+ std::string ToString(bool fShort=false) const;
+ void print() const;
+ CScriptID GetID() const;
};
bool IsCanonicalPubKey(const std::vector<unsigned char> &vchPubKey, unsigned int flags);
bool IsDERSignature(const valtype &vchSig, bool fWithHashType=false, bool fCheckLow=false);
bool IsCanonicalSignature(const std::vector<unsigned char> &vchSig, unsigned int flags);
-bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
+bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, uint32_t nIn, unsigned int flags, int nHashType);
bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, std::vector<std::vector<unsigned char> >& vSolutionsRet);
int ScriptSigArgsExpected(txnouttype t, const std::vector<std::vector<unsigned char> >& vSolutions);
bool IsStandard(const CScript& scriptPubKey, txnouttype& whichType);
isminetype IsMine(const CKeyStore& keystore, const CScript& scriptPubKey);
-isminetype IsMine(const CKeyStore& keystore, const CTxDestination& dest);
+//isminetype IsMine(const CKeyStore& keystore, const CTxDestination& dest);
+isminetype IsMine(const CKeyStore& keystore, const CBitcoinAddress& dest);
void ExtractAffectedKeys(const CKeyStore &keystore, const CScript& scriptPubKey, std::vector<CKeyID> &vKeys);
bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet);
+bool ExtractAddress(const CKeyStore &keystore, const CScript& scriptPubKey, CBitcoinAddress& addressRet);
bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, std::vector<CTxDestination>& addressRet, int& nRequiredRet);
-bool SignSignature(const CKeyStore& keystore, const CScript& fromPubKey, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL);
-bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL);
-bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
+bool SignSignature(const CKeyStore& keystore, const CScript& fromPubKey, CTransaction& txTo, uint32_t nIn, int nHashType=SIGHASH_ALL);
+bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, uint32_t nIn, int nHashType=SIGHASH_ALL);
+bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, uint32_t nIn, unsigned int flags, int nHashType);
// Given two sets of signatures for scriptPubKey, possibly with OP_0 placeholders,
// combine them intelligently and return the result.
git://git.novaco.in / novacoin.git / blobdiff