From d8e940f30135f771ea1a0683d5967711a69b28d0 Mon Sep 17 00:00:00 2001
From: David Burkett <davidburkett38@gmail.com>
Date: Sat, 29 Jan 2022 14:28:57 -0500
Subject: [PATCH] MWEB: Add StealthAddress to CTxDestination and add pegin and
 hogex script consts & logic

---
 src/chainparams.cpp            |  3 +++
 src/chainparams.h              |  2 ++
 src/key_io.cpp                 | 23 ++++++++++++++++++++++
 src/rpc/blockchain.cpp         |  2 +-
 src/rpc/util.cpp               | 14 ++++++++++++++
 src/script/script.cpp          | 35 ++++++++++++++++++++++++++++++++++
 src/script/script.h            | 16 ++++++++++++++++
 src/script/standard.cpp        | 35 ++++++++++++++++++++++++++++++++++
 src/script/standard.h          | 10 +++++++++-
 src/test/script_tests.cpp      | 15 ++++++++++++++-
 src/wallet/rpcwallet.cpp       |  8 ++++++++
 src/wallet/scriptpubkeyman.cpp |  2 ++
 12 files changed, 162 insertions(+), 3 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index e2f54cb5e..00575d2f8 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -132,6 +132,7 @@ public:
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
 
         bech32_hrp = "ltc";
+        mweb_hrp = "ltcmweb";
 
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 
@@ -236,6 +237,7 @@ public:
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
         bech32_hrp = "tltc";
+        mweb_hrp = "tmweb";
 
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 
@@ -341,6 +343,7 @@ public:
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
         bech32_hrp = "rltc";
