diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 7f9ca8c2c..1bde8150e 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -1,367 +1,367 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_PRIMITIVES_TRANSACTION_H
 #define BITCOIN_PRIMITIVES_TRANSACTION_H
 
 #include <amount.h>
 #include <feerate.h>
 #include <primitives/txid.h>
 #include <script/script.h>
 #include <serialize.h>
 
 static const int SERIALIZE_TRANSACTION = 0x00;
 
 /**
  * An outpoint - a combination of a transaction hash and an index n into its
  * vout.
  */
 class COutPoint {
 private:
     TxId txid;
     uint32_t n;
 
 public:
     COutPoint() : txid(), n(-1) {}
     COutPoint(TxId txidIn, uint32_t nIn) : txid(txidIn), n(nIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(txid);
         READWRITE(n);
     }
 
     bool IsNull() const { return txid.IsNull() && n == uint32_t(-1); }
 
     const TxId &GetTxId() const { return txid; }
     uint32_t GetN() const { return n; }
 
     friend bool operator<(const COutPoint &a, const COutPoint &b) {
         int cmp = a.txid.Compare(b.txid);
         return cmp < 0 || (cmp == 0 && a.n < b.n);
     }
 
     friend bool operator==(const COutPoint &a, const COutPoint &b) {
         return (a.txid == b.txid && a.n == b.n);
     }
 
     friend bool operator!=(const COutPoint &a, const COutPoint &b) {
         return !(a == b);
     }
 
     std::string ToString() const;
 };
 
 /**
  * An input of a transaction. It contains the location of the previous
  * transaction's output that it claims and a signature that matches the output's
  * public key.
  */
 class CTxIn {
 public:
     COutPoint prevout;
     CScript scriptSig;
     uint32_t nSequence;
 
     /**
      * Setting nSequence to this value for every input in a transaction disables
      * nLockTime.
      */
     static const uint32_t SEQUENCE_FINAL = 0xffffffff;
 
     /* Below flags apply in the context of BIP 68*/
     /**
      * If this flag set, CTxIn::nSequence is NOT interpreted as a relative
      * lock-time.
      */
     static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = (1U << 31);
 
     /**
      * If CTxIn::nSequence encodes a relative lock-time and this flag is set,
      * the relative lock-time has units of 512 seconds, otherwise it specifies
      * blocks with a granularity of 1.
      */
     static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22);
 
     /**
      * If CTxIn::nSequence encodes a relative lock-time, this mask is applied to
      * extract that lock-time from the sequence field.
      */
     static const uint32_t SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
 
     /**
      * In order to use the same number of bits to encode roughly the same
      * wall-clock duration, and because blocks are naturally limited to occur
      * every 600s on average, the minimum granularity for time-based relative
      * lock-time is fixed at 512 seconds. Converting from CTxIn::nSequence to
      * seconds is performed by multiplying by 512 = 2^9, or equivalently
      * shifting up by 9 bits.
      */
     static const int SEQUENCE_LOCKTIME_GRANULARITY = 9;
 
     CTxIn() { nSequence = SEQUENCE_FINAL; }
 
     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn = CScript(),
                    uint32_t nSequenceIn = SEQUENCE_FINAL)
         : prevout(prevoutIn), scriptSig(scriptSigIn), nSequence(nSequenceIn) {}
     CTxIn(TxId prevTxId, uint32_t nOut, CScript scriptSigIn = CScript(),
           uint32_t nSequenceIn = SEQUENCE_FINAL)
         : CTxIn(COutPoint(prevTxId, nOut), scriptSigIn, nSequenceIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(prevout);
         READWRITE(scriptSig);
         READWRITE(nSequence);
     }
 
     friend bool operator==(const CTxIn &a, const CTxIn &b) {
         return (a.prevout == b.prevout && a.scriptSig == b.scriptSig &&
                 a.nSequence == b.nSequence);
     }
 
     friend bool operator!=(const CTxIn &a, const CTxIn &b) { return !(a == b); }
 
     std::string ToString() const;
 };
 
 /**
  * An output of a transaction.  It contains the public key that the next input
  * must be able to sign with to claim it.
  */
 class CTxOut {
 public:
     Amount nValue;
     CScript scriptPubKey;
 
     CTxOut() { SetNull(); }
 
     CTxOut(Amount nValueIn, CScript scriptPubKeyIn)
         : nValue(nValueIn), scriptPubKey(scriptPubKeyIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(nValue);
         READWRITE(scriptPubKey);
     }
 
     void SetNull() {
         nValue = -SATOSHI;
         scriptPubKey.clear();
     }
 
     bool IsNull() const { return nValue == -SATOSHI; }
 
     friend bool operator==(const CTxOut &a, const CTxOut &b) {
         return (a.nValue == b.nValue && a.scriptPubKey == b.scriptPubKey);
     }
 
     friend bool operator!=(const CTxOut &a, const CTxOut &b) {
         return !(a == b);
     }
 
     std::string ToString() const;
 };
 
 class CMutableTransaction;
 
 /**
  * Basic transaction serialization format:
  * - int32_t nVersion
  * - std::vector<CTxIn> vin
  * - std::vector<CTxOut> vout
  * - uint32_t nLockTime
  */
 template <typename Stream, typename TxType>
 inline void UnserializeTransaction(TxType &tx, Stream &s) {
     s >> tx.nVersion;
     tx.vin.clear();
     tx.vout.clear();
     /* Try to read the vin. In case the dummy is there, this will be read as an
      * empty vector. */
     s >> tx.vin;
     /* We read a non-empty vin. Assume a normal vout follows. */
     s >> tx.vout;
     s >> tx.nLockTime;
 }
 
 template <typename Stream, typename TxType>
 inline void SerializeTransaction(const TxType &tx, Stream &s) {
     s << tx.nVersion;
     s << tx.vin;
     s << tx.vout;
     s << tx.nLockTime;
 }
 
 /**
  * The basic transaction that is broadcasted on the network and contained in
  * blocks. A transaction can contain multiple inputs and outputs.
  */
 class CTransaction {
 public:
     // Default transaction version.
     static const int32_t CURRENT_VERSION = 2;
 
     // Changing the default transaction version requires a two step process:
     // first adapting relay policy by bumping MAX_STANDARD_VERSION, and then
     // later date bumping the default CURRENT_VERSION at which point both
     // CURRENT_VERSION and MAX_STANDARD_VERSION will be equal.
     static const int32_t MAX_STANDARD_VERSION = 2;
 
     // The local variables are made const to prevent unintended modification
     // without updating the cached hash value. However, CTransaction is not
     // actually immutable; deserialization and assignment are implemented,
     // and bypass the constness. This is safe, as they update the entire
     // structure, including the hash.
     const std::vector<CTxIn> vin;
     const std::vector<CTxOut> vout;
     const int32_t nVersion;
     const uint32_t nLockTime;
 
 private:
     /** Memory only. */
     const uint256 hash;
 
     uint256 ComputeHash() const;
 
 public:
     /** Construct a CTransaction that qualifies as IsNull() */
     CTransaction();
 
     /** Convert a CMutableTransaction into a CTransaction. */
     explicit CTransaction(const CMutableTransaction &tx);
     explicit CTransaction(CMutableTransaction &&tx);
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         SerializeTransaction(*this, s);
     }
 
     /**
      * This deserializing constructor is provided instead of an Unserialize
      * method. Unserialize is not possible, since it would require overwriting
      * const fields.
      */
     template <typename Stream>
     CTransaction(deserialize_type, Stream &s)
         : CTransaction(CMutableTransaction(deserialize, s)) {}
 
     bool IsNull() const { return vin.empty() && vout.empty(); }
 
     const TxId GetId() const { return TxId(hash); }
     const TxHash GetHash() const { return TxHash(hash); }
 
     // Return sum of txouts.
     Amount GetValueOut() const;
     // GetValueIn() is a method on CCoinsViewCache, because
     // inputs must be known to compute value in.
 
     // Compute priority, given priority of inputs and (optionally) tx size
     double ComputePriority(double dPriorityInputs,
                            unsigned int nTxSize = 0) const;
 
     // Compute modified tx size for priority calculation (optionally given tx
     // size)
     unsigned int CalculateModifiedSize(unsigned int nTxSize = 0) const;
 
     /**
      * Get the total transaction size in bytes.
      * @return Total transaction size in bytes
      */
     unsigned int GetTotalSize() const;
 
     bool IsCoinBase() const {
         return (vin.size() == 1 && vin[0].prevout.IsNull());
     }
 
     friend bool operator==(const CTransaction &a, const CTransaction &b) {
-        return a.hash == b.hash;
+        return a.GetHash() == b.GetHash();
     }
 
     friend bool operator!=(const CTransaction &a, const CTransaction &b) {
-        return a.hash != b.hash;
+        return !(a == b);
     }
 
     std::string ToString() const;
 };
 #if defined(__x86_64__)
 static_assert(sizeof(CTransaction) == 88,
               "sizeof CTransaction is expected to be 88 bytes");
 #endif
 
 /**
  * A mutable version of CTransaction.
  */
 class CMutableTransaction {
 public:
     std::vector<CTxIn> vin;
     std::vector<CTxOut> vout;
     int32_t nVersion;
     uint32_t nLockTime;
 
     CMutableTransaction();
     explicit CMutableTransaction(const CTransaction &tx);
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         SerializeTransaction(*this, s);
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         UnserializeTransaction(*this, s);
     }
 
     template <typename Stream>
     CMutableTransaction(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 
     /**
      * Compute the id and hash of this CMutableTransaction. This is computed on
      * the fly, as opposed to GetId() and GetHash() in CTransaction, which uses
      * a cached result.
      */
     TxId GetId() const;
     TxHash GetHash() const;
 
     friend bool operator==(const CMutableTransaction &a,
                            const CMutableTransaction &b) {
-        return a.GetId() == b.GetId();
+        return a.GetHash() == b.GetHash();
     }
 };
 #if defined(__x86_64__)
 static_assert(sizeof(CMutableTransaction) == 56,
               "sizeof CMutableTransaction is expected to be 56 bytes");
 #endif
 
 typedef std::shared_ptr<const CTransaction> CTransactionRef;
 static inline CTransactionRef MakeTransactionRef() {
     return std::make_shared<const CTransaction>();
 }
 template <typename Tx>
 static inline CTransactionRef MakeTransactionRef(Tx &&txIn) {
     return std::make_shared<const CTransaction>(std::forward<Tx>(txIn));
 }
 
 /** Precompute sighash midstate to avoid quadratic hashing */
 struct PrecomputedTransactionData {
     uint256 hashPrevouts, hashSequence, hashOutputs;
 
     PrecomputedTransactionData()
         : hashPrevouts(), hashSequence(), hashOutputs() {}
 
     PrecomputedTransactionData(const PrecomputedTransactionData &txdata)
         : hashPrevouts(txdata.hashPrevouts), hashSequence(txdata.hashSequence),
           hashOutputs(txdata.hashOutputs) {}
 
     template <class T> explicit PrecomputedTransactionData(const T &tx);
 };
 
 #endif // BITCOIN_PRIMITIVES_TRANSACTION_H
