Add WitnessV1Point as a destination

Author: elichai

src/key_io.cpp

@@ -56,6 +56,14 @@ class DestinationEncoder : public boost::static_visitor<std::string>
         return bech32::Encode(m_params.Bech32HRP(), data);
     }
 
+    std::string operator()(const WitnessV1Point& id) const
+    {
+        std::vector<unsigned char> data = {1};
+        data.reserve(53);
+        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
+        return bech32::Encode(m_params.Bech32HRP(), data);
+    }
+
     std::string operator()(const WitnessUnknown& id) const
     {
         if (id.version < 1 || id.version > 16 || id.length < 2 || id.length > 40) {

src/rpc/util.cpp

@@ -233,6 +233,16 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
         return obj;
     }
 
+    UniValue operator()(const WitnessV1Point& id) const
+    {
+        //TODO: What other data should be here?
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("iswitness", true);
+        obj.pushKV("witness_version", 1);
+        obj.pushKV("witness_program", HexStr(id.begin(), id.end()));
+        return obj;
+    }
+
     UniValue operator()(const WitnessUnknown& id) const
     {
         UniValue obj(UniValue::VOBJ);

src/script/script.h

@@ -59,6 +59,14 @@ std::vector<unsigned char> ToByteVector(const T& in)
     return std::vector<unsigned char>(in.begin(), in.end());
 }
 
+
+template <typename I, typename O>
+void ExtendByteVector(const I& in, std::vector<O>& out)
+{
+    out.reserve(out.size() + in.size());
+    out.insert(out.end(), in.begin(), in.end());
+}
+
 /** Script opcodes */
 enum opcodetype
 {

src/script/sign.cpp

@@ -168,6 +168,9 @@ static bool SignStep(const SigningProvider& provider, const BaseSignatureCreator
         sigdata.missing_witness_script = uint256(vSolutions[0]);
         return false;
 
+    case TX_WITNESS_V1_TAPROOT:
+        ret.push_back(vSolutions[0]);
+        return true;
     default:
         return false;
     }
@@ -188,6 +191,26 @@ static CScript PushAll(const std::vector<valtype>& values)
     return result;
 }
 
+bool IsTaprootAllowed(txnouttype type) {
+    switch(type)
+    {
+    case TX_WITNESS_V1_TAPROOT:
+    case TX_WITNESS_V0_KEYHASH:
+    case TX_WITNESS_V0_SCRIPTHASH:
+    case TX_SCRIPTHASH:
+    case TX_NULL_DATA:
+    case TX_WITNESS_UNKNOWN:
+        return false;
+
+    case TX_PUBKEY:
+    case TX_PUBKEYHASH:
+    case TX_NONSTANDARD:
+    case TX_MULTISIG:
+        return true;
+    }
+}
+
+
 bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& fromPubKey, SignatureData& sigdata)
 {
     if (sigdata.complete) return true;
@@ -230,6 +253,50 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
         sigdata.scriptWitness.stack = result;
         sigdata.witness = true;
         result.clear();
+    } else if (solved && whichType == TX_WITNESS_V1_TAPROOT) {
+        std::vector<unsigned char> address_vec(result[0]);
+        address_vec[0] += 2;
+        CPubKey address{address_vec}, base;
+        uint256 tweak;
+        txnouttype sub_type;
+        // First see if we control the point key in the witness program.
+        if (SignStep(provider, creator, (CScript() << address_vec << OP_CHECKSIG), result, sub_type, SigVersion::TAPROOT, sigdata)) {
+        // If not see if the signing provider have a Pay-To-Contract tweak for this key.
+        } else if(provider.GetP2CTweaks(address.GetID(), base, tweak)) {
+            std::vector<unsigned char> base_vec(base.begin(), base.end());
+            std::vector<unsigned char> control_block;
+            std::vector<ScriptPath> paths;
+            sigdata.p2c_tweaks.emplace(base, tweak);
+            base_vec[0] -= 2;
+            // TODO: Should I assume that if I can't sign fo`r the tweaked key then I can't sign for the base key?. if so the next if can be removed.
+            // Check if we're in control with the base key.
+            if (!SignStep(provider, creator, (CScript() << base_vec << OP_CHECKSIG), result, sub_type, SigVersion::TAPROOT, sigdata)) {
+                if(provider.GetScriptPaths(address.GetID(), paths)) {
+                    bool can_sign_any_path = false;
+                    for (auto& path : paths) {
+                        // Check if we can sign for any of the paths scripts.
+                        if (SignStep(provider, creator, path.leaf, result, sub_type, SigVersion::TAPROOT, sigdata) && IsTaprootAllowed(sub_type)) {
+                            ExtendByteVector(base_vec, control_block);
+                            for (auto& hash : path.path) {
+                                ExtendByteVector(hash, control_block);
+                            }
+                            sigdata.taproot_script_path = path;
+                            can_sign_any_path = true;
+                            break; // break out the second we found a script we can sign for.
+                        }
+                    }
+                    solved = solved && can_sign_any_path;
+                } else {
+                    solved = false;
+                }
+                if (!control_block.empty()) result.emplace_back(control_block);
+            }
+        } else {
+            solved = false;
+        }
+        sigdata.witness = true;
+        sigdata.scriptWitness.stack = result;
+        result.clear();
     } else if (solved && whichType == TX_WITNESS_UNKNOWN) {
         sigdata.witness = true;
     }
