Fill in more randomx miner code

src/miner.cpp

@@ -1012,9 +1012,6 @@ void static RandomXMiner()
             break;
     }
 
-    if ( notaryid != My_notaryid )
-        My_notaryid = notaryid;
-
     std::mutex m_cs;
     bool cancelSolver = false;
     boost::signals2::connection c = uiInterface.NotifyBlockTip.connect(
@@ -1026,9 +1023,8 @@ void static RandomXMiner()
     miningTimer.start();
 
     try {
-        if ( SMART_CHAIN_SYMBOL[0] != 0 ) {
+        fprintf(stderr,"trying %s Mining with randomx\n",SMART_CHAIN_SYMBOL);
-            fprintf(stderr,"trying %s Mining with randomx\n",SMART_CHAIN_SYMBOL);
+       
-        }
         while (true)
         {
             if (chainparams.MiningRequiresPeers()) {
@@ -1073,7 +1069,7 @@ void static RandomXMiner()
                 {
                     miningTimer.stop();
                     c.disconnect();
-                    LogPrintf("HushMiner terminated\n");
+                    LogPrintf("HushRandomXMiner terminated\n");
                     return;
                 }
                 static uint32_t counter;
@@ -1087,10 +1083,10 @@ void static RandomXMiner()
             if (!pblocktemplate.get())
             {
                 if (GetArg("-mineraddress", "").empty()) {
-                    LogPrintf("Error in HushMiner: Keypool ran out, please call keypoolrefill before restarting the mining thread\n");
+                    LogPrintf("Error in HushRandomXMiner: Keypool ran out, please call keypoolrefill before restarting the mining thread\n");
                 } else {
                     // Should never reach here, because -mineraddress validity is checked in init.cpp
-                    LogPrintf("Error in HushMiner: Invalid -mineraddress\n");
+                    LogPrintf("Error in HushRandomXMiner: Invalid -mineraddress\n");
                 }
                 return;
             }
@@ -1119,12 +1115,12 @@ void static RandomXMiner()
             savebits = pblock->nBits;
             HASHTarget = arith_uint256().SetCompact(savebits);
             roundrobin_delay = ROUNDROBIN_DELAY;
+            Mining_start = 0;
 
-            //    HASHTarget_POW = hush_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
             gotinvalid = 0;
             while (true)
             {
-                //fprintf(stderr,"gotinvalid.%d\n",gotinvalid);
+                fprintf(stderr,"gotinvalid.%d\n",gotinvalid);
                 if ( gotinvalid != 0 )
                     break;
                 hush_longestchain();
@@ -1160,9 +1156,6 @@ void static RandomXMiner()
                     return;
                 }
 
-
-                // TODO: we may want to tweak these params to more closely match the 2.8 days and ~2 hrs
-                // which is what they work out to on XMR
                 // The key block will change every ~21.3 hours with a 75s block time
                 // and every ~17 hours with the default 60s block time for HSCs
                 int randomxInterval = 1024;
@@ -1204,9 +1197,79 @@ void static RandomXMiner()
                 printf("\n");
                 // TODO: use randomx hash to build a block
 
-            }
+                std::function<bool(std::vector<unsigned char>)> validBlock =
+#ifdef ENABLE_WALLET
+                [&pblock, &hashTarget, &pwallet, &reservekey, &m_cs, &cancelSolver, &chainparams]
+#else
+                [&pblock, &hashTarget, &m_cs, &cancelSolver, &chainparams]
+#endif
+                (std::vector<unsigned char> soln) {
+                    int32_t z; arith_uint256 h; CBlock B;
+                    // Write the solution to the hash and compute the result.
+                    LogPrint("pow", "- Checking solution against target\n");
+                    pblock->nSolution = soln;
+                    solutionTargetChecks.increment();
+                    B = *pblock;
+                    h = UintToArith256(B.GetHash());
+                    if ( h > hashTarget )
+                    {
+                        return false;
+                    }
 
-        }
+                    CValidationState state;
+                    if ( !TestBlockValidity(state,B, chainActive.LastTip(), true, false))
+                    {
+                        h = UintToArith256(B.GetHash());
+                        //for (z=31; z>=0; z--)
+                        //    fprintf(stderr,"%02x",((uint8_t *)&h)[z]);
+                        fprintf(stderr," Invalid block mined, try again\n");
+                        gotinvalid = 1;
+                        return(false);
+                    }
+                    SetThreadPriority(THREAD_PRIORITY_NORMAL);
+                    LogPrintf("HushRandomXMiner:\n");
+                    LogPrintf("proof-of-work found  \n  hash: %s  \ntarget: %s\n", B.GetHash().GetHex(), HASHTarget.GetHex());
+#ifdef ENABLE_WALLET
+                    if (ProcessBlockFound(&B, *pwallet, reservekey)) {
+#else
+                        if (ProcessBlockFound(&B)) {
+#endif
+                            // Ignore chain updates caused by us
+                            std::lock_guard<std::mutex> lock{m_cs};
+                            cancelSolver = false;
+                        }
+                        SetThreadPriority(THREAD_PRIORITY_LOWEST);
+                        // In regression test mode, stop mining after a block is found.
+                        if (chainparams.MineBlocksOnDemand()) {
+                            // Increment here because throwing skips the call below
+                            // TODO: equivalent of ehSolverRuns.increment();
+                            throw boost::thread_interrupted();
+                        }
+                        return true;
+                    };
+                    // TODO: solver specific stuff
+                    // TODO: Convert solution indices to byte array (decompress) and pass it to validBlock method.
+
+                    boost::this_thread::interruption_point();
+
+                    if (vNodes.empty() && chainparams.MiningRequiresPeers())
+                    {
+                        if ( Mining_height > ASSETCHAINS_MINHEIGHT )
+                        {
+                            fprintf(stderr,"no nodes, break\n");
+                            break;
+                        }
+                    }
+                    if ((UintToArith256(pblock->nNonce) & 0xffff) == 0xffff)
+                    {
+                        fprintf(stderr,"nonce & 0xffff == 0xffff, break\n");
+                        break;
+                    }
+                    // Update nNonce and nTime
+                    pblock->nNonce = ArithToUint256(UintToArith256(pblock->nNonce) + 1);
+                    pblock->nBits = savebits;
+                }
+            }
    }
    catch (const boost::thread_interrupted&)
    {