compile

src/coins.h

@@ -31,9 +31,8 @@
 class Coin
 {
 public:
-    // SYSCOIN
     //! unspent transaction output
-    CTxOutCoin out;
+    CTxOut out;
 
     //! whether containing transaction was a coinbase
     unsigned int fCoinBase : 1;
@@ -42,9 +41,7 @@ class Coin
     uint32_t nHeight : 31;
 
     //! construct a Coin from a CTxOut and height/coinbase information.
-    Coin(CTxOutCoin&& outIn, int nHeightIn, bool fCoinBaseIn) : out(std::move(outIn)), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
     Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn) : out(std::move(outIn)), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
-    Coin(const CTxOutCoin& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn),nHeight(nHeightIn) {}
     Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn),nHeight(nHeightIn) {}
 
     void Clear() {

src/consensus/tx_verify.cpp

@@ -138,8 +138,7 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& in
     {
         const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
         assert(!coin.IsSpent());
-        // SYSCOIN
-        const CTxOutCoin &prevout = coin.out;
+        const CTxOut &prevout = coin.out;
         if (prevout.scriptPubKey.IsPayToScriptHash())
             nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
     }
@@ -161,8 +160,7 @@ int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& i
     {
         const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
         assert(!coin.IsSpent());
-        // SYSCOIN
-        const CTxOutCoin &prevout = coin.out;
+        const CTxOut &prevout = coin.out;
         nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
     }
     return nSigOps;

src/core_write.cpp

@@ -29,20 +29,20 @@
 bool SyscoinMintTxToJson(const CTransaction& tx, const uint256& txHash, const uint256& hashBlock, UniValue &entry) {
     CMintSyscoin mintSyscoin(tx);
     if (!mintSyscoin.IsNull()) {
-        entry.__pushKV("txid", txHash.GetHex());
-        entry.__pushKV("blockhash", hashBlock.GetHex());  
+        entry.pushKV("txid", txHash.GetHex());
+        entry.pushKV("blockhash", hashBlock.GetHex());  
         UniValue oSPVProofObj(UniValue::VOBJ);
-        oSPVProofObj.__pushKV("txhash", mintSyscoin.nTxHash.GetHex());  
-        oSPVProofObj.__pushKV("blockhash", mintSyscoin.nBlockHash.GetHex());  
-        oSPVProofObj.__pushKV("postx", mintSyscoin.posTx);
-        oSPVProofObj.__pushKV("txroot", mintSyscoin.nTxRoot.GetHex()); 
-        oSPVProofObj.__pushKV("txparentnodes", HexStr(mintSyscoin.vchTxParentNodes)); 
-        oSPVProofObj.__pushKV("txpath", HexStr(mintSyscoin.vchTxPath)); 
-        oSPVProofObj.__pushKV("posReceipt", mintSyscoin.posReceipt);  
-        oSPVProofObj.__pushKV("receiptroot", mintSyscoin.nReceiptRoot.GetHex());  
-        oSPVProofObj.__pushKV("receiptparentnodes", HexStr(mintSyscoin.vchReceiptParentNodes));  
-        oSPVProofObj.__pushKV("amount", ValueFromAmount(mintSyscoin.nValue));  
-        entry.__pushKV("spv_proof", oSPVProofObj);
+        oSPVProofObj.pushKV("txhash", mintSyscoin.nTxHash.GetHex());  
+        oSPVProofObj.pushKV("blockhash", mintSyscoin.nBlockHash.GetHex());  
+        oSPVProofObj.pushKV("postx", mintSyscoin.posTx);
+        oSPVProofObj.pushKV("txroot", mintSyscoin.nTxRoot.GetHex()); 
+        oSPVProofObj.pushKV("txparentnodes", HexStr(mintSyscoin.vchTxParentNodes)); 
+        oSPVProofObj.pushKV("txpath", HexStr(mintSyscoin.vchTxPath)); 
+        oSPVProofObj.pushKV("posReceipt", mintSyscoin.posReceipt);  
+        oSPVProofObj.pushKV("receiptroot", mintSyscoin.nReceiptRoot.GetHex());  
+        oSPVProofObj.pushKV("receiptparentnodes", HexStr(mintSyscoin.vchReceiptParentNodes));  
+        oSPVProofObj.pushKV("amount", ValueFromAmount(mintSyscoin.nValue));  
+        entry.pushKV("spv_proof", oSPVProofObj);
         return true;
     } 
     return false;
@@ -247,8 +247,7 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
         }
         if (have_undo) {
             const Coin& prev_coin = txundo->vprevout[i];
-            // SYSCOIN
-            const CTxOutCoin& prev_txout = prev_coin.out;
+            const CTxOut& prev_txout = prev_coin.out;
 
             amt_total_in += prev_txout.nValue;
 

src/node/psbt.cpp

@@ -33,8 +33,8 @@ PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
         // We set next role here and ratchet backwards as required
         input_analysis.next = PSBTRole::EXTRACTOR;
 
-        // SYSCOIN Check for a UTXO
-        CTxOutCoin utxo;
+        // Check for a UTXO
+        CTxOut utxo;
         if (psbtx.GetInputUTXO(utxo, i)) {
             if (!MoneyRange(utxo.nValue) || !MoneyRange(in_amt + utxo.nValue)) {
                 result.SetInvalid(strprintf("PSBT is not valid. Input %u has invalid value", i));

src/policy/policy.cpp

@@ -191,8 +191,7 @@ bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
     }
 
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
-        // SYSCOIN
-        const CTxOutCoin& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
+        const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
 
         std::vector<std::vector<unsigned char> > vSolutions;
         TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
@@ -230,8 +229,7 @@ bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
         // If the script is invalid without witness, it would be caught sooner or later during validation.
         if (tx.vin[i].scriptWitness.IsNull())
             continue;
-        // SYSCOIN
-        const CTxOutCoin &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
+        const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
 
         // get the scriptPubKey corresponding to this input:
         CScript prevScript = prev.scriptPubKey;

src/primitives/transaction.cpp

@@ -73,20 +73,10 @@ CTxOut::CTxOut(const CAmount& nValueIn,  const CScript &scriptPubKeyIn)
     scriptPubKey = scriptPubKeyIn;
     vchNEVMData.clear();
 }
-// SYSCOIN
-CTxOutCoin::CTxOutCoin(const CAmount& nValueIn,  const CScript &scriptPubKeyIn)
-{
-    nValue = nValueIn;
-    scriptPubKey = scriptPubKeyIn;
-}
 std::string CTxOut::ToString() const
 {
     return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
 }
-std::string CTxOutCoin::ToString() const
-{
-    return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
-}
 CMutableTransaction::CMutableTransaction() : nVersion(CTransaction::CURRENT_VERSION), nLockTime(0) {}
 CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nLockTime(tx.nLockTime) {}
 

src/primitives/transaction.h

@@ -371,58 +371,6 @@ class CTxOut
     }
     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 CTxOutCoin
-{
-public:
-    CAmount nValue;
-    CScript scriptPubKey;
-    CTxOutCoin()
-    {
-        SetNull();
-    }
-    // SYSCOIN
-    CTxOutCoin(const CTxOut& txOutIn) {
-        nValue = txOutIn.nValue;
-        scriptPubKey = txOutIn.scriptPubKey;
-    }
-    CTxOutCoin(CTxOut&& txOutIn) {
-        nValue = std::move(txOutIn.nValue);
-        scriptPubKey = std::move(txOutIn.scriptPubKey);
-    }
-    CTxOutCoin(const CAmount& nValueIn, const CScript &scriptPubKeyIn);
-    SERIALIZE_METHODS(CTxOutCoin, obj)
-    {
-        READWRITE(obj.nValue, obj.scriptPubKey);
-    }
-
-
-    void SetNull()
-    {
-        nValue = -1;
-        scriptPubKey.clear();
-    }
-
-    bool IsNull() const
-    {
-        return (nValue == -1);
-    }
-
-    friend bool operator==(const CTxOutCoin& a, const CTxOutCoin& b)
-    {
-        return (a.nValue       == b.nValue &&
-                a.scriptPubKey == b.scriptPubKey);
-    }
-
-    friend bool operator!=(const CTxOutCoin& a, const CTxOutCoin& b)
-    {
-        return !(a == b);
-    }
-    std::string ToString() const;
-};
-
 
 template<typename TxType>
 inline CAmount CalculateOutputValue(const TxType& tx)

src/psbt.cpp

@@ -65,8 +65,7 @@ bool PartiallySignedTransaction::AddOutput(const CTxOut& txout, const PSBTOutput
     outputs.push_back(psbtout);
     return true;
 }
-// SYSCOIN
-bool PartiallySignedTransaction::GetInputUTXO(CTxOutCoin& utxo, int input_index) const
+bool PartiallySignedTransaction::GetInputUTXO(CTxOut& utxo, int input_index) const
 {
     const PSBTInput& input = inputs[input_index];
     uint32_t prevout_index = tx->vin[input_index].prevout.n;
@@ -295,8 +294,7 @@ bool PSBTInputSigned(const PSBTInput& input)
 
 bool PSBTInputSignedAndVerified(const PartiallySignedTransaction psbt, unsigned int input_index, const PrecomputedTransactionData* txdata)
 {
-    // SYSCOIN
-    CTxOutCoin utxo;
+    CTxOut utxo;
     assert(psbt.inputs.size() >= input_index);
     const PSBTInput& input = psbt.inputs[input_index];
 
@@ -358,8 +356,7 @@ PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction&
 {
     const CMutableTransaction& tx = *psbt.tx;
     bool have_all_spent_outputs = true;
-    // SYSCOIN
-    std::vector<CTxOutCoin> utxos(tx.vin.size());
+    std::vector<CTxOut> utxos(tx.vin.size());
     for (size_t idx = 0; idx < tx.vin.size(); ++idx) {
         if (!psbt.GetInputUTXO(utxos[idx], idx)) have_all_spent_outputs = false;
     }
@@ -387,8 +384,7 @@ bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction&
 
     // Get UTXO
     bool require_witness_sig = false;
-    // SYSCOIN
-    CTxOutCoin utxo;
+    CTxOut utxo;
 
     if (input.non_witness_utxo) {
         // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.

src/psbt.h

@@ -191,8 +191,7 @@ void SerializeHDKeypaths(Stream& s, const std::map<CPubKey, KeyOriginInfo>& hd_k
 struct PSBTInput
 {
     CTransactionRef non_witness_utxo;
-    // SYSCOIN
-    CTxOutCoin witness_utxo;
+    CTxOut witness_utxo;
     CScript redeem_script;
     CScript witness_script;
     CScript final_script_sig;
@@ -973,8 +972,7 @@ struct PartiallySignedTransaction
      * @param[in] input_index Index of the input to retrieve the UTXO of
      * @return Whether the UTXO for the specified input was found
      */
-    // SYSCOIN
-    bool GetInputUTXO(CTxOutCoin& utxo, int input_index) const;
+    bool GetInputUTXO(CTxOut& utxo, int input_index) const;
 
     template <typename Stream>
     inline void Serialize(Stream& s) const {

src/rest.cpp

@@ -52,8 +52,7 @@ static const struct {
 
 struct CCoin {
     uint32_t nHeight;
-    // SYSCOIN
-    CTxOutCoin out;
+    CTxOut out;
 
     CCoin() : nHeight(0) {}
     explicit CCoin(Coin&& in) : nHeight(in.nHeight), out(std::move(in.out)) {}

src/rpc/blockchain.cpp

@@ -2084,8 +2084,7 @@ static RPCHelpMan getblockstats()
             CAmount tx_total_in = 0;
             const auto& txundo = blockUndo.vtxundo.at(i - 1);
             for (const Coin& coin: txundo.vprevout) {
-                // SYSCOIN
-                const CTxOutCoin& prevoutput = coin.out;
+                const CTxOut& prevoutput = coin.out;
 
                 tx_total_in += prevoutput.nValue;
                 size_t prevout_size = GetSerializeSize(prevoutput, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
@@ -2371,8 +2370,7 @@ static RPCHelpMan scantxoutset()
 
         // Scan the unspent transaction output set for inputs
         UniValue unspents(UniValue::VARR);
-        // SYSCOIN
-        std::vector<CTxOutCoin> input_txos;
+        std::vector<CTxOut> input_txos;
         std::map<COutPoint, Coin> coins;
         g_should_abort_scan = false;
         int64_t count = 0;
@@ -2396,8 +2394,7 @@ static RPCHelpMan scantxoutset()
         for (const auto& it : coins) {
             const COutPoint& outpoint = it.first;
             const Coin& coin = it.second;
-            // SYSCOIN
-            const CTxOutCoin& txo = coin.out;
+            const CTxOut& txo = coin.out;
             input_txos.push_back(txo);
             total_in += txo.nValue;
 

src/rpc/rawtransaction.cpp

@@ -1210,8 +1210,7 @@ static RPCHelpMan decodepsbt()
         UniValue in(UniValue::VOBJ);
         // UTXOs
         bool have_a_utxo = false;
-        // SYSCOIN
-        CTxOutCoin txout;
+        CTxOut txout;
         if (!input.witness_utxo.IsNull()) {
             txout = input.witness_utxo;
 

src/script/interpreter.cpp

@@ -1370,8 +1370,8 @@ uint256 GetOutputsSHA256(const T& txTo)
     return ss.GetSHA256();
 }
 
-/** SYSCOIN Compute the (single) SHA256 of the concatenation of all amounts spent by a tx. */
-uint256 GetSpentAmountsSHA256(const std::vector<CTxOutCoin>& outputs_spent)
+/** Compute the (single) SHA256 of the concatenation of all amounts spent by a tx. */
+uint256 GetSpentAmountsSHA256(const std::vector<CTxOut>& outputs_spent)
 {
     HashWriter ss{};
     for (const auto& txout : outputs_spent) {
@@ -1380,8 +1380,8 @@ uint256 GetSpentAmountsSHA256(const std::vector<CTxOutCoin>& outputs_spent)
     return ss.GetSHA256();
 }
 
-/** SYSCOIN Compute the (single) SHA256 of the concatenation of all scriptPubKeys spent by a tx. */
-uint256 GetSpentScriptsSHA256(const std::vector<CTxOutCoin>& outputs_spent)
+/** Compute the (single) SHA256 of the concatenation of all scriptPubKeys spent by a tx. */
+uint256 GetSpentScriptsSHA256(const std::vector<CTxOut>& outputs_spent)
 {
     HashWriter ss{};
     for (const auto& txout : outputs_spent) {
@@ -1392,9 +1392,8 @@ uint256 GetSpentScriptsSHA256(const std::vector<CTxOutCoin>& outputs_spent)
 
 
 } // namespace
-// SYSCOIN
 template <class T>
-void PrecomputedTransactionData::Init(const T& txTo, std::vector<CTxOutCoin>&& spent_outputs, bool force)
+void PrecomputedTransactionData::Init(const T& txTo, std::vector<CTxOut>&& spent_outputs, bool force)
 {
     assert(!m_spent_outputs_ready);
 
@@ -1451,9 +1450,9 @@ PrecomputedTransactionData::PrecomputedTransactionData(const T& txTo)
     Init(txTo, {});
 }
 
-// SYSCOIN explicit instantiation
-template void PrecomputedTransactionData::Init(const CTransaction& txTo, std::vector<CTxOutCoin>&& spent_outputs, bool force);
-template void PrecomputedTransactionData::Init(const CMutableTransaction& txTo, std::vector<CTxOutCoin>&& spent_outputs, bool force);
+// explicit instantiation
+template void PrecomputedTransactionData::Init(const CTransaction& txTo, std::vector<CTxOut>&& spent_outputs, bool force);
+template void PrecomputedTransactionData::Init(const CMutableTransaction& txTo, std::vector<CTxOut>&& spent_outputs, bool force);
 template PrecomputedTransactionData::PrecomputedTransactionData(const CTransaction& txTo);
 template PrecomputedTransactionData::PrecomputedTransactionData(const CMutableTransaction& txTo);
 

src/script/interpreter.h

@@ -164,13 +164,11 @@ struct PrecomputedTransactionData
     uint256 hashPrevouts, hashSequence, hashOutputs;
     //! Whether the 3 fields above are initialized.
     bool m_bip143_segwit_ready = false;
-    // SYSCOIN
-    std::vector<CTxOutCoin> m_spent_outputs;
+    std::vector<CTxOut> m_spent_outputs;
     //! Whether m_spent_outputs is initialized.
     bool m_spent_outputs_ready = false;
 
     PrecomputedTransactionData() = default;
-    // SYSCOIN
     /** Initialize this PrecomputedTransactionData with transaction data.
      *
      * @param[in]   tx             The transaction for which data is being precomputed.
@@ -179,7 +177,7 @@ struct PrecomputedTransactionData
      *                             regardless of what is in the inputs (used at signing
      *                             time, when the inputs aren't filled in yet). */
     template <class T>
-    void Init(const T& tx, std::vector<CTxOutCoin>&& spent_outputs, bool force = false);
+    void Init(const T& tx, std::vector<CTxOut>&& spent_outputs, bool force = false);
 
     template <class T>
     explicit PrecomputedTransactionData(const T& tx);

src/script/sign.cpp

@@ -575,8 +575,8 @@ struct Stacks
 };
 }
 
-// SYSCOIN Extracts signatures and scripts from incomplete scriptSigs. Please do not extend this, use PSBT instead
-SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nIn, const CTxOutCoin& txout)
+// 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);
@@ -762,8 +762,7 @@ bool SignTransaction(CMutableTransaction& mtx, const SigningProvider* keystore,
     const CTransaction txConst(mtx);
 
     PrecomputedTransactionData txdata;
-    // SYSCOIN
-    std::vector<CTxOutCoin> spent_outputs;
+    std::vector<CTxOut> spent_outputs;
     for (unsigned int i = 0; i < mtx.vin.size(); ++i) {
         CTxIn& txin = mtx.vin[i];
         auto coin = coins.find(txin.prevout);