git / moonbite-core / src/script/signingprovider.cpp · raw
// Copyright (c) 2009-2010 Satoshi Nakamoto// Copyright (c) 2009-2019 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/keyorigin.h>#include <script/signingprovider.h>#include <script/standard.h>#include <util/system.h>const SigningProvider& DUMMY_SIGNING_PROVIDER = SigningProvider();template<typename M, typename K, typename V>bool LookupHelper(const M& map, const K& key, V& value){ auto it = map.find(key); if (it != map.end()) { value = it->second; return true; } return false;}bool HidingSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const{ return m_provider->GetCScript(scriptid, script);}bool HidingSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const{ return m_provider->GetPubKey(keyid, pubkey);}bool HidingSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const{ if (m_hide_secret) return false; return m_provider->GetKey(keyid, key);}bool HidingSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const{ if (m_hide_origin) return false; return m_provider->GetKeyOrigin(keyid, info);}bool FlatSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const { return LookupHelper(scripts, scriptid, script); }bool FlatSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const { return LookupHelper(pubkeys, keyid, pubkey); }bool FlatSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const{ std::pair<CPubKey, KeyOriginInfo> out; bool ret = LookupHelper(origins, keyid, out); if (ret) info = std::move(out.second); return ret;}bool FlatSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const { return LookupHelper(keys, keyid, key); }FlatSigningProvider Merge(const FlatSigningProvider& a, const FlatSigningProvider& b){ FlatSigningProvider ret; ret.scripts = a.scripts; ret.scripts.insert(b.scripts.begin(), b.scripts.end()); ret.pubkeys = a.pubkeys; ret.pubkeys.insert(b.pubkeys.begin(), b.pubkeys.end()); ret.keys = a.keys; ret.keys.insert(b.keys.begin(), b.keys.end()); ret.origins = a.origins; ret.origins.insert(b.origins.begin(), b.origins.end()); return ret;}void FillableSigningProvider::ImplicitlyLearnRelatedKeyScripts(const CPubKey& pubkey){ AssertLockHeld(cs_KeyStore); CKeyID key_id = pubkey.GetID(); // This adds the redeemscripts necessary to detect P2WPKH and P2SH-P2WPKH // outputs. Technically P2WPKH outputs don't have a redeemscript to be // spent. However, our current IsMine logic requires the corresponding // P2SH-P2WPKH redeemscript to be present in the wallet in order to accept // payment even to P2WPKH outputs. // Also note that having superfluous scripts in the keystore never hurts. // They're only used to guide recursion in signing and IsMine logic - if // a script is present but we can't do anything with it, it has no effect. // "Implicitly" refers to fact that scripts are derived automatically from // existing keys, and are present in memory, even without being explicitly // loaded (e.g. from a file). if (pubkey.IsCompressed()) { CScript script = GetScriptForDestination(WitnessV0KeyHash(key_id)); // This does not use AddCScript, as it may be overridden. CScriptID id(script); mapScripts[id] = std::move(script); }}bool FillableSigningProvider::GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const{ CKey key; if (!GetKey(address, key)) { return false; } vchPubKeyOut = key.GetPubKey(); return true;}bool FillableSigningProvider::AddKeyPubKey(const CKey& key, const CPubKey &pubkey){ LOCK(cs_KeyStore); mapKeys[pubkey.GetID()] = key; ImplicitlyLearnRelatedKeyScripts(pubkey); return true;}bool FillableSigningProvider::HaveKey(const CKeyID &address) const{ LOCK(cs_KeyStore); return mapKeys.count(address) > 0;}std::set<CKeyID> FillableSigningProvider::GetKeys() const{ LOCK(cs_KeyStore); std::set<CKeyID> set_address; for (const auto& mi : mapKeys) { set_address.insert(mi.first); } return set_address;}bool FillableSigningProvider::GetKey(const CKeyID &address, CKey &keyOut) const{ LOCK(cs_KeyStore); KeyMap::const_iterator mi = mapKeys.find(address); if (mi != mapKeys.end()) { keyOut = mi->second; return true; } return false;}bool FillableSigningProvider::AddCScript(const CScript& redeemScript){ if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) return error("FillableSigningProvider::AddCScript(): redeemScripts > %i bytes are invalid", MAX_SCRIPT_ELEMENT_SIZE); LOCK(cs_KeyStore); mapScripts[CScriptID(redeemScript)] = redeemScript; return true;}bool FillableSigningProvider::HaveCScript(const CScriptID& hash) const{ LOCK(cs_KeyStore); return mapScripts.count(hash) > 0;}std::set<CScriptID> FillableSigningProvider::GetCScripts() const{ LOCK(cs_KeyStore); std::set<CScriptID> set_script; for (const auto& mi : mapScripts) { set_script.insert(mi.first); } return set_script;}bool FillableSigningProvider::GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const{ LOCK(cs_KeyStore); ScriptMap::const_iterator mi = mapScripts.find(hash); if (mi != mapScripts.end()) { redeemScriptOut = (*mi).second; return true; } return false;}CKeyID GetKeyForDestination(const SigningProvider& store, const CTxDestination& dest){ // Only supports destinations which map to single public keys, i.e. P2PKH, // P2WPKH, and P2SH-P2WPKH. if (auto id = boost::get<PKHash>(&dest)) { return ToKeyID(*id); } if (auto witness_id = boost::get<WitnessV0KeyHash>(&dest)) { return ToKeyID(*witness_id); } if (auto script_hash = boost::get<ScriptHash>(&dest)) { CScript script; CScriptID script_id(*script_hash); CTxDestination inner_dest; if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) { if (auto inner_witness_id = boost::get<WitnessV0KeyHash>(&inner_dest)) { return ToKeyID(*inner_witness_id); } } } if (auto stealth_address = boost::get<StealthAddress>(&dest)) { return stealth_address->B().GetID(); } return CKeyID();}