mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-02-18 11:57:37 -05:00
4cef8e0593
984d72ec65 Return the script type from Solver (Ben Woosley)
Pull request description:
Because false is synonymous with TX_NONSTANDARD, this conveys the same
information and makes the handling explicitly based on script type,
simplifying each call site.
Prior to this change it was common for the return value to be ignored, or for the
return value and TX_NONSTANDARD to be redundantly handled.
Tree-SHA512: 31864f856b8cb75f4b782d12678070e8b1cfe9665c6f57cfb25e7ac8bcea8a22f9a78d7c8cf0101c841f2a612400666fb91798bffe88de856e98b873703b0965
326 lines
10 KiB
C++
326 lines
10 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2018 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 <script/standard.h>
|
|
|
|
#include <crypto/sha256.h>
|
|
#include <pubkey.h>
|
|
#include <script/script.h>
|
|
#include <util.h>
|
|
#include <utilstrencodings.h>
|
|
|
|
|
|
typedef std::vector<unsigned char> valtype;
|
|
|
|
bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;
|
|
unsigned nMaxDatacarrierBytes = MAX_OP_RETURN_RELAY;
|
|
|
|
CScriptID::CScriptID(const CScript& in) : uint160(Hash160(in.begin(), in.end())) {}
|
|
|
|
WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
|
|
{
|
|
CSHA256().Write(in.data(), in.size()).Finalize(begin());
|
|
}
|
|
|
|
const char* GetTxnOutputType(txnouttype t)
|
|
{
|
|
switch (t)
|
|
{
|
|
case TX_NONSTANDARD: return "nonstandard";
|
|
case TX_PUBKEY: return "pubkey";
|
|
case TX_PUBKEYHASH: return "pubkeyhash";
|
|
case TX_SCRIPTHASH: return "scripthash";
|
|
case TX_MULTISIG: return "multisig";
|
|
case TX_NULL_DATA: return "nulldata";
|
|
case TX_WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
|
|
case TX_WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
|
|
case TX_WITNESS_UNKNOWN: return "witness_unknown";
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static bool MatchPayToPubkey(const CScript& script, valtype& pubkey)
|
|
{
|
|
if (script.size() == CPubKey::PUBLIC_KEY_SIZE + 2 && script[0] == CPubKey::PUBLIC_KEY_SIZE && script.back() == OP_CHECKSIG) {
|
|
pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::PUBLIC_KEY_SIZE + 1);
|
|
return CPubKey::ValidSize(pubkey);
|
|
}
|
|
if (script.size() == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 2 && script[0] == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE && script.back() == OP_CHECKSIG) {
|
|
pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1);
|
|
return CPubKey::ValidSize(pubkey);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool MatchPayToPubkeyHash(const CScript& script, valtype& pubkeyhash)
|
|
{
|
|
if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 && script[2] == 20 && script[23] == OP_EQUALVERIFY && script[24] == OP_CHECKSIG) {
|
|
pubkeyhash = valtype(script.begin () + 3, script.begin() + 23);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** Test for "small positive integer" script opcodes - OP_1 through OP_16. */
|
|
static constexpr bool IsSmallInteger(opcodetype opcode)
|
|
{
|
|
return opcode >= OP_1 && opcode <= OP_16;
|
|
}
|
|
|
|
static bool MatchMultisig(const CScript& script, unsigned int& required, std::vector<valtype>& pubkeys)
|
|
{
|
|
opcodetype opcode;
|
|
valtype data;
|
|
CScript::const_iterator it = script.begin();
|
|
if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) return false;
|
|
|
|
if (!script.GetOp(it, opcode, data) || !IsSmallInteger(opcode)) return false;
|
|
required = CScript::DecodeOP_N(opcode);
|
|
while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
|
|
pubkeys.emplace_back(std::move(data));
|
|
}
|
|
if (!IsSmallInteger(opcode)) return false;
|
|
unsigned int keys = CScript::DecodeOP_N(opcode);
|
|
if (pubkeys.size() != keys || keys < required) return false;
|
|
return (it + 1 == script.end());
|
|
}
|
|
|
|
txnouttype Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned char>>& vSolutionsRet)
|
|
{
|
|
vSolutionsRet.clear();
|
|
|
|
// Shortcut for pay-to-script-hash, which are more constrained than the other types:
|
|
// it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
|
|
if (scriptPubKey.IsPayToScriptHash())
|
|
{
|
|
std::vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
|
|
vSolutionsRet.push_back(hashBytes);
|
|
return TX_SCRIPTHASH;
|
|
}
|
|
|
|
int witnessversion;
|
|
std::vector<unsigned char> witnessprogram;
|
|
if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
|
|
if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
|
|
vSolutionsRet.push_back(witnessprogram);
|
|
return TX_WITNESS_V0_KEYHASH;
|
|
}
|
|
if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
|
|
vSolutionsRet.push_back(witnessprogram);
|
|
return TX_WITNESS_V0_SCRIPTHASH;
|
|
}
|
|
if (witnessversion != 0) {
|
|
vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
|
|
vSolutionsRet.push_back(std::move(witnessprogram));
|
|
return TX_WITNESS_UNKNOWN;
|
|
}
|
|
return TX_NONSTANDARD;
|
|
}
|
|
|
|
// Provably prunable, data-carrying output
|
|
//
|
|
// So long as script passes the IsUnspendable() test and all but the first
|
|
// byte passes the IsPushOnly() test we don't care what exactly is in the
|
|
// script.
|
|
if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN && scriptPubKey.IsPushOnly(scriptPubKey.begin()+1)) {
|
|
return TX_NULL_DATA;
|
|
}
|
|
|
|
std::vector<unsigned char> data;
|
|
if (MatchPayToPubkey(scriptPubKey, data)) {
|
|
vSolutionsRet.push_back(std::move(data));
|
|
return TX_PUBKEY;
|
|
}
|
|
|
|
if (MatchPayToPubkeyHash(scriptPubKey, data)) {
|
|
vSolutionsRet.push_back(std::move(data));
|
|
return TX_PUBKEYHASH;
|
|
}
|
|
|
|
unsigned int required;
|
|
std::vector<std::vector<unsigned char>> keys;
|
|
if (MatchMultisig(scriptPubKey, required, keys)) {
|
|
vSolutionsRet.push_back({static_cast<unsigned char>(required)}); // safe as required is in range 1..16
|
|
vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
|
|
vSolutionsRet.push_back({static_cast<unsigned char>(keys.size())}); // safe as size is in range 1..16
|
|
return TX_MULTISIG;
|
|
}
|
|
|
|
vSolutionsRet.clear();
|
|
return TX_NONSTANDARD;
|
|
}
|
|
|
|
bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
|
|
{
|
|
std::vector<valtype> vSolutions;
|
|
txnouttype whichType = Solver(scriptPubKey, vSolutions);
|
|
|
|
if (whichType == TX_PUBKEY) {
|
|
CPubKey pubKey(vSolutions[0]);
|
|
if (!pubKey.IsValid())
|
|
return false;
|
|
|
|
addressRet = pubKey.GetID();
|
|
return true;
|
|
}
|
|
else if (whichType == TX_PUBKEYHASH)
|
|
{
|
|
addressRet = CKeyID(uint160(vSolutions[0]));
|
|
return true;
|
|
}
|
|
else if (whichType == TX_SCRIPTHASH)
|
|
{
|
|
addressRet = CScriptID(uint160(vSolutions[0]));
|
|
return true;
|
|
} else if (whichType == TX_WITNESS_V0_KEYHASH) {
|
|
WitnessV0KeyHash hash;
|
|
std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
|
|
addressRet = hash;
|
|
return true;
|
|
} else if (whichType == TX_WITNESS_V0_SCRIPTHASH) {
|
|
WitnessV0ScriptHash hash;
|
|
std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
|
|
addressRet = hash;
|
|
return true;
|
|
} else if (whichType == TX_WITNESS_UNKNOWN) {
|
|
WitnessUnknown unk;
|
|
unk.version = vSolutions[0][0];
|
|
std::copy(vSolutions[1].begin(), vSolutions[1].end(), unk.program);
|
|
unk.length = vSolutions[1].size();
|
|
addressRet = unk;
|
|
return true;
|
|
}
|
|
// Multisig txns have more than one address...
|
|
return false;
|
|
}
|
|
|
|
bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, std::vector<CTxDestination>& addressRet, int& nRequiredRet)
|
|
{
|
|
addressRet.clear();
|
|
std::vector<valtype> vSolutions;
|
|
typeRet = Solver(scriptPubKey, vSolutions);
|
|
if (typeRet == TX_NONSTANDARD) {
|
|
return false;
|
|
} else if (typeRet == TX_NULL_DATA) {
|
|
// This is data, not addresses
|
|
return false;
|
|
}
|
|
|
|
if (typeRet == TX_MULTISIG)
|
|
{
|
|
nRequiredRet = vSolutions.front()[0];
|
|
for (unsigned int i = 1; i < vSolutions.size()-1; i++)
|
|
{
|
|
CPubKey pubKey(vSolutions[i]);
|
|
if (!pubKey.IsValid())
|
|
continue;
|
|
|
|
CTxDestination address = pubKey.GetID();
|
|
addressRet.push_back(address);
|
|
}
|
|
|
|
if (addressRet.empty())
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
nRequiredRet = 1;
|
|
CTxDestination address;
|
|
if (!ExtractDestination(scriptPubKey, address))
|
|
return false;
|
|
addressRet.push_back(address);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class CScriptVisitor : public boost::static_visitor<bool>
|
|
{
|
|
private:
|
|
CScript *script;
|
|
public:
|
|
explicit CScriptVisitor(CScript *scriptin) { script = scriptin; }
|
|
|
|
bool operator()(const CNoDestination &dest) const {
|
|
script->clear();
|
|
return false;
|
|
}
|
|
|
|
bool operator()(const CKeyID &keyID) const {
|
|
script->clear();
|
|
*script << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
|
|
return true;
|
|
}
|
|
|
|
bool operator()(const CScriptID &scriptID) const {
|
|
script->clear();
|
|
*script << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
|
|
return true;
|
|
}
|
|
|
|
bool operator()(const WitnessV0KeyHash& id) const
|
|
{
|
|
script->clear();
|
|
*script << OP_0 << ToByteVector(id);
|
|
return true;
|
|
}
|
|
|
|
bool operator()(const WitnessV0ScriptHash& id) const
|
|
{
|
|
script->clear();
|
|
*script << OP_0 << ToByteVector(id);
|
|
return true;
|
|
}
|
|
|
|
bool operator()(const WitnessUnknown& id) const
|
|
{
|
|
script->clear();
|
|
*script << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
|
|
return true;
|
|
}
|
|
};
|
|
} // namespace
|
|
|
|
CScript GetScriptForDestination(const CTxDestination& dest)
|
|
{
|
|
CScript script;
|
|
|
|
boost::apply_visitor(CScriptVisitor(&script), dest);
|
|
return script;
|
|
}
|
|
|
|
CScript GetScriptForRawPubKey(const CPubKey& pubKey)
|
|
{
|
|
return CScript() << std::vector<unsigned char>(pubKey.begin(), pubKey.end()) << OP_CHECKSIG;
|
|
}
|
|
|
|
CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
|
|
{
|
|
CScript script;
|
|
|
|
script << CScript::EncodeOP_N(nRequired);
|
|
for (const CPubKey& key : keys)
|
|
script << ToByteVector(key);
|
|
script << CScript::EncodeOP_N(keys.size()) << OP_CHECKMULTISIG;
|
|
return script;
|
|
}
|
|
|
|
CScript GetScriptForWitness(const CScript& redeemscript)
|
|
{
|
|
std::vector<std::vector<unsigned char> > vSolutions;
|
|
txnouttype typ = Solver(redeemscript, vSolutions);
|
|
if (typ == TX_PUBKEY) {
|
|
return GetScriptForDestination(WitnessV0KeyHash(Hash160(vSolutions[0].begin(), vSolutions[0].end())));
|
|
} else if (typ == TX_PUBKEYHASH) {
|
|
return GetScriptForDestination(WitnessV0KeyHash(vSolutions[0]));
|
|
}
|
|
return GetScriptForDestination(WitnessV0ScriptHash(redeemscript));
|
|
}
|
|
|
|
bool IsValidDestination(const CTxDestination& dest) {
|
|
return dest.which() != 0;
|
|
}
|