#ifndef H_BITCOIN_SCRIPT
#define H_BITCOIN_SCRIPT
+#include "keystore.h"
+#include "bignum.h"
+#include "util.h"
+
#include <string>
#include <vector>
-#include <boost/foreach.hpp>
-
-#include "keystore.h"
-#include "bignum.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_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 */
+// Script opcodes
enum opcodetype
{
// push value
OP_ENDIF = 0x68,
OP_VERIFY = 0x69,
OP_RETURN = 0x6a,
+ OP_CHECKLOCKTIMEVERIFY = 0xb1,
+ OP_CHECKSEQUENCEVERIFY = 0xb2,
// stack ops
OP_TOALTSTACK = 0x6b,
// expansion
OP_NOP1 = 0xb0,
- OP_NOP2 = 0xb1,
- 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 std::vector<unsigned char>& 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(const uint8_t* pbegin, const uint8_t* pend) : std::vector<uint8_t>(pbegin, pend) { }
#endif
+ CScript& operator=(const CScript&) = default;
+
CScript& operator+=(const CScript& b)
{
insert(end(), b.begin(), b.end());
CScript& operator<<(const CPubKey& key)
{
- std::vector<uint8_t> vchKey = key.Raw();
+ std::vector<uint8_t> vchKey(key.begin(), key.end());
return (*this) << vchKey;
}
bool IsPayToScriptHash() const;
- // Called by CTransaction::IsStandard and P2SH VerifyScript (which makes it consensus-critical).
- bool IsPushOnly() const
+ bool IsPushOnly(const_iterator pc) const
{
- const_iterator pc = begin();
while (pc < end())
{
opcodetype opcode;
return true;
}
+ // Called by CTransaction::IsStandard and P2SH VerifyScript (which makes it consensus-critical).
+ bool IsPushOnly() const
+ {
+ return this->IsPushOnly(begin());
+ }
+
// 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 SetAddress(const CBitcoinAddress& dest);
+ void SetMultisig(int nRequired, const std::vector<CPubKey>& keys);
void PrintHex() const
printf("%s\n", ToString().c_str());
}
- CScriptID GetID() const
- {
- return CScriptID(Hash160(*this));
- }
+ CScriptID GetID() const;
};
bool IsCanonicalPubKey(const std::vector<unsigned char> &vchPubKey, unsigned int flags);
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);
git://git.novaco.in / novacoin.git / blobdiff