From 41363b7ea4089cc8720877f7a9eb3f626cb9cda0 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Mon, 14 Jan 2019 17:09:17 +0800
Subject: [PATCH 01/18] fix prints

---
 src/miner.cpp | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/miner.cpp b/src/miner.cpp
index 26d1a1df9..e06a570c7 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -1303,9 +1303,8 @@ void static BitcoinMiner_noeq()
             {
                 int32_t percPoS,z;
                 hashTarget = komodo_PoWtarget(&percPoS,hashTarget,Mining_height,ASSETCHAINS_STAKED);
-                for (z=31; z>=0; z--)
-                    fprintf(stderr,"%02x",((uint8_t *)&hashTarget)[z]);
-                fprintf(stderr," PoW for staked coin PoS %d%% vs target %d%%\n",percPoS,(int32_t)ASSETCHAINS_STAKED);
+                if ( ASSETCHAINS_STAKED < 100 )
+                    LogPrintf("Block %d : PoS %d%% vs target %d%% \n",Mining_height,percPoS,(int32_t)ASSETCHAINS_STAKED);
             }
 
             while (true)
@@ -1630,18 +1629,16 @@ void static BitcoinMiner()
                     } //else fprintf(stderr,"duplicate at j.%d\n",j);
                 } else Mining_start = 0;
             } else Mining_start = 0;
+            
             if ( ASSETCHAINS_STAKED > 0 )
             {
                 int32_t percPoS,z; bool fNegative,fOverflow;
                 HASHTarget_POW = komodo_PoWtarget(&percPoS,HASHTarget,Mining_height,ASSETCHAINS_STAKED);
                 HASHTarget.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
                 if ( ASSETCHAINS_STAKED < 100 )
-                {
-                    //for (z=31; z>=0; z--)
-                    //    fprintf(stderr,"%02x",((uint8_t *)&HASHTarget_POW)[z]);
                     LogPrintf("Block %d : PoS %d%% vs target %d%% \n",Mining_height,percPoS,(int32_t)ASSETCHAINS_STAKED);
-                }
             }
