Page MenuHomePhabricator
Differential D8415 Diff 25768 src/script/descriptor.cpp

Changeset View

Standalone View

View Options

src/script/descriptor.cpp

Show First 20 Lines • Show All 733 Lines • ▼ Show 20 Lines Optional<OutputType> GetOutputType() const override {
case 1 /* PKHash */: case 1 /* PKHash */:
case 2 /* ScriptHash */: case 2 /* ScriptHash */:
return OutputType::LEGACY; return OutputType::LEGACY;
case 0 /* CNoDestination */: case 0 /* CNoDestination */:
default: default:
return nullopt; return nullopt;
} }
} }
bool IsSingleType() const final { return true; }
}; };
/** A parsed raw(H) descriptor. */ /** A parsed raw(H) descriptor. */
class RawDescriptor final : public DescriptorImpl { class RawDescriptor final : public DescriptorImpl {
const CScript m_script; const CScript m_script;
protected: protected:
std::string ToStringExtra() const override { std::string ToStringExtra() const override {
Show All 17 Lines Optional<OutputType> GetOutputType() const override {
case 1 /* PKHash */: case 1 /* PKHash */:
case 2 /* ScriptHash */: case 2 /* ScriptHash */:
return OutputType::LEGACY; return OutputType::LEGACY;
case 0 /* CNoDestination */: case 0 /* CNoDestination */:
default: default:
return nullopt; return nullopt;
} }
} }
bool IsSingleType() const final { return true; }
}; };
/** A parsed pk(P) descriptor. */ /** A parsed pk(P) descriptor. */
class PKDescriptor final : public DescriptorImpl { class PKDescriptor final : public DescriptorImpl {
protected: protected:
std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys, std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
const CScript *, const CScript *,
FlatSigningProvider &) const override { FlatSigningProvider &) const override {
return Vector(GetScriptForRawPubKey(keys[0])); return Vector(GetScriptForRawPubKey(keys[0]));
} }
public: public:
PKDescriptor(std::unique_ptr<PubkeyProvider> prov) PKDescriptor(std::unique_ptr<PubkeyProvider> prov)
: DescriptorImpl(Vector(std::move(prov)), {}, "pk") {} : DescriptorImpl(Vector(std::move(prov)), {}, "pk") {}
bool IsSingleType() const final { return true; }
}; };
/** A parsed pkh(P) descriptor. */ /** A parsed pkh(P) descriptor. */
class PKHDescriptor final : public DescriptorImpl { class PKHDescriptor final : public DescriptorImpl {
protected: protected:
std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys, std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
const CScript *, const CScript *,
FlatSigningProvider &out) const override { FlatSigningProvider &out) const override {
CKeyID id = keys[0].GetID(); CKeyID id = keys[0].GetID();
out.pubkeys.emplace(id, keys[0]); out.pubkeys.emplace(id, keys[0]);
return Vector(GetScriptForDestination(PKHash(id))); return Vector(GetScriptForDestination(PKHash(id)));
} }
public: public:
PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) PKHDescriptor(std::unique_ptr<PubkeyProvider> prov)
: DescriptorImpl(Vector(std::move(prov)), {}, "pkh") {} : DescriptorImpl(Vector(std::move(prov)), {}, "pkh") {}
Optional<OutputType> GetOutputType() const override { Optional<OutputType> GetOutputType() const override {
return OutputType::LEGACY; return OutputType::LEGACY;
} }
bool IsSingleType() const final { return true; }
}; };
/** A parsed combo(P) descriptor. */ /** A parsed combo(P) descriptor. */
class ComboDescriptor final : public DescriptorImpl { class ComboDescriptor final : public DescriptorImpl {
protected: protected:
std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys, std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
const CScript *, const CScript *,
FlatSigningProvider &out) const override { FlatSigningProvider &out) const override {
std::vector<CScript> ret; std::vector<CScript> ret;
CKeyID id = keys[0].GetID(); CKeyID id = keys[0].GetID();
out.pubkeys.emplace(id, keys[0]); out.pubkeys.emplace(id, keys[0]);
// P2PK // P2PK
ret.emplace_back(GetScriptForRawPubKey(keys[0])); ret.emplace_back(GetScriptForRawPubKey(keys[0]));
// P2PKH // P2PKH
ret.emplace_back(GetScriptForDestination(PKHash(id))); ret.emplace_back(GetScriptForDestination(PKHash(id)));
return ret; return ret;
} }
public: public:
ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) ComboDescriptor(std::unique_ptr<PubkeyProvider> prov)
: DescriptorImpl(Vector(std::move(prov)), {}, "combo") {} : DescriptorImpl(Vector(std::move(prov)), {}, "combo") {}
bool IsSingleType() const final { return false; }
}; };
/** A parsed multi(...) descriptor. */ /** A parsed multi(...) descriptor. */
class MultisigDescriptor final : public DescriptorImpl { class MultisigDescriptor final : public DescriptorImpl {
const int m_threshold; const int m_threshold;
const bool m_sorted; const bool m_sorted;
protected: protected:
Show All 13 Lines
public: public:
MultisigDescriptor(int threshold, MultisigDescriptor(int threshold,
std::vector<std::unique_ptr<PubkeyProvider>> providers, std::vector<std::unique_ptr<PubkeyProvider>> providers,
bool sorted = false) bool sorted = false)
: DescriptorImpl(std::move(providers), {}, : DescriptorImpl(std::move(providers), {},
sorted ? "sortedmulti" : "multi"), sorted ? "sortedmulti" : "multi"),
m_threshold(threshold), m_sorted(sorted) {} m_threshold(threshold), m_sorted(sorted) {}
bool IsSingleType() const final { return true; }
}; };
/** A parsed sh(...) descriptor. */ /** A parsed sh(...) descriptor. */
class SHDescriptor final : public DescriptorImpl { class SHDescriptor final : public DescriptorImpl {
protected: protected:
std::vector<CScript> MakeScripts(const std::vector<CPubKey> &, std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
const CScript *script, const CScript *script,
FlatSigningProvider &) const override { FlatSigningProvider &) const override {
return Vector(GetScriptForDestination(ScriptHash(*script))); return Vector(GetScriptForDestination(ScriptHash(*script)));
} }
public: public:
SHDescriptor(std::unique_ptr<DescriptorImpl> desc) SHDescriptor(std::unique_ptr<DescriptorImpl> desc)
: DescriptorImpl({}, std::move(desc), "sh") {} : DescriptorImpl({}, std::move(desc), "sh") {}
Optional<OutputType> GetOutputType() const override { Optional<OutputType> GetOutputType() const override {
return OutputType::LEGACY; return OutputType::LEGACY;
} }
bool IsSingleType() const final { return true; }
}; };
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Parser // // Parser //
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
enum class ParseScriptContext { enum class ParseScriptContext {
TOP, TOP,
▲ Show 20 Lines • Show All 463 Lines • Show Last 20 Lines