standard.cpp

// 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 <script/standard.h>

#include <pubkey.h>
#include <script/script.h>
#include <util/strencodings.h>
#include <util/system.h>

using valtype = std::vector<uint8_t>;

bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;

CScriptID::CScriptID(const CScript &in)
    : uint160(Hash160(in.begin(), in.end())) {}

const char *GetTxnOutputType(txnouttype t) {
    switch (t) {
        case TX_NONSTANDARD:
            return "nonstandard";
        case TX_PUBKEY:
            return "pubkey";
        case TX_BLSPUBKEY:
            return "blspubkey";
        case TX_PUBKEYHASH:
            return "pubkeyhash";
        case TX_BLSKEYHASH:
            return "blskeyhash";
        case TX_SCRIPTHASH:
            return "scripthash";
        case TX_MULTISIG:
            return "multisig";
        case TX_NULL_DATA:
            return "nulldata";
    }
    return nullptr;
}

static bool MatchPayToPubkey(const CScript &script, valtype &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;
}

bool MatchPayToBLSPubkey(const CScript &script, valtype &pubkey) {
    if (script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE + 2 &&
        script[0] == CPubKey::BLS_PUBLIC_KEY_SIZE &&
        script.back() == OP_CHECKSIG) {
        pubkey =
            valtype(script.begin() + 1,
                    script.begin() + CPubKey::BLS_PUBLIC_KEY_SIZE + 1);
        return true;
    }
    //std::cout << "Script size in MatchPay = " << script.size() << "\n";
    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;
}

bool MatchPayToBLSkeyHash(const CScript &script, valtype &pubkeyhash) {
    if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_BLSKEYHASH &&
        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());
}

// Just used for debug stuff. BLS P2PKH (25) would be same size as a legacy P2PKH
bool IsValidBLSScriptSize(const CScript &script) {
  // for all inputs except final, should only be either 0, BLS_PUBLIC_KEY_SIZE + 1, BLS_PUBLIC_KEY_SIZE + 2
  // Last input will be BLS_SIGNATURE_SIZE + 1 + n*(BLS_PUBLIC_KEY_SIZE+2)
  auto script_size = script.size();
  //std::cout << "Script size = << " << script_size << "\n";
  if (script_size > CPubKey::BLS_PUBLIC_KEY_SIZE+2) {
    script_size -= (CPubKey::BLS_SIGNATURE_SIZE + 3);
    return ((script_size % (CPubKey::BLS_PUBLIC_KEY_SIZE+1) == 0));
  } else {
    return ((script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE+1) ||
            (script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE+2) ||
            (script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE) ||
            (script.size() == 25) || // B2PKH
            (script.size() == 0));
  }
}

bool IsValidBLSPubKeySize(const CScript &script) {
   return ((script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE+2) ||
           (script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE+1) ||
           (script.size() == CPubKey::BLS_PUBLIC_KEY_SIZE+CPubKey::BLS_SIGNATURE_SIZE+4));
}

CPubKey ExtractBLSPubKey(const CScript & scr) {
    CPubKey pubkey(scr.begin()+1,scr.begin()+CPubKey::BLS_PUBLIC_KEY_SIZE+1);
    return pubkey;
}

std::vector<uint8_t> ExtractBLSSig(const CScript & scr) {
    // Handle Agg Sig
    std::vector<uint8_t> aggSig = std::vector<uint8_t>(scr.begin()+2, scr.begin()+2+CPubKey::BLS_SIGNATURE_SIZE);
    return aggSig;
}

std::tuple<CPubKey,std::vector<uint8_t> > ExtractBLSPubKeyAndSig(const CScript & scr) {
    // Handle Grabbing PubKey + Agg Sig
    std::vector<uint8_t> aggSig = std::vector<uint8_t>(scr.begin()+2, scr.begin()+2+CPubKey::BLS_SIGNATURE_SIZE);
    CPubKey pubkey(scr.begin()+4+CPubKey::BLS_SIGNATURE_SIZE,
                   scr.begin()+4+CPubKey::BLS_SIGNATURE_SIZE+CPubKey::BLS_PUBLIC_KEY_SIZE);
    return std::tuple(pubkey,aggSig);
}

std::tuple<std::vector<std::vector<uint8_t>>,std::vector<uint8_t> > ExtractBLSPubKeysAndSig(const CScript & scr, int rand_keys) {
    std::vector<std::vector<uint8_t> > pubkeys;
    
    int start = 1;
    for (int i=0;i < rand_keys+1 ; i++) {
        std::vector<uint8_t> p = std::vector<uint8_t>(scr.begin()+start, scr.begin()+start+CPubKey::BLS_PUBLIC_KEY_SIZE);
        start += CPubKey::BLS_PUBLIC_KEY_SIZE + 1;
        pubkeys.push_back(p);
    }
    
    start++;
    std::vector<uint8_t> aggSig = std::vector<uint8_t>(scr.begin()+start, scr.begin()+start+CPubKey::BLS_SIGNATURE_SIZE+1);

    
    return std::tuple(pubkeys,aggSig);
}
    