+            
             while (true)
             {
                 /*if ( KOMODO_INSYNC == 0 )

From b0ca0415ef02b2f32753e51befa98c4709a12d16 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Mon, 14 Jan 2019 17:27:34 +0800
Subject: [PATCH 02/18] fix build

---
 src/wallet/rpcwallet.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 9e253b6ea..eae71f987 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -5672,7 +5672,7 @@ UniValue marmara_poolpayout(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 3 )
     {
         // marmarapoolpayout 0.5 2 '[["024131032ed90941e714db8e6dd176fe5a86c9d873d279edecf005c06f773da686",1000],["02ebc786cb83de8dc3922ab83c21f3f8a2f3216940c3bf9da43ce39e2a3a882c92",100]]';
-        marmarapoolpayout 0 2 '[["024131032ed90941e714db8e6dd176fe5a86c9d873d279edecf005c06f773da686",1000]]'
+        //marmarapoolpayout 0 2 '[["024131032ed90941e714db8e6dd176fe5a86c9d873d279edecf005c06f773da686",1000]]'
         throw runtime_error("marmarapoolpayout perc firstheight \"[[\\\"pubkey\\\":shares], ...]\"\n");
     }
     if ( ensure_CCrequirements() < 0 )

From f20420ea80a5147d56502968c6a77b8f2678851d Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Mon, 14 Jan 2019 18:18:18 +0800
Subject: [PATCH 03/18] fixed staking/generate in getmininginfo

---
 src/rpc/mining.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index dccbd9cfe..3843529ac 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -438,8 +438,11 @@ UniValue getmininginfo(const UniValue& params, bool fHelp)
     obj.push_back(Pair("testnet",          Params().TestnetToBeDeprecatedFieldRPC()));
     obj.push_back(Pair("chain",            Params().NetworkIDString()));
 #ifdef ENABLE_MINING
-    obj.push_back(Pair("staking",          VERUS_MINTBLOCKS));
-    obj.push_back(Pair("generate",         GetBoolArg("-gen", false)));
+    bool staking = VERUS_MINTBLOCKS;
+    if ( ASSETCHAINS_STAKED != 0 && GetBoolArg("-gen", false) && GetBoolArg("-genproclimit", -1) == 0 )
+        staking = true;
+    obj.push_back(Pair("staking",          staking));
+    obj.push_back(Pair("generate",         GetBoolArg("-gen", false) && GetBoolArg("-genproclimit", -1) != 0 ));
     obj.push_back(Pair("numthreads",       (int64_t)KOMODO_MININGTHREADS));
 #endif
     return obj;

From 400a0758c1cd785bcedc5864794084045849cf58 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 16 Jan 2019 20:27:35 +0800
Subject: [PATCH 04/18] Many bug fixes. VerusHash now works with PoS64 without
 special exemptions. Difficulty on new chains still behaves weridly, hoping
 resolves as chain ages.  Also reduced CPU load on all staking. These changes
 should work better if you are not the only node staking.

---
 src/komodo_bitcoind.h | 29 ++++++++++++++++-------------
 src/komodo_globals.h  |  4 +++-
 src/komodo_utils.h    |  5 +++--
 src/miner.cpp         | 41 ++++++++++++++++++++++++++---------------
 4 files changed, 48 insertions(+), 31 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index bb85ef1d1..662d0703c 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1274,7 +1274,7 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
     if ( value < SATOSHIDEN )
         return(0);
     value /= SATOSHIDEN;
-    mindiff.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
+    mindiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
     ratio = (mindiff / bnTarget);
     if ( (minage= nHeight*3) > 6000 ) // about 100 blocks
         minage = 6000;
@@ -1342,11 +1342,12 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
     int32_t oldflag = 0,dispflag = 0;
     CBlockIndex *pindex; arith_uint256 easydiff,bnTarget,hashval,sum,ave; bool fNegative,fOverflow; int32_t i,n,m,ht,percPoS,diff,val;
     *percPoSp = percPoS = 0;
-    if ( height <= 10 || (ASSETCHAINS_STAKED == 100 && height <= 100) )
+    if ( height <= 10 || (ASSETCHAINS_STAKED == 100 && height <= 100) ) 
         return(target);
+        
     sum = arith_uint256(0);
     ave = sum;
-    easydiff.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
+    easydiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
     for (i=n=m=0; i<100; i++)
     {
         ht = height - 100 + i;
@@ -1372,8 +1373,10 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
         if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 && (i % 10) == 9 )
             fprintf(stderr," %d, ",percPoS);
     }
+    // We now do actual PoS % at the start. Requires coin distribution in first 10 blocks! 
+    // This is not hard to do and stops the chain having its PoS/PoW in large chunks. 
     if ( m+n < 100 )
-        percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;
+        percPoS = (percPoS*100) / (m+n); 
     if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 )
         fprintf(stderr," -> %d%% percPoS vs goalperc.%d ht.%d\n",percPoS,goalperc,height);
     *percPoSp = percPoS;
@@ -1432,7 +1435,8 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
             fprintf(stderr," ht.%d percPoS.%d vs goal.%d -> diff %d\n",height,percPoS,goalperc,goalperc - percPoS);
         }
     }
-    else bnTarget = ave; // recent ave is perfect
+    else  
+        bnTarget = ave; // recent ave is perfect
     return(bnTarget);
 }
 
@@ -1468,7 +1472,7 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
             {
                 if ( 0 && ASSETCHAINS_STAKED < 100 )
                     fprintf(stderr,"komodo_is_PoSblock PoS failure ht.%d eligible.%u vs blocktime.%u, lag.%d -> check to see if it is PoW block\n",height,eligible,(uint32_t)pblock->nTime,(int32_t)(eligible - pblock->nTime));
-                if ( slowflag != 0 && pindex != 0 && height > 100)
+                if ( slowflag != 0 && pindex != 0 )
                 {
                     pindex->segid = -1;
                     //fprintf(stderr,"PoW block detected set segid.%d <- %d\n",height,pindex->segid);
@@ -1477,7 +1481,7 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
             else
             {
                 isPoS = 2; // 2 means staking utxo validated
-                if ( slowflag != 0 && height > 100 )
+                if ( slowflag != 0 )
                 {
                     CTxDestination voutaddress; char voutaddr[64];
                     if ( ExtractDestination(pblock->vtx[txn_count-1].vout[0].scriptPubKey,voutaddress) )
@@ -1831,12 +1835,11 @@ int32_t komodo_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height)
                     return(-1);
                 } else
                 {
-                    // I think this means the block is valid PoW. We need to set the pindex->segid here.
                     failed = 0; 
                     CBlockIndex *pindex; 
                     BlockMap::const_iterator it = mapBlockIndex.find(pblock->GetHash());
                     pindex = it != mapBlockIndex.end() ? it->second : NULL;
-                    if ( pindex != 0 && height > 100 && pindex->segid == -2  ) {
+                    if ( pindex != 0 && pindex->segid == -2 ) {
                         pindex->segid = -1;
                         //fprintf(stderr,"PoW block detected set segid.%d <- %d\n",height,pindex->segid);
                     }
@@ -2083,7 +2086,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
         return 0;
 
     bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
-    mindiff.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
+    mindiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
     ratio = (mindiff / bnTarget);
     assert(pwalletMain != NULL);
     *utxovaluep = 0;
@@ -2096,7 +2099,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
     if ( (minage= nHeight*3) > 6000 ) // about 100 blocks
         minage = 6000;
     komodo_segids(hashbuf,nHeight-101,100);
-    if ( *blocktimep < tipindex->nTime+60 )
+    if ( *blocktimep < tipindex->nTime+60)
         *blocktimep = tipindex->nTime+60;
 //fprintf(stderr,"Start scan of utxo for staking %u ht.%d\n",(uint32_t)time(NULL),nHeight);
 
@@ -2155,7 +2158,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
 //fprintf(stderr,"finished kp data of utxo for staking %u ht.%d numkp.%d maxkp.%d\n",(uint32_t)time(NULL),nHeight,numkp,maxkp);
     }
 //fprintf(stderr,"numkp.%d blocktime.%u\n",numkp,*blocktimep);
-    block_from_future_rejecttime = (uint32_t)GetAdjustedTime() + 57;
+    block_from_future_rejecttime = (uint32_t)GetAdjustedTime() + 57;    
     for (i=winners=0; i<numkp; i++)
     {
         if (fRequestShutdown)
@@ -2169,7 +2172,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
         if ( (eligible2= komodo_eligible(bnTarget,ratio,kp,nHeight,*blocktimep,(uint32_t)tipindex->nTime+27,minage,hashbuf)) == 0 )
             continue;
         eligible = komodo_stake(0,bnTarget,nHeight,kp->txid,kp->vout,0,(uint32_t)tipindex->nTime+27,kp->address);
-//fprintf(stderr,"i.%d %u vs %u\n",i,eligible2,eligible);
+        //fprintf(stderr,"i.%d %u vs %u\n",i,eligible2,eligible);
         if ( eligible > 0 )
         {
             besttime = m = 0;
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index ef7af0ba2..f2f6ed6b4 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -53,7 +53,7 @@ bool VERUS_MINTBLOCKS;
 
 char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN],ASSETCHAINS_USERPASS[4096],NOTARYADDRS[64][36];
 uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_BEAMPORT,ASSETCHAINS_CODAPORT;
-uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC,KOMODO_STOPAT,KOMODO_DPOWCONFS = 1;
+uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC,KOMODO_STOPAT,KOMODO_DPOWCONFS = 1,STAKING_MIN_DIFF;
 uint32_t ASSETCHAINS_MAGIC = 2387029918;
 int64_t ASSETCHAINS_GENESISTXVAL = 5000000000;
 
@@ -80,6 +80,8 @@ uint64_t ASSETCHAINS_NONCEMASK[] = {0xffff,0xfffffff};
 uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16};
 uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096};
 uint32_t ASSETCHAINS_ALGO = _ASSETCHAINS_EQUIHASH;
+// min diff returned from GetNextWorkRequired needs to be added here for each algo, so they can work with ac_staked.
+uint32_t ASSETCHAINS_MINDIFF[] = {537857807,504303375};
 
 // Verus proof of stake controls
 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 0ac40a48b..74e82f1e2 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1684,13 +1684,13 @@ void komodo_args(char *argv0)
                     IS_KOMODO_NOTARY = 1;
                     KOMODO_MININGTHREADS = 1;
                     mapArgs ["-genproclimit"] = itostr(KOMODO_MININGTHREADS);
-										IS_STAKED_NOTARY = -1;
+					IS_STAKED_NOTARY = -1;
                     fprintf(stderr,"running as notary.%d %s\n",i,Notaries_elected1[i][0]);
                     break;
                 }
         }
     }
-		name = GetArg("-ac_name","");
+	name = GetArg("-ac_name","");
     if ( argv0 != 0 )
     {
         len = (int32_t)strlen(argv0);
@@ -1726,6 +1726,7 @@ void komodo_args(char *argv0)
             if (std::string(ASSETCHAINS_ALGORITHMS[i]) == selectedAlgo)
             {
                 ASSETCHAINS_ALGO = i;
+                STAKING_MIN_DIFF = ASSETCHAINS_MINDIFF[i];
                 // only worth mentioning if it's not equihash
                 if (ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH)
                     printf("ASSETCHAINS_ALGO, algorithm set to %s\n", selectedAlgo.c_str());
diff --git a/src/miner.cpp b/src/miner.cpp
index e06a570c7..e90b22a5a 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -531,6 +531,19 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                 //if ( blocktime > pindexPrev->GetMedianTimePast()+60 )
                 //    blocktime = pindexPrev->GetMedianTimePast() + 60;
                 siglen = komodo_staked(txStaked, pblock->nBits, &blocktime, &txtime, &utxotxid, &utxovout, &utxovalue, utxosig);
+                // if you skip this check it will create a block too far into the future and not pass ProcessBlock or AcceptBlock.
+                // This has been moved from the mining loop to save CPU, and to also make ac_staked work with the verus miner.
+                while ( blocktime-57 > GetAdjustedTime() )
+                {
+                    sleep(1);
+                    if ( (rand() % 100) < 1 )
+                        fprintf(stderr, "%u seconds until elegible, waiting.\n", blocktime-((uint32_t)GetAdjustedTime()+57));
+                    if ( chainActive.LastTip()->GetHeight() >= stakeHeight )
+                    {
+                        fprintf(stderr, "Block Arrived, reset staking loop.\n");
+                        return(0);
+                    }
+                }
             }
 
             if ( siglen > 0 )
@@ -546,7 +559,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                 pblock->nTime = blocktime;
                 //printf("staking PoS ht.%d t%u lag.%u\n",(int32_t)chainActive.LastTip()->GetHeight()+1,blocktime,(uint32_t)(GetAdjustedTime() - (blocktime-13)));
             } else return(0); //fprintf(stderr,"no utxos eligible for staking\n");
-            
+                 
         }
         // Create coinbase tx
         CMutableTransaction txNew = CreateNewContextualCMutableTransaction(consensusParams, nHeight);
@@ -838,7 +851,7 @@ CBlockTemplate* CreateNewBlockWithKey(CReserveKey& reservekey, int32_t nHeight,
         scriptPubKey = Marmara_scriptPubKey(nHeight,pubkey);
     if ( ASSETCHAINS_STAKED != 0 && KOMODO_MININGTHREADS == 0 )
         isStake = true;
-    return CreateNewBlock(pubkey,scriptPubKey, gpucount, isStake);
+    return CreateNewBlock(pubkey, scriptPubKey, gpucount, isStake);
 }
 
 void komodo_broadcast(CBlock *pblock,int32_t limit)
@@ -1241,7 +1254,7 @@ void static BitcoinMiner_noeq()
             if ( ptr == 0 )
             {
                 static uint32_t counter;
-                if ( counter++ < 10 )
+                if ( ASSETCHAINS_STAKED == 0 && counter++ < 10 )
                     fprintf(stderr,"created illegal block, retry\n");
                 continue;
             }
@@ -1301,10 +1314,12 @@ void static BitcoinMiner_noeq()
 
             if ( ASSETCHAINS_STAKED != 0 )
             {
-                int32_t percPoS,z;
-                hashTarget = komodo_PoWtarget(&percPoS,hashTarget,Mining_height,ASSETCHAINS_STAKED);
+                int32_t percPoS,z; bool fNegative,fOverflow;
+                HASHTarget_POW = komodo_PoWtarget(&percPoS,hashTarget,Mining_height,ASSETCHAINS_STAKED);
+                // We use equihash min diff here to make the verus miner instantly finds a blockhash, this saves CPU when staking.
+                HASHTarget.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
                 if ( ASSETCHAINS_STAKED < 100 )
-                    LogPrintf("Block %d : PoS %d%% vs target %d%% \n",Mining_height,percPoS,(int32_t)ASSETCHAINS_STAKED);
+                    LogPrintf("Block %d : PoS %d%% vs target %d%%\n", Mining_height, percPoS, (int32_t)ASSETCHAINS_STAKED);
             }
 
             while (true)
@@ -1319,6 +1334,9 @@ void static BitcoinMiner_noeq()
                 vh.ClearExtra();
                 int64_t i, count = ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1;
                 int64_t hashesToGo = ASSETCHAINS_HASHESPERROUND[ASSETCHAINS_ALGO];
+                if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED > 0 && ASSETCHAINS_STAKED < 100 )
+                    hashTarget = HASHTarget_POW;
+                else hashTarget = HASHTarget;
 
                 // for speed check NONCEMASK at a time
                 for (i = 0; i < count; i++)
@@ -1414,7 +1432,6 @@ void static BitcoinMiner_noeq()
                 printf("%lu mega hashes complete - working\n", (ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1) / 1048576);
 #endif
                 break;
-
             }
         }
     }
@@ -1724,12 +1741,6 @@ void static BitcoinMiner()
                     }
                     else
                     {
-                        while ( B.nTime-57 > GetAdjustedTime() )
-                        {
-                            sleep(1);
-                            if ( chainActive.LastTip()->GetHeight() >= Mining_height )
-                                return(false);
-                        }
                         uint256 tmp = B.GetHash();
                         int32_t z; for (z=31; z>=0; z--)
                             fprintf(stderr,"%02x",((uint8_t *)&tmp)[z]);
@@ -1938,12 +1949,12 @@ void static BitcoinMiner()
         for (int i = 0; i < nThreads; i++) {
 
 #ifdef ENABLE_WALLET
-            if (ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH || (ASSETCHAINS_STAKED != 0 && KOMODO_MININGTHREADS == 0) )
+            if ( ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH )
                 minerThreads->create_thread(boost::bind(&BitcoinMiner, pwallet));
             else
                 minerThreads->create_thread(boost::bind(&BitcoinMiner_noeq, pwallet));
 #else
-            if (ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH || (ASSETCHAINS_STAKED != 0 && KOMODO_MININGTHREADS == 0) )
+            if (ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH )
                 minerThreads->create_thread(&BitcoinMiner);
             else
                 minerThreads->create_thread(&BitcoinMiner_noeq);

From a4f197794fb89e670714516b130c0ae0acfe0e0a Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 16 Jan 2019 21:16:30 +0800
Subject: [PATCH 05/18] Many bug fixes. VerusHash now works with PoS64 without
 special exemptions. Difficulty on new chains still behaves weridly, hoping
 resolves as chain ages.  Also reduced CPU load on all staking. These changes
 should work better if you are not the only node staking.

---
 src/komodo_bitcoind.h | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 662d0703c..0fea33ee5 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1342,6 +1342,12 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
     int32_t oldflag = 0,dispflag = 0;
     CBlockIndex *pindex; arith_uint256 easydiff,bnTarget,hashval,sum,ave; bool fNegative,fOverflow; int32_t i,n,m,ht,percPoS,diff,val;
     *percPoSp = percPoS = 0;
+    static bool new_rules, didinit;
+    if ( !didinit ) {
+        new_rules = is_STAKED(ASSETCHAINS_SYMBOL) != 0 && is_STAKED(ASSETCHAINS_SYMBOL) != 3 ? true : false;
+        didinit = true;
+    }
+    
     if ( height <= 10 || (ASSETCHAINS_STAKED == 100 && height <= 100) ) 
         return(target);
         
@@ -1353,6 +1359,9 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
         ht = height - 100 + i;
         if ( ht <= 1 )
             continue;
+        // never count the first 10 blocks, they are always PoW! Cant do this for old chains, so limit to LABS and LAB for now.
+        if ( new_rules && ht < 10 ) 
+            continue; 
         if ( (pindex= komodo_chainactive(ht)) != 0 )
         {
             if ( komodo_segid(0,ht) >= 0 )
@@ -1376,7 +1385,12 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
     // We now do actual PoS % at the start. Requires coin distribution in first 10 blocks! 
     // This is not hard to do and stops the chain having its PoS/PoW in large chunks. 
     if ( m+n < 100 )
-        percPoS = (percPoS*100) / (m+n); 
+    {
+        if ( new_rules)
+            percPoS = (percPoS*100) / (m+n); 
+        else
+            percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
+    }
     if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 )
         fprintf(stderr," -> %d%% percPoS vs goalperc.%d ht.%d\n",percPoS,goalperc,height);
     *percPoSp = percPoS;

From d072863d6f047b99354d05e583cd85f005e54dc3 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Thu, 17 Jan 2019 00:06:00 +0800
Subject: [PATCH 06/18] fix 100% chains.

---
 src/komodo_bitcoind.h |  2 +-
 src/miner.cpp         | 10 ++++------
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 0fea33ee5..1ffc68c62 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1457,7 +1457,7 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
 int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_uint256 bnTarget,arith_uint256 bhash)
 {
     CBlockIndex *previndex,*pindex; char voutaddr[64],destaddr[64]; uint256 txid; uint32_t txtime,prevtime=0; int32_t vout,PoSperc,txn_count,eligible=0,isPoS = 0,segid; uint64_t value; CTxDestination voutaddress;
-    if ( ASSETCHAINS_STAKED == 100 && height <= 10 )
+    if ( ASSETCHAINS_STAKED == 100 && height <= 100 )
         return(1);
     BlockMap::const_iterator it = mapBlockIndex.find(pblock->GetHash());
     pindex = it != mapBlockIndex.end() ? it->second : NULL;
diff --git a/src/miner.cpp b/src/miner.cpp
index e90b22a5a..98bfa55a1 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -132,7 +132,7 @@ void UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams,
 #include "komodo_defs.h"
 
 extern CCriticalSection cs_metrics;
-extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAIN_INIT,KOMODO_INITDONE,KOMODO_ON_DEMAND,KOMODO_INITDONE,KOMODO_PASSPORT_INITDONE;
+extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAIN_INIT,KOMODO_INITDONE,KOMODO_ON_DEMAND,KOMODO_INITDONE,KOMODO_PASSPORT_INITDONE,STAKING_MIN_DIFF;
 extern uint64_t ASSETCHAINS_COMMISSION, ASSETCHAINS_STAKED;
 extern bool VERUS_MINTBLOCKS;
 extern uint64_t ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_NONCEMASK[];
@@ -1316,10 +1316,8 @@ void static BitcoinMiner_noeq()
             {
                 int32_t percPoS,z; bool fNegative,fOverflow;
                 HASHTarget_POW = komodo_PoWtarget(&percPoS,hashTarget,Mining_height,ASSETCHAINS_STAKED);
-                // We use equihash min diff here to make the verus miner instantly finds a blockhash, this saves CPU when staking.
-                HASHTarget.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
-                if ( ASSETCHAINS_STAKED < 100 )
-                    LogPrintf("Block %d : PoS %d%% vs target %d%%\n", Mining_height, percPoS, (int32_t)ASSETCHAINS_STAKED);
+                HASHTarget.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
+                LogPrintf("Block %d : PoS %d%% vs target %d%%\n", Mining_height, percPoS, (int32_t)ASSETCHAINS_STAKED);
             }
 
             while (true)
@@ -1334,7 +1332,7 @@ void static BitcoinMiner_noeq()
                 vh.ClearExtra();
                 int64_t i, count = ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1;
                 int64_t hashesToGo = ASSETCHAINS_HASHESPERROUND[ASSETCHAINS_ALGO];
-                if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED > 0 && ASSETCHAINS_STAKED < 100 )
+                if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED > 0 && ASSETCHAINS_STAKED < 100 && Mining_height > 10 )
                     hashTarget = HASHTarget_POW;
                 else hashTarget = HASHTarget;
 

From 43be0a0e918c5d83a8be0492499f8c962d9b51d5 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Fri, 18 Jan 2019 17:54:41 +0800
Subject: [PATCH 07/18] VerusHash fix. 100% PoW wasnt working, min diff is now
 much higher fixing PoW doing 1s blocks.

---
 src/komodo_bitcoind.h   | 24 ++++++++----------------
 src/komodo_globals.h    |  4 +++-
 src/miner.cpp           | 16 ++++++++++------
 src/notaries_staked.cpp |  4 ++--
 4 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 1ffc68c62..2fea50e7b 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1296,6 +1296,11 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
         if ( iter > 0 )
             diff += segid*2;
         coinage = (value * diff);
+        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH )
+        {
+            if ( blocktime+iter+segid*2 > prevtime+200 )
+                coinage *= ((blocktime+iter+segid*2) - (prevtime+120));
+        }
         if ( blocktime+iter+segid*2 > prevtime+480 )
             coinage *= ((blocktime+iter+segid*2) - (prevtime+400));
         coinage256 = arith_uint256(coinage+1);
@@ -1339,14 +1344,9 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
 
 arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc)
 {
-    int32_t oldflag = 0,dispflag = 0;
+    int32_t oldflag = 0,dispflag = 1;
     CBlockIndex *pindex; arith_uint256 easydiff,bnTarget,hashval,sum,ave; bool fNegative,fOverflow; int32_t i,n,m,ht,percPoS,diff,val;
     *percPoSp = percPoS = 0;
-    static bool new_rules, didinit;
-    if ( !didinit ) {
-        new_rules = is_STAKED(ASSETCHAINS_SYMBOL) != 0 && is_STAKED(ASSETCHAINS_SYMBOL) != 3 ? true : false;
-        didinit = true;
-    }
     
     if ( height <= 10 || (ASSETCHAINS_STAKED == 100 && height <= 100) ) 
         return(target);
@@ -1359,9 +1359,6 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
         ht = height - 100 + i;
         if ( ht <= 1 )
             continue;
-        // never count the first 10 blocks, they are always PoW! Cant do this for old chains, so limit to LABS and LAB for now.
-        if ( new_rules && ht < 10 ) 
-            continue; 
         if ( (pindex= komodo_chainactive(ht)) != 0 )
         {
             if ( komodo_segid(0,ht) >= 0 )
@@ -1385,12 +1382,7 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
     // We now do actual PoS % at the start. Requires coin distribution in first 10 blocks! 
     // This is not hard to do and stops the chain having its PoS/PoW in large chunks. 
     if ( m+n < 100 )
-    {
-        if ( new_rules)
-            percPoS = (percPoS*100) / (m+n); 
-        else
-            percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
-    }
+        percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
     if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 )
         fprintf(stderr," -> %d%% percPoS vs goalperc.%d ht.%d\n",percPoS,goalperc,height);
     *percPoSp = percPoS;
@@ -1449,7 +1441,7 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
             fprintf(stderr," ht.%d percPoS.%d vs goal.%d -> diff %d\n",height,percPoS,goalperc,goalperc - percPoS);
         }
     }
-    else  
+    else
         bnTarget = ave; // recent ave is perfect
     return(bnTarget);
 }
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index f2f6ed6b4..70d621756 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -81,7 +81,9 @@ uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16};
 uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096};
 uint32_t ASSETCHAINS_ALGO = _ASSETCHAINS_EQUIHASH;
 // min diff returned from GetNextWorkRequired needs to be added here for each algo, so they can work with ac_staked.
-uint32_t ASSETCHAINS_MINDIFF[] = {537857807,504303375};
+uint32_t ASSETCHAINS_MINDIFF[] = {537857807,486648905};
+                                   // nBits.486704888 -- too low? 
+
 
 // Verus proof of stake controls
 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS
diff --git a/src/miner.cpp b/src/miner.cpp
index 98bfa55a1..aac5164cb 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -1297,6 +1297,7 @@ void static BitcoinMiner_noeq()
             pblock->nSolution = solnPlaceholder;
             savebits = pblock->nBits;
             arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
+            HASHTarget = arith_uint256().SetCompact(savebits);
             arith_uint256 mask(ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO]);
 
             Mining_start = 0;
@@ -1315,8 +1316,8 @@ void static BitcoinMiner_noeq()
             if ( ASSETCHAINS_STAKED != 0 )
             {
                 int32_t percPoS,z; bool fNegative,fOverflow;
-                HASHTarget_POW = komodo_PoWtarget(&percPoS,hashTarget,Mining_height,ASSETCHAINS_STAKED);
-                HASHTarget.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
+                HASHTarget_POW = komodo_PoWtarget(&percPoS,HASHTarget,Mining_height,ASSETCHAINS_STAKED);
+                HASHTarget.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
                 LogPrintf("Block %d : PoS %d%% vs target %d%%\n", Mining_height, percPoS, (int32_t)ASSETCHAINS_STAKED);
             }
 
@@ -1332,10 +1333,12 @@ void static BitcoinMiner_noeq()
                 vh.ClearExtra();
                 int64_t i, count = ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1;
                 int64_t hashesToGo = ASSETCHAINS_HASHESPERROUND[ASSETCHAINS_ALGO];
-                if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED > 0 && ASSETCHAINS_STAKED < 100 && Mining_height > 10 )
-                    hashTarget = HASHTarget_POW;
-                else hashTarget = HASHTarget;
-
+                if ( ASSETCHAINS_STAKED != 0)
+                {    
+                    if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED < 100 )
+                        hashTarget = HASHTarget_POW;
+                    else hashTarget = HASHTarget;
+                }
                 // for speed check NONCEMASK at a time
                 for (i = 0; i < count; i++)
                 {
@@ -1429,6 +1432,7 @@ void static BitcoinMiner_noeq()
 #else
                 printf("%lu mega hashes complete - working\n", (ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1) / 1048576);
 #endif
+                pblock->nBits = savebits;
                 break;
             }
         }
diff --git a/src/notaries_staked.cpp b/src/notaries_staked.cpp
index ebee4868e..596c78b90 100644
--- a/src/notaries_staked.cpp
+++ b/src/notaries_staked.cpp
@@ -14,9 +14,9 @@ int8_t is_STAKED(const char *chain_name) {
   static int8_t STAKED,doneinit;
   if (doneinit == 1 && ASSETCHAINS_SYMBOL[0] != 0)
     return(STAKED);
-  if ( (strcmp(chain_name, "LABS") == 0) || (strncmp(chain_name, "LABS", 4) == 0) )
+  if ( (strcmp(chain_name, "LABMAIN") == 0) || (strncmp(chain_name, "LABT1", 4) == 0) )
     STAKED = 1;
-  else if ( (strcmp(chain_name, "LAB") == 0) || (strncmp(chain_name, "LAB", 3) == 0) )
+  else if ( (strcmp(chain_name, "LABT2") == 0) || (strncmp(chain_name, "LABT2", 3) == 0) )
     STAKED = 2;
   else if ( (strcmp(chain_name, "CFEK") == 0) || (strncmp(chain_name, "CFEK", 4) == 0) )
     STAKED =  3;

From 45dfd3a590a3cab4635f3262d9d8e3b06a3b5138 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Fri, 18 Jan 2019 17:55:20 +0800
Subject: [PATCH 08/18] fix back to LABS

---
 src/notaries_staked.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/notaries_staked.cpp b/src/notaries_staked.cpp
index 596c78b90..ad1a2132f 100644
--- a/src/notaries_staked.cpp
+++ b/src/notaries_staked.cpp
@@ -14,7 +14,7 @@ int8_t is_STAKED(const char *chain_name) {
   static int8_t STAKED,doneinit;
   if (doneinit == 1 && ASSETCHAINS_SYMBOL[0] != 0)
     return(STAKED);
-  if ( (strcmp(chain_name, "LABMAIN") == 0) || (strncmp(chain_name, "LABT1", 4) == 0) )
+  if ( (strcmp(chain_name, "LABS") == 0) || (strncmp(chain_name, "LABS", 4) == 0) )
     STAKED = 1;
   else if ( (strcmp(chain_name, "LABT2") == 0) || (strncmp(chain_name, "LABT2", 3) == 0) )
     STAKED = 2;

From f7b6af7b3faac79ba62a8d2bec410c4490de555a Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Sun, 20 Jan 2019 19:11:31 +0800
Subject: [PATCH 09/18] ac_founders_reward test for Alright

---
 src/komodo_bitcoind.h | 13 +++++++++----
 src/komodo_globals.h  |  2 +-
 src/komodo_utils.h    | 11 ++++++++---
 3 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 4117347b6..e38436c71 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1151,7 +1151,12 @@ uint64_t komodo_commission(const CBlock *pblock,int32_t height)
         if ( ASSETCHAINS_FOUNDERS > 1 )
         {
             if ( (height % ASSETCHAINS_FOUNDERS) == 0 )
-                commission = commission * ASSETCHAINS_FOUNDERS;
+            {
+                if ( ASSETCHAINS_FOUNDERS_REWARD == 0 )
+                    commission = commission * ASSETCHAINS_FOUNDERS;
+                else
+                    commission = ASSETCHAINS_FOUNDERS_REWARD;
+            }
             else commission = 0;
         }
     }
@@ -1820,15 +1825,15 @@ int32_t komodo_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height)
                 } else
                 {
                     // I think this means the block is valid PoW. We need to set the pindex->segid here.
-                    failed = 0; 
-                    CBlockIndex *pindex; 
+                    failed = 0;
+                    CBlockIndex *pindex;
                     BlockMap::const_iterator it = mapBlockIndex.find(pblock->GetHash());
                     pindex = it != mapBlockIndex.end() ? it->second : NULL;
                     if ( pindex != 0 && height > 100 && pindex->segid == -2  ) {
                         pindex->segid = -1;
                         //fprintf(stderr,"PoW block detected set segid.%d <- %d\n",height,pindex->segid);
                     }
-                } 
+                }
             }
         }
         else if ( is_PoSblock < 0 )
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index 244655f5f..d5c6ca27e 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -92,7 +92,7 @@ int32_t ASSETCHAINS_SAPLING = -1;
 int32_t ASSETCHAINS_OVERWINTER = -1;
 
 uint64_t KOMODO_INTERESTSUM,KOMODO_WALLETBALANCE;
-uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_STAKED,ASSETCHAINS_SUPPLY = 10,MIN_RECV_SATS;
+uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_STAKED,ASSETCHAINS_SUPPLY = 10,MIN_RECV_SATS, ASSETCHAINS_FOUNDERS_REWARD;
 
 uint32_t KOMODO_INITDONE;
 char KMDUSERPASS[8192+512+1],BTCUSERPASS[8192]; uint16_t KMD_PORT = 7771,BITCOIND_RPCPORT = 7771;
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 17e849338..a86c993e8 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1777,6 +1777,7 @@ void komodo_args(char *argv0)
         MAX_BLOCK_SIGOPS = 60000;
         ASSETCHAINS_TXPOW = GetArg("-ac_txpow",0) & 3;
         ASSETCHAINS_FOUNDERS = GetArg("-ac_founders",0);// & 1;
+				ASSETCHAINS_FOUNDERS_REWARD = GetArg("-ac_founders_reward",0);
         ASSETCHAINS_SUPPLY = GetArg("-ac_supply",10);
         ASSETCHAINS_COMMISSION = GetArg("-ac_perc",0);
         ASSETCHAINS_OVERRIDE_PUBKEY = GetArg("-ac_pubkey","");
@@ -1809,7 +1810,7 @@ void komodo_args(char *argv0)
         }
         // else it can be gateway coin
 
-        
+
         if ( (ASSETCHAINS_STAKED= GetArg("-ac_staked",0)) > 100 )
             ASSETCHAINS_STAKED = 100;
 
@@ -1835,13 +1836,17 @@ void komodo_args(char *argv0)
                 decode_hex(ASSETCHAINS_OVERRIDE_PUBKEY33,33,(char *)ASSETCHAINS_OVERRIDE_PUBKEY.c_str());
                 calc_rmd160_sha256(ASSETCHAINS_OVERRIDE_PUBKEYHASH,ASSETCHAINS_OVERRIDE_PUBKEY33,33);
             }
-            if ( ASSETCHAINS_COMMISSION == 0 )
+            if ( ASSETCHAINS_COMMISSION == 0 && ASSETCHAINS_FOUNDERS != 0 )
             {
-                if (ASSETCHAINS_FOUNDERS != 0 )
+                if ( ASSETCHAINS_FOUNDERS_REWARD == 0 )
                 {
                     ASSETCHAINS_COMMISSION = 53846154; // maps to 35%
                     printf("ASSETCHAINS_COMMISSION defaulted to 35%% when founders reward active\n");
                 }
+								else
+								{
+										printf("ASSETCHAINS_FOUNDERS_REWARD set to %ld\n", ASSETCHAINS_FOUNDERS_REWARD);
+								}
                 /*else if ( ASSETCHAINS_SELFIMPORT.size() == 0 )
                 {
                     //ASSETCHAINS_OVERRIDE_PUBKEY.clear();

From 2c3247e8f1e8e9e9fe5336fb6b94353d7a98817b Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Tue, 22 Jan 2019 00:12:05 +0800
Subject: [PATCH 10/18] Enable -ac_algo=verushash11

---
 src/chainparams.cpp      |  8 +++-----
 src/init.cpp             |  8 +++++++-
 src/komodo_bitcoind.h    |  6 ++----
 src/komodo_globals.h     | 18 +++++++++---------
 src/komodo_utils.h       |  5 +++--
 src/metrics.cpp          |  4 ++--
 src/miner.cpp            | 32 +++++++++++++++++++++++++-------
 src/primitives/block.cpp | 12 ++++++++++--
 src/primitives/block.h   |  1 +
 src/wallet-utility.cpp   |  1 +
 10 files changed, 63 insertions(+), 32 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 6b0627d20..368e0eb50 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -94,11 +94,10 @@ void *chainparams_commandline(void *ptr);
 
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
-extern uint32_t ASSETCHAIN_INIT, ASSETCHAINS_MAGIC;
+extern uint32_t ASSETCHAIN_INIT, ASSETCHAINS_MAGIC, ASSETCHAINS_EQUIHASH, ASSETCHAINS_VERUSHASH, ASSETCHAINS_VERUSHASHV2;
 extern int32_t VERUS_BLOCK_POSUNITS, ASSETCHAINS_LWMAPOS, ASSETCHAINS_SAPLING, ASSETCHAINS_OVERWINTER;
-extern uint64_t ASSETCHAINS_SUPPLY, ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_VERUSHASH;
+extern uint64_t ASSETCHAINS_SUPPLY, ASSETCHAINS_ALGO;
 
-extern int8_t is_STAKED(const char *chain_name);
 const arith_uint256 maxUint = UintToArith256(uint256S("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
 
 class CMainParams : public CChainParams {
@@ -269,8 +268,7 @@ void *chainparams_commandline(void *ptr)
         mainParams.pchMessageStart[2] = (ASSETCHAINS_MAGIC >> 16) & 0xff;
         mainParams.pchMessageStart[3] = (ASSETCHAINS_MAGIC >> 24) & 0xff;
         fprintf(stderr,">>>>>>>>>> %s: p2p.%u rpc.%u magic.%08x %u %u coins\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_MAGIC,ASSETCHAINS_MAGIC,(uint32_t)ASSETCHAINS_SUPPLY);
-
-        if (ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH)
+        if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2) 
         {
             // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
             // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
diff --git a/src/init.cpp b/src/init.cpp
index 3dd09ac50..6aca3ce1b 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1177,7 +1177,8 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     globalVerifyHandle.reset(new ECCVerifyHandle());
 
     // set the hash algorithm to use for this chain
-    extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_VERUSHASH;
+    // Again likely better solution here, than using long IF ELSE. 
+    extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_VERUSHASH, ASSETCHAINS_VERUSHASHV2;
     CVerusHash::init();
     CVerusHashV2::init();
     if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH)
@@ -1185,6 +1186,11 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
         // initialize VerusHash
         CBlockHeader::SetVerusHash();
     }
+    else if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2)
+    {
+        // initialize VerusHashV2
+        CBlockHeader::SetVerusHashV2();
+    }
 
     // Sanity check
     if (!InitSanityCheck())
diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 2fea50e7b..b567c1488 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1296,11 +1296,11 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
         if ( iter > 0 )
             diff += segid*2;
         coinage = (value * diff);
-        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH )
+        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
         {
             if ( blocktime+iter+segid*2 > prevtime+200 )
                 coinage *= ((blocktime+iter+segid*2) - (prevtime+120));
-        }
+        } 
         if ( blocktime+iter+segid*2 > prevtime+480 )
             coinage *= ((blocktime+iter+segid*2) - (prevtime+400));
         coinage256 = arith_uint256(coinage+1);
@@ -1379,8 +1379,6 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
         if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 && (i % 10) == 9 )
             fprintf(stderr," %d, ",percPoS);
     }
-    // We now do actual PoS % at the start. Requires coin distribution in first 10 blocks! 
-    // This is not hard to do and stops the chain having its PoS/PoW in large chunks. 
     if ( m+n < 100 )
         percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
     if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 )
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index 70d621756..2c2d4e855 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -68,22 +68,22 @@ int64_t MAX_MONEY = 200000000 * 100000000LL;
 uint64_t ASSETCHAINS_TIMELOCKGTE = _ASSETCHAINS_TIMELOCKOFF;
 uint64_t ASSETCHAINS_TIMEUNLOCKFROM = 0, ASSETCHAINS_TIMEUNLOCKTO = 0;
 
-uint32_t ASSETCHAINS_LASTERA = 1;
+uint64_t ASSETCHAINS_LASTERA = 1;
 uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_DECAY[ASSETCHAINS_MAX_ERAS];
 
 #define _ASSETCHAINS_EQUIHASH 0
-uint32_t ASSETCHAINS_NUMALGOS = 2;
+uint32_t ASSETCHAINS_NUMALGOS = 3;
 uint32_t ASSETCHAINS_EQUIHASH = _ASSETCHAINS_EQUIHASH;
 uint32_t ASSETCHAINS_VERUSHASH = 1;
-const char *ASSETCHAINS_ALGORITHMS[] = {"equihash", "verushash"};
-uint64_t ASSETCHAINS_NONCEMASK[] = {0xffff,0xfffffff};
-uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16};
-uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096};
+uint32_t ASSETCHAINS_VERUSHASHV2 = 2;
+const char *ASSETCHAINS_ALGORITHMS[] = {"equihash", "verushash", "verushash11"};
+uint64_t ASSETCHAINS_NONCEMASK[] = {0xffff,0xfffffff,0xfffffff};
+uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16,16};
+uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096,4096};
 uint32_t ASSETCHAINS_ALGO = _ASSETCHAINS_EQUIHASH;
 // min diff returned from GetNextWorkRequired needs to be added here for each algo, so they can work with ac_staked.
-uint32_t ASSETCHAINS_MINDIFF[] = {537857807,486648905};
-                                   // nBits.486704888 -- too low? 
-
+// VerusHash v1 and 1.1 use a custom tuned number or PoW blocks all are 1s. 
+uint32_t ASSETCHAINS_MINDIFF[] = {537857807,486648905,486648905};
 
 // Verus proof of stake controls
 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 74e82f1e2..1fe4c012a 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1742,9 +1742,10 @@ void komodo_args(char *argv0)
         if ( ASSETCHAINS_LASTERA < 1 || ASSETCHAINS_LASTERA > ASSETCHAINS_MAX_ERAS )
         {
             ASSETCHAINS_LASTERA = 1;
-            printf("ASSETCHAINS_LASTERA, if specified, must be between 1 and %u. ASSETCHAINS_LASTERA set to %u\n", ASSETCHAINS_MAX_ERAS, ASSETCHAINS_LASTERA);
+            printf("ASSETCHAINS_LASTERA, if specified, must be between 1 and %u. ASSETCHAINS_LASTERA set to %lu\n", ASSETCHAINS_MAX_ERAS, ASSETCHAINS_LASTERA);
         }
         ASSETCHAINS_LASTERA -= 1;
+        printf("ASSETCHAINS_LASTERA = %lu\n", ASSETCHAINS_LASTERA);
 
         ASSETCHAINS_TIMELOCKGTE = (uint64_t)GetArg("-ac_timelockgte", _ASSETCHAINS_TIMELOCKOFF);
         ASSETCHAINS_TIMEUNLOCKFROM = GetArg("-ac_timeunlockfrom", 0);
@@ -2069,7 +2070,7 @@ void komodo_args(char *argv0)
         if ( strcmp("PIRATE",ASSETCHAINS_SYMBOL) == 0 && ASSETCHAINS_HALVING[0] == 77777 )
         {
             ASSETCHAINS_HALVING[0] *= 5;
-            fprintf(stderr,"PIRATE halving changed to %d %.1f days ASSETCHAINS_LASTERA.%d\n",(int32_t)ASSETCHAINS_HALVING[0],(double)ASSETCHAINS_HALVING[0]/1440,ASSETCHAINS_LASTERA);
+            fprintf(stderr,"PIRATE halving changed to %d %.1f days ASSETCHAINS_LASTERA.%lu\n",(int32_t)ASSETCHAINS_HALVING[0],(double)ASSETCHAINS_HALVING[0]/1440,ASSETCHAINS_LASTERA);
         }
         else if ( strcmp("VRSC",ASSETCHAINS_SYMBOL) == 0 )
             dpowconfs = 0;
diff --git a/src/metrics.cpp b/src/metrics.cpp
index a01d381a1..879765933 100644
--- a/src/metrics.cpp
+++ b/src/metrics.cpp
@@ -40,7 +40,7 @@
 #include <unistd.h>
 
 extern uint64_t ASSETCHAINS_TIMELOCKGTE;
-extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_VERUSHASH;
+extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_VERUSHASH, ASSETCHAINS_VERUSHASHV2;
 int64_t komodo_block_unlocktime(uint32_t nHeight);
 
 void AtomicTimer::start()
@@ -137,7 +137,7 @@ int64_t GetUptime()
 
 double GetLocalSolPS()
 {
-    if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH)
+    if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2)
     {
         return miningTimer.rate(nHashCount);
     }
diff --git a/src/miner.cpp b/src/miner.cpp
index aac5164cb..66f1a263f 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -137,7 +137,7 @@ extern uint64_t ASSETCHAINS_COMMISSION, ASSETCHAINS_STAKED;
 extern bool VERUS_MINTBLOCKS;
 extern uint64_t ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_NONCEMASK[];
 extern const char *ASSETCHAINS_ALGORITHMS[];
-extern int32_t VERUS_MIN_STAKEAGE, ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_VERUSHASH, ASSETCHAINS_LASTERA, ASSETCHAINS_LWMAPOS, ASSETCHAINS_NONCESHIFT[], ASSETCHAINS_HASHESPERROUND[];
+extern int32_t VERUS_MIN_STAKEAGE, ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_VERUSHASH, ASSETCHAINS_VERUSHASHV2, ASSETCHAINS_LASTERA, ASSETCHAINS_LWMAPOS, ASSETCHAINS_NONCESHIFT[], ASSETCHAINS_HASHESPERROUND[];
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN],NOTARYADDRS[64][36];
 extern std::string NOTARY_PUBKEY,ASSETCHAINS_OVERRIDE_PUBKEY,ASSETCHAINS_SCRIPTPUB;
 void vcalc_sha256(char deprecated[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len);
@@ -1324,26 +1324,44 @@ void static BitcoinMiner_noeq()
             while (true)
             {
                 arith_uint256 arNonce = UintToArith256(pblock->nNonce);
-
+                int64_t *extraPtr;
+                
+                // This seems to be a really bad way to do this, but its better than copy pasting the entire miner function at this stage.
                 CVerusHashWriter ss = CVerusHashWriter(SER_GETHASH, PROTOCOL_VERSION);
                 ss << *((CBlockHeader *)pblock);
-                int64_t *extraPtr = ss.xI64p();
+                if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH )
+                    extraPtr = ss.xI64p();
                 CVerusHash &vh = ss.GetState();
                 uint256 hashResult = uint256();
                 vh.ClearExtra();
+                
+                CVerusHashV2Writer ss2 = CVerusHashV2Writer(SER_GETHASH, PROTOCOL_VERSION);
+                ss2 << *((CBlockHeader *)pblock);
+                if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
+                    extraPtr = ss2.xI64p();
+                CVerusHashV2 &vh2 = ss2.GetState();
+                vh2.ClearExtra();
+                
                 int64_t i, count = ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1;
                 int64_t hashesToGo = ASSETCHAINS_HASHESPERROUND[ASSETCHAINS_ALGO];
-                if ( ASSETCHAINS_STAKED != 0)
+                if ( ASSETCHAINS_STAKED > 0 && ASSETCHAINS_STAKED < 100 )
                 {    
-                    if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED < 100 )
+                    if ( KOMODO_MININGTHREADS > 0 )
                         hashTarget = HASHTarget_POW;
-                    else hashTarget = HASHTarget;
+                    else 
+                        hashTarget = HASHTarget;
                 }
+                else if ( ASSETCHAINS_STAKED == 100 && Mining_height > 100 )
+                    hashTarget = HASHTarget;
+                
                 // for speed check NONCEMASK at a time
                 for (i = 0; i < count; i++)
                 {
                     *extraPtr = i;
-                    vh.ExtraHash((unsigned char *)&hashResult);
+                    if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH )
+                        vh.ExtraHash((unsigned char *)&hashResult);
+                    else if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
+                        vh2.ExtraHash((unsigned char *)&hashResult);
 
                     if ( UintToArith256(hashResult) <= hashTarget )
                     {
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index 00fc8cee9..3c0dfdd37 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -46,8 +46,11 @@ uint256 CBlockHeader::GetVerusHash() const
 
 uint256 CBlockHeader::GetVerusV2Hash() const
 {
-    // no check for genesis block and use the optimized hash
-    return SerializeVerusHashV2(*this);
+    if (hashPrevBlock.IsNull())
+        // always use SHA256D for genesis block
+        return SerializeHash(*this);
+    else
+        return SerializeVerusHashV2(*this);
 }
 
 void CBlockHeader::SetSHA256DHash()
@@ -60,6 +63,11 @@ void CBlockHeader::SetVerusHash()
     CBlockHeader::hashFunction = &CBlockHeader::GetVerusHash;
 }
 
+void CBlockHeader::SetVerusHashV2()
+{
+    CBlockHeader::hashFunction = &CBlockHeader::GetVerusV2Hash;
+}
+
 // returns false if unable to fast calculate the VerusPOSHash from the header. 
 // if it returns false, value is set to 0, but it can still be calculated from the full block
 // in that case. the only difference between this and the POS hash for the contest is that it is not divided by the value out
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 5cd0a72fe..6ef8e0633 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -106,6 +106,7 @@ public:
     uint256 GetVerusEntropyHash(int32_t nHeight) const;
 
     uint256 GetVerusV2Hash() const;
+    static void SetVerusHashV2();
 
     int64_t GetBlockTime() const
     {
diff --git a/src/wallet-utility.cpp b/src/wallet-utility.cpp
index 7af2ca5bf..f4041dfbe 100644
--- a/src/wallet-utility.cpp
+++ b/src/wallet-utility.cpp
@@ -18,6 +18,7 @@ uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC;
 uint32_t ASSETCHAINS_MAGIC = 2387029918;
 uint32_t ASSETCHAINS_EQUIHASH = 0;
 uint32_t ASSETCHAINS_VERUSHASH = 1;
+uint32_t ASSETCHAINS_VERUSHASHV2 = 2;
 uint32_t ASSETCHAINS_ALGO = 0;
 int32_t ASSETCHAINS_LWMAPOS = 0;
 int32_t VERUS_BLOCK_POSUNITS = 1000;

From 8324e606cd99b240b812013fa3e5f43854d6a6e6 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Tue, 22 Jan 2019 14:39:29 +0800
Subject: [PATCH 11/18] try to add PoS% to staking loop, to adjust staking
 difficulty

---
 src/chainparams.cpp   |  14 ++-
 src/komodo_bitcoind.h | 220 +++++++++++++++++++++++-------------------
 src/komodo_globals.h  |   5 +-
 src/pow.cpp           |   2 +
 4 files changed, 135 insertions(+), 106 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 368e0eb50..03a518d4b 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -94,9 +94,9 @@ void *chainparams_commandline(void *ptr);
 
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
-extern uint32_t ASSETCHAIN_INIT, ASSETCHAINS_MAGIC, ASSETCHAINS_EQUIHASH, ASSETCHAINS_VERUSHASH, ASSETCHAINS_VERUSHASHV2;
+extern uint32_t ASSETCHAIN_INIT, ASSETCHAINS_MAGIC, ASSETCHAINS_VERUSHASHV2, ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_VERUSHASH;
 extern int32_t VERUS_BLOCK_POSUNITS, ASSETCHAINS_LWMAPOS, ASSETCHAINS_SAPLING, ASSETCHAINS_OVERWINTER;
-extern uint64_t ASSETCHAINS_SUPPLY, ASSETCHAINS_ALGO;
+extern uint64_t ASSETCHAINS_SUPPLY;
 
 const arith_uint256 maxUint = UintToArith256(uint256S("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
 
@@ -268,7 +268,7 @@ void *chainparams_commandline(void *ptr)
         mainParams.pchMessageStart[2] = (ASSETCHAINS_MAGIC >> 16) & 0xff;
         mainParams.pchMessageStart[3] = (ASSETCHAINS_MAGIC >> 24) & 0xff;
         fprintf(stderr,">>>>>>>>>> %s: p2p.%u rpc.%u magic.%08x %u %u coins\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_MAGIC,ASSETCHAINS_MAGIC,(uint32_t)ASSETCHAINS_SUPPLY);
-        if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2) 
+        if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH) 
         {
             // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
             // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
@@ -276,6 +276,14 @@ void *chainparams_commandline(void *ptr)
             mainParams.consensus.nPowAveragingWindow = 45;
             mainParams.consensus.powAlternate = uint256S("00000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
         }
+        else if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2)
+        {
+            // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
+            // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
+            mainParams.consensus.nLwmaAjustedWeight = 1350;
+            mainParams.consensus.nPowAveragingWindow = 45;
+            mainParams.consensus.powAlternate = uint256S("000000ff0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
+        }
 
         if (ASSETCHAINS_LWMAPOS != 0)
         {
diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index b567c1488..d2c3b3b30 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1253,95 +1253,6 @@ uint32_t komodo_stakehash(uint256 *hashp,char *address,uint8_t *hashbuf,uint256
     return(addrhash.uints[0]);
 }
 
-uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeight,uint256 txid,int32_t vout,uint32_t blocktime,uint32_t prevtime,char *destaddr)
-{
-    bool fNegative,fOverflow; uint8_t hashbuf[256]; char address[64]; bits256 addrhash; arith_uint256 hashval,mindiff,ratio,coinage256; uint256 hash,pasthash; int32_t diff=0,segid,minage,i,iter=0; uint32_t txtime,segid32,winner = 0 ; uint64_t value,coinage;
-    txtime = komodo_txtime2(&value,txid,vout,address);
-    if ( validateflag == 0 )
-    {
-        //fprintf(stderr,"blocktime.%u -> ",blocktime);
-        if ( blocktime < prevtime+3 )
-            blocktime = prevtime+3;
-        if ( blocktime < GetAdjustedTime()-60 )
-            blocktime = GetAdjustedTime()+30;
-        //fprintf(stderr,"blocktime.%u txtime.%u\n",blocktime,txtime);
-    }
-    if ( value == 0 || txtime == 0 || blocktime == 0 || prevtime == 0 )
-    {
-        //fprintf(stderr,"komodo_stake null %.8f %u %u %u\n",dstr(value),txtime,blocktime,prevtime);
-        return(0);
-    }
-    if ( value < SATOSHIDEN )
-        return(0);
-    value /= SATOSHIDEN;
-    mindiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
-    ratio = (mindiff / bnTarget);
-    if ( (minage= nHeight*3) > 6000 ) // about 100 blocks
-        minage = 6000;
-    komodo_segids(hashbuf,nHeight-101,100);
-    segid32 = komodo_stakehash(&hash,address,hashbuf,txid,vout);
-    segid = ((nHeight + segid32) & 0x3f);
-    for (iter=0; iter<600; iter++)
-    {
-        if ( blocktime+iter+segid*2 < txtime+minage )
-            continue;
-        diff = (iter + blocktime - txtime - minage);
-        if ( diff < 0 )
-            diff = 60;
-        else if ( diff > 3600*24*30 )
-        {
-            //printf("diff.%d (iter.%d blocktime.%u txtime.%u minage.%d)\n",(int32_t)diff,iter,blocktime,txtime,(int32_t)minage);
-            diff = 3600*24*30;
-        }
-        if ( iter > 0 )
-            diff += segid*2;
-        coinage = (value * diff);
-        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
-        {
-            if ( blocktime+iter+segid*2 > prevtime+200 )
-                coinage *= ((blocktime+iter+segid*2) - (prevtime+120));
-        } 
-        if ( blocktime+iter+segid*2 > prevtime+480 )
-            coinage *= ((blocktime+iter+segid*2) - (prevtime+400));
-        coinage256 = arith_uint256(coinage+1);
-        hashval = ratio * (UintToArith256(hash) / coinage256);
-        if ( hashval <= bnTarget )
-        {
-            winner = 1;
-            if ( validateflag == 0 )
-            {
-                //fprintf(stderr,"winner blocktime.%u iter.%d segid.%d\n",blocktime,iter,segid);
-                blocktime += iter;
-                blocktime += segid * 2;
-            }
-            break;
-        }
-        if ( validateflag != 0 )
-        {
-            /*for (i=31; i>=24; i--)
-                fprintf(stderr,"%02x",((uint8_t *)&hashval)[i]);
-            fprintf(stderr," vs ");
-            for (i=31; i>=24; i--)
-                fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
-            fprintf(stderr," segid.%d iter.%d winner.%d coinage.%llu %d ht.%d t.%u v%d diff.%d\n",segid,iter,winner,(long long)coinage,(int32_t)(blocktime - txtime),nHeight,blocktime,(int32_t)value,(int32_t)diff);*/
-            break;
-        }
-    }
-    //fprintf(stderr,"iterated until i.%d winner.%d\n",i,winner);
-    if ( 0 && validateflag != 0 )
-    {
-        for (i=31; i>=24; i--)
-            fprintf(stderr,"%02x",((uint8_t *)&hashval)[i]);
-        fprintf(stderr," vs ");
-        for (i=31; i>=24; i--)
-            fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
-        fprintf(stderr," segid.%d iter.%d winner.%d coinage.%llu %d ht.%d t.%u v%d diff.%d ht.%d\n",segid,iter,winner,(long long)coinage,(int32_t)(blocktime - txtime),nHeight,blocktime,(int32_t)value,(int32_t)diff,nHeight);
-    }
-    if ( nHeight < 10 )
-        return(blocktime);
-    return(blocktime * winner);
-}
-
 arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc)
 {
     int32_t oldflag = 0,dispflag = 1;
@@ -1380,7 +1291,17 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
             fprintf(stderr," %d, ",percPoS);
     }
     if ( m+n < 100 )