@@ -238,7 +305,6 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
         result.push_back(std::vector<unsigned char>(subscript.begin(), subscript.end()));
     }
     sigdata.scriptSig = PushAll(result);
-
     // Test solution
     sigdata.complete = solved && VerifyScript(sigdata.scriptSig, fromPubKey, &sigdata.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
     return sigdata.complete;
@@ -454,14 +520,25 @@ bool IsSegWitOutput(const SigningProvider& provider, const CScript& script)
 {
     std::vector<valtype> solutions;
     auto whichtype = Solver(script, solutions);
-    if (whichtype == TX_WITNESS_V0_SCRIPTHASH || whichtype == TX_WITNESS_V0_KEYHASH || whichtype == TX_WITNESS_UNKNOWN) return true;
-    if (whichtype == TX_SCRIPTHASH) {
+    switch (whichtype) {
+    case TX_WITNESS_V0_SCRIPTHASH:
+    case TX_WITNESS_V0_KEYHASH:
+    case TX_WITNESS_V1_TAPROOT:
+    case TX_WITNESS_UNKNOWN:
+        return true;
+    case TX_NULL_DATA:
+    case TX_PUBKEY:
+    case TX_PUBKEYHASH:
+    case TX_NONSTANDARD:
+    case TX_MULTISIG:
+        return false;
+    case TX_SCRIPTHASH: {
         auto h160 = uint160(solutions[0]);
         CScript subscript;
-        if (provider.GetCScript(h160, subscript)) {
-            whichtype = Solver(subscript, solutions);
-            if (whichtype == TX_WITNESS_V0_SCRIPTHASH || whichtype == TX_WITNESS_V0_KEYHASH || whichtype == TX_WITNESS_UNKNOWN) return true;
-        }
+        if (provider.GetCScript(h160, subscript))
+            return IsSegWitOutput(provider, subscript);
+        else
+            return false;
+    }
     }
-    return false;
 }

src/script/sign.h

@@ -6,6 +6,7 @@
 #ifndef BITCOIN_SCRIPT_SIGN_H
 #define BITCOIN_SCRIPT_SIGN_H
 
+#include "signingprovider.h"
 #include <boost/optional.hpp>
 #include <hash.h>
 #include <pubkey.h>
@@ -62,6 +63,8 @@ struct SignatureData {
     CScript scriptSig; ///< The scriptSig of an input. Contains complete signatures or the traditional partial signatures format
     CScript redeem_script; ///< The redeemScript (if any) for the input
     CScript witness_script; ///< The witnessScript (if any) for the input. witnessScripts are used in P2WSH outputs.
+    ScriptPath taproot_script_path; ///< The (if any) tapscript + merkle path for the control block. This is used in SegwitV1(Taproot) outputs.
+    std::map<CPubKey, uint256> p2c_tweaks; ///< The Pay-To-Contract tweaks (if any), needed to contruct the control block. This is used in SegwitV1(Taproot) outputs
     CScriptWitness scriptWitness; ///< The scriptWitness of an input. Contains complete signatures or the traditional partial signatures format. scriptWitness is part of a transaction input per BIP 144.
     std::map<CKeyID, SigPair> signatures; ///< BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a final scriptSig or scriptWitness.
     std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> misc_pubkeys;

src/script/standard.cpp

@@ -37,6 +37,7 @@ const char* GetTxnOutputType(txnouttype t)
     case TX_NULL_DATA: return "nulldata";
     case TX_WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
     case TX_WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
+    case TX_WITNESS_V1_TAPROOT: return "witness_v1_taproot";
     case TX_WITNESS_UNKNOWN: return "witness_unknown";
     }
     return nullptr;
@@ -112,6 +113,10 @@ txnouttype Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned
             vSolutionsRet.push_back(witnessprogram);
             return TX_WITNESS_V0_SCRIPTHASH;
         }
+        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
+            vSolutionsRet.push_back(witnessprogram);
+            return TX_WITNESS_V1_TAPROOT;
+        }
         if (witnessversion != 0) {
             vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
             vSolutionsRet.push_back(std::move(witnessprogram));
@@ -185,6 +190,10 @@ bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
         std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
         addressRet = hash;
         return true;
+    } else if (whichType == TX_WITNESS_V1_TAPROOT) {
+        vSolutions[0][0] += 2;
+        addressRet = WitnessV1Point(vSolutions[0]);
+        return true;
     } else if (whichType == TX_WITNESS_UNKNOWN) {
         WitnessUnknown unk;
         unk.version = vSolutions[0][0];
@@ -270,6 +279,15 @@ class CScriptVisitor : public boost::static_visitor<bool>
         return true;
     }
 