+        mweb_hrp = "tmweb";
     }
 
     /**
diff --git a/src/chainparams.h b/src/chainparams.h
index 6b45c8af7..a48fbd853 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -89,6 +89,7 @@ public:
     const std::vector<std::string>& DNSSeeds() const { return vSeeds; }
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
     const std::string& Bech32HRP() const { return bech32_hrp; }
+    const std::string& MWEB_HRP() const { return mweb_hrp; }
     const std::vector<SeedSpec6>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
     const ChainTxData& TxData() const { return chainTxData; }
@@ -104,6 +105,7 @@ protected:
     std::vector<std::string> vSeeds;
     std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
     std::string bech32_hrp;
+    std::string mweb_hrp;
     std::string strNetworkID;
     CBlock genesis;
     std::vector<SeedSpec6> vFixedSeeds;
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 007e89557..1fb8160e6 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -66,6 +66,16 @@ public:
         return bech32::Encode(bech32::Encoding::BECH32M, m_params.Bech32HRP(), data);
     }
 
+    std::string operator()(const StealthAddress& id) const
+    {
+        std::vector<uint8_t> serialized = id.Serialized();
+
+        std::vector<uint8_t> converted = {0};
+        ConvertBits<8, 5, true>([&](unsigned char c) { converted.push_back(c); }, serialized.begin(), serialized.end());
+
+        return bech32::Encode(bech32::Encoding::BECH32, m_params.MWEB_HRP(), converted);
+    }
+
     std::string operator()(const CNoDestination& no) const { return {}; }
 };
 
@@ -138,6 +148,19 @@ CTxDestination DecodeDestination(const std::string& str, const CChainParams& par
             return unk;
         }
     }
+
+    auto decoded = bech32::Decode(str, true);
+    if (decoded.encoding == bech32::Encoding::BECH32 && decoded.hrp == params.MWEB_HRP()) {
+        std::vector<uint8_t> converted;
+        converted.reserve(((decoded.data.size() - 1) * 5) / 8);
+
+        if (ConvertBits<5, 8, false>([&](unsigned char c) { converted.push_back(c); }, decoded.data.begin() + 1, decoded.data.end())) {
+            if (converted.size() == 66) {
+                return StealthAddress(BigInt<33>(converted.data()), BigInt<33>(converted.data() + 33));
+            }
+        }
+    }
+
     return CNoDestination();
 }
 } // namespace
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 9bc139b0d..9407fc3a5 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -154,7 +154,7 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* tip, const CBlockIn
     const CBlockIndex* pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
-    result.pushKV("strippedsize", (int)::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS));
+    result.pushKV("strippedsize", (int)::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS | SERIALIZE_NO_MWEB));
     result.pushKV("size", (int)::GetSerializeSize(block, PROTOCOL_VERSION));
     result.pushKV("weight", (int)::GetBlockWeight(block));
     result.pushKV("height", blockindex->nHeight);
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index b8609e3e7..dd999362d 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -224,6 +224,7 @@ public:
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", false);
         obj.pushKV("iswitness", false);
+        obj.pushKV("ismweb", false);
         return obj;
     }
 
@@ -232,6 +233,7 @@ public:
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", true);
         obj.pushKV("iswitness", false);
+        obj.pushKV("ismweb", false);
         return obj;
     }
 
@@ -242,6 +244,7 @@ public:
         obj.pushKV("iswitness", true);
         obj.pushKV("witness_version", 0);
         obj.pushKV("witness_program", HexStr(id));
+        obj.pushKV("ismweb", false);
         return obj;
     }
 
@@ -252,6 +255,7 @@ public:
         obj.pushKV("iswitness", true);
         obj.pushKV("witness_version", 0);
         obj.pushKV("witness_program", HexStr(id));
+        obj.pushKV("ismweb", false);
         return obj;
     }
 
@@ -261,6 +265,16 @@ public:
         obj.pushKV("iswitness", true);
         obj.pushKV("witness_version", (int)id.version);
         obj.pushKV("witness_program", HexStr(Span<const unsigned char>(id.program, id.length)));
+        obj.pushKV("ismweb", false);
+        return obj;
+    }
+
+    UniValue operator()(const StealthAddress& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("isscript", false);
+        obj.pushKV("iswitness", false);
+        obj.pushKV("ismweb", true);
         return obj;
     }
 };
diff --git a/src/script/script.cpp b/src/script/script.cpp
index f31472e42..a787c3738 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -5,6 +5,7 @@
 
 #include <script/script.h>
 
+#include <mw/models/crypto/Hash.h>
 #include <util/strencodings.h>
 
 #include <string>
@@ -233,6 +234,40 @@ bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program
     return false;
 }
 
+bool CScript::IsMWEBPegin(mw::Hash* const kernel_id) const
+{
+    int version;
+    std::vector<uint8_t> program;
+    if (IsWitnessProgram(version, program)) {
+        if (version == MWEB_PEGIN_WITNESS_VERSION && program.size() == WITNESS_MWEB_PEGIN_SIZE) {
+            if (kernel_id != nullptr) {
+                *kernel_id = mw::Hash(std::move(program));
+            }
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CScript::IsMWEBHogAddr(mw::Hash* const header_hash) const
+{
+    int version;
+    std::vector<uint8_t> program;
+    if (IsWitnessProgram(version, program)) {
+        if (version == MWEB_HOG_ADDR_WITNESS_VERSION && program.size() == WITNESS_MWEB_HEADERHASH_SIZE) {
+            if (header_hash != nullptr) {
+                *header_hash = mw::Hash(std::move(program));
+            }
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
 bool CScript::IsPushOnly(const_iterator pc) const
 {
     while (pc < end())
diff --git a/src/script/script.h b/src/script/script.h
index 974cde498..243ffc77a 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -7,6 +7,7 @@
 #define BITCOIN_SCRIPT_SCRIPT_H
 
 #include <crypto/common.h>
+#include <mw/models/crypto/Hash.h>
 #include <prevector.h>
 #include <serialize.h>
 
@@ -19,6 +20,18 @@
 #include <string>
 #include <vector>
 
+// MWEB: Size of the witness program of the first output in HogEx transactions
+static constexpr size_t WITNESS_MWEB_HEADERHASH_SIZE = 32;
+
+// MWEB: Size of the witness program for peg-in transactions
+static constexpr size_t WITNESS_MWEB_PEGIN_SIZE = 32;
+
+// MWEB: Version of MWEB witness programs for HogAddr outputs
+static constexpr int MWEB_HOG_ADDR_WITNESS_VERSION = 8;
+
+// MWEB: Version of MWEB witness programs for peg-in transactions
+static constexpr int MWEB_PEGIN_WITNESS_VERSION = 9;
+
 // Maximum number of bytes pushable to the stack
 static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520;
 
@@ -528,6 +541,9 @@ public:
     bool IsPayToWitnessScriptHash() const;
     bool IsWitnessProgram(int& version, std::vector<unsigned char>& program) const;
 
+    bool IsMWEBPegin(mw::Hash* const kernel_id = nullptr) const;
+    bool IsMWEBHogAddr(mw::Hash* const header_hash) const;
+
     /** Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical). */
     bool IsPushOnly(const_iterator pc) const;
     bool IsPushOnly() const;
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index f2f81664f..d937aabef 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -56,6 +56,8 @@ std::string GetTxnOutputType(TxoutType t)
     case TxoutType::WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
     case TxoutType::WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
     case TxoutType::WITNESS_V1_TAPROOT: return "witness_v1_taproot";