-        percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
+    {
+        // We do actual PoS % at the start. Requires coin distribution in first 10 blocks! 
+        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
+            percPoS = (percPoS*100) / (m+n); 
+        else
+            // This seems to be inverse. The actual PoS % is backwards in the first 100 blocks. 
+            // I dont't understand the math here, or why its backwards, so I am just disabling it for VerusHash.
+            // No doubt this is probably wrong for equihash aswell, we may need to test an equihash chain with the rule above.
+            // Need to ask james what the deal is here! Seems to be causeing ALL the problems.
+            percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
+    } 
     if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 )
         fprintf(stderr," -> %d%% percPoS vs goalperc.%d ht.%d\n",percPoS,goalperc,height);
     *percPoSp = percPoS;
@@ -1444,9 +1365,104 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
     return(bnTarget);
 }
 
+uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeight,uint256 txid,int32_t vout,uint32_t blocktime,uint32_t prevtime,char *destaddr,int32_t PoSperc)
+{
+    bool fNegative,fOverflow; uint8_t hashbuf[256]; char address[64]; bits256 addrhash; arith_uint256 hashval,mindiff,ratio,coinage256; uint256 hash,pasthash; int32_t diff=0,segid,minage,i,iter=0; uint32_t txtime,segid32,winner = 0 ; uint64_t value,coinage;
+    txtime = komodo_txtime2(&value,txid,vout,address);
+    if ( validateflag == 0 )
+    {
+        //fprintf(stderr,"blocktime.%u -> ",blocktime);
+        if ( blocktime < prevtime+3 )
+            blocktime = prevtime+3;
+        if ( blocktime < GetAdjustedTime()-60 )
+            blocktime = GetAdjustedTime()+30;
+        //fprintf(stderr,"blocktime.%u txtime.%u\n",blocktime,txtime);
+    }
+    if ( value == 0 || txtime == 0 || blocktime == 0 || prevtime == 0 )
+    {
+        //fprintf(stderr,"komodo_stake null %.8f %u %u %u\n",dstr(value),txtime,blocktime,prevtime);
+        return(0);
+    }
+    if ( value < SATOSHIDEN )
+        return(0);
+    value /= SATOSHIDEN;
+    mindiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
+    ratio = (mindiff / bnTarget);
+    if ( (minage= nHeight*3) > 6000 ) // about 100 blocks
+        minage = 6000;
+    komodo_segids(hashbuf,nHeight-101,100);
+    segid32 = komodo_stakehash(&hash,address,hashbuf,txid,vout);
+    segid = ((nHeight + segid32) & 0x3f);
+    for (iter=0; iter<600; iter++)
+    {
+        if ( blocktime+iter+segid*2 < txtime+minage )
+            continue;
+        diff = (iter + blocktime - txtime - minage);
+        if ( diff < 0 )
+            diff = 60;
+        else if ( diff > 3600*24*30 )
+        {
+            //printf("diff.%d (iter.%d blocktime.%u txtime.%u minage.%d)\n",(int32_t)diff,iter,blocktime,txtime,(int32_t)minage);
+            diff = 3600*24*30;
+        }
+        if ( iter > 0 )
+            diff += segid*2;
+        coinage = (value * diff);
+        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
+        {
+            fprintf(stderr, "PoS % is: %i% vs. %i% \n", PoSperc, ASSETCHAINS_STAKED);
+            if ( PoSperc < ASSETCHAINS_STAKED )
+            {
+                // This means we are under PoS % required and we need some extra help getting an elegible utxo. 
+                // Likley there is some math required here to make it work properly. But getting the data here is no1 priority.
+                coinage = coinage * 1000;
+            }
+        }
+        // leave this here for now... 
+        if ( blocktime+iter+segid*2 > prevtime+480 )
+            coinage *= ((blocktime+iter+segid*2) - (prevtime+400));
+        coinage256 = arith_uint256(coinage+1);
+        hashval = ratio * (UintToArith256(hash) / coinage256);
+        if ( hashval <= bnTarget )
+        {
+            winner = 1;
+            if ( validateflag == 0 )
+            {
+                //fprintf(stderr,"winner blocktime.%u iter.%d segid.%d\n",blocktime,iter,segid);
+                blocktime += iter;
+                blocktime += segid * 2;
+            }
+            break;
+        }
+        if ( validateflag != 0 )
+        {
+            /*for (i=31; i>=24; i--)
+                fprintf(stderr,"%02x",((uint8_t *)&hashval)[i]);
+            fprintf(stderr," vs ");
+            for (i=31; i>=24; i--)
+                fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
+            fprintf(stderr," segid.%d iter.%d winner.%d coinage.%llu %d ht.%d t.%u v%d diff.%d\n",segid,iter,winner,(long long)coinage,(int32_t)(blocktime - txtime),nHeight,blocktime,(int32_t)value,(int32_t)diff);*/
+            break;
+        }
+    }
+    //fprintf(stderr,"iterated until i.%d winner.%d\n",i,winner);
+    if ( 0 && validateflag != 0 )
+    {
+        for (i=31; i>=24; i--)
+            fprintf(stderr,"%02x",((uint8_t *)&hashval)[i]);
+        fprintf(stderr," vs ");
+        for (i=31; i>=24; i--)
+            fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
+        fprintf(stderr," segid.%d iter.%d winner.%d coinage.%llu %d ht.%d t.%u v%d diff.%d ht.%d\n",segid,iter,winner,(long long)coinage,(int32_t)(blocktime - txtime),nHeight,blocktime,(int32_t)value,(int32_t)diff,nHeight);
+    }
+    if ( nHeight < 10 )
+        return(blocktime);
+    return(blocktime * winner);
+}
+
 int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_uint256 bnTarget,arith_uint256 bhash)
 {
-    CBlockIndex *previndex,*pindex; char voutaddr[64],destaddr[64]; uint256 txid; uint32_t txtime,prevtime=0; int32_t vout,PoSperc,txn_count,eligible=0,isPoS = 0,segid; uint64_t value; CTxDestination voutaddress;
+    CBlockIndex *previndex,*pindex; char voutaddr[64],destaddr[64]; uint256 txid; uint32_t txtime,prevtime=0; int32_t vout,PoSperc,txn_count,eligible=0,isPoS = 0,segid; uint64_t value; CTxDestination voutaddress; arith_uint256 POWTarget;
     if ( ASSETCHAINS_STAKED == 100 && height <= 100 )
         return(1);
     BlockMap::const_iterator it = mapBlockIndex.find(pblock->GetHash());
@@ -1457,6 +1473,8 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
             return(0);
         else return(1);
     }