diff --git a/src/pubkey.h b/src/pubkey.h
index f2479b252..976a52aed 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -1,244 +1,245 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_PUBKEY_H
 #define BITCOIN_PUBKEY_H
 
 #include <hash.h>
 #include <serialize.h>
 #include <uint256.h>
 
 #include <boost/range/adaptor/sliced.hpp>
 
 #include <stdexcept>
 #include <vector>
 
 const unsigned int BIP32_EXTKEY_SIZE = 74;
 
 /** A reference to a CKey: the Hash160 of its serialized public key */
 class CKeyID : public uint160 {
 public:
     CKeyID() : uint160() {}
     explicit CKeyID(const uint160 &in) : uint160(in) {}
 };
 
 typedef uint256 ChainCode;
 
 /** An encapsulated public key. */
 class CPubKey {
 public:
     /**
      * secp256k1:
      */
     static constexpr unsigned int PUBLIC_KEY_SIZE = 65;
     static constexpr unsigned int COMPRESSED_PUBLIC_KEY_SIZE = 33;
     static constexpr unsigned int SIGNATURE_SIZE = 72;
     static constexpr unsigned int COMPACT_SIGNATURE_SIZE = 65;
     /**
      * see www.keylength.com
      * script supports up to 75 for single byte push
      */
     static_assert(PUBLIC_KEY_SIZE >= COMPRESSED_PUBLIC_KEY_SIZE,
                   "COMPRESSED_PUBLIC_KEY_SIZE is larger than PUBLIC_KEY_SIZE");
 
 private:
     /**
      * Just store the serialized data.
      * Its length can very cheaply be computed from the first byte.
      */
     uint8_t vch[PUBLIC_KEY_SIZE];
 
     //! Compute the length of a pubkey with a given first byte.
     static unsigned int GetLen(uint8_t chHeader) {
         if (chHeader == 2 || chHeader == 3) {
             return COMPRESSED_PUBLIC_KEY_SIZE;
         }
         if (chHeader == 4 || chHeader == 6 || chHeader == 7) {
             return PUBLIC_KEY_SIZE;
         }
         return 0;
     }
 
     //! Set this key data to be invalid
     void Invalidate() { vch[0] = 0xFF; }
 
 public:
     bool static ValidSize(const std::vector<uint8_t> &vch) {
         return vch.size() > 0 && GetLen(vch[0]) == vch.size();
     }
 
     //! Construct an invalid public key.
     CPubKey() { Invalidate(); }
 
     //! Initialize a public key using begin/end iterators to byte data.
     template <typename T> void Set(const T pbegin, const T pend) {
         int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
         if (len && len == (pend - pbegin)) {
             memcpy(vch, (uint8_t *)&pbegin[0], len);
         } else {
             Invalidate();
         }
     }
 
     //! Construct a public key using begin/end iterators to byte data.
     template <typename T> CPubKey(const T pbegin, const T pend) {
         Set(pbegin, pend);
     }
 
     //! Construct a public key from a byte vector.
     explicit CPubKey(const std::vector<uint8_t> &_vch) {
         Set(_vch.begin(), _vch.end());
     }
 
     //! Simple read-only vector-like interface to the pubkey data.
     unsigned int size() const { return GetLen(vch[0]); }
+    const uint8_t *data() const { return vch; }
     const uint8_t *begin() const { return vch; }
     const uint8_t *end() const { return vch + size(); }
     const uint8_t &operator[](unsigned int pos) const { return vch[pos]; }
 
     //! Comparator implementation.
     friend bool operator==(const CPubKey &a, const CPubKey &b) {
         return a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) == 0;
     }
     friend bool operator!=(const CPubKey &a, const CPubKey &b) {
         return !(a == b);
     }
     friend bool operator<(const CPubKey &a, const CPubKey &b) {
         return a.vch[0] < b.vch[0] ||
                (a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) < 0);
     }
 
     //! Implement serialization, as if this was a byte vector.
     template <typename Stream> void Serialize(Stream &s) const {
         unsigned int len = size();
         ::WriteCompactSize(s, len);
         s.write((char *)vch, len);
     }
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int len = ::ReadCompactSize(s);
         if (len <= PUBLIC_KEY_SIZE) {
             s.read((char *)vch, len);
         } else {
             // invalid pubkey, skip available data
             char dummy;
             while (len--) {
                 s.read(&dummy, 1);
             }
             Invalidate();
         }
     }
 
     //! Get the KeyID of this public key (hash of its serialization)
     CKeyID GetID() const { return CKeyID(Hash160(vch, vch + size())); }
 
     //! Get the 256-bit hash of this public key.
     uint256 GetHash() const { return Hash(vch, vch + size()); }
 
     /*
      * Check syntactic correctness.
      *
      * Note that this is consensus critical as CheckSig() calls it!
      */
     bool IsValid() const { return size() > 0; }
 
     //! fully validate whether this is a valid public key (more expensive than
     //! IsValid())
     bool IsFullyValid() const;
 
     //! Check whether this is a compressed public key.
     bool IsCompressed() const { return size() == COMPRESSED_PUBLIC_KEY_SIZE; }
 
     /**
      * Verify a DER-serialized ECDSA signature (~72 bytes).
      * If this public key is not fully valid, the return value will be false.
      */
     bool VerifyECDSA(const uint256 &hash,
                      const std::vector<uint8_t> &vchSig) const;
 
     /**
      * Verify a Schnorr signature (=64 bytes).
      * If this public key is not fully valid, the return value will be false.
      */
     bool VerifySchnorr(const uint256 &hash,
                        const std::vector<uint8_t> &vchSig) const;
 
     /**
      * Check whether a DER-serialized ECDSA signature is normalized (lower-S).
      */
     static bool
     CheckLowS(const boost::sliced_range<const std::vector<uint8_t>> &vchSig);
     static bool CheckLowS(const std::vector<uint8_t> &vchSig) {
         return CheckLowS(vchSig | boost::adaptors::sliced(0, vchSig.size()));
     }
 
     //! Recover a public key from a compact ECDSA signature.
     bool RecoverCompact(const uint256 &hash,
                         const std::vector<uint8_t> &vchSig);
 
     //! Turn this public key into an uncompressed public key.
     bool Decompress();
 
     //! Derive BIP32 child pubkey.
     bool Derive(CPubKey &pubkeyChild, ChainCode &ccChild, unsigned int nChild,
                 const ChainCode &cc) const;
 };
 
 struct CExtPubKey {
     uint8_t nDepth;
     uint8_t vchFingerprint[4];
     unsigned int nChild;
     ChainCode chaincode;
     CPubKey pubkey;
 
     friend bool operator==(const CExtPubKey &a, const CExtPubKey &b) {
         return a.nDepth == b.nDepth &&
                memcmp(&a.vchFingerprint[0], &b.vchFingerprint[0],
                       sizeof(vchFingerprint)) == 0 &&
                a.nChild == b.nChild && a.chaincode == b.chaincode &&
                a.pubkey == b.pubkey;
     }
 
     void Encode(uint8_t code[BIP32_EXTKEY_SIZE]) const;
     void Decode(const uint8_t code[BIP32_EXTKEY_SIZE]);
     bool Derive(CExtPubKey &out, unsigned int nChild) const;
 
     void Serialize(CSizeComputer &s) const {
         // Optimized implementation for ::GetSerializeSize that avoids copying.
         // add one byte for the size (compact int)
         s.seek(BIP32_EXTKEY_SIZE + 1);
     }
     template <typename Stream> void Serialize(Stream &s) const {
         unsigned int len = BIP32_EXTKEY_SIZE;
         ::WriteCompactSize(s, len);
         uint8_t code[BIP32_EXTKEY_SIZE];
         Encode(code);
         s.write((const char *)&code[0], len);
     }
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int len = ::ReadCompactSize(s);
         if (len != BIP32_EXTKEY_SIZE) {
             throw std::runtime_error("Invalid extended key size\n");
         }
 
         uint8_t code[BIP32_EXTKEY_SIZE];
         s.read((char *)&code[0], len);
         Decode(code);
     }
 };
 
 /**
  * Users of this module must hold an ECCVerifyHandle. The constructor and
  * destructor of these are not allowed to run in parallel, though.
  */
 class ECCVerifyHandle {
     static int refcount;
 
 public:
     ECCVerifyHandle();
     ~ECCVerifyHandle();
 };
 
 #endif // BITCOIN_PUBKEY_H
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index aae899029..f35b09c11 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -1,402 +1,415 @@
 // 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/sign.h>
 
 #include <key.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <uint256.h>
 
 typedef std::vector<uint8_t> valtype;
 
 MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(
     const CMutableTransaction *txToIn, unsigned int nInIn,
     const Amount &amountIn, SigHashType sigHashTypeIn)
     : txTo(txToIn), nIn(nInIn), amount(amountIn), sigHashType(sigHashTypeIn),
       checker(txTo, nIn, amountIn) {}
 
 bool MutableTransactionSignatureCreator::CreateSig(
     const SigningProvider &provider, std::vector<uint8_t> &vchSig,
     const CKeyID &address, const CScript &scriptCode) const {
     CKey key;
     if (!provider.GetKey(address, key)) {
         return false;
     }
 
     uint256 hash = SignatureHash(scriptCode, *txTo, nIn, sigHashType, amount);
     if (!key.SignECDSA(hash, vchSig)) {
         return false;
     }
 
     vchSig.push_back(uint8_t(sigHashType.getRawSigHashType()));
     return true;
 }
 
 static bool GetCScript(const SigningProvider &provider,
                        const SignatureData &sigdata, const CScriptID &scriptid,
                        CScript &script) {
     if (provider.GetCScript(scriptid, script)) {
         return true;
     }
     // Look for scripts in SignatureData
     if (CScriptID(sigdata.redeem_script) == scriptid) {
         script = sigdata.redeem_script;
         return true;
     }
     return false;
 }
 
 static bool GetPubKey(const SigningProvider &provider,
                       const SignatureData &sigdata, const CKeyID &address,
                       CPubKey &pubkey) {
     if (provider.GetPubKey(address, pubkey)) {
         return true;
     }
     // Look for pubkey in all partial sigs
     const auto it = sigdata.signatures.find(address);
     if (it != sigdata.signatures.end()) {
         pubkey = it->second.first;
         return true;
     }
     return false;
 }
 
 static bool CreateSig(const BaseSignatureCreator &creator,
                       SignatureData &sigdata, const SigningProvider &provider,
                       std::vector<uint8_t> &sig_out, const CKeyID &keyid,
                       const CScript &scriptcode) {
     const auto it = sigdata.signatures.find(keyid);
     if (it != sigdata.signatures.end()) {
         sig_out = it->second.second;
         return true;
     }
     if (creator.CreateSig(provider, sig_out, keyid, scriptcode)) {
         CPubKey pubkey;
         GetPubKey(provider, sigdata, keyid, pubkey);
         auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
         assert(i.second);
         return true;
     }
     return false;
 }
 
 /**
  * Sign scriptPubKey using signature made with creator.
  * Signatures are returned in scriptSigRet (or returns false if scriptPubKey
  * can't be signed), unless whichTypeRet is TX_SCRIPTHASH, in which case
  * scriptSigRet is the redemption script.
  * Returns false if scriptPubKey could not be completely satisfied.
  */
 static bool SignStep(const SigningProvider &provider,
                      const BaseSignatureCreator &creator,
                      const CScript &scriptPubKey, std::vector<valtype> &ret,
                      txnouttype &whichTypeRet, SignatureData &sigdata) {
     CScript scriptRet;
     uint160 h160;
     ret.clear();
     std::vector<uint8_t> sig;
 
     std::vector<valtype> vSolutions;
     if (!Solver(scriptPubKey, whichTypeRet, vSolutions)) {
         return false;
     }
 
     switch (whichTypeRet) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             return false;
         case TX_PUBKEY:
             if (!CreateSig(creator, sigdata, provider, sig,
                            CPubKey(vSolutions[0]).GetID(), scriptPubKey)) {
                 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)) {
                 return false;
             }
             ret.push_back(std::move(sig));
             CPubKey pubkey;
             provider.GetPubKey(keyID, pubkey);
             ret.push_back(ToByteVector(pubkey));
             return true;
         }
         case TX_SCRIPTHASH:
             if (GetCScript(provider, sigdata, uint160(vSolutions[0]),
                            scriptRet)) {
                 ret.push_back(
                     std::vector<uint8_t>(scriptRet.begin(), scriptRet.end()));
                 return true;
             }
             return false;
         case TX_MULTISIG: {
             size_t required = vSolutions.front()[0];
             // workaround CHECKMULTISIG bug
             ret.push_back(valtype());
             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)) {
                     ret.push_back(std::move(sig));
                 }
             }
             bool ok = ret.size() == required + 1;
             for (size_t i = 0; i + ret.size() < required + 1; ++i) {
                 ret.push_back(valtype());
             }
             return ok;
         }
         default:
             return false;
     }
 }
 
 static CScript PushAll(const std::vector<valtype> &values) {
     CScript result;
     for (const valtype &v : values) {
         if (v.size() == 0) {
             result << OP_0;
         } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
             result << CScript::EncodeOP_N(v[0]);
         } else {
             result << v;
         }
     }
 
     return result;
 }
 
 bool ProduceSignature(const SigningProvider &provider,
                       const BaseSignatureCreator &creator,
                       const CScript &fromPubKey, SignatureData &sigdata) {
     if (sigdata.complete) {
         return true;
     }
 
     std::vector<valtype> result;
     txnouttype whichType;
     bool solved =
         SignStep(provider, creator, fromPubKey, result, whichType, sigdata);
     CScript subscript;
 
     if (solved && whichType == TX_SCRIPTHASH) {
         // Solver returns the subscript that needs to be evaluated; the final
         // scriptSig is the signatures from that and then the serialized
         // subscript:
         subscript = CScript(result[0].begin(), result[0].end());
         sigdata.redeem_script = subscript;
 
         solved = solved &&
                  SignStep(provider, creator, subscript, result, whichType,
                           sigdata) &&
                  whichType != TX_SCRIPTHASH;
         result.push_back(
             std::vector<uint8_t>(subscript.begin(), subscript.end()));
     }
 
     sigdata.scriptSig = PushAll(result);
 
     // Test solution
     sigdata.complete =
         solved && VerifyScript(sigdata.scriptSig, fromPubKey,
                                STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
     return sigdata.complete;
 }
 
 class SignatureExtractorChecker final : public BaseSignatureChecker {
 private:
     SignatureData &sigdata;
     BaseSignatureChecker &checker;
 
 public:
     SignatureExtractorChecker(SignatureData &sigdata_,
                               BaseSignatureChecker &checker_)
         : sigdata(sigdata_), checker(checker_) {}
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override;
 };
 
 bool SignatureExtractorChecker::CheckSig(const std::vector<uint8_t> &scriptSig,
                                          const std::vector<uint8_t> &vchPubKey,
                                          const CScript &scriptCode,
                                          uint32_t flags) const {
     if (checker.CheckSig(scriptSig, vchPubKey, scriptCode, flags)) {
         CPubKey pubkey(vchPubKey);
         sigdata.signatures.emplace(pubkey.GetID(), SigPair(pubkey, scriptSig));
         return true;
     }
     return false;
 }
 
 namespace {
 struct Stacks {
     std::vector<valtype> script;
 
     Stacks() {}
     explicit Stacks(const std::vector<valtype> &scriptSigStack_)
         : script(scriptSigStack_) {}
     explicit Stacks(const SignatureData &data) {
         EvalScript(script, data.scriptSig, MANDATORY_SCRIPT_VERIFY_FLAGS,
                    BaseSignatureChecker());
     }
 
     SignatureData Output() const {
         SignatureData result;
         result.scriptSig = PushAll(script);
         return result;
     }
 };
 } // namespace
 
 // Extracts signatures and scripts from incomplete scriptSigs. Please do not
 // extend this, use PSBT instead
 SignatureData DataFromTransaction(const CMutableTransaction &tx,
                                   unsigned int nIn, const CTxOut &txout) {
     SignatureData data;
     assert(tx.vin.size() > nIn);
     data.scriptSig = tx.vin[nIn].scriptSig;
     Stacks stack(data);
 
     // Get signatures
     MutableTransactionSignatureChecker tx_checker(&tx, nIn, txout.nValue);
     SignatureExtractorChecker extractor_checker(data, tx_checker);
     if (VerifyScript(data.scriptSig, txout.scriptPubKey,
                      STANDARD_SCRIPT_VERIFY_FLAGS, extractor_checker)) {
         data.complete = true;
         return data;
     }
 
     // Get scripts
     txnouttype script_type;
     std::vector<std::vector<uint8_t>> solutions;
     Solver(txout.scriptPubKey, script_type, solutions);
     CScript next_script = txout.scriptPubKey;
 
     if (script_type == TX_SCRIPTHASH && !stack.script.empty() &&
         !stack.script.back().empty()) {
         // Get the redeemScript
         CScript redeem_script(stack.script.back().begin(),
                               stack.script.back().end());
         data.redeem_script = redeem_script;
         next_script = std::move(redeem_script);
 
         // Get redeemScript type
         Solver(next_script, script_type, solutions);
         stack.script.pop_back();
     }
     if (script_type == TX_MULTISIG && !stack.script.empty()) {
         // Build a map of pubkey -> signature by matching sigs to pubkeys:
         assert(solutions.size() > 1);
         unsigned int num_pubkeys = solutions.size() - 2;
         unsigned int last_success_key = 0;
         for (const valtype &sig : stack.script) {
             for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
                 const valtype &pubkey = solutions[i + 1];
                 // We either have a signature for this pubkey, or we have found
                 // a signature and it is valid
                 if (data.signatures.count(CPubKey(pubkey).GetID()) ||
                     extractor_checker.CheckSig(sig, pubkey, next_script,
                                                STANDARD_SCRIPT_VERIFY_FLAGS)) {
                     last_success_key = i + 1;
                     break;
                 }
             }
         }
     }
 
     return data;
 }
 
 void UpdateInput(CTxIn &input, const SignatureData &data) {
     input.scriptSig = data.scriptSig;
 }
 
 void SignatureData::MergeSignatureData(SignatureData sigdata) {
     if (complete) {
         return;
     }
     if (sigdata.complete) {
         *this = std::move(sigdata);
         return;
     }
     if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
         redeem_script = sigdata.redeem_script;
     }
     signatures.insert(std::make_move_iterator(sigdata.signatures.begin()),
                       std::make_move_iterator(sigdata.signatures.end()));
 }
 
 bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
                    CMutableTransaction &txTo, unsigned int nIn,
                    const Amount amount, SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
 
     MutableTransactionSignatureCreator creator(&txTo, nIn, amount, sigHashType);
 
     SignatureData sigdata;
     bool ret = ProduceSignature(provider, creator, fromPubKey, sigdata);
     UpdateInput(txTo.vin.at(nIn), sigdata);
     return ret;
 }
 
 bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
                    CMutableTransaction &txTo, unsigned int nIn,
                    SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
     CTxIn &txin = txTo.vin[nIn];
     assert(txin.prevout.GetN() < txFrom.vout.size());
     const CTxOut &txout = txFrom.vout[txin.prevout.GetN()];
 
     return SignSignature(provider, txout.scriptPubKey, txTo, nIn, txout.nValue,
                          sigHashType);
 }
 
 namespace {
 /** Dummy signature checker which accepts all signatures. */
 class DummySignatureChecker final : public BaseSignatureChecker {
 public:
     DummySignatureChecker() {}
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override {
         return true;
     }
 };
 const DummySignatureChecker DUMMY_CHECKER;
 
 class DummySignatureCreator final : public BaseSignatureCreator {
 public:
     DummySignatureCreator() {}
     const BaseSignatureChecker &Checker() const override {
         return DUMMY_CHECKER;
     }
     bool CreateSig(const SigningProvider &provider,
                    std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                    const CScript &scriptCode) const override {
         // Create a dummy signature that is a valid DER-encoding
         vchSig.assign(72, '\000');
         vchSig[0] = 0x30;
         vchSig[1] = 69;
         vchSig[2] = 0x02;
         vchSig[3] = 33;
         vchSig[4] = 0x01;
         vchSig[4 + 33] = 0x02;
         vchSig[5 + 33] = 32;
         vchSig[6 + 33] = 0x01;
         vchSig[6 + 33 + 32] = SIGHASH_ALL | SIGHASH_FORKID;
         return true;
     }
 };
 } // namespace
 
 const BaseSignatureCreator &DUMMY_SIGNATURE_CREATOR = DummySignatureCreator();
 const SigningProvider &DUMMY_SIGNING_PROVIDER = SigningProvider();