+    case TxoutType::WITNESS_MWEB_PEGIN: return "witness_mweb_pegin";
+    case TxoutType::WITNESS_MWEB_HOGADDR: return "witness_mweb_hogaddr";
     case TxoutType::WITNESS_UNKNOWN: return "witness_unknown";
     } // no default case, so the compiler can warn about missing cases
     assert(false);
@@ -136,6 +138,14 @@ TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned c
             vSolutionsRet.push_back(std::move(witnessprogram));
             return TxoutType::WITNESS_V1_TAPROOT;
         }
+        if (witnessversion == MWEB_PEGIN_WITNESS_VERSION && witnessprogram.size() == WITNESS_MWEB_PEGIN_SIZE) {
+            vSolutionsRet.push_back(witnessprogram);
+            return TxoutType::WITNESS_MWEB_PEGIN;
+        }
+        if (witnessversion == MWEB_HOG_ADDR_WITNESS_VERSION && witnessprogram.size() == WITNESS_MWEB_HEADERHASH_SIZE) {
+            vSolutionsRet.push_back(witnessprogram);
+            return TxoutType::WITNESS_MWEB_HOGADDR;
+        }
         if (witnessversion != 0) {
             vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
             vSolutionsRet.push_back(std::move(witnessprogram));
@@ -295,6 +305,11 @@ public:
     {
         return CScript() << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
     }
+
+    CScript operator()(const StealthAddress& id) const
+    {
+		return CScript();
+    }
 };
 } // namespace
 
@@ -319,6 +334,26 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
     return script;
 }
 
+CScript GetScriptForPegin(const mw::Hash& kernel_id)
+{
+    CScript script;
+    script << CScript::EncodeOP_N(MWEB_PEGIN_WITNESS_VERSION);
+    script << kernel_id.vec();
+    return script;
+}
+
 bool IsValidDestination(const CTxDestination& dest) {
     return dest.which() != 0;
 }
+
+bool IsPegInOutput(const CTxOutput& output)
+{
+    if (!output.IsMWEB()) {
+        std::vector<std::vector<uint8_t>> solutions_data;
+        auto which_type = Solver(output.GetTxOut().scriptPubKey, solutions_data);
+        return which_type == TxoutType::WITNESS_MWEB_PEGIN;
+    }
+
+    return false;
+}
+
diff --git a/src/script/standard.h b/src/script/standard.h
index 721203385..2608ab1ff 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_SCRIPT_STANDARD_H
 #define BITCOIN_SCRIPT_STANDARD_H
 
