diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 5e3c752e6c..73e4ac22ce 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -47,6 +47,9 @@ FUZZ_SUITE_LD_COMMON = \
  $(LIBBITCOIN_CLI) \
  $(LIBUNIVALUE) \
  $(LIBLEVELDB) \
+ $(BOOST_LIBS) \
+ $(SSL_LIBS) \
+ $(CRYPTO_LIBS) \
  $(LIBMEMENV) \
  $(LIBSECP256K1) \
  $(MINISKETCH_LIBS) \
diff --git a/src/addresstype.cpp b/src/addresstype.cpp
index f199d1b479..684bc6eb35 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)
+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
@@ -167,3 +178,102 @@ CScript GetScriptForDestination(const CTxDestination& dest)
 bool IsValidDestination(const CTxDestination& dest) {
     return std::visit(ValidDestinationVisitor(), dest);
 }
+
+PKHash ExtractPublicKeyHash(const CScript& scriptPubKey, bool* OK)
+{
+    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 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;
+}
+
+int GetAddressIndexType(const CTxDestination &dest)
+{
+    if(dest.index() > 1)
+        return dest.index() - 1; // PubKeyDestination and PKHash are considered the same
+    return dest.index();
+}
diff --git a/src/addresstype.h b/src/addresstype.h
index 0152858bad..10b8ffd900 100644
--- a/src/addresstype.h
+++ b/src/addresstype.h
@@ -10,10 +10,14 @@
 #include <script/script.h>
 #include <uint256.h>
 #include <util/hash_type.h>
+#include <primitives/transaction.h>
 
 #include <algorithm>
 #include <variant>
 #include <vector>
+enum class TxoutType;
+
+typedef std::vector<unsigned char> valtype;
 
 class CNoDestination
 {
@@ -143,7 +147,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);
+bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet, TxoutType* typeRet = NULL, bool convertPublicKeyToHash = false);
 
 /**
  * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
@@ -152,4 +156,37 @@ bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
  */
 CScript GetScriptForDestination(const CTxDestination& dest);
 
+inline bool operator!=(const CTxDestination& lhs, const CTxDestination& rhs){ return !(lhs == rhs); }
+
+enum addresstype
+{
+    PUBKEYHASH = 1,
+    SCRIPTHASH = 2,
+    WITNESSSCRIPTHASH = 3,
+    WITNESSPUBKEYHASH = 4,
+    WITNESSTAPROOT = 5,
+    NONSTANDARD = 6
+};
+
+/** Check whether a CTxDestination can be used as contract sender address. */
+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);
+
+int GetAddressIndexType(const CTxDestination& dest);
+
 #endif // BITCOIN_ADDRESSTYPE_H
diff --git a/src/key.cpp b/src/key.cpp
index 2bd6396298..09b538af81 100644
--- a/src/key.cpp
+++ b/src/key.cpp
@@ -16,8 +16,25 @@
 #include <secp256k1_recovery.h>
 #include <secp256k1_schnorrsig.h>
 
+#include <openssl/bn.h>
+#include <openssl/ecdsa.h>
+#include <openssl/rand.h>
+#include <openssl/obj_mac.h>
+#include <openssl/opensslv.h>
+
 static secp256k1_context* secp256k1_context_sign = nullptr;
 
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+// Compatibility Layer for older versions of Open SSL
+void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
+ {
+    if (pr != NULL)
+        *pr = sig->r;
+    if (ps != NULL)
+        *ps = sig->s;
+ }
+#endif
+
 /** These functions are taken from the libsecp256k1 distribution and are very ugly. */
 
 /**
@@ -154,6 +171,45 @@ int ec_seckey_export_der(const secp256k1_context *ctx, unsigned char *seckey, si
     return 1;
 }
 
+const unsigned char vchOrder[32] = {
+    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xba,0xae,0xdc,0xe6,0xaf,0x48,0xa0,0x3b,0xbf,0xd2,0x5e,0x8c,0xd0,0x36,0x41,0x41
+};
+
+const unsigned char vchHalfOrder[32] = {
+    0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x5d,0x57,0x6e,0x73,0x57,0xa4,0x50,0x1d,0xdf,0xe9,0x2f,0x46,0x68,0x1b,0x20,0xa0
+};
+
+bool EnsureLowS(std::vector<unsigned char>& vchSig) {
+    unsigned char *pos;
+
+    if (vchSig.empty())
+        return false;
+
+    pos = &vchSig[0];
+    ECDSA_SIG *sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&pos, vchSig.size());
+    if (sig == NULL)
+        return false;
+
+    BIGNUM *order = BN_bin2bn(vchOrder, sizeof(vchOrder), NULL);
+    BIGNUM *halforder = BN_bin2bn(vchHalfOrder, sizeof(vchHalfOrder), NULL);
+
+    BIGNUM *s = 0;
+    ECDSA_SIG_get0(sig, 0, (const BIGNUM **)&s);
+    if (BN_cmp(s, halforder) > 0) {
+        // enforce low S values, by negating the value (modulo the order) if above order/2.
+        BN_sub(s, order, s);
+    }
+
+    BN_free(halforder);
+    BN_free(order);
+
+    pos = &vchSig[0];
+    unsigned int nSize = i2d_ECDSA_SIG(sig, &pos);
+    ECDSA_SIG_free(sig);
+    vchSig.resize(nSize); // Shrink to fit actual size
+    return true;
+}
+
 bool CKey::Check(const unsigned char *vch) {
     return secp256k1_ec_seckey_verify(secp256k1_context_sign, vch);
 }
@@ -244,7 +300,7 @@ bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
         return false;
     }
     unsigned char rnd[8];
-    std::string str = "Bitcoin key verification\n";
+    std::string str = "Qtum key verification\n";
     GetRandBytes(rnd);
     uint256 hash{Hash(str, rnd)};
     std::vector<unsigned char> vchSig;
diff --git a/src/key.h b/src/key.h
index d6b26f891d..8a59e45d08 100644
--- a/src/key.h
+++ b/src/key.h
@@ -239,4 +239,7 @@ void ECC_Stop();
 /** Check that required EC support is available at runtime. */
 bool ECC_InitSanityCheck();
 