+
+bool PartiallySignedTransaction::IsNull() const {
+    return !tx && inputs.empty() && outputs.empty() && unknown.empty();
+}
+
+bool PSBTInput::IsNull() const {
+    return utxo.IsNull() && partial_sigs.empty() && unknown.empty() &&
+           hd_keypaths.empty() && redeem_script.empty();
+}
+
+bool PSBTOutput::IsNull() const {
+    return redeem_script.empty() && hd_keypaths.empty() && unknown.empty();
+}
diff --git a/src/script/sign.h b/src/script/sign.h
index e895433b0..0a44d1fb3 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -1,110 +1,610 @@
 // 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.
 
 #ifndef BITCOIN_SCRIPT_SIGN_H
 #define BITCOIN_SCRIPT_SIGN_H
 
+#include <hash.h>
+#include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/sighashtype.h>
+#include <streams.h>
+
+#include <boost/optional.hpp>
 
 class CKey;
 class CKeyID;
 class CMutableTransaction;
 class CScript;
 class CScriptID;
 class CTransaction;
 
 /** An interface to be implemented by keystores that support signing. */
 class SigningProvider {
 public:
     virtual ~SigningProvider() {}
     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;
     }
 };
 
 extern const SigningProvider &DUMMY_SIGNING_PROVIDER;
 
 /** Interface for signature creators. */
 class BaseSignatureCreator {
 public:
     virtual ~BaseSignatureCreator() {}
     virtual const BaseSignatureChecker &Checker() const = 0;
 
     /** Create a singular (non-script) signature. */
     virtual bool CreateSig(const SigningProvider &provider,
                            std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                            const CScript &scriptCode) const = 0;
 };
 
 /** A signature creator for transactions. */
 class MutableTransactionSignatureCreator : public BaseSignatureCreator {
     const CMutableTransaction *txTo;
     unsigned int nIn;
     Amount amount;
     SigHashType sigHashType;
     const MutableTransactionSignatureChecker checker;
 
 public:
     MutableTransactionSignatureCreator(
         const CMutableTransaction *txToIn, unsigned int nInIn,
         const Amount &amountIn, SigHashType sigHashTypeIn = SigHashType());
     const BaseSignatureChecker &Checker() const override { return checker; }
     bool CreateSig(const SigningProvider &provider,
                    std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                    const CScript &scriptCode) const override;
 };
 
 /** A signature creator that just produces 72-byte empty signatures. */
 extern const BaseSignatureCreator &DUMMY_SIGNATURE_CREATOR;
 
 typedef std::pair<CPubKey, std::vector<uint8_t>> SigPair;
 
 // This struct contains information from a transaction input and also contains
 // signatures for that input. The information contained here can be used to
 // create a signature and is also filled by ProduceSignature in order to
 // construct final scriptSigs.
 struct SignatureData {
     /// Stores whether the scriptSig and scriptWitness are complete.
     bool complete = false;
     /// The scriptSig of an input. Contains complete signatures or the
     /// traditional partial signatures format.
     CScript scriptSig;
     /// The redeemScript (if any) for the input.
     CScript redeem_script;
     /// BIP 174 style partial signatures for the input. May contain all
     /// signatures necessary for producing a final scriptSig.
     std::map<CKeyID, SigPair> signatures;
 
     SignatureData() {}
     explicit SignatureData(const CScript &script) : scriptSig(script) {}
     void MergeSignatureData(SignatureData sigdata);
 };
 
