Enable -ac_algo=verushash11

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_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV2) 
-        if (ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH)
         {
             // 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

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())

src/komodo_bitcoind.h

@@ -1296,7 +1296,7 @@ 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));
@@ -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 )

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"};
+uint32_t ASSETCHAINS_VERUSHASHV2 = 2;
-uint64_t ASSETCHAINS_NONCEMASK[] = {0xffff,0xfffffff};
+const char *ASSETCHAINS_ALGORITHMS[] = {"equihash", "verushash", "verushash11"};
-uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16};
+uint64_t ASSETCHAINS_NONCEMASK[] = {0xffff,0xfffffff,0xfffffff};
-uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,4096};
+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};
+// VerusHash v1 and 1.1 use a custom tuned number or PoW blocks all are 1s. 
-                                   // nBits.486704888 -- too low? 
+uint32_t ASSETCHAINS_MINDIFF[] = {537857807,486648905,486648905};
-
 
 // Verus proof of stake controls
 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS

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;

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);
     }

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 )
                     {

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
+    if (hashPrevBlock.IsNull())
-    return SerializeVerusHashV2(*this);
+        // 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

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
     {

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;