+/** Ensure that the signature is LowS */
+bool EnsureLowS(std::vector<unsigned char>& vchSig);
+
 #endif // BITCOIN_KEY_H
diff --git a/src/script/solver.cpp b/src/script/solver.cpp
index 5271e9a01a..4a07f17ce9 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>
@@ -29,6 +33,10 @@ std::string GetTxnOutputType(TxoutType t)
     case TxoutType::WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
     case TxoutType::WITNESS_V1_TAPROOT: return "witness_v1_taproot";
     case TxoutType::WITNESS_UNKNOWN: return "witness_unknown";
+    case TxoutType::CREATE_SENDER: return "create_sender";
+    case TxoutType::CALL_SENDER: return "call_sender";
+    case TxoutType::CREATE: return "create";
+    case TxoutType::CALL: return "call";
     } // no default case, so the compiler can warn about missing cases
     assert(false);
 }
@@ -138,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);
+                DataStream ss;
+                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();
@@ -203,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;
 }
diff --git a/src/uint256.cpp b/src/uint256.cpp
index 7f81c3c448..de012f4f4d 100644
--- a/src/uint256.cpp
+++ b/src/uint256.cpp
@@ -17,6 +17,18 @@ std::string base_blob<BITS>::GetHex() const
     return HexStr(m_data_rev);
 }
 
+template <unsigned int BITS>
+std::string base_blob<BITS>::GetReverseHex() const
+{
+    char psz[WIDTH * 2 + 1];
+    int j=0;
+    for (int i = sizeof(m_data)-1; i >= 0; i--) {
+        sprintf(psz + j * 2, "%02x", m_data[WIDTH - i - 1]);
+        j++;
+    }
+    return std::string(psz, psz + WIDTH * 2);
+}
+
 template <unsigned int BITS>
 void base_blob<BITS>::SetHex(const char* psz)
 {
@@ -51,6 +63,27 @@ void base_blob<BITS>::SetHex(const std::string& str)
     SetHex(str.c_str());
 }
 
+template <unsigned int BITS>
+void base_blob<BITS>::SetReverseHex(const char* psz)
+{
+    SetHex(psz);
+    //reverse in-place
+    int left = 0;
+    int right = size()-1;
+    unsigned char* p1 = m_data.data();
+    while(left < right){
+        int temp=p1[left];
+        p1[left++] = p1[right];
+        p1[right--] = temp;
+    }
+}
+
+template <unsigned int BITS>
+void base_blob<BITS>::SetReverseHex(const std::string& str)
+{
+    SetReverseHex(str.c_str());
+}
+
 template <unsigned int BITS>
 std::string base_blob<BITS>::ToString() const
 {
@@ -62,12 +95,18 @@ template std::string base_blob<160>::GetHex() const;
 template std::string base_blob<160>::ToString() const;
 template void base_blob<160>::SetHex(const char*);
 template void base_blob<160>::SetHex(const std::string&);
+template std::string base_blob<160>::GetReverseHex() const;
+template void base_blob<160>::SetReverseHex(const char*);
+template void base_blob<160>::SetReverseHex(const std::string&);
 
 // Explicit instantiations for base_blob<256>
 template std::string base_blob<256>::GetHex() const;
 template std::string base_blob<256>::ToString() const;
 template void base_blob<256>::SetHex(const char*);
 template void base_blob<256>::SetHex(const std::string&);
+template std::string base_blob<256>::GetReverseHex() const;
+template void base_blob<256>::SetReverseHex(const char*);
+template void base_blob<256>::SetReverseHex(const std::string&);
 
 const uint256 uint256::ZERO(0);
 const uint256 uint256::ONE(1);
diff --git a/src/uint256.h b/src/uint256.h
index d35b3a66fa..70c7581192 100644
--- a/src/uint256.h
+++ b/src/uint256.h
@@ -58,8 +58,11 @@ class base_blob
     friend constexpr bool operator<(const base_blob& a, const base_blob& b) { return a.Compare(b) < 0; }
 
     std::string GetHex() const;
+    std::string GetReverseHex() const;
     void SetHex(const char* psz);
     void SetHex(const std::string& str);
+    void SetReverseHex(const char* psz);
+    void SetReverseHex(const std::string& str);
     std::string ToString() const;
 
     constexpr const unsigned char* data() const { return m_data.data(); }
@@ -97,6 +100,18 @@ class uint160 : public base_blob<160> {
     constexpr uint160() = default;
     constexpr explicit uint160(Span<const unsigned char> vch) : base_blob<160>(vch) {}
 };
+inline uint160 uint160S(const char *str)
+{
+    uint160 rv;
+    rv.SetHex(str);
+    return rv;
+}
+inline uint160 uint160S(const std::string& str)
+{
+    uint160 rv;
+    rv.SetHex(str);
+    return rv;
+}
 
 /** 256-bit opaque blob.
  * @note This type is called uint256 for historical reasons only. It is an