bool Solver(const CScript &scriptPubKey, txnouttype &typeRet,
            std::vector<std::vector<uint8_t>> &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()) {
        typeRet = TX_SCRIPTHASH;
        std::vector<uint8_t> hashBytes(scriptPubKey.begin() + 2,
                                       scriptPubKey.begin() + 22);
        vSolutionsRet.push_back(hashBytes);
        return true;
    }

    // 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)) {
        typeRet = TX_NULL_DATA;
        return true;
    }

    std::vector<uint8_t> data;
    if (MatchPayToPubkey(scriptPubKey, data)) {
        typeRet = TX_PUBKEY;
        vSolutionsRet.push_back(std::move(data));
        return true;
    }
  
    if (MatchPayToBLSPubkey(scriptPubKey, data)) {
        typeRet = TX_BLSPUBKEY;
        vSolutionsRet.push_back(std::move(data));
        return true;
    }

    if (MatchPayToPubkeyHash(scriptPubKey, data)) {
        typeRet = TX_PUBKEYHASH;
        vSolutionsRet.push_back(std::move(data));
        return true;
    }

    // just checking for BLS..
    if (MatchPayToBLSkeyHash(scriptPubKey, data)) {
        typeRet = TX_BLSKEYHASH;
        vSolutionsRet.push_back(std::move(data));
        return true;
    }

    unsigned int required;
    std::vector<std::vector<uint8_t>> keys;
    if (MatchMultisig(scriptPubKey, required, keys)) {
        typeRet = TX_MULTISIG;
        // safe as required is in range 1..16
        vSolutionsRet.push_back({static_cast<uint8_t>(required)});
        vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
        // safe as size is in range 1..16
        vSolutionsRet.push_back({static_cast<uint8_t>(keys.size())});
        return true;
    }

    vSolutionsRet.clear();
    typeRet = TX_NONSTANDARD;
    return false;
}

bool ExtractDestination(const CScript &scriptPubKey,
                        CTxDestination &addressRet) {
    std::vector<valtype> vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKey, whichType, vSolutions)) {
        return false;
    }

    if (whichType == TX_PUBKEY) {
        CPubKey pubKey(vSolutions[0]);
        if (!pubKey.IsValid()) {
            return false;
        }

        addressRet = pubKey.GetKeyID();
        return true;
    }
    if (whichType == TX_BLSPUBKEY) {
        CPubKey pubKey(vSolutions[0]);
        if (!pubKey.IsValid()) {
            return false;
        }

        addressRet = pubKey.GetBLSKeyID();
        return true;
    }

    if (whichType == TX_PUBKEYHASH) {
        addressRet = CKeyID(uint160(vSolutions[0]));
        return true;
    }
    if (whichType == TX_BLSKEYHASH) {
        addressRet = BKeyID(uint160(vSolutions[0]));
        return true;
    }
    if (whichType == TX_SCRIPTHASH) {
        addressRet = CScriptID(uint160(vSolutions[0]));
        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();
    typeRet = TX_NONSTANDARD;
    std::vector<valtype> vSolutions;
    if (!Solver(scriptPubKey, typeRet, vSolutions)) {
        return false;
    }
    if (typeRet == TX_NULL_DATA) {
        // This is data, not addresses
        return false;
    }

    if (typeRet == TX_MULTISIG) {
        nRequiredRet = vSolutions.front()[0];
        for (size_t i = 1; i < vSolutions.size() - 1; i++) {
            CPubKey pubKey(vSolutions[i]);
            if (!pubKey.IsValid()) {
                continue;
            }

            CTxDestination address = pubKey.GetKeyID();
            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 std::variant<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 BKeyID &keyID) const {
        script->clear();
        *script << OP_DUP << OP_BLSKEYHASH << 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;
    }
};
} // namespace

CScript GetScriptForDestination(const CTxDestination &dest) {
    CScript script;
    std::visit(CScriptVisitor(&script), dest);
    return script;
}

CScript GetScriptForRawPubKey(const CPubKey &pubKey) {
    return CScript() << std::vector<uint8_t>(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;
}

bool IsValidDestination(const CTxDestination &dest) {
  return !std::holds_alternative<CNoDestination>(dest);
}