+    // Get PoSperc and POW Target. for later.
+    POWTarget = komodo_PoWtarget(&PoSperc,bnTarget,height,ASSETCHAINS_STAKED);
     txn_count = pblock->vtx.size();
     if ( txn_count > 1 && pblock->vtx[txn_count-1].vin.size() == 1 && pblock->vtx[txn_count-1].vout.size() == 1 )
     {
@@ -1470,7 +1488,7 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
         {
             if ( komodo_isPoS(pblock) != 0 )
             {
-                eligible = komodo_stake(1,bnTarget,height,txid,vout,pblock->nTime,prevtime+27,(char *)"");
+                eligible = komodo_stake(1,bnTarget,height,txid,vout,pblock->nTime,prevtime+27,(char *)"",PoSperc);
             }
             if ( eligible == 0 || eligible > pblock->nTime )
             {
@@ -1515,8 +1533,7 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
             }
             else
             {
-                bnTarget = komodo_PoWtarget(&PoSperc,bnTarget,height,ASSETCHAINS_STAKED);
-                if ( bhash < bnTarget )
+                if ( bhash < POWTarget )
                 {
                     //fprintf(stderr,"ht.%d isPoS but meets PoW diff!\n",height);
                     isPoS = 0;
@@ -2085,10 +2102,11 @@ uint32_t komodo_eligible(arith_uint256 bnTarget,arith_uint256 ratio,struct komod
 int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blocktimep,uint32_t *txtimep,uint256 *utxotxidp,int32_t *utxovoutp,uint64_t *utxovaluep,uint8_t *utxosig)
 {
     static struct komodo_staking *array; static int32_t numkp,maxkp; static uint32_t lasttime;
-    set<CBitcoinAddress> setAddress; struct komodo_staking *kp; int32_t winners,segid,minage,nHeight,counter=0,i,m,siglen=0,nMinDepth = 1,nMaxDepth = 99999999; vector<COutput> vecOutputs; uint32_t block_from_future_rejecttime,besttime,eligible,eligible2,earliest = 0; CScript best_scriptPubKey; arith_uint256 mindiff,ratio,bnTarget; CBlockIndex *tipindex,*pindex; CTxDestination address; bool fNegative,fOverflow; uint8_t hashbuf[256]; CTransaction tx; uint256 hashBlock;
+    int32_t PoSperc;
+    set<CBitcoinAddress> setAddress; struct komodo_staking *kp; int32_t winners,segid,minage,nHeight,counter=0,i,m,siglen=0,nMinDepth = 1,nMaxDepth = 99999999; vector<COutput> vecOutputs; uint32_t block_from_future_rejecttime,besttime,eligible,eligible2,earliest = 0; CScript best_scriptPubKey; arith_uint256 mindiff,ratio,bnTarget,tmpTarget; CBlockIndex *tipindex,*pindex; CTxDestination address; bool fNegative,fOverflow; uint8_t hashbuf[256]; CTransaction tx; uint256 hashBlock;
     if (!EnsureWalletIsAvailable(0))
         return 0;
-
+    
     bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
     mindiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
     ratio = (mindiff / bnTarget);
@@ -2100,6 +2118,8 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
     if ( (tipindex= chainActive.Tip()) == 0 )
         return(0);
     nHeight = tipindex->GetHeight() + 1;
+    // Get the PoS% so we can pass it to komodo_stake, this is to adjust PoS dofficulty when it is under the target %!
+    tmpTarget = komodo_PoWtarget(&PoSperc,bnTarget,nHeight,ASSETCHAINS_STAKED);
     if ( (minage= nHeight*3) > 6000 ) // about 100 blocks
         minage = 6000;
     komodo_segids(hashbuf,nHeight-101,100);
@@ -2119,7 +2139,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
         }
     }
 
-    if ( time(NULL) > lasttime+600 || array == 0 || resetstaker )
+    if ( resetstaker || array == 0 || time(NULL) > lasttime+600 )
     {
         LOCK2(cs_main, pwalletMain->cs_wallet);
         pwalletMain->AvailableCoins(vecOutputs, false, NULL, true);
@@ -2175,14 +2195,14 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
         kp = &array[i];
         if ( (eligible2= komodo_eligible(bnTarget,ratio,kp,nHeight,*blocktimep,(uint32_t)tipindex->nTime+27,minage,hashbuf)) == 0 )
             continue;
-        eligible = komodo_stake(0,bnTarget,nHeight,kp->txid,kp->vout,0,(uint32_t)tipindex->nTime+27,kp->address);
+        eligible = komodo_stake(0,bnTarget,nHeight,kp->txid,kp->vout,0,(uint32_t)tipindex->nTime+27,kp->address,PoSperc);
         //fprintf(stderr,"i.%d %u vs %u\n",i,eligible2,eligible);
         if ( eligible > 0 )
         {
             besttime = m = 0;
-            if ( eligible == komodo_stake(1,bnTarget,nHeight,kp->txid,kp->vout,eligible,(uint32_t)tipindex->nTime+27,kp->address) )
+            if ( eligible == komodo_stake(1,bnTarget,nHeight,kp->txid,kp->vout,eligible,(uint32_t)tipindex->nTime+27,kp->address,PoSperc) )
             {
-                while ( eligible == komodo_stake(1,bnTarget,nHeight,kp->txid,kp->vout,eligible,(uint32_t)tipindex->nTime+27,kp->address) )
+                while ( eligible == komodo_stake(1,bnTarget,nHeight,kp->txid,kp->vout,eligible,(uint32_t)tipindex->nTime+27,kp->address,PoSperc) )
                 {
                     besttime = eligible;
                     eligible--;
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index 2c2d4e855..cb1d9987d 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -82,9 +82,8 @@ uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16,16};
 uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096,4096};
 uint32_t ASSETCHAINS_ALGO = _ASSETCHAINS_EQUIHASH;
 // min diff returned from GetNextWorkRequired needs to be added here for each algo, so they can work with ac_staked.
-// VerusHash v1 and 1.1 use a custom tuned number or PoW blocks all are 1s. 
-uint32_t ASSETCHAINS_MINDIFF[] = {537857807,486648905,486648905};
-
+uint32_t ASSETCHAINS_MINDIFF[] = {537857807,503381775,503381775};
+                                            // ^ wrong!
 // Verus proof of stake controls
 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS
 int32_t VERUS_BLOCK_POSUNITS = 1024;    // one block is 1000 units
diff --git a/src/pow.cpp b/src/pow.cpp
index b69c4fce6..0e4b706a8 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -134,6 +134,8 @@ unsigned int lwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const
         bnLimit = UintToArith256(params.powAlternate);
 
     unsigned int nProofOfWorkLimit = bnLimit.GetCompact();
+    
+    printf("PoWLimit: %u\n", nProofOfWorkLimit);
 
     // Find the first block in the averaging interval as we total the linearly weighted average
     const CBlockIndex* pindexFirst = pindexLast;

From 7167793dbf4b776f6d4d8ae6daf7a6b150747c65 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 02:50:53 +0800
Subject: [PATCH 12/18] new version

---
 src/chainparams.cpp    |  2 +-
 src/komodo_bitcoind.h  | 54 +++++++++++++++++++++++-------------------
 src/komodo_globals.h   |  5 ++--
 src/komodo_utils.h     |  2 +-
 src/main.cpp           |  3 ++-
 src/miner.cpp          |  8 +++----
 src/pow.cpp            |  4 ++--
 src/rpc/blockchain.cpp |  2 +-
 src/rpc/mining.cpp     |  3 +--
 src/rpc/misc.cpp       |  4 ++--
 10 files changed, 47 insertions(+), 40 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 03a518d4b..45824f22b 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -282,7 +282,7 @@ void *chainparams_commandline(void *ptr)
             // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
             mainParams.consensus.nLwmaAjustedWeight = 1350;
             mainParams.consensus.nPowAveragingWindow = 45;
-            mainParams.consensus.powAlternate = uint256S("000000ff0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
+            mainParams.consensus.powAlternate = uint256S("0000000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
         }
 
         if (ASSETCHAINS_LWMAPOS != 0)
diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index d2c3b3b30..b2b8011b5 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1255,7 +1255,7 @@ uint32_t komodo_stakehash(uint256 *hashp,char *address,uint8_t *hashbuf,uint256
 
 arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc)
 {
-    int32_t oldflag = 0,dispflag = 1;
+    int32_t oldflag = 0,dispflag = 0;
     CBlockIndex *pindex; arith_uint256 easydiff,bnTarget,hashval,sum,ave; bool fNegative,fOverflow; int32_t i,n,m,ht,percPoS,diff,val;
     *percPoSp = percPoS = 0;
     
@@ -1367,7 +1367,7 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
 
 uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeight,uint256 txid,int32_t vout,uint32_t blocktime,uint32_t prevtime,char *destaddr,int32_t PoSperc)
 {
-    bool fNegative,fOverflow; uint8_t hashbuf[256]; char address[64]; bits256 addrhash; arith_uint256 hashval,mindiff,ratio,coinage256; uint256 hash,pasthash; int32_t diff=0,segid,minage,i,iter=0; uint32_t txtime,segid32,winner = 0 ; uint64_t value,coinage;
+    bool fNegative,fOverflow; uint8_t hashbuf[256]; char address[64]; bits256 addrhash; arith_uint256 hashval,mindiff,ratio,coinage256; uint256 hash,pasthash; int32_t segid,minage,i,iter=0; int64_t diff=0; uint32_t txtime,segid32,winner = 0 ; uint64_t value,coinage;
     txtime = komodo_txtime2(&value,txid,vout,address);
     if ( validateflag == 0 )
     {
@@ -1398,6 +1398,23 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
         if ( blocktime+iter+segid*2 < txtime+minage )
             continue;
         diff = (iter + blocktime - txtime - minage);
+        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
+        {
+            if ( PoSperc < ASSETCHAINS_STAKED )
+            {
+                // Under PoS % target and we need to increase diff.
+                //fprintf(stderr, "PoS too low diff.%i changed to.",diff);
+                diff = diff * ( (ASSETCHAINS_STAKED - PoSperc + 1) * (ASSETCHAINS_STAKED - PoSperc + 1) );
+                //fprintf(stderr, "%i \n",diff);
+            }
+            else if ( PoSperc > ASSETCHAINS_STAKED )
+            {
+                // Over PoS target need to lower diff.
+                //fprintf(stderr, "PoS too high diff.%i changed to.",diff);
+                diff = diff / ( (PoSperc - ASSETCHAINS_STAKED + 1) * (PoSperc - ASSETCHAINS_STAKED + 1) );
+                //fprintf(stderr, "%i \n",diff);
+            }
+        }
         if ( diff < 0 )
             diff = 60;
         else if ( diff > 3600*24*30 )
@@ -1408,19 +1425,8 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
         if ( iter > 0 )
             diff += segid*2;
         coinage = (value * diff);
-        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2 )
-        {
-            fprintf(stderr, "PoS % is: %i% vs. %i% \n", PoSperc, ASSETCHAINS_STAKED);
-            if ( PoSperc < ASSETCHAINS_STAKED )
-            {
-                // This means we are under PoS % required and we need some extra help getting an elegible utxo. 
-                // Likley there is some math required here to make it work properly. But getting the data here is no1 priority.
-                coinage = coinage * 1000;
-            }
-        }
-        // leave this here for now... 
-        if ( blocktime+iter+segid*2 > prevtime+480 )
-            coinage *= ((blocktime+iter+segid*2) - (prevtime+400));
+        if ( blocktime+iter+segid*2 > prevtime+128 )
+            coinage *= ((blocktime+iter+segid*2) - (prevtime+102));
         coinage256 = arith_uint256(coinage+1);
         hashval = ratio * (UintToArith256(hash) / coinage256);
         if ( hashval <= bnTarget )
@@ -1441,7 +1447,7 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh
             fprintf(stderr," vs ");
             for (i=31; i>=24; i--)
                 fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
-            fprintf(stderr," segid.%d iter.%d winner.%d coinage.%llu %d ht.%d t.%u v%d diff.%d\n",segid,iter,winner,(long long)coinage,(int32_t)(blocktime - txtime),nHeight,blocktime,(int32_t)value,(int32_t)diff);*/
+            fprintf(stderr," segid.%d iter.%d winner.%d coinage.%llu %d ht.%d t.%u v%d diff.%d\n",segid,iter,winner,(long long)coinage,(int32_t)(blocktime - txtime),nHeight,blocktime,(int32_t)value,(int32_t)diff); */
             break;
         }
     }
@@ -2048,7 +2054,8 @@ struct komodo_staking *komodo_addutxo(struct komodo_staking *array,int32_t *numk
     return(array);
 }
 
-arith_uint256 _komodo_eligible(struct komodo_staking *kp,arith_uint256 ratio,uint32_t blocktime,int32_t iter,int32_t minage,int32_t segid,int32_t nHeight,uint32_t prevtime)
+// WHY IS THIS HERE! It does this in komodo_stake! WTF!
+/*arith_uint256 _komodo_eligible(struct komodo_staking *kp,arith_uint256 ratio,uint32_t blocktime,int32_t iter,int32_t minage,int32_t segid,int32_t nHeight,uint32_t prevtime)
 {
     int32_t diff; uint64_t coinage; arith_uint256 coinage256,hashval;
     diff = (iter + blocktime - kp->txtime - minage);
@@ -2074,12 +2081,12 @@ uint32_t komodo_eligible(arith_uint256 bnTarget,arith_uint256 ratio,struct komod
     kp->hashval = UintToArith256(hash);
     segid = ((nHeight + kp->segid32) & 0x3f);
     hashval = _komodo_eligible(kp,ratio,blocktime,maxiters,minage,segid,nHeight,prevtime);
-    /*for (int i=31; i>=16; i--)
+    for (int i=31; i>=16; i--)
         fprintf(stderr,"%02x",((uint8_t *)&hashval)[i]);
     fprintf(stderr," vs ");
     for (int i=31; i>=16; i--)
         fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
-    fprintf(stderr," b.%u minage.%d segid.%d ht.%d prev.%u\n",blocktime,minage,segid,nHeight,prevtime);*/
+    fprintf(stderr," b.%u minage.%d segid.%d ht.%d prev.%u\n",blocktime,minage,segid,nHeight,prevtime);
     if ( hashval <= bnTarget )
     {
         for (iter=0; iter<maxiters; iter++)
@@ -2097,7 +2104,7 @@ uint32_t komodo_eligible(arith_uint256 bnTarget,arith_uint256 ratio,struct komod
         }
     } //else fprintf(stderr,"maxiters is not good enough\n");
     return(0);
-}
+}*/
 
 int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blocktimep,uint32_t *txtimep,uint256 *utxotxidp,int32_t *utxovoutp,uint64_t *utxovaluep,uint8_t *utxosig)
 {
@@ -2108,8 +2115,6 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
         return 0;
     
     bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
-    mindiff.SetCompact(STAKING_MIN_DIFF,&fNegative,&fOverflow);
-    ratio = (mindiff / bnTarget);
     assert(pwalletMain != NULL);
     *utxovaluep = 0;
     memset(utxotxidp,0,sizeof(*utxotxidp));
@@ -2193,8 +2198,9 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
             return(0);
         }
         kp = &array[i];
-        if ( (eligible2= komodo_eligible(bnTarget,ratio,kp,nHeight,*blocktimep,(uint32_t)tipindex->nTime+27,minage,hashbuf)) == 0 )
-            continue;
+        // WTF! was this here for! 
+        //if ( (eligible2= komodo_eligible(bnTarget,ratio,kp,nHeight,*blocktimep,(uint32_t)tipindex->nTime+27,minage,hashbuf)) == 0 )
+        //    continue;
         eligible = komodo_stake(0,bnTarget,nHeight,kp->txid,kp->vout,0,(uint32_t)tipindex->nTime+27,kp->address,PoSperc);
         //fprintf(stderr,"i.%d %u vs %u\n",i,eligible2,eligible);
         if ( eligible > 0 )
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index cb1d9987d..dd51d9c93 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -82,7 +82,7 @@ uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16,16};
 uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096,4096};
 uint32_t ASSETCHAINS_ALGO = _ASSETCHAINS_EQUIHASH;
 // min diff returned from GetNextWorkRequired needs to be added here for each algo, so they can work with ac_staked.
