mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-19 13:27:35 +02:00
UPSTREAM MERGE BROKEN: Merge commit 'f617e05c38' into master
This commit is contained in:
Steven Roose
commit
7f894ae00b
393 changed files with 7992 additions and 3340 deletions
|
|
@ -10,8 +10,8 @@
|
|||
#include <script/standard.h>
|
||||
|
||||
#include <span.h>
|
||||
#include <util.h>
|
||||
#include <utilstrencodings.h>
|
||||
#include <util/system.h>
|
||||
#include <util/strencodings.h>
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
|
@ -41,7 +41,7 @@ struct PubkeyProvider
|
|||
virtual ~PubkeyProvider() = default;
|
||||
|
||||
/** Derive a public key. */
|
||||
virtual bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& out) const = 0;
|
||||
virtual bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const = 0;
|
||||
|
||||
/** Whether this represent multiple public keys at different positions. */
|
||||
virtual bool IsRange() const = 0;
|
||||
|
|
@ -56,6 +56,37 @@ struct PubkeyProvider
|
|||
virtual bool ToPrivateString(const SigningProvider& arg, std::string& out) const = 0;
|
||||
};
|
||||
|
||||
class OriginPubkeyProvider final : public PubkeyProvider
|
||||
{
|
||||
KeyOriginInfo m_origin;
|
||||
std::unique_ptr<PubkeyProvider> m_provider;
|
||||
|
||||
std::string OriginString() const
|
||||
{
|
||||
return HexStr(std::begin(m_origin.fingerprint), std::end(m_origin.fingerprint)) + FormatKeyPath(m_origin.path);
|
||||
}
|
||||
|
||||
public:
|
||||
OriginPubkeyProvider(KeyOriginInfo info, std::unique_ptr<PubkeyProvider> provider) : m_origin(std::move(info)), m_provider(std::move(provider)) {}
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const override
|
||||
{
|
||||
if (!m_provider->GetPubKey(pos, arg, key, info)) return false;
|
||||
std::copy(std::begin(m_origin.fingerprint), std::end(m_origin.fingerprint), info.fingerprint);
|
||||
info.path.insert(info.path.begin(), m_origin.path.begin(), m_origin.path.end());
|
||||
return true;
|
||||
}
|
||||
bool IsRange() const override { return m_provider->IsRange(); }
|
||||
size_t GetSize() const override { return m_provider->GetSize(); }
|
||||
std::string ToString() const override { return "[" + OriginString() + "]" + m_provider->ToString(); }
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& ret) const override
|
||||
{
|
||||
std::string sub;
|
||||
if (!m_provider->ToPrivateString(arg, sub)) return false;
|
||||
ret = "[" + OriginString() + "]" + std::move(sub);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/** An object representing a parsed constant public key in a descriptor. */
|
||||
class ConstPubkeyProvider final : public PubkeyProvider
|
||||
{
|
||||
|
|
@ -63,9 +94,12 @@ class ConstPubkeyProvider final : public PubkeyProvider
|
|||
|
||||
public:
|
||||
ConstPubkeyProvider(const CPubKey& pubkey) : m_pubkey(pubkey) {}
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& out) const override
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const override
|
||||
{
|
||||
out = m_pubkey;
|
||||
key = m_pubkey;
|
||||
info.path.clear();
|
||||
CKeyID keyid = m_pubkey.GetID();
|
||||
std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint), info.fingerprint);
|
||||
return true;
|
||||
}
|
||||
bool IsRange() const override { return false; }
|
||||
|
|
@ -98,7 +132,7 @@ class BIP32PubkeyProvider final : public PubkeyProvider
|
|||
CKey key;
|
||||
if (!arg.GetKey(m_extkey.pubkey.GetID(), key)) return false;
|
||||
ret.nDepth = m_extkey.nDepth;
|
||||
std::copy(m_extkey.vchFingerprint, m_extkey.vchFingerprint + 4, ret.vchFingerprint);
|
||||
std::copy(m_extkey.vchFingerprint, m_extkey.vchFingerprint + sizeof(ret.vchFingerprint), ret.vchFingerprint);
|
||||
ret.nChild = m_extkey.nChild;
|
||||
ret.chaincode = m_extkey.chaincode;
|
||||
ret.key = key;
|
||||
|
|
@ -118,27 +152,32 @@ public:
|
|||
BIP32PubkeyProvider(const CExtPubKey& extkey, KeyPath path, DeriveType derive) : m_extkey(extkey), m_path(std::move(path)), m_derive(derive) {}
|
||||
bool IsRange() const override { return m_derive != DeriveType::NO; }
|
||||
size_t GetSize() const override { return 33; }
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& out) const override
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const override
|
||||
{
|
||||
if (IsHardened()) {
|
||||
CExtKey key;
|
||||
if (!GetExtKey(arg, key)) return false;
|
||||
CExtKey extkey;
|
||||
if (!GetExtKey(arg, extkey)) return false;
|
||||
for (auto entry : m_path) {
|
||||
key.Derive(key, entry);
|
||||
extkey.Derive(extkey, entry);
|
||||
}
|
||||
if (m_derive == DeriveType::UNHARDENED) key.Derive(key, pos);
|
||||
if (m_derive == DeriveType::HARDENED) key.Derive(key, pos | 0x80000000UL);
|
||||
out = key.Neuter().pubkey;
|
||||
if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
|
||||
if (m_derive == DeriveType::HARDENED) extkey.Derive(extkey, pos | 0x80000000UL);
|
||||
key = extkey.Neuter().pubkey;
|
||||
} else {
|
||||
// TODO: optimize by caching
|
||||
CExtPubKey key = m_extkey;
|
||||
CExtPubKey extkey = m_extkey;
|
||||
for (auto entry : m_path) {
|
||||
key.Derive(key, entry);
|
||||
extkey.Derive(extkey, entry);
|
||||
}
|
||||
if (m_derive == DeriveType::UNHARDENED) key.Derive(key, pos);
|
||||
if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
|
||||
assert(m_derive != DeriveType::HARDENED);
|
||||
out = key.pubkey;
|
||||
key = extkey.pubkey;
|
||||
}
|
||||
CKeyID keyid = m_extkey.pubkey.GetID();
|
||||
std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint), info.fingerprint);
|
||||
info.path = m_path;
|
||||
if (m_derive == DeriveType::UNHARDENED) info.path.push_back((uint32_t)pos);
|
||||
if (m_derive == DeriveType::HARDENED) info.path.push_back(((uint32_t)pos) | 0x80000000L);
|
||||
return true;
|
||||
}
|
||||
std::string ToString() const override
|
||||
|
|
@ -221,9 +260,11 @@ public:
|
|||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
{
|
||||
CPubKey key;
|
||||
if (!m_provider->GetPubKey(pos, arg, key)) return false;
|
||||
KeyOriginInfo info;
|
||||
if (!m_provider->GetPubKey(pos, arg, key, info)) return false;
|
||||
output_scripts = std::vector<CScript>{m_script_fn(key)};
|
||||
out.pubkeys.emplace(key.GetID(), std::move(key));
|
||||
out.origins.emplace(key.GetID(), std::move(info));
|
||||
out.pubkeys.emplace(key.GetID(), key);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
|
@ -272,15 +313,19 @@ public:
|
|||
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
{
|
||||
std::vector<CPubKey> pubkeys;
|
||||
pubkeys.reserve(m_providers.size());
|
||||
std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;
|
||||
entries.reserve(m_providers.size());
|
||||
// Construct temporary data in `entries`, to avoid producing output in case of failure.
|
||||
for (const auto& p : m_providers) {
|
||||
CPubKey key;
|
||||
if (!p->GetPubKey(pos, arg, key)) return false;
|
||||
pubkeys.push_back(key);
|
||||
entries.emplace_back();
|
||||
if (!p->GetPubKey(pos, arg, entries.back().first, entries.back().second)) return false;
|
||||
}
|
||||
for (const CPubKey& key : pubkeys) {
|
||||
out.pubkeys.emplace(key.GetID(), std::move(key));
|
||||
std::vector<CPubKey> pubkeys;
|
||||
pubkeys.reserve(entries.size());
|
||||
for (auto& entry : entries) {
|
||||
pubkeys.push_back(entry.first);
|
||||
out.origins.emplace(entry.first.GetID(), std::move(entry.second));
|
||||
out.pubkeys.emplace(entry.first.GetID(), entry.first);
|
||||
}
|
||||
output_scripts = std::vector<CScript>{GetScriptForMultisig(m_threshold, pubkeys)};
|
||||
return true;
|
||||
|
|
@ -343,13 +388,15 @@ public:
|
|||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
{
|
||||
CPubKey key;
|
||||
if (!m_provider->GetPubKey(pos, arg, key)) return false;
|
||||
KeyOriginInfo info;
|
||||
if (!m_provider->GetPubKey(pos, arg, key, info)) return false;
|
||||
CKeyID keyid = key.GetID();
|
||||
{
|
||||
CScript p2pk = GetScriptForRawPubKey(key);
|
||||
CScript p2pkh = GetScriptForDestination(PKHash(keyid));
|
||||
output_scripts = std::vector<CScript>{std::move(p2pk), std::move(p2pkh)};
|
||||
out.pubkeys.emplace(keyid, key);
|
||||
out.origins.emplace(keyid, std::move(info));
|
||||
}
|
||||
if (key.IsCompressed()) {
|
||||
CScript p2wpkh = GetScriptForDestination(WitnessV0KeyHash(keyid));
|
||||
|
|
@ -447,7 +494,8 @@ bool ParseKeyPath(const std::vector<Span<const char>>& split, KeyPath& out)
|
|||
return true;
|
||||
}
|
||||
|
||||
std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char>& sp, bool permit_uncompressed, FlatSigningProvider& out)
|
||||
/** Parse a public key that excludes origin information. */
|
||||
std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char>& sp, bool permit_uncompressed, FlatSigningProvider& out)
|
||||
{
|
||||
auto split = Split(sp, '/');
|
||||
std::string str(split[0].begin(), split[0].end());
|
||||
|
|
@ -484,6 +532,28 @@ std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char>& sp, bool per
|
|||
return MakeUnique<BIP32PubkeyProvider>(extpubkey, std::move(path), type);
|
||||
}
|
||||
|
||||
/** Parse a public key including origin information (if enabled). */
|
||||
std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char>& sp, bool permit_uncompressed, FlatSigningProvider& out)
|
||||
{
|
||||
auto origin_split = Split(sp, ']');
|
||||
if (origin_split.size() > 2) return nullptr;
|
||||
if (origin_split.size() == 1) return ParsePubkeyInner(origin_split[0], permit_uncompressed, out);
|
||||
if (origin_split[0].size() < 1 || origin_split[0][0] != '[') return nullptr;
|
||||
auto slash_split = Split(origin_split[0].subspan(1), '/');
|
||||
if (slash_split[0].size() != 8) return nullptr;
|
||||
std::string fpr_hex = std::string(slash_split[0].begin(), slash_split[0].end());
|
||||
if (!IsHex(fpr_hex)) return nullptr;
|
||||
auto fpr_bytes = ParseHex(fpr_hex);
|
||||
KeyOriginInfo info;
|
||||
static_assert(sizeof(info.fingerprint) == 4, "Fingerprint must be 4 bytes");
|
||||
assert(fpr_bytes.size() == 4);
|
||||
std::copy(fpr_bytes.begin(), fpr_bytes.end(), info.fingerprint);
|
||||
if (!ParseKeyPath(slash_split, info.path)) return nullptr;
|
||||
auto provider = ParsePubkeyInner(origin_split[1], permit_uncompressed, out);
|
||||
if (!provider) return nullptr;
|
||||
return MakeUnique<OriginPubkeyProvider>(std::move(info), std::move(provider));
|
||||
}
|
||||
|
||||
/** Parse a script in a particular context. */
|
||||
std::unique_ptr<Descriptor> ParseScript(Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@ namespace {
|
|||
*/
|
||||
enum class IsMineSigVersion
|
||||
{
|
||||
TOP = 0, //! scriptPubKey execution
|
||||
P2SH = 1, //! P2SH redeemScript
|
||||
WITNESS_V0 = 2 //! P2WSH witness script execution
|
||||
TOP = 0, //!< scriptPubKey execution
|
||||
P2SH = 1, //!< P2SH redeemScript
|
||||
WITNESS_V0 = 2, //!< P2WSH witness script execution
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -36,10 +36,10 @@ enum class IsMineSigVersion
|
|||
*/
|
||||
enum class IsMineResult
|
||||
{
|
||||
NO = 0, //! Not ours
|
||||
WATCH_ONLY = 1, //! Included in watch-only balance
|
||||
SPENDABLE = 2, //! Included in all balances
|
||||
INVALID = 3, //! Not spendable by anyone (uncompressed pubkey in segwit, P2SH inside P2SH or witness, witness inside witness)
|
||||
NO = 0, //!< Not ours
|
||||
WATCH_ONLY = 1, //!< Included in watch-only balance
|
||||
SPENDABLE = 2, //!< Included in all balances
|
||||
INVALID = 3, //!< Not spendable by anyone (uncompressed pubkey in segwit, P2SH inside P2SH or witness, witness inside witness)
|
||||
};
|
||||
|
||||
bool PermitsUncompressed(IsMineSigVersion sigversion)
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
#include <script/script.h>
|
||||
|
||||
#include <tinyformat.h>
|
||||
#include <utilstrencodings.h>
|
||||
#include <util/strencodings.h>
|
||||
|
||||
const char* GetOpName(opcodetype opcode)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -42,6 +42,12 @@ static const int MAX_STACK_SIZE = 1000;
|
|||
// otherwise as UNIX timestamp.
|
||||
static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
|
||||
|
||||
// Maximum nLockTime. Since a lock time indicates the last invalid timestamp, a
|
||||
// transaction with this lock time will never be valid unless lock time
|
||||
// checking is disabled (by setting all input sequence numbers to
|
||||
// SEQUENCE_FINAL).
|
||||
static const uint32_t LOCKTIME_MAX = 0xFFFFFFFFU;
|
||||
|
||||
// ELEMENTS:
|
||||
// Number of confirms on parent chain required to confirm on sidechain.
|
||||
static const unsigned int DEFAULT_PEGIN_CONFIRMATION_DEPTH = 8;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
#include <pubkey.h>
|
||||
#include <random.h>
|
||||
#include <uint256.h>
|
||||
#include <util.h>
|
||||
#include <util/system.h>
|
||||
|
||||
#include <cuckoocache.h>
|
||||
#include <boost/thread.hpp>
|
||||
|
|
|
|||
|
|
@ -75,15 +75,18 @@ static bool GetPubKey(const SigningProvider& provider, SignatureData& sigdata, c
|
|||
return false;
|
||||
}
|
||||
|
||||
static bool CreateSig(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const CKeyID& keyid, const CScript& scriptcode, SigVersion sigversion)
|
||||
static bool CreateSig(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const CPubKey& pubkey, const CScript& scriptcode, SigVersion sigversion)
|
||||
{
|
||||
CKeyID keyid = pubkey.GetID();
|
||||
const auto it = sigdata.signatures.find(keyid);
|
||||
if (it != sigdata.signatures.end()) {
|
||||
sig_out = it->second.second;
|
||||
return true;
|
||||
}
|
||||
CPubKey pubkey;
|
||||
GetPubKey(provider, sigdata, keyid, pubkey);
|
||||
KeyOriginInfo info;
|
||||
if (provider.GetKeyOrigin(keyid, info)) {
|
||||
sigdata.misc_pubkeys.emplace(keyid, std::make_pair(pubkey, std::move(info)));
|
||||
}
|
||||
if (creator.CreateSig(provider, sig_out, keyid, scriptcode, sigversion)) {
|
||||
auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
|
||||
assert(i.second);
|
||||
|
|
@ -116,15 +119,15 @@ static bool SignStep(const SigningProvider& provider, const BaseSignatureCreator
|
|||
case TX_WITNESS_UNKNOWN:
|
||||
return false;
|
||||
case TX_PUBKEY:
|
||||
if (!CreateSig(creator, sigdata, provider, sig, CPubKey(vSolutions[0]).GetID(), scriptPubKey, sigversion)) return false;
|
||||
if (!CreateSig(creator, sigdata, provider, sig, CPubKey(vSolutions[0]), scriptPubKey, sigversion)) return false;
|
||||
ret.push_back(std::move(sig));
|
||||
return true;
|
||||
case TX_PUBKEYHASH: {
|
||||
CKeyID keyID = CKeyID(uint160(vSolutions[0]));
|
||||
if (!CreateSig(creator, sigdata, provider, sig, keyID, scriptPubKey, sigversion)) return false;
|
||||
ret.push_back(std::move(sig));
|
||||
CPubKey pubkey;
|
||||
GetPubKey(provider, sigdata, keyID, pubkey);
|
||||
if (!GetPubKey(provider, sigdata, keyID, pubkey)) return false;
|
||||
if (!CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) return false;
|
||||
ret.push_back(std::move(sig));
|
||||
ret.push_back(ToByteVector(pubkey));
|
||||
return true;
|
||||
}
|
||||
|
|
@ -140,7 +143,7 @@ static bool SignStep(const SigningProvider& provider, const BaseSignatureCreator
|
|||
ret.push_back(valtype()); // workaround CHECKMULTISIG bug
|
||||
for (size_t i = 1; i < vSolutions.size() - 1; ++i) {
|
||||
CPubKey pubkey = CPubKey(vSolutions[i]);
|
||||
if (ret.size() < required + 1 && CreateSig(creator, sigdata, provider, sig, pubkey.GetID(), scriptPubKey, sigversion)) {
|
||||
if (ret.size() < required + 1 && CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) {
|
||||
ret.push_back(std::move(sig));
|
||||
}
|
||||
}
|
||||
|
|
@ -241,10 +244,17 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
|
|||
return sigdata.complete;
|
||||
}
|
||||
|
||||
bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& tx, PSBTInput& input, int index, int sighash)
|
||||
bool PSBTInputSigned(PSBTInput& input)
|
||||
{
|
||||
// if this input has a final scriptsig or scriptwitness, don't do anything with it
|
||||
if (!input.final_script_sig.empty() || !input.final_script_witness.IsNull()) {
|
||||
return !input.final_script_sig.empty() || !input.final_script_witness.IsNull();
|
||||
}
|
||||
|
||||
bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, int sighash)
|
||||
{
|
||||
PSBTInput& input = psbt.inputs.at(index);
|
||||
const CMutableTransaction& tx = *psbt.tx;
|
||||
|
||||
if (PSBTInputSigned(input)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -255,15 +265,19 @@ bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& t
|
|||
// Get UTXO
|
||||
bool require_witness_sig = false;
|
||||
CTxOut utxo;
|
||||
|
||||
// Verify input sanity, which checks that at most one of witness or non-witness utxos is provided.
|
||||
if (!input.IsSane()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (input.non_witness_utxo) {
|
||||
// If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
|
||||
if (input.non_witness_utxo->GetHash() != tx.vin[index].prevout.hash) return false;
|
||||
// If both witness and non-witness UTXO are provided, verify that they match. This check shouldn't
|
||||
// matter, as the PSBT deserializer enforces only one of both is provided, and the only way both
|
||||
// can be present is when they're added simultaneously by FillPSBT (in which case they always match).
|
||||
// Still, check in order to not rely on callers to enforce this.
|
||||
if (!input.witness_utxo.IsNull() && input.non_witness_utxo->vout[tx.vin[index].prevout.n] != input.witness_utxo) return false;
|
||||
utxo = input.non_witness_utxo->vout[tx.vin[index].prevout.n];
|
||||
COutPoint prevout = tx.vin[index].prevout;
|
||||
if (input.non_witness_utxo->GetHash() != prevout.hash) {
|
||||
return false;
|
||||
}
|
||||
utxo = input.non_witness_utxo->vout[prevout.n];
|
||||
} else if (!input.witness_utxo.IsNull()) {
|
||||
utxo = input.witness_utxo;
|
||||
// When we're taking our information from a witness UTXO, we can't verify it is actually data from
|
||||
|
|
@ -282,13 +296,10 @@ bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& t
|
|||
if (require_witness_sig && !sigdata.witness) return false;
|
||||
input.FromSignatureData(sigdata);
|
||||
|
||||
// If both UTXO types are present, drop the unnecessary one.
|
||||
if (input.non_witness_utxo && !input.witness_utxo.IsNull()) {
|
||||
if (sigdata.witness) {
|
||||
input.non_witness_utxo = nullptr;
|
||||
} else {
|
||||
input.witness_utxo.SetNull();
|
||||
}
|
||||
// If we have a witness signature, use the smaller witness UTXO.
|
||||
if (sigdata.witness) {
|
||||
input.witness_utxo = utxo;
|
||||
input.non_witness_utxo = nullptr;
|
||||
}
|
||||
|
||||
return sig_complete;
|
||||
|
|
@ -514,6 +525,12 @@ bool IsSolvable(const SigningProvider& provider, const CScript& script)
|
|||
return false;
|
||||
}
|
||||
|
||||
PartiallySignedTransaction::PartiallySignedTransaction(const CTransaction& tx) : tx(tx)
|
||||
{
|
||||
inputs.resize(tx.vin.size());
|
||||
outputs.resize(tx.vout.size());
|
||||
}
|
||||
|
||||
bool PartiallySignedTransaction::IsNull() const
|
||||
{
|
||||
return !tx && inputs.empty() && outputs.empty() && unknown.empty();
|
||||
|
|
@ -692,6 +709,7 @@ bool HidingSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& inf
|
|||
|
||||
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 { return LookupHelper(origins, keyid, info); }
|
||||
bool FlatSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const { return LookupHelper(keys, keyid, key); }
|
||||
|
||||
FlatSigningProvider Merge(const FlatSigningProvider& a, const FlatSigningProvider& b)
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ public:
|
|||
virtual bool GetCScript(const CScriptID &scriptid, CScript& script) const { return false; }
|
||||
virtual bool GetPubKey(const CKeyID &address, CPubKey& pubkey) const { return false; }
|
||||
virtual bool GetKey(const CKeyID &address, CKey& key) const { return false; }
|
||||
virtual bool GetKeyOrigin(const CKeyID& id, KeyOriginInfo& info) const { return false; }
|
||||
virtual bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const { return false; }
|
||||
};
|
||||
|
||||
extern const SigningProvider& DUMMY_SIGNING_PROVIDER;
|
||||
|
|
@ -58,10 +58,12 @@ struct FlatSigningProvider final : public SigningProvider
|
|||
{
|
||||
std::map<CScriptID, CScript> scripts;
|
||||
std::map<CKeyID, CPubKey> pubkeys;
|
||||
std::map<CKeyID, KeyOriginInfo> origins;
|
||||
std::map<CKeyID, CKey> keys;
|
||||
|
||||
bool GetCScript(const CScriptID& scriptid, CScript& script) const override;
|
||||
bool GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const override;
|
||||
bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override;
|
||||
bool GetKey(const CKeyID& keyid, CKey& key) const override;
|
||||
};
|
||||
|
||||
|
|
@ -204,6 +206,9 @@ template<typename Stream>
|
|||
void SerializeHDKeypaths(Stream& s, const std::map<CPubKey, KeyOriginInfo>& hd_keypaths, uint8_t type)
|
||||
{
|
||||
for (auto keypath_pair : hd_keypaths) {
|
||||
if (!keypath_pair.first.IsValid()) {
|
||||
throw std::ios_base::failure("Invalid CPubKey being serialized");
|
||||
}
|
||||
SerializeToVector(s, type, MakeSpan(keypath_pair.first));
|
||||
WriteCompactSize(s, (keypath_pair.second.path.size() + 1) * sizeof(uint32_t));
|
||||
s << keypath_pair.second.fingerprint;
|
||||
|
|
@ -300,6 +305,7 @@ struct PSBTInput
|
|||
template <typename Stream>
|
||||
inline void Unserialize(Stream& s) {
|
||||
// Read loop
|
||||
bool found_sep = false;
|
||||
while(!s.empty()) {
|
||||
// Read
|
||||
std::vector<unsigned char> key;
|
||||
|
|
@ -307,7 +313,10 @@ struct PSBTInput
|
|||
|
||||
// the key is empty if that was actually a separator byte
|
||||
// This is a special case for key lengths 0 as those are not allowed (except for separator)
|
||||
if (key.empty()) return;
|
||||
if (key.empty()) {
|
||||
found_sep = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// First byte of key is the type
|
||||
unsigned char type = key[0];
|
||||
|
|
@ -422,6 +431,10 @@ struct PSBTInput
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found_sep) {
|
||||
throw std::ios_base::failure("Separator is missing at the end of an input map");
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Stream>
|
||||
|
|
@ -475,6 +488,7 @@ struct PSBTOutput
|
|||
template <typename Stream>
|
||||
inline void Unserialize(Stream& s) {
|
||||
// Read loop
|
||||
bool found_sep = false;
|
||||
while(!s.empty()) {
|
||||
// Read
|
||||
std::vector<unsigned char> key;
|
||||
|
|
@ -482,7 +496,10 @@ struct PSBTOutput
|
|||
|
||||
// the key is empty if that was actually a separator byte
|
||||
// This is a special case for key lengths 0 as those are not allowed (except for separator)
|
||||
if (key.empty()) return;
|
||||
if (key.empty()) {
|
||||
found_sep = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// First byte of key is the type
|
||||
unsigned char type = key[0];
|
||||
|
|
@ -527,6 +544,10 @@ struct PSBTOutput
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!found_sep) {
|
||||
throw std::ios_base::failure("Separator is missing at the end of an output map");
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Stream>
|
||||
|
|
@ -548,6 +569,7 @@ struct PartiallySignedTransaction
|
|||
bool IsSane() const;
|
||||
PartiallySignedTransaction() {}
|
||||
PartiallySignedTransaction(const PartiallySignedTransaction& psbt_in) : tx(psbt_in.tx), inputs(psbt_in.inputs), outputs(psbt_in.outputs), unknown(psbt_in.unknown) {}
|
||||
explicit PartiallySignedTransaction(const CTransaction& tx);
|
||||
|
||||
// Only checks if they refer to the same transaction
|
||||
friend bool operator==(const PartiallySignedTransaction& a, const PartiallySignedTransaction &b)
|
||||
|
|
@ -602,6 +624,7 @@ struct PartiallySignedTransaction
|
|||
}
|
||||
|
||||
// Read global data
|
||||
bool found_sep = false;
|
||||
while(!s.empty()) {
|
||||
// Read
|
||||
std::vector<unsigned char> key;
|
||||
|
|
@ -609,7 +632,10 @@ struct PartiallySignedTransaction
|
|||
|
||||
// the key is empty if that was actually a separator byte
|
||||
// This is a special case for key lengths 0 as those are not allowed (except for separator)
|
||||
if (key.empty()) break;
|
||||
if (key.empty()) {
|
||||
found_sep = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// First byte of key is the type
|
||||
unsigned char type = key[0];
|
||||
|
|
@ -652,6 +678,10 @@ struct PartiallySignedTransaction
|
|||
}
|
||||
}
|
||||
|
||||
if (!found_sep) {
|
||||
throw std::ios_base::failure("Separator is missing at the end of the global map");
|
||||
}
|
||||
|
||||
// Make sure that we got an unsigned tx
|
||||
if (!tx) {
|
||||
throw std::ios_base::failure("No unsigned transcation was provided");
|
||||
|
|
@ -706,8 +736,11 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
|
|||
bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CConfidentialValue& amount, int nHashType);
|
||||
bool SignSignature(const SigningProvider &provider, const CTransaction& txFrom, CMutableTransaction& txTo, unsigned int nIn, int nHashType);
|
||||
|
||||
/** Checks whether a PSBTInput is already signed. */
|
||||
bool PSBTInputSigned(PSBTInput& input);
|
||||
|
||||
/** Signs a PSBTInput, verifying that all provided data matches what is being signed. */
|
||||
bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& tx, PSBTInput& input, int index, int sighash = SIGHASH_ALL);
|
||||
bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, int sighash = SIGHASH_ALL);
|
||||
|
||||
/** Extract signature data from a transaction input, and insert it. */
|
||||
SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nIn, const CTxOut& txout);
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@
|
|||
#include <crypto/sha256.h>
|
||||
#include <pubkey.h>
|
||||
#include <script/script.h>
|
||||
#include <util.h>
|
||||
#include <utilstrencodings.h>
|
||||
#include <util/system.h>
|
||||
#include <util/strencodings.h>
|
||||
|
||||
#include <chainparams.h>
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue