From 2def8e87728e8552f732aa121be43f86c1ae5656 Mon Sep 17 00:00:00 2001
From: timemarkovqtum <time.markov@qtum.com>
Date: Tue, 19 Mar 2024 15:16:59 +0100
Subject: [PATCH] Port address type

---
 src/addresstype.cpp   | 102 ++++++++++++++++++-
 src/addresstype.h     |  19 +++-
 src/script/solver.cpp | 228 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 344 insertions(+), 5 deletions(-)

diff --git a/src/addresstype.cpp b/src/addresstype.cpp
index a3671577e5..5632879471 100644
--- a/src/addresstype.cpp
+++ b/src/addresstype.cpp
@@ -11,11 +11,11 @@
 #include <script/solver.h>
 #include <uint256.h>
 #include <util/hash_type.h>
+#include <qtum/qtumstate.h>
 
 #include <cassert>
 #include <vector>
 
-typedef std::vector<unsigned char> valtype;
 
 ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
 ScriptHash::ScriptHash(const CScriptID& in) : BaseHash{in} {}
@@ -46,16 +46,23 @@ WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
     CSHA256().Write(in.data(), in.size()).Finalize(begin());
 }
 
-bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet)
+bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet, bool convertPublicKeyToHash)
 {
     std::vector<valtype> vSolutions;
     TxoutType whichType = Solver(scriptPubKey, vSolutions);
 
+    if(typeRet){
+        *typeRet = whichType;
+    }
+
     switch (whichType) {
     case TxoutType::PUBKEY: {
         CPubKey pubKey(vSolutions[0]);
         if (!pubKey.IsValid()) {
             addressRet = CNoDestination(scriptPubKey);
+        } else if (convertPublicKeyToHash) {
+            addressRet = PKHash(pubKey);
+            return true;
         } else {
             addressRet = PubKeyDestination(pubKey);
         }
@@ -94,6 +101,10 @@ bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet,
     case TxoutType::MULTISIG:
     case TxoutType::NULL_DATA:
     case TxoutType::NONSTANDARD:
+    case TxoutType::CREATE_SENDER:
+    case TxoutType::CALL_SENDER:
+    case TxoutType::CREATE:
+    case TxoutType::CALL:
         addressRet = CNoDestination(scriptPubKey);
         return false;
     } // no default case, so the compiler can warn about missing cases
@@ -170,9 +181,92 @@ bool IsValidDestination(const CTxDestination& dest) {
 
 PKHash ExtractPublicKeyHash(const CScript& scriptPubKey, bool* OK)
 {
-    return {};
+    if(OK) *OK = false;
+    CTxDestination address;
+    TxoutType txType=TxoutType::NONSTANDARD;
+    if(ExtractDestination(scriptPubKey, address, &txType, true)){
+        if ((txType == TxoutType::PUBKEY || txType == TxoutType::PUBKEYHASH) && std::holds_alternative<PKHash>(address)) {
+            if(OK) *OK = true;
+            return std::get<PKHash>(address);
+        }
+    }
+
+    return PKHash();
 }
 
 bool IsValidContractSenderAddress(const CTxDestination& dest) {
-    return {};
+    return std::holds_alternative<PKHash>(dest);
+}
+
+valtype DataVisitor::operator()(const CNoDestination& noDest) const { return valtype(); }
+valtype DataVisitor::operator()(const PKHash& keyID) const { return valtype(keyID.begin(), keyID.end()); }
+valtype DataVisitor::operator()(const PubKeyDestination& pubKey) const {
+    PKHash keyID(pubKey.GetPubKey());
+    return valtype(keyID.begin(), keyID.end());
+}
+valtype DataVisitor::operator()(const ScriptHash& scriptID) const { return valtype(scriptID.begin(), scriptID.end()); }
+valtype DataVisitor::operator()(const WitnessV0ScriptHash& witnessScriptHash) const { return valtype(witnessScriptHash.begin(), witnessScriptHash.end()); }
+valtype DataVisitor::operator()(const WitnessV0KeyHash& witnessKeyHash) const { return valtype(witnessKeyHash.begin(), witnessKeyHash.end()); }
+valtype DataVisitor::operator()(const WitnessV1Taproot& witnessTaproot) const { return valtype(witnessTaproot.begin(), witnessTaproot.end()); }
+valtype DataVisitor::operator()(const WitnessUnknown&) const { return valtype(); }
+
+bool ExtractDestination(const COutPoint& prevout, const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet)
+{
+    std::vector<valtype> vSolutions;
+    TxoutType whichType = Solver(scriptPubKey, vSolutions);
+
+    if(typeRet){
+        *typeRet = whichType;
+    }
+
+
+    if (whichType == TxoutType::PUBKEY)
+    {
+        CPubKey pubKey(vSolutions[0]);
+        if (!pubKey.IsValid())
+            return false;
+
+        addressRet = PKHash(pubKey);
+        return true;
+    }
+    else if (whichType == TxoutType::PUBKEYHASH)
+    {
+        addressRet = PKHash(uint160(vSolutions[0]));
+        return true;
+    }
+    else if (whichType == TxoutType::SCRIPTHASH)
+    {
+        addressRet = ScriptHash(uint160(vSolutions[0]));
+        return true;
+    }
+    else if(whichType == TxoutType::CALL){
+        addressRet = PKHash(uint160(vSolutions[0]));
+        return true;
+    }
+    else if(whichType == TxoutType::WITNESS_V0_KEYHASH)
+    {
+        addressRet = WitnessV0KeyHash(uint160(vSolutions[0]));
+        return true;
+    }
+    else if(whichType == TxoutType::WITNESS_V0_SCRIPTHASH)
+    {
+        addressRet = WitnessV0ScriptHash(uint256(vSolutions[0]));
+        return true;
+    }
+    else if(whichType == TxoutType::WITNESS_V1_TAPROOT)
+    {
+        WitnessV1Taproot tap;
+        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
+        addressRet = tap;
+        return true;
+    }
+    else if (whichType == TxoutType::WITNESS_UNKNOWN) {
+        addressRet = WitnessUnknown{vSolutions[0][0], vSolutions[1]};
+        return true;
+    }
+    else if (whichType == TxoutType::CREATE) {
+        addressRet = PKHash(uint160(QtumState::createQtumAddress(uintToh256(prevout.hash), prevout.n).asBytes()));
+        return true;
+    }
+    return false;
 }
diff --git a/src/addresstype.h b/src/addresstype.h
index 0a94275a8f..92379d1cbc 100644
--- a/src/addresstype.h
+++ b/src/addresstype.h
@@ -9,11 +9,14 @@
 #include <script/script.h>
 #include <uint256.h>
 #include <util/hash_type.h>
+#include <primitives/transaction.h>
 
 #include <variant>
 #include <algorithm>
 enum class TxoutType;
 
+typedef std::vector<unsigned char> valtype;
+
 class CNoDestination
 {
 private:
@@ -142,7 +145,7 @@ bool IsValidDestination(const CTxDestination& dest);
  * Returns true for standard destinations with addresses - P2PKH, P2SH, P2WPKH, P2WSH, P2TR and P2W??? scripts.
  * Returns false for non-standard destinations and those without addresses - P2PK, bare multisig, null data, and nonstandard scripts.
  */
-bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet = NULL);
+bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet = NULL, bool convertPublicKeyToHash = false);
 
 /**
  * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
@@ -168,4 +171,18 @@ bool IsValidContractSenderAddress(const CTxDestination& dest);
 
 PKHash ExtractPublicKeyHash(const CScript& scriptPubKey, bool* OK = nullptr);
 
+struct DataVisitor
+{
+    valtype operator()(const CNoDestination& noDest) const;
+    valtype operator()(const PKHash& keyID) const;
+    valtype operator()(const PubKeyDestination& pubKey) const;
+    valtype operator()(const ScriptHash& scriptID) const;
+    valtype operator()(const WitnessV0ScriptHash& witnessScriptHash) const;
+    valtype operator()(const WitnessV0KeyHash& witnessKeyHash) const;
+    valtype operator()(const WitnessV1Taproot& witnessTaproot) const;
+    valtype operator()(const WitnessUnknown& witnessUnknown) const;
+};
+
+bool ExtractDestination(const COutPoint& prevout, const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet = NULL);
+
 #endif // BITCOIN_ADDRESSTYPE_H
diff --git a/src/script/solver.cpp b/src/script/solver.cpp
index 321a9340e2..89c95c399a 100644
--- a/src/script/solver.cpp
+++ b/src/script/solver.cpp
@@ -8,6 +8,10 @@
 #include <script/script.h>
 #include <script/solver.h>
 #include <span.h>
+#include <qtum/qtumDGP.h>
+#include <qtum/qtumtransaction.h>
+#include <validation.h>
+#include <addresstype.h>
 
 #include <algorithm>
 #include <cassert>
@@ -142,6 +146,224 @@ std::optional<std::pair<int, std::vector<Span<const unsigned char>>>> MatchMulti
     return std::pair{*threshold, std::move(keyspans)};
 }
 
+static bool MatchContract(const CScript& scriptPubKey, std::vector<std::vector<unsigned char>>& vSolutionsRet, bool contractConsensus, bool allowEmptySenderSig, TxoutType& typeRet )
+{
+    //contractConsesus is true when evaluating if a contract tx is "standard" for consensus purposes
+    //It is false in all other cases, so to prevent a particular contract tx from being broadcast on mempool, but allowed in blocks,
+    //one should ensure that contractConsensus is false
+
+    // Templates
+    static std::multimap<TxoutType, CScript> mTemplates;
+    if (mTemplates.empty())
+    {
+        // Contract creation tx with sender
+        mTemplates.insert(std::make_pair(TxoutType::CREATE_SENDER, CScript() << OP_ADDRESS_TYPE << OP_ADDRESS << OP_SCRIPT_SIG << OP_SENDER << OP_VERSION << OP_GAS_LIMIT << OP_GAS_PRICE << OP_DATA << OP_CREATE));
+
+        // Call contract tx with sender
+        mTemplates.insert(std::make_pair(TxoutType::CALL_SENDER, CScript() << OP_ADDRESS_TYPE << OP_ADDRESS << OP_SCRIPT_SIG << OP_SENDER << OP_VERSION << OP_GAS_LIMIT << OP_GAS_PRICE << OP_DATA << OP_PUBKEYHASH << OP_CALL));
+
+        // Contract creation tx
+        mTemplates.insert(std::make_pair(TxoutType::CREATE, CScript() << OP_VERSION << OP_GAS_LIMIT << OP_GAS_PRICE << OP_DATA << OP_CREATE));
+
+        // Call contract tx
+        mTemplates.insert(std::make_pair(TxoutType::CALL, CScript() << OP_VERSION << OP_GAS_LIMIT << OP_GAS_PRICE << OP_DATA << OP_PUBKEYHASH << OP_CALL));
+    }
+
+    // Scan templates
+    typeRet = TxoutType::NONSTANDARD;
+    const CScript& script1 = scriptPubKey;
+    for (const std::pair<TxoutType, CScript>& tplate : mTemplates)
+    {
+        const CScript& script2 = tplate.second;
+        vSolutionsRet.clear();
+
+        opcodetype opcode1, opcode2;
+        std::vector<unsigned char> vch1, vch2;
+
+        uint64_t addressType = 0;
+        VersionVM version;
+        version.rootVM=20; //set to some invalid value
+
+        // Compare
+        CScript::const_iterator pc1 = script1.begin();
+        CScript::const_iterator pc2 = script2.begin();
+        while (true)
+        {
+            if (pc1 == script1.end() && pc2 == script2.end())
+            {
+                // Found a match
+                typeRet =  tplate.first;
+                return true;
+            }
+            if (!script1.GetOp(pc1, opcode1, vch1))
+                break;
+            if (!script2.GetOp(pc2, opcode2, vch2))
+                break;
+
+            // Template matching opcodes:
+            if (opcode2 == OP_PUBKEYS)
+            {
+                while (vch1.size() >= 33 && vch1.size() <= 65)
+                {
+                    vSolutionsRet.push_back(vch1);
+                    if (!script1.GetOp(pc1, opcode1, vch1))
+                        break;
+                }
+                if (!script2.GetOp(pc2, opcode2, vch2))
+                    break;
+                // Normal situation is to fall through
+                // to other if/else statements
+            }
+
+            if (opcode2 == OP_PUBKEY)
+            {
+                if (vch1.size() < 33 || vch1.size() > 65)
+                    break;
+                vSolutionsRet.push_back(vch1);
+            }
+            else if (opcode2 == OP_PUBKEYHASH)
+            {
+                if (vch1.size() != sizeof(uint160))
+                    break;
+                vSolutionsRet.push_back(vch1);
+            }
+            else if (opcode2 == OP_SMALLINTEGER)
+            {   // Single-byte small integer pushed onto vSolutions
+                if (opcode1 == OP_0 ||
+                    (opcode1 >= OP_1 && opcode1 <= OP_16))
+                {
+                    char n = (char)CScript::DecodeOP_N(opcode1);
+                    vSolutionsRet.push_back(valtype(1, n));
+                }
+                else
+                    break;
+            }
+            else if (opcode2 == OP_VERSION)
+            {
+                if(0 <= opcode1 && opcode1 <= OP_PUSHDATA4)
+                {
+                    if(vch1.empty() || vch1.size() > 4 || (vch1.back() & 0x80))
+                        return false;
+
+                    version = VersionVM::fromRaw(CScriptNum::vch_to_uint64(vch1));
+                    if(!(version.toRaw() == VersionVM::GetEVMDefault().toRaw() || version.toRaw() == VersionVM::GetNoExec().toRaw())){
+                        // only allow standard EVM and no-exec transactions to live in mempool
+                        return false;
+                    }
+                }
+            }
+            else if(opcode2 == OP_GAS_LIMIT) {
+                try {
+                    uint64_t val = CScriptNum::vch_to_uint64(vch1);
+                    if(contractConsensus) {
+                        //consensus rules (this is checked more in depth later using DGP)
+                        if (version.rootVM != 0 && val < 1) {
+                            return false;
+                        }
+                        if (val > MAX_BLOCK_GAS_LIMIT_DGP) {
+                            //do not allow transactions that could use more gas than is in a block
+                            return false;
+                        }
+                    }else{
+                        //standard mempool rules for contracts
+                        //consensus rules for contracts
+                        if (version.rootVM != 0 && val < STANDARD_MINIMUM_GAS_LIMIT) {
+                            return false;
+                        }
+                        if (val > DEFAULT_BLOCK_GAS_LIMIT_DGP / 2) {
+                            //don't allow transactions that use more than 1/2 block of gas to be broadcast on the mempool
+                            return false;
+                        }
+
+                    }
+                }
+                catch (const scriptnum_error &err) {
+                    return false;
+                }
+            }
+            else if(opcode2 == OP_GAS_PRICE) {
+                try {
+                    uint64_t val = CScriptNum::vch_to_uint64(vch1);
+                    if(contractConsensus) {
+                        //consensus rules (this is checked more in depth later using DGP)
+                        if (version.rootVM != 0 && val < 1) {
+                            return false;
+                        }
+                    }else{
+                        //standard mempool rules
+                        if (version.rootVM != 0 && val < STANDARD_MINIMUM_GAS_PRICE) {
+                            return false;
+                        }
+                    }
+                }
+                catch (const scriptnum_error &err) {
+                    return false;
+                }
+            }
+            else if(opcode2 == OP_DATA)
+            {
+                if(0 <= opcode1 && opcode1 <= OP_PUSHDATA4)
+                {
+                    if(vch1.empty())
+                        break;
+                }
+            }
+            else if(opcode2 == OP_ADDRESS_TYPE)
+            {
+                try {
+                    uint64_t val = CScriptNum::vch_to_uint64(vch1);
+                    if(val < addresstype::PUBKEYHASH || val > addresstype::NONSTANDARD)
+                        break;
+
+                    addressType = val;
+                }
+                catch (const scriptnum_error &err) {
+                    break;
+                }
+            }
+            else if(opcode2 == OP_ADDRESS)
+            {
+                // Get the destination
+                CTxDestination dest;
+                if(addressType == addresstype::PUBKEYHASH && vch1.size() == sizeof(PKHash))
+                {
+                    dest = PKHash(uint160(vch1));
+                }
+                else
+                    break;
+
+                // Get the public key for the destination
+                CScript senderPubKey = GetScriptForDestination(dest);
+                CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                ss << senderPubKey;
+                Span<const uint8_t> sp = MakeUCharSpan(ss);
+                vSolutionsRet.push_back(std::vector<unsigned char>(sp.begin(), sp.end()));
+            }
+            else if(opcode2 == OP_SCRIPT_SIG)
+            {
+                if(0 <= opcode1 && opcode1 <= OP_PUSHDATA4)
+                {
+                    if(!allowEmptySenderSig && vch1.empty())
+                        break;
+
+                    // Check the max size of the signature script
+                    if(vch1.size() > MAX_BASE_SCRIPT_SIZE)
+                        return false;
+
+                    vSolutionsRet.push_back(vch1);
+                }
+            }
+            else if (opcode1 != opcode2 || vch1 != vch2)
+            {
+                // Others must match exactly
+                break;
+            }
+        }
+    }
+
+    return false;
+}
+
 TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned char>>& vSolutionsRet, bool contractConsensus, bool allowEmptySenderSig)
 {
     vSolutionsRet.clear();
@@ -207,6 +429,12 @@ TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned c
         return TxoutType::MULTISIG;
     }
 
+    TxoutType typeContract = TxoutType::NONSTANDARD;
+    if(MatchContract(scriptPubKey, vSolutionsRet, contractConsensus, allowEmptySenderSig, typeContract))
+    {
+        return typeContract;
+    }
+
     vSolutionsRet.clear();
     return TxoutType::NONSTANDARD;
 }