-uint32_t ASSETCHAINS_MINDIFF[] = {537857807,503381775,503381775};
+uint32_t ASSETCHAINS_MINDIFF[] = {537857807,504303375,487526159};
                                             // ^ wrong!
 // Verus proof of stake controls
 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS
@@ -95,7 +95,8 @@ int32_t ASSETCHAINS_SAPLING = -1;
 int32_t ASSETCHAINS_OVERWINTER = -1;
 
 uint64_t KOMODO_INTERESTSUM,KOMODO_WALLETBALANCE;
-uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_STAKED,ASSETCHAINS_SUPPLY = 10,MIN_RECV_SATS;
+int32_t ASSETCHAINS_STAKED;
+uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY = 10,MIN_RECV_SATS;
 
 uint32_t KOMODO_INITDONE;
 char KMDUSERPASS[8192+512+1],BTCUSERPASS[8192]; uint16_t KMD_PORT = 7771,BITCOIND_RPCPORT = 7771;
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 1fe4c012a..cb7275898 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1916,7 +1916,7 @@ void komodo_args(char *argv0)
                 extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_LWMAPOS),(void *)&ASSETCHAINS_LWMAPOS);
             }
 
-            val = ASSETCHAINS_COMMISSION | (((uint64_t)ASSETCHAINS_STAKED & 0xff) << 32) | (((uint64_t)ASSETCHAINS_CC & 0xffff) << 40) | ((ASSETCHAINS_PUBLIC != 0) << 7) | ((ASSETCHAINS_PRIVATE != 0) << 6) | ASSETCHAINS_TXPOW;
+            val = ASSETCHAINS_COMMISSION | (((int64_t)ASSETCHAINS_STAKED & 0xff) << 32) | (((uint64_t)ASSETCHAINS_CC & 0xffff) << 40) | ((ASSETCHAINS_PUBLIC != 0) << 7) | ((ASSETCHAINS_PRIVATE != 0) << 6) | ASSETCHAINS_TXPOW;
             extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(val),(void *)&val);
             if ( ASSETCHAINS_FOUNDERS != 0 )
             {
diff --git a/src/main.cpp b/src/main.cpp
index c1cdc3935..5aaf69bfb 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -2216,8 +2216,9 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex,bool checkPOW)
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS];
 extern uint32_t ASSETCHAINS_MAGIC;
