Place block signing pubkey in coinbase

Author: ComputerCraftr

src/miner.cpp

@@ -511,20 +511,25 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
     }
 }
 
-void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
+void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce, const CPubKey* signingPubKey)
 {
     // Update nExtraNonce
-    static uint256 hashPrevBlock;
-    if (hashPrevBlock != pblock->hashPrevBlock)
-    {
-        if (!pblock->IsProofOfStake())
+    if (!pblock->IsProofOfStake()) {
+        static uint256 hashPrevBlock;
+        if (hashPrevBlock != pblock->hashPrevBlock)
+        {
             nExtraNonce = 0;
-        hashPrevBlock = pblock->hashPrevBlock;
+            hashPrevBlock = pblock->hashPrevBlock;
+        }
     }
     ++nExtraNonce;
     unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
     CMutableTransaction txCoinbase(*pblock->vtx[0]);
     txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce));
+    if (signingPubKey) {
+        txCoinbase.vin[0].scriptSig << ToByteVector(*signingPubKey);
+        //txCoinbase.vout.push_back(CTxOut(0, CScript() << OP_RETURN << ToByteVector(*signingPubKey)));
+    }
     assert(txCoinbase.vin[0].scriptSig.size() <= 100);
 
     pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
@@ -591,13 +596,20 @@ bool CreateCoinStake(CMutableTransaction& coinstakeTx, CBlock* pblock, std::shar
                 if (gArgs.GetBoolArg("-debug", false) && gArgs.GetBoolArg("-printcoinstake", false))
                     LogPrintf("%s : parsed kernel type=%s\n", __func__, GetTxnOutputType(whichType));
 
-                if (whichType == TxoutType::PUBKEYHASH || whichType == TxoutType::WITNESS_V0_KEYHASH || whichType == TxoutType::SCRIPTHASH) { // we support p2pkh, p2wpkh, and p2sh-p2wpkh inputs
-                    if (whichType == TxoutType::SCRIPTHASH) { // a p2sh input could be many things, but we only support p2sh-p2wpkh for now
+                if (whichType == TxoutType::PUBKEY || whichType == TxoutType::PUBKEYHASH || whichType == TxoutType::WITNESS_V0_KEYHASH || whichType == TxoutType::SCRIPTHASH || whichType == TxoutType::WITNESS_V0_SCRIPTHASH) { // we support p2pkh, p2wpkh, p2sh-p2wpkh, and p2sh/p2wsh-multisig inputs
+                    const bool fNewStakingCodeActive = Params().NetworkIDString() != CBaseChainParams::MAIN;
+                    if (whichType == TxoutType::SCRIPTHASH || whichType == TxoutType::WITNESS_V0_SCRIPTHASH) { // a p2sh/p2wsh input could be many things, but we only support p2sh-p2wpkh and multisig for now
                         CScript subscript;
                         std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKeyKernel);
-                        if (provider && provider->GetCScript(CScriptID(uint160(vSolutions[0])), subscript)) { // extract the redeem script
+                        uint160 hash;
+                        if (whichType == TxoutType::WITNESS_V0_SCRIPTHASH) {
+                            CRIPEMD160 hasher;
+                            hasher.Write(&vSolutions[0][0], 32).Finalize(hash.begin());
+                        } else // whichType == TxoutType::SCRIPTHASH
+                            hash = uint160(vSolutions[0]);
+                        if (provider && provider->GetCScript(CScriptID(hash), subscript)) { // extract the redeem script
                             TxoutType scriptType = Solver(subscript, vSolutions);
-                            if (scriptType != TxoutType::WITNESS_V0_KEYHASH || Params().NetworkIDString() == CBaseChainParams::MAIN) { // this is a script we don't recognize
+                            if (!fNewStakingCodeActive || (scriptType != TxoutType::WITNESS_V0_KEYHASH && scriptType != TxoutType::MULTISIG && scriptType != TxoutType::MULTISIG_DATA)) { // this is a script we don't recognize
                                 if (gArgs.GetBoolArg("-debug", false) && gArgs.GetBoolArg("-printcoinstake", false))
                                     LogPrintf("%s : no support for %s kernel type=%s\n", __func__, GetTxnOutputType(whichType), GetTxnOutputType(scriptType));
                                 continue;
@@ -610,7 +622,7 @@ bool CreateCoinStake(CMutableTransaction& coinstakeTx, CBlock* pblock, std::shar
                         }
                     }
 
-                    if (gArgs.GetBoolArg("-quantumsafestaking", false)) { // a new bech32 address is generated for every stake to protect the public key from quantum computers
+                    if ((fNewStakingCodeActive || whichType != TxoutType::PUBKEY) && gArgs.GetBoolArg("-quantumsafestaking", false)) { // a new bech32 address is generated for every stake to protect the public key from quantum computers
                         OutputType output_type = OutputType::BECH32;
                         CTxDestination dest;
                         std::string error;
@@ -621,7 +633,18 @@ bool CreateCoinStake(CMutableTransaction& coinstakeTx, CBlock* pblock, std::shar
                             LogPrintf("%s : failed to get new destination for coinstake (%s)\n", __func__, error);
                             scriptPubKeyOut = scriptPubKeyKernel;
                         }
-                    } else if (!pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) { // on legacy wallets we can convert every input to p2pk for smaller coinstake TXs
+                    } else if (whichType == TxoutType::MULTISIG || whichType == TxoutType::MULTISIG_DATA) { // try to create a new destination for p2sh/p2wsh-multisig inputs
+                        OutputType output_type = OutputType::BECH32;
+                        CTxDestination dest;
+                        std::string error;
+                        if (pwallet->GetNewChangeDestination(output_type, dest, error)) {
+                            LogPrintf("%s : using new destination for coinstake (%s)\n", __func__, EncodeDestination(dest));
+                            scriptPubKeyOut = GetScriptForDestination(dest);
+                        } else
+                            continue;
+                    } else if (pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) || whichType == TxoutType::PUBKEY) { // descriptor wallets only credit earnings back to the original address and p2pk inputs can be left alone
+                        scriptPubKeyOut = scriptPubKeyKernel;
+                    } else { // on legacy wallets we can convert every input to p2pk for smaller coinstake TXs
                         // convert to pay to public key type
                         CPubKey pubkey;
                         std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKeyKernel);
@@ -631,11 +654,7 @@ bool CreateCoinStake(CMutableTransaction& coinstakeTx, CBlock* pblock, std::shar
                             continue; // unable to find corresponding public key
                         }
                         scriptPubKeyOut << ToByteVector(pubkey) << OP_CHECKSIG;
-                    } else { // descriptor wallets only credit earnings back to the original address
-                        scriptPubKeyOut = scriptPubKeyKernel;
                     }
-                } else if (whichType == TxoutType::PUBKEY) { // p2pk inputs can be left alone
-                    scriptPubKeyOut = scriptPubKeyKernel;
                 } else if (!pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) && (whichType == TxoutType::MULTISIG || whichType == TxoutType::MULTISIG_DATA)) { // convert multisig to p2pk
                     // convert to pay to public key type
                     CPubKey pubkey;
@@ -655,7 +674,7 @@ bool CreateCoinStake(CMutableTransaction& coinstakeTx, CBlock* pblock, std::shar
                 } else {
                     if (gArgs.GetBoolArg("-debug", false) && gArgs.GetBoolArg("-printcoinstake", false))
                         LogPrintf("%s : no support for kernel type=%s\n", __func__, GetTxnOutputType(whichType));
-                    continue; // only support p2pk, p2pkh, p2wpkh, and p2sh-p2wpkh
+                    continue; // only support p2pk, p2pkh, p2wpkh, p2sh-p2wpkh, and p2sh/p2wsh-multisig
                 }
 
                 coinstakeTx.vin.push_back(CTxIn(prevout.hash, prevout.n));
@@ -693,8 +712,9 @@ bool CreateCoinStake(CMutableTransaction& coinstakeTx, CBlock* pblock, std::shar
 
 static inline bool ProcessBlockFound(const CBlock* pblock, const CChainParams& chainparams, ChainstateManager* chainman)
 {
-    LogPrintf("%s\n", pblock->ToString());
-    LogPrintf("generated %s\n", FormatMoney(pblock->IsProofOfStake() ? pblock->vtx[1]->GetValueOut() : pblock->vtx[0]->GetValueOut()));
+    if (chainparams.NetworkIDString() != CBaseChainParams::REGTEST)
+        LogPrintf("%s", pblock->ToString());
+    //LogPrintf("generated %s\n", FormatMoney(pblock->IsProofOfStake() ? pblock->vtx[1]->GetValueOut() : pblock->vtx[0]->GetValueOut()));
 
     // Found a solution
     {
@@ -813,12 +833,21 @@ static inline void PoSMiner(std::shared_ptr<CWallet> pwallet, ChainstateManager*
                 return;
             }
             pblock = &pblocktemplate->block;
-            IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
+            CPubKey signingPubKey;
+            bool pubkeyInSig = true;
+            {
+                LOCK(pwallet->cs_wallet);
+                if (!pwallet->GetBlockSigningPubKey(*pblock, signingPubKey, pubkeyInSig)) {
+                    LogPrintf("PoSMiner(): failed to get signing pubkey for PoS block\n");
+                    continue;
+                }
+            }
+            IncrementExtraNonce(pblock, pindexPrev, nExtraNonce, pubkeyInSig ? nullptr : &signingPubKey);
 
             // peercoin: if proof-of-stake block found then process block
             {
                 LOCK(pwallet->cs_wallet);
-                if (!pwallet->SignBlock(*pblock)) {
+                if (!pwallet->SignBlock(*pblock, signingPubKey)) {
                     LogPrintf("PoSMiner(): failed to sign PoS block\n");
                     continue;
                 }

src/miner.h

@@ -8,6 +8,7 @@
 
 #include <optional.h>
 #include <primitives/block.h>
+#include <pubkey.h>
 #include <txmempool.h>
 #include <validation.h>
 
@@ -210,7 +211,7 @@ class BlockAssembler
 };
 
 /** Modify the extranonce in a block */
-void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
+void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce, const CPubKey* signingPubKey = nullptr);
 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev);
 
 /** Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed */

src/validation.cpp

@@ -5731,28 +5731,39 @@ bool CheckBlockSignature(const CBlock& block)
     if (block.vchBlockSig.empty())
         return error("%s : vchBlockSig is empty!", __func__);
 
+    const bool fProofOfStake = block.IsProofOfStake();
     std::vector<std::vector<unsigned char>> vSolutions;
-    const CTxOut& txout = block.IsProofOfStake() ? block.vtx[1]->vout[1] : block.vtx[0]->vout[0];
+    const CTxOut& txout = fProofOfStake ? block.vtx[1]->vout[1] : block.vtx[0]->vout[0];
     TxoutType whichType = Solver(txout.scriptPubKey, vSolutions);
     CPubKey pubkey;
 
     if (whichType == TxoutType::PUBKEY) {
         pubkey = CPubKey(vSolutions[0]);
     } else {
-        if (block.IsProofOfWork()) // no inputs for coinbase
-            return false;
-        const CTxIn& txin = block.vtx[1]->vin[0];
-        if ((txin.scriptSig.size() == 0 || txin.scriptSig.size() == 23) && txin.scriptWitness.stack.size() == 2 && txin.scriptWitness.stack.back().size() == CPubKey::COMPRESSED_SIZE) { // p2wpkh or p2sh-p2wpkh input
+        const CTxIn& cbtxin = block.vtx[0]->vin[0];
+        const CTxIn& txin = fProofOfStake ? block.vtx[1]->vin[0] : cbtxin;
+        if (fProofOfStake && (txin.scriptSig.size() == 0 || txin.scriptSig.size() == 23) && txin.scriptWitness.stack.size() == 2 && txin.scriptWitness.stack.back().size() == CPubKey::COMPRESSED_SIZE) { // p2wpkh or p2sh-p2wpkh input
             pubkey = CPubKey(txin.scriptWitness.stack.back());
-        } else if (txin.scriptWitness.stack.size() == 0 && txin.scriptSig.size() >= 70 && txin.scriptSig.size() <= 140 && txin.scriptSig.IsPushOnly() && txin.scriptSig[0] >= 70 && txin.scriptSig[0] <= 73) { // p2pkh input (sig + pubkey)
+        } else if (fProofOfStake && txin.scriptWitness.stack.size() == 0 && txin.scriptSig.size() >= 100 && txin.scriptSig.size() <= 140 && txin.scriptSig.IsPushOnly() && txin.scriptSig[0] >= 70 && txin.scriptSig[0] <= 73) { // p2pkh input (sig + pubkey)
             unsigned int pubkeyStart = txin.scriptSig[0] + 2u; // skip sig and length bytes by reading sig length from pushdata
             //LogPrintf("%s : p2pkh txin.scriptSig = %s\n", __func__, HexStr(txin.scriptSig));
             //LogPrintf("%s : txin.scriptSig.size() = %u, txin.scriptSig[0] = %u, pubkeyStart = %u\n", __func__, txin.scriptSig.size(), txin.scriptSig[0], pubkeyStart);
             if ((pubkeyStart + CPubKey::COMPRESSED_SIZE) > txin.scriptSig.size() || txin.scriptSig[pubkeyStart-1] < CPubKey::COMPRESSED_SIZE) // last pushdata must be large enough to at least hold a compressed pubkey
-                return false;
+                return error("%s : p2pkh txin.scriptSig.size() = %u is too small", __func__, txin.scriptSig.size());
             pubkey = CPubKey(txin.scriptSig.begin()+pubkeyStart, txin.scriptSig.end());
+        } else if (cbtxin.scriptSig.size() > CPubKey::COMPRESSED_SIZE) { // check for pubkey in coinbase
+            //std::vector<unsigned char> vchPubKey(cbtxin.scriptSig.end()-CPubKey::COMPRESSED_SIZE, cbtxin.scriptSig.end());
+            //LogPrintf("%s : coinbase cbtxin.scriptSig = %s\n", __func__, HexStr(cbtxin.scriptSig));
+            //LogPrintf("%s : cbtxin.scriptSig.size() = %u, vchPubKey = %s\n", __func__, cbtxin.scriptSig.size(), HexStr(vchPubKey));
+            pubkey = CPubKey(cbtxin.scriptSig.end()-CPubKey::COMPRESSED_SIZE, cbtxin.scriptSig.end());
+            if (whichType == TxoutType::PUBKEYHASH || whichType == TxoutType::WITNESS_V0_KEYHASH) { // this code could be removed in the future to allow block signing with any arbitrary pubkey
+                if (Hash160(pubkey) != uint160(vSolutions[0])) {
+                    return error("%s : pubkey used for block signature (%s) does not correspond to first output", __func__, HexStr(pubkey));
+                }
+            } else
+                return error("%s : unable to verify pubkey belongs to first output of type=%s", __func__, GetTxnOutputType(whichType));
         } else { // we don't know where the pubkey is or how to parse it
-            return false;
+            return error("%s : unable to find pubkey to validate block signature", __func__);
         }
     }
     //LogPrintf("%s : validating signature for %s output using pubkey %s\n", __func__, GetTxnOutputType(whichType), HexStr(pubkey));

src/wallet/wallet.cpp

@@ -4629,7 +4629,7 @@ bool CWallet::SelectStakeCoins(std::set<CInputCoin>& setCoins) const
 }
 
 // peercoin: sign block
-bool CWallet::SignBlock(CBlock& block) const
+bool CWallet::GetBlockSigningPubKey(const CBlock& block, CPubKey& pubkey, bool& pubkeyInSig) const
 {
     AssertLockHeld(cs_wallet);
 
@@ -4649,20 +4649,26 @@ bool CWallet::SignBlock(CBlock& block) const
     }
     TxoutType whichType = Solver(scriptPubKey, vSolutions);
 
-    // Sign
-    CPubKey pubkey;
     if (whichType == TxoutType::PUBKEY) {
         pubkey = CPubKey(vSolutions[0]);
     } else if (whichType == TxoutType::PUBKEYHASH || whichType == TxoutType::WITNESS_V0_KEYHASH) {
         std::unique_ptr<SigningProvider> provider = GetSolvingProvider(scriptPubKey);
         if (!provider || !provider->GetPubKey(CKeyID(uint160(vSolutions[0])), pubkey))
             return false;
-    } else if (whichType == TxoutType::SCRIPTHASH) {
+    } else if (whichType == TxoutType::SCRIPTHASH || whichType == TxoutType::WITNESS_V0_SCRIPTHASH) {
         CScript subscript;
         std::unique_ptr<SigningProvider> provider = GetSolvingProvider(scriptPubKey);
-        if (provider && provider->GetCScript(CScriptID(uint160(vSolutions[0])), subscript)) {
-            whichType = Solver(subscript, vSolutions);
-            if (whichType != TxoutType::WITNESS_V0_KEYHASH || !provider->GetPubKey(CKeyID(uint160(vSolutions[0])), pubkey))
+        uint160 hash;
+        if (whichType == TxoutType::WITNESS_V0_SCRIPTHASH) {
+            CRIPEMD160 hasher;
+            hasher.Write(&vSolutions[0][0], 32).Finalize(hash.begin());
+        } else // whichType == TxoutType::SCRIPTHASH
+            hash = uint160(vSolutions[0]);
+        if (provider && provider->GetCScript(CScriptID(hash), subscript)) {
+            TxoutType scriptType = Solver(subscript, vSolutions);
+            if (fProofOfStake && (scriptType == TxoutType::MULTISIG || scriptType == TxoutType::MULTISIG_DATA))
+                whichType = scriptType; // pubkey is retrieved from PoS output below
+            else if (scriptType != TxoutType::WITNESS_V0_KEYHASH || !provider->GetPubKey(CKeyID(uint160(vSolutions[0])), pubkey))
                 return false;
         } else
             return false;
@@ -4676,6 +4682,34 @@ bool CWallet::SignBlock(CBlock& block) const
         return false;
     }
 
+    if (fProofOfStake) {
+        TxoutType outputType = Solver(txout.scriptPubKey, vSolutions); // check the output
+        if (outputType == TxoutType::PUBKEY) { // pubkey is revealed in p2pk output
+            pubkey = CPubKey(vSolutions[0]); // use pubkey from output rather than input
+            pubkeyInSig = true;
+        } else if (whichType == TxoutType::PUBKEY || whichType == TxoutType::MULTISIG || whichType == TxoutType::MULTISIG_DATA) { // p2pk and multisig PoS inputs don't place the pubkey in the scriptSig
+            pubkeyInSig = false;
+            if (outputType == TxoutType::PUBKEYHASH || outputType == TxoutType::WITNESS_V0_KEYHASH) {
+                std::unique_ptr<SigningProvider> provider = GetSolvingProvider(txout.scriptPubKey);
+                if (!provider || !provider->GetPubKey(CKeyID(uint160(vSolutions[0])), pubkey)) // extract pubkey from output to put in coinbase
+                    return false;
+            } else
+                return false;
+        } else
+            pubkeyInSig = true;
+    } else if (whichType != TxoutType::PUBKEY) // PoW has no inputs so the pubkey isn't revealed unless it uses a p2pk output
+        pubkeyInSig = false;
+    else
+        pubkeyInSig = true;
+
+    return true;
+}
+
+// peercoin: sign block
+bool CWallet::SignBlock(CBlock& block, const CPubKey& pubkey) const
+{
+    AssertLockHeld(cs_wallet);
+
     // Try to sign with all ScriptPubKeyMans
     for (ScriptPubKeyMan* spk_man : GetAllScriptPubKeyMans()) {
         if (spk_man->SignBlock(block, pubkey) == SigningResult::OK)

src/wallet/wallet.h

@@ -984,7 +984,8 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
      */
     void CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm);
     bool SelectStakeCoins(std::set<CInputCoin>& setCoins) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
-    bool SignBlock(CBlock& block) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool GetBlockSigningPubKey(const CBlock& block, CPubKey& pubkey, bool& pubkeyInSig) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool SignBlock(CBlock& block, const CPubKey& pubkey) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts, bool use_max_sig = false) const
     {