RingCT Stake: verify block signature

and unmark pending spends if the block is not created.

src/miner.cpp

@@ -33,6 +33,8 @@
 
 #include <veil/budget.h>
 #include <veil/proofoffullnode/proofoffullnode.h>
+#include <veil/ringct/anonwallet.h>
+#include <veil/ringct/anon.h>
 #include <veil/zerocoin/zchain.h>
 
 #include <algorithm>
@@ -178,6 +180,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         LOCK(cs_mapblockindex);
         pindexPrev = mapBlockIndex.at(hashBest);
     }
+    std::unique_ptr<CPendingSpend> pendingRCTStake;
     if (fProofOfStake && pindexPrev->nHeight + 1 >= Params().HeightPoSStart()) {
         //POS block - one coinbase is null then non null coinstake
         //POW block - one coinbase that is not null
@@ -192,10 +195,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         if (!pwalletMain->CreateZerocoinStake(pindexPrev, pblock->nBits, txCoinStake, nTxNewTime, nComputeTimeStart)) {
             if (!pwalletMain->CreateRingCTStake(pindexPrev, pblock->nBits, txCoinStake, nTxNewTime, nComputeTimeStart))
                 return nullptr;
-            else {
-                // output debugging info
-                return nullptr;
-            }
+            pendingRCTStake = pwalletMain->GetAnonWallet()->GetPendingSpendForTx(txCoinStake.GetHash());
         }
 
         pblock->nTime = nTxNewTime;
@@ -539,8 +539,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         } else if (pblock->vtx[1]->IsRingCtSpend()) {
             // TODO: enable_wallet guards.
             COutPoint prevout;
-            COutputRecord record;
-            CKeyID keyid;
+            // Get keyimage from the input
             if (!pwalletMain->GetAnonWallet()->IsMyAnonInput(pblock->vtx[1]->vin[0], prevout, key)) {
                 LogPrint(BCLog::STAKING, "Failed to get key from anon spend\n");
                 return nullptr;
@@ -560,6 +559,8 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     if (pindexPrev && pindexPrev != chainActive.Tip()) {
         error("%s: stale tip.", __func__);
         pblocktemplate->nFlags |= TF_STAILTIP;
+        if (pendingRCTStake)
+            pendingRCTStake->SetSuccess(true);
         return std::move(pblocktemplate);
     }
 
@@ -580,6 +581,8 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     }
 
     pblocktemplate->nFlags = TF_SUCCESS;
+    if (pendingRCTStake)
+        pendingRCTStake->SetSuccess(true);
     return std::move(pblocktemplate);
 }
 

src/veil/proofofstake/blockvalidation.cpp

@@ -4,9 +4,12 @@
 
 #include "blockvalidation.h"
 
+#include "chainparams.h"
 #include "primitives/block.h"
 #include "primitives/transaction.h"
 #include "util/system.h"
+#include "validation.h"
+#include "veil/ringct/rctindex.h"
 #include "veil/zerocoin/zchain.h"
 
 namespace veil {
@@ -16,19 +19,63 @@ bool ValidateBlockSignature(const CBlock& block)
     if (block.IsProofOfWork())
         return true;
 
-    if (block.vtx.size() < 2 || block.vtx[1]->vin.empty() || !block.vtx[1]->vin[0].IsZerocoinSpend())
+    if (block.vtx.size() < 2 || block.vtx[1]->vin.empty())
         return error("%s: Block transaction structure is not compatible with Veil's Proof of Stake validation", __func__);
 
-    //Get the zerocoin that was staked
-    auto spend = TxInToZerocoinSpend(block.vtx[1]->vin[0]);
-    if (!spend)
-        return error("%s: failed to get spend from txin", __func__);
-    auto pubkey = spend->getPubKey();
+    //Get the coin that was staked
+    if (block.vtx[1]->vin[0].IsZerocoinSpend()) {
+        auto spend = TxInToZerocoinSpend(block.vtx[1]->vin[0]);
+        if (!spend)
+            return error("%s: failed to get spend from txin", __func__);
+        CPubKey pubkey = spend->getPubKey();
 
-    if (!pubkey.IsValid())
-        return error("%s: Public Key from zerocoin stake is not valid", __func__);
+        if (!pubkey.IsValid())
+            return error("%s: Public Key from zerocoin stake is not valid", __func__);
 
-    return pubkey.Verify(block.GetHash(), block.vchBlockSig);
+        return pubkey.Verify(block.GetHash(), block.vchBlockSig);
+    } else if (block.vtx[1]->vin[0].IsAnonInput()) {
+        if (block.nHeight < Params().HeightRingCTStaking()) {
+            return error("%s: RingCT staking not accepted before height %d",
+                         __func__, Params().HeightRingCTStaking());
+        }
+        CTxIn txin = block.vtx[1]->vin[0];
+        const std::vector<uint8_t> &vKeyImages = txin.scriptData.stack[0];
+        const std::vector<uint8_t> vMI = txin.scriptWitness.stack[0];
+
+        uint32_t nInputs, nRingSize;
+        txin.GetAnonInfo(nInputs, nRingSize);
+        size_t nCols = nRingSize;
+        size_t nRows = nInputs + 1;
+
+        if (vKeyImages.size() != nInputs * 33)
+            return error("%s: bad keyimage size", __func__);
+
+        const CCmpPubKey &ki = *((CCmpPubKey *) &vKeyImages[0]);
+
+        size_t ofs = 0, nB = 0;
+        for (size_t i = 0; i < nCols; ++i) {
+            int64_t nIndex = 0;
+
+            if (0 != GetVarInt(vMI, ofs, (uint64_t &) nIndex, nB))
+                return false;
+            ofs += nB;
+
+            CAnonOutput ao;
+            if (!pblocktree->ReadRCTOutput(nIndex, ao))
+                return false;
+
+            CPubKey pubkey;
+            pubkey.Set(ao.pubkey.begin(), ao.pubkey.end());
+            if (!pubkey.IsValid())
+                return error("%s: public key from ringct stake is not valid");
+
+            if (pubkey.Verify(block.GetHash(), block.vchBlockSig))
+                return true;
+        }
+        return error("%s: No pubkeys verified for RingCT stake", __func__);
+    }
+
+    return error("%s: Stake transaction is not zerocoin or ringct spend", __func__);
 }
 
 }