-extern uint64_t ASSETCHAINS_STAKED,ASSETCHAINS_LINEAR,ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY;
+extern uint64_t ASSETCHAINS_LINEAR,ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY;
 extern uint8_t ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE;
+extern int32_t ASSETCHAINS_STAKED;
 
 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
 {
diff --git a/src/miner.cpp b/src/miner.cpp
index 66f1a263f..4ce3bc37b 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -132,8 +132,8 @@ void UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams,
 #include "komodo_defs.h"
 
 extern CCriticalSection cs_metrics;
-extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAIN_INIT,KOMODO_INITDONE,KOMODO_ON_DEMAND,KOMODO_INITDONE,KOMODO_PASSPORT_INITDONE,STAKING_MIN_DIFF;
-extern uint64_t ASSETCHAINS_COMMISSION, ASSETCHAINS_STAKED;
+extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAIN_INIT,KOMODO_INITDONE,KOMODO_ON_DEMAND,KOMODO_INITDONE,KOMODO_PASSPORT_INITDONE,STAKING_MIN_DIFF,ASSETCHAINS_STAKED;
+extern uint64_t ASSETCHAINS_COMMISSION;
 extern bool VERUS_MINTBLOCKS;
 extern uint64_t ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_NONCEMASK[];
 extern const char *ASSETCHAINS_ALGORITHMS[];
@@ -558,9 +558,9 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                 nFees += txfees;
                 pblock->nTime = blocktime;
                 //printf("staking PoS ht.%d t%u lag.%u\n",(int32_t)chainActive.LastTip()->GetHeight()+1,blocktime,(uint32_t)(GetAdjustedTime() - (blocktime-13)));
-            } else return(0); //fprintf(stderr,"no utxos eligible for staking\n");
-                 
+            } else return(0); //fprintf(stderr,"no utxos eligible for staking\n");         
         }