+// Magic bytes
+static constexpr uint8_t PSBT_MAGIC_BYTES[5] = {'p', 's', 'b', 't', 0xff};
+
+// Global types
+static constexpr uint8_t PSBT_GLOBAL_UNSIGNED_TX = 0x00;
+
+// Input types
+static constexpr uint8_t PSBT_IN_UTXO = 0x00;
+static constexpr uint8_t PSBT_IN_PARTIAL_SIG = 0x02;
+static constexpr uint8_t PSBT_IN_SIGHASH = 0x03;
+static constexpr uint8_t PSBT_IN_REDEEMSCRIPT = 0x04;
+static constexpr uint8_t PSBT_IN_BIP32_DERIVATION = 0x06;
+static constexpr uint8_t PSBT_IN_SCRIPTSIG = 0x07;
+
+// Output types
+static constexpr uint8_t PSBT_OUT_REDEEMSCRIPT = 0x00;
+static constexpr uint8_t PSBT_OUT_BIP32_DERIVATION = 0x02;
+
+// The separator is 0x00. Reading this in means that the unserializer can
+// interpret it as a 0 length key which indicates that this is the separator.
+// The separator has no value.
+static constexpr uint8_t PSBT_SEPARATOR = 0x00;
+
+// Takes a stream and multiple arguments and serializes them into a vector and
+// then into the stream. The resulting output into the stream has the total
+// serialized length of all of the objects followed by all objects concatenated
+// with each other.
+template <typename Stream, typename... X>
+void SerializeToVector(Stream &s, const X &... args) {
+    std::vector<uint8_t> ret;
+    CVectorWriter ss(SER_NETWORK, PROTOCOL_VERSION, ret, 0);
+    SerializeMany(ss, args...);
+    s << ret;
+}
+
+// Takes a stream and multiple arguments and unserializes them first as a vector
+// then each object individually in the order provided in the arguments
+template <typename Stream, typename... X>
+void UnserializeFromVector(Stream &s, X &... args) {
+    std::vector<uint8_t> data;
+    s >> data;
+    CDataStream ss(data, SER_NETWORK, PROTOCOL_VERSION);
+    UnserializeMany(ss, args...);
+    if (!ss.eof()) {
+        throw std::ios_base::failure("Size of value was not the stated size");
+    }
+}
+
+// Deserialize HD keypaths into a map
+template <typename Stream>
+void DeserializeHDKeypaths(
+    Stream &s, const std::vector<uint8_t> &key,
+    std::map<CPubKey, std::vector<uint32_t>> &hd_keypaths) {
+    // Make sure that the key is the size of pubkey + 1
+    if (key.size() != CPubKey::PUBLIC_KEY_SIZE + 1 &&
+        key.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1) {
+        throw std::ios_base::failure(
+            "Size of key was not the expected size for the type BIP32 keypath");
+    }
+    // Read in the pubkey from key
+    CPubKey pubkey(key.begin() + 1, key.end());
+    if (!pubkey.IsFullyValid()) {
+        throw std::ios_base::failure("Invalid pubkey");
+    }
+    if (hd_keypaths.count(pubkey) > 0) {
+        throw std::ios_base::failure(
+            "Duplicate Key, pubkey derivation path already provided");
+    }
+
+    // Read in key path
+    uint64_t value_len = ReadCompactSize(s);
+    std::vector<uint32_t> keypath;
+    for (uint64_t i = 0; i < value_len; i += sizeof(uint32_t)) {
+        uint32_t index;
+        s >> index;
+        keypath.push_back(index);
+    }
+
+    // Add to map
+    hd_keypaths.emplace(pubkey, keypath);
+}
+
+// Serialize HD keypaths to a stream from a map
+template <typename Stream>
+void SerializeHDKeypaths(
+    Stream &s, const std::map<CPubKey, std::vector<uint32_t>> &hd_keypaths,
+    uint8_t type) {
+    for (auto keypath_pair : hd_keypaths) {
+        SerializeToVector(s, type, MakeSpan(keypath_pair.first));
+        WriteCompactSize(s, keypath_pair.second.size() * sizeof(uint32_t));
+        for (auto &path : keypath_pair.second) {
+            s << path;
+        }
+    }
+}
+
+/** A structure for PSBTs which contain per-input information */
+struct PSBTInput {
+    CTxOut utxo;
+    CScript redeem_script;
+    CScript final_script_sig;
+    std::map<CPubKey, std::vector<uint32_t>> hd_keypaths;
+    std::map<CKeyID, SigPair> partial_sigs;
+    std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
+    SigHashType sighash_type = SigHashType(0);
+
+    bool IsNull() const;
+    PSBTInput() {}
+
+    template <typename Stream> inline void Serialize(Stream &s) const {
+        // Write the utxo
+        SerializeToVector(s, PSBT_IN_UTXO);
+        SerializeToVector(s, utxo);
+
+        if (final_script_sig.empty()) {
+            // Write any partial signatures
+            for (auto sig_pair : partial_sigs) {
+                SerializeToVector(s, PSBT_IN_PARTIAL_SIG,
+                                  MakeSpan(sig_pair.second.first));
+                s << sig_pair.second.second;
+            }
+
+            // Write the sighash type
+            if (sighash_type.getRawSigHashType() != 0) {
+                SerializeToVector(s, PSBT_IN_SIGHASH);
+                SerializeToVector(s, sighash_type);
+            }
+
+            // Write the redeem script
+            if (!redeem_script.empty()) {
+                SerializeToVector(s, PSBT_IN_REDEEMSCRIPT);
+                s << redeem_script;
+            }
+
+            // Write any hd keypaths
+            SerializeHDKeypaths(s, hd_keypaths, PSBT_IN_BIP32_DERIVATION);
+        }
+
+        // Write script sig
+        if (!final_script_sig.empty()) {
+            SerializeToVector(s, PSBT_IN_SCRIPTSIG);
+            s << final_script_sig;
+        }
+
+        // Write unknown things
+        for (auto &entry : unknown) {
+            s << entry.first;
+            s << entry.second;
+        }
+
+        s << PSBT_SEPARATOR;
+    }
+
+    template <typename Stream> inline void Unserialize(Stream &s) {
+        // Read loop
+        while (!s.empty()) {
+            // Read
+            std::vector<uint8_t> key;
+            s >> key;
+
+            // 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;
+            }
+
+            // First byte of key is the type
+            uint8_t type = key[0];
+
+            // Do stuff based on type
+            switch (type) {
+                case PSBT_IN_UTXO:
+                    if (!utxo.IsNull()) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, input utxo already provided");
+                    }
+                    UnserializeFromVector(s, utxo);
+                    break;
+                case PSBT_IN_PARTIAL_SIG: {
+                    // Make sure that the key is the size of pubkey + 1
+                    if (key.size() != CPubKey::PUBLIC_KEY_SIZE + 1 &&
+                        key.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1) {
+                        throw std::ios_base::failure(
+                            "Size of key was not the expected size for the "
+                            "type partial signature pubkey");
+                    }
+                    // Read in the pubkey from key
+                    CPubKey pubkey(key.begin() + 1, key.end());
+                    if (!pubkey.IsFullyValid()) {
+                        throw std::ios_base::failure("Invalid pubkey");
+                    }
+                    if (partial_sigs.count(pubkey.GetID()) > 0) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, input partial signature for pubkey "
+                            "already provided");
+                    }
+
+                    // Read in the signature from value
+                    std::vector<uint8_t> sig;
+                    s >> sig;
+
+                    // Add to list
+                    partial_sigs.emplace(pubkey.GetID(),
+                                         SigPair(pubkey, std::move(sig)));
+                    break;
+                }
+                case PSBT_IN_SIGHASH:
+                    if (sighash_type.getRawSigHashType() != 0) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, input sighash type already "
+                            "provided");
+                    }
+                    UnserializeFromVector(s, sighash_type);
+                    break;
+                case PSBT_IN_REDEEMSCRIPT: {
+                    if (!redeem_script.empty()) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, input redeemScript already "
+                            "provided");
+                    }
+                    s >> redeem_script;
+                    break;
+                }
+                case PSBT_IN_BIP32_DERIVATION: {
+                    DeserializeHDKeypaths(s, key, hd_keypaths);
+                    break;
+                }
+                case PSBT_IN_SCRIPTSIG: {
+                    if (!final_script_sig.empty()) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, input final scriptSig already "
+                            "provided");
+                    }
+                    s >> final_script_sig;
+                    break;
+                }
+                // Unknown stuff
+                default:
+                    if (unknown.count(key) > 0) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, key for unknown value already "
+                            "provided");
+                    }
+                    // Read in the value
+                    std::vector<uint8_t> val_bytes;
+                    s >> val_bytes;
+                    unknown.emplace(std::move(key), std::move(val_bytes));
+                    break;
+            }
+        }
+    }
+
+    template <typename Stream> PSBTInput(deserialize_type, Stream &s) {
+        Unserialize(s);
+    }
+};
+
+/** A structure for PSBTs which contains per output information */
+struct PSBTOutput {
+    CScript redeem_script;
+    std::map<CPubKey, std::vector<uint32_t>> hd_keypaths;
+    std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
+
+    bool IsNull() const;
+    PSBTOutput() {}
+
+    template <typename Stream> inline void Serialize(Stream &s) const {
+        // Write the redeem script
+        if (!redeem_script.empty()) {
+            SerializeToVector(s, PSBT_OUT_REDEEMSCRIPT);
+            s << redeem_script;
+        }
+
+        // Write any hd keypaths
+        SerializeHDKeypaths(s, hd_keypaths, PSBT_OUT_BIP32_DERIVATION);
+
+        // Write unknown things
+        for (auto &entry : unknown) {
+            s << entry.first;
+            s << entry.second;
+        }
+
+        s << PSBT_SEPARATOR;
+    }
+
+    template <typename Stream> inline void Unserialize(Stream &s) {
+        // Read loop
+        while (!s.empty()) {
+            // Read
+            std::vector<uint8_t> key;
+            s >> key;
+
+            // 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;
+            }
+
+            // First byte of key is the type
+            uint8_t type = key[0];
+
+            // Do stuff based on type
+            switch (type) {
+                case PSBT_OUT_REDEEMSCRIPT: {
+                    if (!redeem_script.empty()) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, output redeemScript already "
+                            "provided");
+                    }
+                    s >> redeem_script;
+                    break;
+                }
+                case PSBT_OUT_BIP32_DERIVATION: {
+                    DeserializeHDKeypaths(s, key, hd_keypaths);
+                    break;
+                }
+                // Unknown stuff
+                default: {
+                    if (unknown.count(key) > 0) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, key for unknown value already "
+                            "provided");
+                    }
+                    // Read in the value
+                    std::vector<uint8_t> val_bytes;
+                    s >> val_bytes;
+                    unknown.emplace(std::move(key), std::move(val_bytes));
+                    break;
+                }
+            }
+        }
+    }
+
+    template <typename Stream> PSBTOutput(deserialize_type, Stream &s) {
+        Unserialize(s);
+    }
+};
+
+/**
+ * A version of CTransaction with the PSBT format.
+ */
+struct PartiallySignedTransaction {
+    boost::optional<CMutableTransaction> tx;
+    std::vector<PSBTInput> inputs;
+    std::vector<PSBTOutput> outputs;
+    std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
+
+    bool IsNull() const;
+    PartiallySignedTransaction() {}
+    PartiallySignedTransaction(const PartiallySignedTransaction &psbt_in)
+        : tx(psbt_in.tx), inputs(psbt_in.inputs), outputs(psbt_in.outputs),
+          unknown(psbt_in.unknown) {}
+
+    // Only checks if they refer to the same transaction
+    friend bool operator==(const PartiallySignedTransaction &a,
+                           const PartiallySignedTransaction &b) {
+        return a.tx == b.tx;
+    }
+    friend bool operator!=(const PartiallySignedTransaction &a,
+                           const PartiallySignedTransaction &b) {
+        return !(a == b);
+    }
+
+    template <typename Stream> inline void Serialize(Stream &s) const {
+        // magic bytes
+        s << PSBT_MAGIC_BYTES;
+
+        // unsigned tx flag
+        SerializeToVector(s, PSBT_GLOBAL_UNSIGNED_TX);
+
+        // Write serialized tx to a stream
+        SerializeToVector(s, *tx);
+
+        // Write the unknown things
+        for (auto &entry : unknown) {
+            s << entry.first;
+            s << entry.second;
+        }
+
+        // Separator
+        s << PSBT_SEPARATOR;
+
+        // Write inputs
+        for (const PSBTInput &input : inputs) {
+            s << input;
+        }
+        // Write outputs
+        for (const PSBTOutput &output : outputs) {
+            s << output;
+        }
+    }
+
+    template <typename Stream> inline void Unserialize(Stream &s) {
+        // Read the magic bytes
+        uint8_t magic[5];
+        s >> magic;
+        if (!std::equal(magic, magic + 5, PSBT_MAGIC_BYTES)) {
+            throw std::ios_base::failure("Invalid PSBT magic bytes");
+        }
+
+        // Read global data
+        while (!s.empty()) {
+            // Read
+            std::vector<uint8_t> key;
+            s >> key;
+
+            // 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;
+            }
+
+            // First byte of key is the type
+            uint8_t type = key[0];
+
+            // Do stuff based on type
+            switch (type) {
+                case PSBT_GLOBAL_UNSIGNED_TX: {
+                    if (tx) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, unsigned tx already provided");
+                    }
+                    CMutableTransaction mtx;
+                    UnserializeFromVector(s, mtx);
+                    tx = std::move(mtx);
+                    // Make sure that all scriptSigs are empty.
+                    for (const CTxIn &txin : tx->vin) {
+                        if (!txin.scriptSig.empty()) {
+                            throw std::ios_base::failure(
+                                "Unsigned tx does not have empty scriptSigs.");
+                        }
+                    }
+                    break;
+                }
+                // Unknown stuff
+                default: {
+                    if (unknown.count(key) > 0) {
+                        throw std::ios_base::failure(
+                            "Duplicate Key, key for unknown value already "
+                            "provided");
+                    }
+                    // Read in the value
+                    std::vector<uint8_t> val_bytes;
+                    s >> val_bytes;
+                    unknown.emplace(std::move(key), std::move(val_bytes));
+                }
+            }
+        }
+
+        // Make sure that we got an unsigned tx
+        if (!tx) {
+            throw std::ios_base::failure(
+                "No unsigned transcation was provided");
+        }
+
+        // Read input data
+        size_t i = 0;
+        while (!s.empty() && i < tx->vin.size()) {
+            PSBTInput input;
+            s >> input;
+            inputs.push_back(input);
+            ++i;
+        }
+        // Make sure that the number of inputs matches the number of inputs in
+        // the transaction
+        if (inputs.size() != tx->vin.size()) {
+            throw std::ios_base::failure("Inputs provided does not match the "
+                                         "number of inputs in transaction.");
+        }
+
+        // Read output data
+        i = 0;
+        while (!s.empty() && i < tx->vout.size()) {
+            PSBTOutput output;
+            s >> output;
+            outputs.push_back(output);
+            ++i;
+        }
+        // Make sure that the number of outputs matches the number of outputs in
+        // the transaction
+        if (outputs.size() != tx->vout.size()) {
+            throw std::ios_base::failure("Outputs provided does not match the "
+                                         "number of outputs in transaction.");
+        }
+    }
+
+    template <typename Stream>
+    PartiallySignedTransaction(deserialize_type, Stream &s) {
+        Unserialize(s);
+    }
+};
+
 /** Produce a script signature using a generic signature creator. */
 bool ProduceSignature(const SigningProvider &provider,
                       const BaseSignatureCreator &creator,
                       const CScript &scriptPubKey, SignatureData &sigdata);
 
 /** Produce a script signature for a transaction. */
 bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
                    CMutableTransaction &txTo, unsigned int nIn,
                    const Amount amount, SigHashType sigHashType);
 bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
                    CMutableTransaction &txTo, unsigned int nIn,
                    SigHashType sigHashType);
 
 /** Extract signature data from a transaction input, and insert it. */
 SignatureData DataFromTransaction(const CMutableTransaction &tx,
                                   unsigned int nIn, const CTxOut &txout);
 void UpdateInput(CTxIn &input, const SignatureData &data);
 
 #endif // BITCOIN_SCRIPT_SIGN_H