+#include <mw/models/wallet/StealthAddress.h>
 #include <script/interpreter.h>
 #include <uint256.h>
 
@@ -130,6 +131,8 @@ enum class TxoutType {
     WITNESS_V0_SCRIPTHASH,
     WITNESS_V0_KEYHASH,
     WITNESS_V1_TAPROOT,
+    WITNESS_MWEB_PEGIN, //!< Hash of the peg-in kernel
+    WITNESS_MWEB_HOGADDR, //!< HogAddr (first output of HogEx)
     WITNESS_UNKNOWN, //!< Only for Witness versions not already defined above
 };
 
@@ -209,9 +212,10 @@ struct WitnessUnknown
  *  * WitnessV0KeyHash: TxoutType::WITNESS_V0_KEYHASH destination (P2WPKH)
  *  * WitnessUnknown: TxoutType::WITNESS_UNKNOWN/WITNESS_V1_TAPROOT destination (P2W???)
  *    (taproot outputs do not require their own type as long as no wallet support exists)
+ *  * StealthAddress: MWEB 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, WitnessUnknown, StealthAddress> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination& dest);
@@ -265,4 +269,8 @@ CScript GetScriptForRawPubKey(const CPubKey& pubkey);
 /** Generate a multisig script. */
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);
 
+bool IsPegInOutput(const CTxOutput& output);
+
+CScript GetScriptForPegin(const mw::Hash& kernel_id);
+
 #endif // BITCOIN_SCRIPT_STANDARD_H
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 25ca171b3..b9a5b4644 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -1473,7 +1473,7 @@ BOOST_AUTO_TEST_CASE(script_HasValidOps)
 static CMutableTransaction TxFromHex(const std::string& str)
 {
     CMutableTransaction tx;
-    VectorReader(SER_DISK, SERIALIZE_TRANSACTION_NO_WITNESS, ParseHex(str), 0) >> tx;
+    VectorReader(SER_DISK, SERIALIZE_TRANSACTION_NO_WITNESS | SERIALIZE_NO_MWEB, ParseHex(str), 0) >> tx;
     return tx;
 }
 
@@ -1500,6 +1500,19 @@ static CScriptWitness ScriptWitnessFromJSON(const UniValue& univalue)
     return scriptwitness;
 }
 
+// MWEB: Pegin Script
+BOOST_AUTO_TEST_CASE(script_mweb_pegin)
+{
+    CScript script;
+    mw::Hash kernel_id = SecretKey::Random().vec();
+
+    script << OP_9 << kernel_id.vec();
+
+    mw::Hash kernel_id2;
+    BOOST_CHECK(script.IsMWEBPegin(&kernel_id2));
+    BOOST_CHECK(kernel_id == kernel_id2);
+}
+
 #if defined(HAVE_CONSENSUS_LIB)
 
 /* Test simple (successful) usage of bitcoinconsensus_verify_script */
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 2a11b7c4e..4a79dea3d 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -3735,6 +3735,14 @@ public:
         return obj;
     }
 
+    UniValue operator()(const StealthAddress& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("scan_pubkey", id.GetScanPubKey().ToHex());
+        obj.pushKV("spend_pubkey", id.GetSpendPubKey().ToHex());
+        return obj;
+    }
+
     UniValue operator()(const WitnessUnknown& id) const { return UniValue(UniValue::VOBJ); }
 };
 
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 7dbbf1730..47b1445a4 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -97,6 +97,8 @@ IsMineResult IsMineInner(const LegacyScriptPubKeyMan& keystore, const CScript& s
     case TxoutType::NULL_DATA:
     case TxoutType::WITNESS_UNKNOWN:
     case TxoutType::WITNESS_V1_TAPROOT:
+    case TxoutType::WITNESS_MWEB_PEGIN:
+    case TxoutType::WITNESS_MWEB_HOGADDR:
         break;
     case TxoutType::PUBKEY:
         keyID = CPubKey(vSolutions[0]).GetID();