+        
         // Create coinbase tx
         CMutableTransaction txNew = CreateNewContextualCMutableTransaction(consensusParams, nHeight);
         txNew.vin.resize(1);
diff --git a/src/pow.cpp b/src/pow.cpp
index 0e4b706a8..3e7afa720 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -37,9 +37,9 @@
 #endif // ENABLE_RUST
 uint32_t komodo_chainactive_timestamp();
 
-extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_STAKED;
+extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH;
 extern char ASSETCHAINS_SYMBOL[65];
-extern int32_t ASSETCHAINS_LWMAPOS,VERUS_BLOCK_POSUNITS, VERUS_CONSECUTIVE_POS_THRESHOLD, VERUS_NOPOS_THRESHHOLD;
+extern int32_t ASSETCHAINS_LWMAPOS,VERUS_BLOCK_POSUNITS, VERUS_CONSECUTIVE_POS_THRESHOLD, VERUS_NOPOS_THRESHHOLD,ASSETCHAINS_STAKED;
 unsigned int lwmaGetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params);
 unsigned int lwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params);
 
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index bb46f47fb..147b94b61 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -622,7 +622,7 @@ UniValue getblockhash(const UniValue& params, bool fHelp)
     return pblockindex->GetBlockHash().GetHex();
 }
 
-extern uint64_t ASSETCHAINS_STAKED;
+extern int32_t ASSETCHAINS_STAKED;
 
 UniValue getlastsegidstakes(const UniValue& params, bool fHelp)
 {
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 3843529ac..44b0162ad 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -48,8 +48,7 @@
 
 using namespace std;
 
-extern int32_t ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_LWMAPOS;
-extern uint64_t ASSETCHAINS_STAKED;
+extern int32_t ASSETCHAINS_ALGO, ASSETCHAINS_EQUIHASH, ASSETCHAINS_LWMAPOS,ASSETCHAINS_STAKED;
 extern int32_t KOMODO_MININGTHREADS;
 extern bool VERUS_MINTBLOCKS;
 arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc);
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index a174fedf7..4fa5c061c 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -80,8 +80,8 @@ int8_t StakedNotaryID(std::string &notaryname, char *Raddress);
 extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
 extern uint32_t ASSETCHAINS_CC;
 extern uint32_t ASSETCHAINS_MAGIC;
-extern uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_STAKED,ASSETCHAINS_SUPPLY,ASSETCHAINS_LASTERA;
-extern int32_t ASSETCHAINS_LWMAPOS,ASSETCHAINS_SAPLING;
+extern uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY,ASSETCHAINS_LASTERA;
+extern int32_t ASSETCHAINS_LWMAPOS,ASSETCHAINS_SAPLING,ASSETCHAINS_STAKED;
 extern uint64_t ASSETCHAINS_ENDSUBSIDY[],ASSETCHAINS_REWARD[],ASSETCHAINS_HALVING[],ASSETCHAINS_DECAY[];
 extern std::string NOTARY_PUBKEY,NOTARY_ADDRESS; extern uint8_t NOTARY_PUBKEY33[];
 

From bbf756704f1bccfdeeae20643a034e53b5e7bfbf Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 13:54:09 +0800
Subject: [PATCH 13/18] clean up

---
 src/komodo_bitcoind.h | 57 +------------------------------------------
 1 file changed, 1 insertion(+), 56 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index b2b8011b5..ce7c0259a 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -2054,63 +2054,11 @@ struct komodo_staking *komodo_addutxo(struct komodo_staking *array,int32_t *numk
     return(array);
 }
 
-// WHY IS THIS HERE! It does this in komodo_stake! WTF!
-/*arith_uint256 _komodo_eligible(struct komodo_staking *kp,arith_uint256 ratio,uint32_t blocktime,int32_t iter,int32_t minage,int32_t segid,int32_t nHeight,uint32_t prevtime)
-{
-    int32_t diff; uint64_t coinage; arith_uint256 coinage256,hashval;
-    diff = (iter + blocktime - kp->txtime - minage);
-    if ( diff < 0 )
-        diff = 60;
-    else if ( diff > 3600*24*30 )
-        diff = 3600*24*30;
-    if ( iter > 0 )
-        diff += segid*2;
-    coinage = ((uint64_t)kp->nValue * diff);
-    if ( blocktime+iter+segid*2 > prevtime+480 )
-        coinage *= ((blocktime+iter+segid*2) - (prevtime+400));
-    coinage256 = arith_uint256(coinage+1);
-    hashval = ratio * (kp->hashval / coinage256);
-    return(hashval);
-}
-
-uint32_t komodo_eligible(arith_uint256 bnTarget,arith_uint256 ratio,struct komodo_staking *kp,int32_t nHeight,uint32_t blocktime,uint32_t prevtime,int32_t minage,uint8_t *hashbuf)
-{
-    int32_t maxiters = 600; uint256 hash;
-    int32_t segid,iter,diff; uint64_t coinage; arith_uint256 hashval,coinage256;
-    komodo_stakehash(&hash,kp->address,hashbuf,kp->txid,kp->vout);
-    kp->hashval = UintToArith256(hash);
-    segid = ((nHeight + kp->segid32) & 0x3f);
-    hashval = _komodo_eligible(kp,ratio,blocktime,maxiters,minage,segid,nHeight,prevtime);
-    for (int i=31; i>=16; i--)
-        fprintf(stderr,"%02x",((uint8_t *)&hashval)[i]);
-    fprintf(stderr," vs ");
-    for (int i=31; i>=16; i--)
-        fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[i]);
-    fprintf(stderr," b.%u minage.%d segid.%d ht.%d prev.%u\n",blocktime,minage,segid,nHeight,prevtime);
-    if ( hashval <= bnTarget )
-    {
-        for (iter=0; iter<maxiters; iter++)
-        {
-            if ( blocktime+iter+segid*2 < kp->txtime+minage )
-                continue;
-            hashval = _komodo_eligible(kp,ratio,blocktime,iter,minage,segid,nHeight,prevtime);
-            if ( hashval <= bnTarget )
-            {
-                //fprintf(stderr,"winner %.8f blocktime.%u iter.%d segid.%d\n",(double)kp->nValue/COIN,blocktime,iter,segid);
-                blocktime += iter;
-                blocktime += segid * 2;
-                return(blocktime);
-            }
-        }
-    } //else fprintf(stderr,"maxiters is not good enough\n");
-    return(0);
-}*/
-
 int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blocktimep,uint32_t *txtimep,uint256 *utxotxidp,int32_t *utxovoutp,uint64_t *utxovaluep,uint8_t *utxosig)
 {
     static struct komodo_staking *array; static int32_t numkp,maxkp; static uint32_t lasttime;
     int32_t PoSperc;
-    set<CBitcoinAddress> setAddress; struct komodo_staking *kp; int32_t winners,segid,minage,nHeight,counter=0,i,m,siglen=0,nMinDepth = 1,nMaxDepth = 99999999; vector<COutput> vecOutputs; uint32_t block_from_future_rejecttime,besttime,eligible,eligible2,earliest = 0; CScript best_scriptPubKey; arith_uint256 mindiff,ratio,bnTarget,tmpTarget; CBlockIndex *tipindex,*pindex; CTxDestination address; bool fNegative,fOverflow; uint8_t hashbuf[256]; CTransaction tx; uint256 hashBlock;
+    set<CBitcoinAddress> setAddress; struct komodo_staking *kp; int32_t winners,segid,minage,nHeight,counter=0,i,m,siglen=0,nMinDepth = 1,nMaxDepth = 99999999; vector<COutput> vecOutputs; uint32_t block_from_future_rejecttime,besttime,eligible,earliest = 0; CScript best_scriptPubKey; arith_uint256 mindiff,ratio,bnTarget,tmpTarget; CBlockIndex *tipindex,*pindex; CTxDestination address; bool fNegative,fOverflow; uint8_t hashbuf[256]; CTransaction tx; uint256 hashBlock;
     if (!EnsureWalletIsAvailable(0))
         return 0;
     
@@ -2198,9 +2146,6 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
             return(0);
         }
         kp = &array[i];