+    bool operator()(const WitnessV1Point& id) const
+    {
+        script->clear();
+        std::vector<unsigned char> point = ToByteVector(id);
+        point[0] -= 2; // According to BIP-Taproot;
+        *script << OP_1 << point;
+        return true;
+    }
+
     bool operator()(const WitnessV0ScriptHash& id) const
     {
         script->clear();

src/script/standard.h

@@ -11,6 +11,7 @@
 
 #include <boost/variant.hpp>
 
+#include <pubkey.h>
 #include <stdint.h>
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
@@ -64,6 +65,7 @@ enum txnouttype
     TX_NULL_DATA, //!< unspendable OP_RETURN script that carries data
     TX_WITNESS_V0_SCRIPTHASH,
     TX_WITNESS_V0_KEYHASH,
+    TX_WITNESS_V1_TAPROOT,
     TX_WITNESS_UNKNOWN, //!< Only for Witness versions not already defined above
 };
 
@@ -97,6 +99,13 @@ struct WitnessV0ScriptHash : public uint256
     using uint256::uint256;
 };
 
+struct WitnessV1Point : public CPubKey
+{
+    WitnessV1Point() : CPubKey() {}
+    explicit WitnessV1Point(const CPubKey& key) : CPubKey(key) {}
+    using CPubKey::CPubKey;
+};
+
 struct WitnessV0KeyHash : public uint160
 {
     WitnessV0KeyHash() : uint160() {}
@@ -134,9 +143,10 @@ struct WitnessUnknown
  *  * WitnessV0ScriptHash: TX_WITNESS_V0_SCRIPTHASH destination (P2WSH)
  *  * WitnessV0KeyHash: TX_WITNESS_V0_KEYHASH destination (P2WPKH)
  *  * WitnessUnknown: TX_WITNESS_UNKNOWN destination (P2W???)
+ *  * WitnessV1Point: Taproot destination
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
-typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown> CTxDestination;
+typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Point, WitnessUnknown> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination& dest);

src/wallet/ismine.cpp

@@ -68,6 +68,7 @@ IsMineResult IsMineInner(const CWallet& keystore, const CScript& scriptPubKey, I
     case TX_NONSTANDARD:
     case TX_NULL_DATA:
     case TX_WITNESS_UNKNOWN:
+    case TX_WITNESS_V1_TAPROOT:
         break;
     case TX_PUBKEY:
         keyID = CPubKey(vSolutions[0]).GetID();

src/wallet/rpcwallet.cpp

@@ -3616,6 +3616,17 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
         return obj;
     }
 
+    UniValue operator()(const WitnessV1Point& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        CPubKey pubkey;
+        // TODO: Add tweak and script paths?
+        if (pwallet && pwallet->GetPubKey(CKeyID(id.GetID()), pubkey)) {
+            obj.pushKV("taproot internal-key", HexStr(pubkey));
+        }
+        return obj;
+    }
+
     UniValue operator()(const WitnessUnknown& id) const { return UniValue(UniValue::VOBJ); }
 };