-        // WTF! was this here for! 
-        //if ( (eligible2= komodo_eligible(bnTarget,ratio,kp,nHeight,*blocktimep,(uint32_t)tipindex->nTime+27,minage,hashbuf)) == 0 )
-        //    continue;
         eligible = komodo_stake(0,bnTarget,nHeight,kp->txid,kp->vout,0,(uint32_t)tipindex->nTime+27,kp->address,PoSperc);
         //fprintf(stderr,"i.%d %u vs %u\n",i,eligible2,eligible);
         if ( eligible > 0 )

From eb164bc03c99e78045391ceb3c7cf75bd13e9a02 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 13:57:04 +0800
Subject: [PATCH 14/18] ok

---
 src/komodo_bitcoind.h | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index a7afe440b..86deb54be 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1867,14 +1867,8 @@ int32_t komodo_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height)
                     return(-1);
                 } else
                 {
-<<<<<<< HEAD
-                    // I think this means the block is valid PoW. We need to set the pindex->segid here.
-                    failed = 0;
-                    CBlockIndex *pindex;
-=======
                     failed = 0; 
                     CBlockIndex *pindex; 
->>>>>>> new_staker
                     BlockMap::const_iterator it = mapBlockIndex.find(pblock->GetHash());
                     pindex = it != mapBlockIndex.end() ? it->second : NULL;
                     if ( pindex != 0 && pindex->segid == -2 ) {

From e460f1aa57d1964965a7b0da629a268e5a4a2df5 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 14:15:43 +0800
Subject: [PATCH 15/18] print

---
 src/pow.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pow.cpp b/src/pow.cpp
index 3e7afa720..5c8baeada 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -135,7 +135,7 @@ unsigned int lwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const
 
     unsigned int nProofOfWorkLimit = bnLimit.GetCompact();
     
-    printf("PoWLimit: %u\n", nProofOfWorkLimit);
+    //printf("PoWLimit: %u\n", nProofOfWorkLimit);
 
     // Find the first block in the averaging interval as we total the linearly weighted average
     const CBlockIndex* pindexFirst = pindexLast;

From a0427ebf79c35e1821631a3102c9427e5af44c06 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 15:01:08 +0800
Subject: [PATCH 16/18] ac_founders_reward fix

---
 src/komodo_bitcoind.h |  2 +-
 src/komodo_utils.h    | 10 +++++-----
 src/main.cpp          |  2 +-
 src/miner.cpp         |  4 ++--
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 86deb54be..ddbadd527 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1739,7 +1739,7 @@ bool verusCheckPOSBlock(int32_t slowflag, CBlock *pblock, int32_t height)
 int64_t komodo_checkcommission(CBlock *pblock,int32_t height)
 {
     int64_t checktoshis=0; uint8_t *script,scripthex[8192]; int32_t scriptlen,matched = 0;
-    if ( ASSETCHAINS_COMMISSION != 0 )
+    if ( ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 )
     {
         checktoshis = komodo_commission(pblock,height);
         if ( checktoshis >= 10000 && pblock->vtx[0].vout.size() < 2 )
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 922179c2d..b66df3833 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1779,7 +1779,7 @@ void komodo_args(char *argv0)
         MAX_BLOCK_SIGOPS = 60000;
         ASSETCHAINS_TXPOW = GetArg("-ac_txpow",0) & 3;
         ASSETCHAINS_FOUNDERS = GetArg("-ac_founders",0);// & 1;
-				ASSETCHAINS_FOUNDERS_REWARD = GetArg("-ac_founders_reward",0);
+		ASSETCHAINS_FOUNDERS_REWARD = GetArg("-ac_founders_reward",0);
         ASSETCHAINS_SUPPLY = GetArg("-ac_supply",10);
         ASSETCHAINS_COMMISSION = GetArg("-ac_perc",0);
         ASSETCHAINS_OVERRIDE_PUBKEY = GetArg("-ac_pubkey","");
@@ -1846,10 +1846,10 @@ void komodo_args(char *argv0)
                     ASSETCHAINS_COMMISSION = 53846154; // maps to 35%
                     printf("ASSETCHAINS_COMMISSION defaulted to 35%% when founders reward active\n");
                 }
-								else
-								{
-										printf("ASSETCHAINS_FOUNDERS_REWARD set to %ld\n", ASSETCHAINS_FOUNDERS_REWARD);
-								}
+				else
+				{
+					printf("ASSETCHAINS_FOUNDERS_REWARD set to %ld\n", ASSETCHAINS_FOUNDERS_REWARD);
+				}
                 /*else if ( ASSETCHAINS_SELFIMPORT.size() == 0 )
                 {
                     //ASSETCHAINS_OVERRIDE_PUBKEY.clear();
diff --git a/src/main.cpp b/src/main.cpp
index 5aaf69bfb..2894b8263 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3474,7 +3474,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
     LogPrint("bench", "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs]\n", (unsigned)block.vtx.size(), 0.001 * (nTime1 - nTimeStart), 0.001 * (nTime1 - nTimeStart) / block.vtx.size(), nInputs <= 1 ? 0 : 0.001 * (nTime1 - nTimeStart) / (nInputs-1), nTimeConnect * 0.000001);
 
     CAmount blockReward = nFees + GetBlockSubsidy(pindex->GetHeight(), chainparams.GetConsensus()) + sum;
-    if ( ASSETCHAINS_COMMISSION != 0 ) //ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 &&
+    if ( ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 ) //ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 &&
     {
         uint64_t checktoshis;
         if ( (checktoshis= komodo_commission((CBlock *)&block,(int32_t)pindex->GetHeight())) != 0 )
diff --git a/src/miner.cpp b/src/miner.cpp
index 4ce3bc37b..f18b195da 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -133,7 +133,7 @@ void UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams,
 
 extern CCriticalSection cs_metrics;
 extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAIN_INIT,KOMODO_INITDONE,KOMODO_ON_DEMAND,KOMODO_INITDONE,KOMODO_PASSPORT_INITDONE,STAKING_MIN_DIFF,ASSETCHAINS_STAKED;
-extern uint64_t ASSETCHAINS_COMMISSION;
+extern uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_FOUNDERS_REWARD;
 extern bool VERUS_MINTBLOCKS;
 extern uint64_t ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_NONCEMASK[];
 extern const char *ASSETCHAINS_ALGORITHMS[];
@@ -587,7 +587,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
             txNew.vout[1].nValue = 0;
             txNew.vout[1].scriptPubKey = MarmaraCoinbaseOpret('C',nHeight,pk);
         }
-        else if ( nHeight > 1 && ASSETCHAINS_SYMBOL[0] != 0 && (ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1) && ASSETCHAINS_COMMISSION != 0 && (commission= komodo_commission((CBlock*)&pblocktemplate->block,(int32_t)nHeight)) != 0 )
+        else if ( nHeight > 1 && ASSETCHAINS_SYMBOL[0] != 0 && (ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1) && (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0)  && (commission= komodo_commission((CBlock*)&pblocktemplate->block,(int32_t)nHeight)) != 0 )
         {
             int32_t i; uint8_t *ptr;
             txNew.vout.resize(2);

From de91bdf571a7adada58a5b98e4276883ff3ab4b7 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 16:13:54 +0800
Subject: [PATCH 17/18] mutually exclusive founders reward and comission +
 magic value.

---
 src/komodo_utils.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index b66df3833..b0642b53d 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1787,6 +1787,11 @@ void komodo_args(char *argv0)
         ASSETCHAINS_BEAMPORT = GetArg("-ac_beam",0);
         ASSETCHAINS_CODAPORT = GetArg("-ac_coda",0);
         ASSETCHAINS_MARMARA = GetArg("-ac_marmara",0);
+        if ( ASSETCHAINS_COMMISSION != 0 && ASSETCHAINS_FOUNDERS_REWARD != 0 )
+        {
+            fprintf(stderr,"cannot use founders reward and commission on the same chain.\n");
+            exit(0);
+        }
         if ( ASSETCHAINS_BEAMPORT != 0 && ASSETCHAINS_CODAPORT != 0 )
         {
             fprintf(stderr,"can only have one of -ac_beam or -ac_coda\n");

From 0c2aa0a6493203f6a89de5bb4d7388e33c2dea97 Mon Sep 17 00:00:00 2001
From: blackjok3r <blackjok3r@gmail.com>
Date: Wed, 23 Jan 2019 16:20:31 +0800
Subject: [PATCH 18/18] oops

---
 src/komodo_utils.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index b0642b53d..5d05abd1e 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1880,7 +1880,7 @@ void komodo_args(char *argv0)
             fprintf(stderr,"-ac_script and -ac_marmara are mutually exclusive\n");
             exit(0);
         }
-        if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 || ASSETCHAINS_SELFIMPORT.size() > 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_TIMELOCKGTE != _ASSETCHAINS_TIMELOCKOFF|| ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH || ASSETCHAINS_LWMAPOS != 0 || ASSETCHAINS_LASTERA > 0 || ASSETCHAINS_BEAMPORT != 0 || ASSETCHAINS_CODAPORT != 0 || ASSETCHAINS_MARMARA != 0 )
+        if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 || ASSETCHAINS_SELFIMPORT.size() > 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_TIMELOCKGTE != _ASSETCHAINS_TIMELOCKOFF|| ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH || ASSETCHAINS_LWMAPOS != 0 || ASSETCHAINS_LASTERA > 0 || ASSETCHAINS_BEAMPORT != 0 || ASSETCHAINS_CODAPORT != 0 || ASSETCHAINS_MARMARA != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 )
         {
             fprintf(stderr,"perc %.4f%% ac_pub=[%02x%02x%02x...] acsize.%d\n",dstr(ASSETCHAINS_COMMISSION)*100,ASSETCHAINS_OVERRIDE_PUBKEY33[0],ASSETCHAINS_OVERRIDE_PUBKEY33[1],ASSETCHAINS_OVERRIDE_PUBKEY33[2],(int32_t)ASSETCHAINS_SCRIPTPUB.size());
             extraptr = extrabuf;
@@ -1928,12 +1928,17 @@ void komodo_args(char *argv0)
 
             val = ASSETCHAINS_COMMISSION | (((int64_t)ASSETCHAINS_STAKED & 0xff) << 32) | (((uint64_t)ASSETCHAINS_CC & 0xffff) << 40) | ((ASSETCHAINS_PUBLIC != 0) << 7) | ((ASSETCHAINS_PRIVATE != 0) << 6) | ASSETCHAINS_TXPOW;
             extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(val),(void *)&val);
+            
             if ( ASSETCHAINS_FOUNDERS != 0 )
             {
                 uint8_t tmp = 1;
                 extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(tmp),(void *)&tmp);
                 if ( ASSETCHAINS_FOUNDERS > 1 )
                     extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_FOUNDERS),(void *)&ASSETCHAINS_FOUNDERS);
+                if ( ASSETCHAINS_FOUNDERS_REWARD != 0 )
+                {
+                    extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_FOUNDERS_REWARD),(void *)&ASSETCHAINS_FOUNDERS_REWARD);
+                }
             }
             if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
             {