From 7102d50a477eccca06ea2166a6ae8a9e87cd76e3 Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 22 Apr 2023 15:54:13 -0700 Subject: [PATCH 01/36] Try to prevent #266 We seem to have a bug that we don't find a peer when looking for a peer in peers.dat . Instead of doing an assertion and crashing the node, just keep iterating in the loop. The code which computes nId may have an off-by-one error, such that it looks up an incorrect bucket position and doesn't find a valid nId. --- src/addrman.cpp | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/addrman.cpp b/src/addrman.cpp index 60f27347a..535151c2a 100644 --- a/src/addrman.cpp +++ b/src/addrman.cpp @@ -499,7 +499,12 @@ CAddrInfo CAddrMan::Select_(bool newOnly) MilliSleep(kRetrySleepInterval); } int nId = vvTried[nKBucket][nKBucketPos]; - assert(mapInfo.count(nId) == 1); + // assert(mapInfo.count(nId) == 1); + if(mapInfo.count(nId) != 1) { + fprintf(stderr,"%s: Could not find tried node with nId=%d=vvTried[%d][%d], mapInfo.count(%d)=%d\n", __func__, nId, nKBucket, nKBuckedPos, nId, mapInfo.count(nId) ); + continue; + } + CAddrInfo& info = mapInfo[nId]; if (info.IsReachableNetwork()) { //deprioritize unreachable networks @@ -534,7 +539,12 @@ CAddrInfo CAddrMan::Select_(bool newOnly) MilliSleep(kRetrySleepInterval); } int nId = vvNew[nUBucket][nUBucketPos]; - assert(mapInfo.count(nId) == 1); + + if(mapInfo.count(nId) != 1) { + fprintf(stderr,"%s: Could not find new node with nId=%d=vvNew[%d][%d], mapInfo.count(%d)=%d\n", __func__, nId, nUBucket, nUBuckedPos, nId, mapInfo.count(nId) ); + continue; + } + // assert(mapInfo.count(nId) == 1); CAddrInfo& info = mapInfo[nId]; if (info.IsReachableNetwork()) { //deprioritize unreachable networks From fbda7b8dec0d69c9807ecd60643b8e87fd79f7a7 Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 22 Apr 2023 19:28:24 -0400 Subject: [PATCH 02/36] Fix compile issues --- src/addrman.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/addrman.cpp b/src/addrman.cpp index 535151c2a..15ced2f61 100644 --- a/src/addrman.cpp +++ b/src/addrman.cpp @@ -501,7 +501,7 @@ CAddrInfo CAddrMan::Select_(bool newOnly) int nId = vvTried[nKBucket][nKBucketPos]; // assert(mapInfo.count(nId) == 1); if(mapInfo.count(nId) != 1) { - fprintf(stderr,"%s: Could not find tried node with nId=%d=vvTried[%d][%d], mapInfo.count(%d)=%d\n", __func__, nId, nKBucket, nKBuckedPos, nId, mapInfo.count(nId) ); + fprintf(stderr,"%s: Could not find tried node with nId=%d=vvTried[%d][%d], mapInfo.count(%d)=%lu\n", __func__, nId, nKBucket, nKBucketPos, nId, mapInfo.count(nId) ); continue; } @@ -541,7 +541,7 @@ CAddrInfo CAddrMan::Select_(bool newOnly) int nId = vvNew[nUBucket][nUBucketPos]; if(mapInfo.count(nId) != 1) { - fprintf(stderr,"%s: Could not find new node with nId=%d=vvNew[%d][%d], mapInfo.count(%d)=%d\n", __func__, nId, nUBucket, nUBuckedPos, nId, mapInfo.count(nId) ); + fprintf(stderr,"%s: Could not find new node with nId=%d=vvNew[%d][%d], mapInfo.count(%d)=%lu\n", __func__, nId, nUBucket, nUBucketPos, nId, mapInfo.count(nId) ); continue; } // assert(mapInfo.count(nId) == 1); From d840a0ec62dd068b84be8fe197e764ae197b2e65 Mon Sep 17 00:00:00 2001 From: Duke Date: Sun, 23 Apr 2023 06:56:19 -0700 Subject: [PATCH 03/36] Only log nbits in ContextualCheckBlockHeader if -debug --- src/main.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main.cpp b/src/main.cpp index 20ea1112f..6ac591353 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -5114,7 +5114,9 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta // changing at run-time, from Consensus::Params being a const struct unsigned int nNextWork = GetNextWorkRequired(pindexPrev, &block, consensusParams); - LogPrintf("%s: nbits ,%d,%lu,%lu,%d\n",__func__, nHeight, nNextWork, block.nBits, nNextWork - block.nBits ); + if (fDebug) { + LogPrintf("%s: nbits ,%d,%lu,%lu,%d\n",__func__, nHeight, nNextWork, block.nBits, nNextWork - block.nBits ); + } if (block.nBits != nNextWork) { // Enforce correct nbits at DAA fork height, before that, ignore if (nHeight > daaForkHeight) { From 519743f704769ec2013c87324e3b943fc25a0f32 Mon Sep 17 00:00:00 2001 From: Duke Date: Sun, 23 Apr 2023 07:03:05 -0700 Subject: [PATCH 04/36] Only log to stderr in CalculateNextWorkRequired and GetNextWorkRequired if -debug --- src/pow.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/pow.cpp b/src/pow.cpp index 260785860..9ac8ef80e 100644 --- a/src/pow.cpp +++ b/src/pow.cpp @@ -503,8 +503,9 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead nbits = bnTarget.GetCompact(); nbits = (nbits & 0xfffffffc) | zawyflag; } - //if(fDebug) + if(fDebug) { fprintf(stderr,"%s: nbits=%d\n", __func__, nbits); + } return(nbits); } @@ -537,11 +538,15 @@ unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg, if ( ASSETCHAINS_ADAPTIVEPOW <= 0 ) { if (nActualTimespan < params.MinActualTimespan()) { - fprintf(stderr,"%s: Adjusting nActualTimespan up to min value %li\n", __func__, params.MinActualTimespan() ); + if(fDebug) { + fprintf(stderr,"%s: Adjusting nActualTimespan up to min value %li\n", __func__, params.MinActualTimespan() ); + } nActualTimespan = params.MinActualTimespan(); } if (nActualTimespan > params.MaxActualTimespan()) { - fprintf(stderr,"%s: Adjusting nActualTimespan down to max value %li\n", __func__, params.MaxActualTimespan() ); + if(fDebug) { + fprintf(stderr,"%s: Adjusting nActualTimespan down to max value %li\n", __func__, params.MaxActualTimespan() ); + } nActualTimespan = params.MaxActualTimespan(); } } From 04c28e3eef00427751d3cd5aecd05858910ba1c8 Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 20 May 2023 06:12:40 -0700 Subject: [PATCH 05/36] Disable run-time asserts in addrman Run-time asserts are a horrible anti-pattern littered across code inherited from BTC. One could maybe argue they are the right thing to do in some situations but not when managing the peer database. Crashing our full node and potentially corrupting our wallet or block index is INSANE in the case of some inconsistencies in peers.dat . --- src/addrman.cpp | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/src/addrman.cpp b/src/addrman.cpp index 15ced2f61..a832ffc4c 100644 --- a/src/addrman.cpp +++ b/src/addrman.cpp @@ -143,15 +143,17 @@ void CAddrMan::SwapRandom(unsigned int nRndPos1, unsigned int nRndPos2) if (nRndPos1 == nRndPos2) return; - assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size()); + // assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size()); int nId1 = vRandom[nRndPos1]; int nId2 = vRandom[nRndPos2]; const auto it_1{mapInfo.find(nId1)}; const auto it_2{mapInfo.find(nId2)}; - assert(it_1 != mapInfo.end()); - assert(it_2 != mapInfo.end()); + + if( (it_1 == mapInfo.end()) || (it_2 == mapInfo.end())) { + return; + } it_1->second.nRandomPos = nRndPos2; it_2->second.nRandomPos = nRndPos1; @@ -167,8 +169,8 @@ void CAddrMan::Delete(int nId) const auto it{mapInfo.find(nId)}; if (it != mapInfo.end()) { CAddrInfo& info = (*it).second; - assert(!info.fInTried); - assert(info.nRefCount == 0); + // assert(!info.fInTried); + // assert(info.nRefCount == 0); SwapRandom(info.nRandomPos, vRandom.size() - 1); vRandom.pop_back(); @@ -189,7 +191,10 @@ void CAddrMan::ClearNew(int nUBucket, int nUBucketPos) const auto it{mapInfo.find(nIdDelete)}; if (it != mapInfo.end()) { CAddrInfo& infoDelete = (*it).second; - assert(infoDelete.nRefCount > 0); + // assert(infoDelete.nRefCount > 0); + if (infoDelete.nRefCount == 0) { + return; + } infoDelete.nRefCount--; vvNew[nUBucket][nUBucketPos] = -1; if (infoDelete.nRefCount == 0) { @@ -217,7 +222,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId) } nNew--; - assert(info.nRefCount == 0); + //assert(info.nRefCount == 0); // which tried bucket to move the entry to int nKBucket = info.GetTriedBucket(nKey, m_asmap); @@ -227,7 +232,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId) if (vvTried[nKBucket][nKBucketPos] != -1) { // find an item to evict int nIdEvict = vvTried[nKBucket][nKBucketPos]; - assert(mapInfo.count(nIdEvict) == 1); + //assert(mapInfo.count(nIdEvict) == 1); CAddrInfo& infoOld = mapInfo[nIdEvict]; // Remove the to-be-evicted item from the tried set. @@ -239,14 +244,14 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId) int nUBucket = infoOld.GetNewBucket(nKey, m_asmap); int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket); ClearNew(nUBucket, nUBucketPos); - assert(vvNew[nUBucket][nUBucketPos] == -1); + //assert(vvNew[nUBucket][nUBucketPos] == -1); // Enter it into the new set again. infoOld.nRefCount = 1; vvNew[nUBucket][nUBucketPos] = nIdEvict; nNew++; } - assert(vvTried[nKBucket][nKBucketPos] == -1); + //assert(vvTried[nKBucket][nKBucketPos] == -1); vvTried[nKBucket][nKBucketPos] = nId; nTried++; @@ -665,7 +670,7 @@ void CAddrMan::GetAddr_(std::vector& vAddr, bool wants_addrv2) if (vAddr.size() >= nNodes) break; - assert(mapInfo.count(vRandom[n]) == 1); + // assert(mapInfo.count(vRandom[n]) == 1); const CAddrInfo& ai = mapInfo[vRandom[n]]; if (!ai.IsTerrible()) { From fc921eba57cdd5b98ad2122c81b60b4b0a2c95db Mon Sep 17 00:00:00 2001 From: Duke Date: Fri, 9 Jun 2023 00:00:42 -0400 Subject: [PATCH 06/36] Remove dead code --- src/miner.cpp | 60 +-------------------------------------------------- 1 file changed, 1 insertion(+), 59 deletions(-) diff --git a/src/miner.cpp b/src/miner.cpp index 4e5e01216..ee85a52eb 100644 --- a/src/miner.cpp +++ b/src/miner.cpp @@ -628,8 +628,6 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32 else txNew.nLockTime = std::max((int64_t)(pindexPrev->nTime+1), GetTime()); - if ( SMART_CHAIN_SYMBOL[0] == 0 && IS_HUSH_NOTARY != 0 && My_notaryid >= 0 ) - txNew.vout[0].nValue += 5000; pblock->vtx[0] = txNew; if ( nHeight > 1 && SMART_CHAIN_SYMBOL[0] != 0 && (ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1) && (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0) && (commission= the_commission((CBlock*)&pblocktemplate->block,(int32_t)nHeight)) != 0 ) @@ -1442,8 +1440,6 @@ void static BitcoinMiner() if ( hush_baseid(SMART_CHAIN_SYMBOL) < 0 ) break; } - if ( SMART_CHAIN_SYMBOL[0] == 0 ) - hush_chosennotary(¬aryid,chainActive.LastTip()->GetHeight(),NOTARY_PUBKEY33,(uint32_t)chainActive.LastTip()->GetBlockTime()); if ( notaryid != My_notaryid ) My_notaryid = notaryid; std::string solver; @@ -1573,61 +1569,7 @@ void static BitcoinMiner() savebits = pblock->nBits; HASHTarget = arith_uint256().SetCompact(savebits); roundrobin_delay = ROUNDROBIN_DELAY; - if ( SMART_CHAIN_SYMBOL[0] == 0 && notaryid >= 0 ) - { - j = 65; - if ( (Mining_height >= 235300 && Mining_height < 236000) || (Mining_height % HUSH_DPOW_GAP) > 64 || (Mining_height % HUSH_DPOW_GAP) == 0 || Mining_height > 1000000 ) - { - int32_t dispflag = 0; - if ( notaryid <= 3 || notaryid == 32 || (notaryid >= 43 && notaryid <= 45) || notaryid == 51 || notaryid == 52 || notaryid == 56 || notaryid == 57 ) - dispflag = 1; - hush_eligiblenotary(pubkeys,mids,blocktimes,&nonzpkeys,pindexPrev->GetHeight()); - if ( nonzpkeys > 0 ) - { - for (i=0; i<33; i++) - if( pubkeys[0][i] != 0 ) - break; - if ( i == 33 ) - externalflag = 1; - else externalflag = 0; - if ( IS_HUSH_NOTARY != 0 ) - { - for (i=1; i<66; i++) - if ( memcmp(pubkeys[i],pubkeys[0],33) == 0 ) - break; - if ( externalflag == 0 && i != 66 && mids[i] >= 0 ) - printf("VIOLATION at %d, notaryid.%d\n",i,mids[i]); - for (j=gpucount=0; j<65; j++) - { - if ( dispflag != 0 ) - { - if ( mids[j] >= 0 ) - { - if ( mids[j] == notaryid ) - fprintf(stderr,"--<%d>-- ",mids[j]); - else - fprintf(stderr,"%d ",mids[j]); - } else fprintf(stderr,"GPU "); - } - if ( mids[j] == -1 ) - gpucount++; - } - if ( dispflag != 0 ) - fprintf(stderr," <- prev minerids from ht.%d notary.%d gpucount.%d %.2f%% t.%u\n",pindexPrev->GetHeight(),notaryid,gpucount,100.*(double)gpucount/j,(uint32_t)time(NULL)); - } - for (j=0; j<65; j++) - if ( mids[j] == notaryid ) - break; - if ( j == 65 ) - HUSH_LASTMINED = 0; - } else fprintf(stderr,"no nonz pubkeys\n"); - if ( (Mining_height >= 235300 && Mining_height < 236000) || (j == 65 && Mining_height > HUSH_MAYBEMINED+1 && Mining_height > HUSH_LASTMINED+64) ) - { - HASHTarget = arith_uint256().SetCompact(HUSH_MINDIFF_NBITS); - fprintf(stderr,"I am the chosen one for %s ht.%d\n",SMART_CHAIN_SYMBOL,pindexPrev->GetHeight()+1); - } //else fprintf(stderr,"duplicate at j.%d\n",j); - } else Mining_start = 0; - } else Mining_start = 0; + Mining_start = 0; //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 ) // HASHTarget_POW = hush_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime); From 18f06896953d96390d925060d6756a50ab3cd94b Mon Sep 17 00:00:00 2001 From: Duke Date: Mon, 12 Jun 2023 07:55:45 -0700 Subject: [PATCH 07/36] Avoid ztx validation during IBD if height is less than latest checkpoint --- src/main.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main.cpp b/src/main.cpp index 18769e520..a54d03ada 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1363,6 +1363,11 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde REJECT_INVALID, "bad-txns-invalid-script-data-for-coinbase-time-lock"); } + // Avoid ztx validation during IBD if height is less than latest checkpoint + if (fCheckpointsEnabled && (nHeight < Checkpoints::GetTotalBlocksEstimate(Params().Checkpoints())) ) { + return true; + } + if (!tx.vShieldedSpend.empty() || !tx.vShieldedOutput.empty()) { From 487fff149c17cab8a70f312d56f4c52e7174e81c Mon Sep 17 00:00:00 2001 From: Duke Date: Mon, 12 Jun 2023 07:59:53 -0700 Subject: [PATCH 08/36] Remove dead code related to invalid joinsplit sigs --- src/main.cpp | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index a54d03ada..98b77dda8 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1340,22 +1340,6 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde } - if (!(tx.IsMint() || tx.vjoinsplit.empty())) - { - BOOST_STATIC_ASSERT(crypto_sign_PUBLICKEYBYTES == 32); - - // We rely on libsodium to check that the signature is canonical. - // https://github.com/jedisct1/libsodium/commit/62911edb7ff2275cccd74bf1c8aefcc4d76924e0 - if (crypto_sign_verify_detached(&tx.joinSplitSig[0], - dataToBeSigned.begin(), 32, - tx.joinSplitPubKey.begin() - ) != 0) { - return state.DoS(isInitBlockDownload() ? 0 : 100, - error("CheckTransaction(): invalid joinsplit signature"), - REJECT_INVALID, "bad-txns-invalid-joinsplit-signature"); - } - } - if (tx.IsCoinBase()) { if (!ContextualCheckCoinbaseTransaction(slowflag,block,previndex,tx, nHeight,validateprices)) From 67c763206218c49f1a228ec69c482b76644929b0 Mon Sep 17 00:00:00 2001 From: Duke Date: Mon, 12 Jun 2023 19:06:41 -0400 Subject: [PATCH 09/36] Remove dead code --- src/hush_nSPV_wallet.h | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-) diff --git a/src/hush_nSPV_wallet.h b/src/hush_nSPV_wallet.h index da8038fb6..af098407d 100644 --- a/src/hush_nSPV_wallet.h +++ b/src/hush_nSPV_wallet.h @@ -383,12 +383,7 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a mtx.nExpiryHeight = 0; mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID; mtx.nVersion = SAPLING_TX_VERSION; - if ( SMART_CHAIN_SYMBOL[0] == 0 ) { - if ( !hush_hardfork_active((uint32_t)chainActive.LastTip()->nTime) ) - mtx.nLockTime = (uint32_t)time(NULL) - 777; - else - mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast(); - } + mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast(); memset(used,0,sizeof(used)); @@ -402,14 +397,6 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a return(result); } hex = NSPV_signtx(rewardsum,interestsum,retcodes,mtx,txfee,opret,used); - if ( SMART_CHAIN_SYMBOL[0] == 0 ) - { - char numstr[64]; - sprintf(numstr,"%.8f",(double)interestsum/COIN); - result.push_back(Pair("rewards",numstr)); - sprintf(numstr,"%.8f",(double)rewardsum/COIN); - result.push_back(Pair("validated",numstr)); - } if ( hex.size() > 0 ) { if ( DecodeHexTx(tx,hex) != 0 ) From 5f9bb80873f7900fe49c2f2a6f948e4e13fda052 Mon Sep 17 00:00:00 2001 From: Duke Date: Mon, 12 Jun 2023 19:06:50 -0400 Subject: [PATCH 10/36] Remove unused function --- src/hush_gateway.h | 101 --------------------------------------------- src/main.cpp | 1 - 2 files changed, 102 deletions(-) diff --git a/src/hush_gateway.h b/src/hush_gateway.h index 8be1f7c39..b040d3d48 100644 --- a/src/hush_gateway.h +++ b/src/hush_gateway.h @@ -635,107 +635,6 @@ int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts) void hush_passport_iteration(); -int32_t hush_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime) // verify above block is valid pax pricing -{ - int32_t i,j,k,n,ht,baseid,txn_count,activation,num,opretlen,offset=1,errs=0,notmatched=0,matched=0,hushheights[256],otherheights[256]; uint256 hash,txids[256]; char symbol[HUSH_SMART_CHAIN_MAXLEN],base[HUSH_SMART_CHAIN_MAXLEN]; uint16_t vouts[256]; int8_t baseids[256]; uint8_t *script,opcode,rmd160s[256*20]; uint64_t total,subsidy,available,deposited,issued,withdrawn,approved,redeemed,seed; int64_t checktoshis,values[256],srcvalues[256]; struct pax_transaction *pax; struct hush_state *sp; CTransaction tx; - activation = 235300; - memset(baseids,0xff,sizeof(baseids)); - memset(values,0,sizeof(values)); - memset(srcvalues,0,sizeof(srcvalues)); - memset(rmd160s,0,sizeof(rmd160s)); - memset(hushheights,0,sizeof(hushheights)); - memset(otherheights,0,sizeof(otherheights)); - txn_count = block.vtx.size(); - - if ( SMART_CHAIN_SYMBOL[0] == 0 || - ((ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD) && height > 1) || - NetworkUpgradeActive(height, Params().GetConsensus(), Consensus::UPGRADE_SAPLING) ) - { - n = block.vtx[0].vout.size(); - int64_t val,prevtotal = 0; int32_t strangeout=0,overflow = 0; - total = 0; - for (i=1; i= MAX_MONEY ) - { - overflow = 1; - break; - } - if ( i > 1 && script[0] != 0x6a && val < 5000 ) - strangeout++; - total += val; - if ( total < prevtotal || (val != 0 && total == prevtotal) ) - { - overflow = 1; - break; - } - prevtotal = total; - } - if ( SMART_CHAIN_SYMBOL[0] == 0 ) - { - if ( overflow != 0 || total > COIN/10 ) - { - if ( height >= activation ) - { - if ( height > 800000 ) - fprintf(stderr,">>>>>>>> <<<<<<<<<< ht.%d illegal nonz output %.8f n.%d\n",height,dstr(block.vtx[0].vout[1].nValue),n); - return(-1); - } - } - else if ( block.nBits == HUSH_MINDIFF_NBITS && total > 0 ) // to deal with fee stealing - { - fprintf(stderr,"notary mined ht.%d with extra %.8f\n",height,dstr(total)); - if ( height > HUSH_NOTARIES_HEIGHT1 ) - return(-1); - } - if ( strangeout != 0 || notmatched != 0 ) - { - if ( 0 && strcmp(NOTARY_PUBKEY.c_str(),"03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828") == 0 ) - fprintf(stderr,">>>>>>>>>>>>> DUST ht.%d strangout.%d notmatched.%d <<<<<<<<<\n",height,strangeout,notmatched); - if ( height > 1000000 && strangeout != 0 ) - return(-1); - } - else if ( height > 814000 ) - { - script = (uint8_t *)&block.vtx[0].vout[0].scriptPubKey[0]; - //int32_t notary = hush_electednotary(&num,script+1,height,0); - //if ( (-1 * (hush_electednotary(&num,script+1,height,0) >= 0) * (height > 1000000)) < 0 ) - // fprintf(stderr, ">>>>>>> FAILED BLOCK.%d notary.%d insync.%d\n",height,notary,HUSH_INSYNC); - //else - // fprintf(stderr, "<<<<<<< VALID BLOCK.%d notary.%d insync.%d\n",height,notary,HUSH_INSYNC); - return(-1 * (hush_electednotary(&num,script+1,height,0) >= 0) * (height > 1000000)); - } - } - else - { - checktoshis = 0; - if ( (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD) && height > 1 ) - { - if ( (checktoshis= hush_checkcommission((CBlock *)&block,height)) < 0 ) - { - fprintf(stderr,"ht.%d checktoshis %.8f overflow.%d total %.8f strangeout.%d\n",height,dstr(checktoshis),overflow,dstr(total),strangeout); - return(-1); - } - } - if ( height > 1 && checktoshis == 0 ) - { - checktoshis = ((uint64_t)GetBlockSubsidy(height, Params().GetConsensus()) - block.vtx[0].vout[0].nValue); - // some pools will need to change their pool fee to be (poolfee % - txfees) - //checktoshis += txn_count * 0.001; // rely on higher level validations to prevent emitting more coins than actual txfees - } - if ( height >= 2 && (overflow != 0 || total > checktoshis || strangeout != 0) ) - { - fprintf(stderr,"checkdeposit: ht.%d checktoshis %.8f overflow.%d total %.8f strangeout.%d\n",height,dstr(checktoshis),overflow,dstr(total),strangeout); - if ( strangeout != 0 ) - fprintf(stderr,">>>>>>>>>>>>> %s DUST ht.%d strangeout.%d notmatched.%d <<<<<<<<<\n",SMART_CHAIN_SYMBOL,height,strangeout,notmatched); - return(-1); - } - } - } - return(0); -} - const char *hush_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int32_t opretlen,uint256 txid,uint16_t vout,char *source) { uint8_t rmd160[20],rmd160s[64*20],addrtype,shortflag,pubkey33[33]; int32_t didstats,i,j,n,kvheight,len,tokomodo,hushheight,otherheights[64],hushheights[64]; int8_t baseids[64]; char base[4],coinaddr[64],destaddr[64]; uint256 txids[64]; uint16_t vouts[64]; uint64_t convtoshis,seed; int64_t fee,fiatoshis,puposhis,checktoshis,values[64],srcvalues[64]; struct pax_transaction *pax,*pax2; struct hush_state *basesp; double diff; diff --git a/src/main.cpp b/src/main.cpp index 98b77dda8..2c037297b 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -4981,7 +4981,6 @@ bool CheckBlockHeader(int32_t *futureblockp,int32_t height,CBlockIndex *pindex, return true; } -int32_t hush_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime); int32_t hush_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height); bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const CBlock& block, CValidationState& state, From 79f126be431fdb07cc81502df716da36b7a10d56 Mon Sep 17 00:00:00 2001 From: Duke Date: Tue, 13 Jun 2023 22:43:16 -0400 Subject: [PATCH 11/36] Use default jobs number when compiling boost According to current boost docs, not specifying -j parameter will default to using all cores to compile, so removing these should speed up compiling boost. This code dates back to 2014 when the default may have been a single core, so it was specified. --- depends/packages/boost.mk | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk index 11c235489..fde0c92c3 100644 --- a/depends/packages/boost.mk +++ b/depends/packages/boost.mk @@ -38,16 +38,16 @@ endef ifeq ($(host_os),linux) define $(package)_build_cmds - ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 stage + ./b2 -d2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 stage endef define $(package)_stage_cmds - ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 install + ./b2 -d0 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 install endef else define $(package)_build_cmds - ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage + ./b2 -d2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage endef define $(package)_stage_cmds - ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install + ./b2 -d0 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install endef endif From c9f1fe4cf351817f89cf9dd68a6e3e206ca1ba14 Mon Sep 17 00:00:00 2001 From: Duke Date: Thu, 15 Jun 2023 10:13:01 -0400 Subject: [PATCH 12/36] Support arbitrary -ac_name in checkpoints.pl --- util/checkpoints.pl | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/util/checkpoints.pl b/util/checkpoints.pl index a79ba2753..be6bf28be 100755 --- a/util/checkpoints.pl +++ b/util/checkpoints.pl @@ -7,16 +7,16 @@ use strict; # Generate checkpoint data for use in src/chainparams.cpp my $perday = 1152; -my $hush = "./src/hush-cli"; -my $gethash = "$hush getblockhash"; +my $cli = "./src/hush-cli"; +my $gethash = "$cli getblockhash"; my $stride = shift || 1000; if ($stride =~ m/help/) { print "To generate checkpoint data every 1000 blocks: $0 &> checkpoints.txt\n"; print "To generate checkpoint data every X blocks: $0 X &> checkpoints.txt\n"; print "To generate checkpoint data every X blocks starting at height Y: $0 X Y &> checkpoints.txt\n"; + print "To generate checkpoint data every X blocks starting at height Y for -ac_name CHAIN: $0 X Y CHAIN &> checkpoints.txt\n"; exit 0; } - unless ($stride == int($stride) and $stride >= 0) { print "Invalid stride! Must be an integer > 0\n"; exit 1; @@ -28,8 +28,17 @@ unless ($start_height == int($start_height) and $start_height >= 0) { exit 1; } +my $acname = shift; +if ($acname) { + # TODO: is acname valid? + $cli .= " -ac_name=$acname"; + # TODO: assumes all HSC's will have a blocktime of 60s + $perday = 1440; +} + + my $count = 0; -my $blocks = qx{$hush getblockcount}; +my $blocks = qx{$cli getblockcount}; if($?) { print "ERROR, exiting...\n"; exit 1; @@ -53,7 +62,7 @@ while (1) { chomp $blockhash; print qq{($block, uint256S("0x$blockhash"))\n}; } -my $time = qx{$hush getblock $last |grep time|cut -d: -f2| sed 's/,//g'}; +my $time = qx{$cli getblock $last |grep time|cut -d: -f2| sed 's/,//g'}; chomp($time); # TODO: This is Linux-only and assumes new (not legacy) dir my $line1 = qx{grep --text height=$prev ~/.hush/HUSH3/debug.log}; From b8ae39ccc7c0fda99cd22c68626ba0f327525a62 Mon Sep 17 00:00:00 2001 From: Duke Date: Thu, 15 Jun 2023 10:25:59 -0400 Subject: [PATCH 13/36] Enable the option for dragonx checkpoints --- src/chainparams.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/chainparams.cpp b/src/chainparams.cpp index 6eb1368ff..787148986 100644 --- a/src/chainparams.cpp +++ b/src/chainparams.cpp @@ -1553,7 +1553,17 @@ void *chainparams_commandline() { }; // END HUSH mainnet checkpoint data + } else if (strcmp(SMART_CHAIN_SYMBOL,"DRAGONX") == 0) { + checkpointData = //(Checkpoints::CCheckpointData) + { + boost::assign::map_list_of + (0, pCurrentParams->consensus.hashGenesisBlock), + (int64_t)1231006505, + (int64_t)1, + (double)2555 + }; } else { + // all other HSC's with no checkpoints checkpointData = //(Checkpoints::CCheckpointData) { boost::assign::map_list_of From f12bfeb7f4728527e99ca52de3691517ffa45691 Mon Sep 17 00:00:00 2001 From: Duke Date: Thu, 15 Jun 2023 15:38:16 -0400 Subject: [PATCH 14/36] Fix bug where it uses the wrong -ac_name --- util/checkpoints.pl | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/util/checkpoints.pl b/util/checkpoints.pl index be6bf28be..910f0abae 100755 --- a/util/checkpoints.pl +++ b/util/checkpoints.pl @@ -8,7 +8,6 @@ use strict; # Generate checkpoint data for use in src/chainparams.cpp my $perday = 1152; my $cli = "./src/hush-cli"; -my $gethash = "$cli getblockhash"; my $stride = shift || 1000; if ($stride =~ m/help/) { print "To generate checkpoint data every 1000 blocks: $0 &> checkpoints.txt\n"; @@ -36,7 +35,7 @@ if ($acname) { $perday = 1440; } - +my $gethash = "$cli getblockhash"; my $count = 0; my $blocks = qx{$cli getblockcount}; if($?) { From 1f0b53854054b635f1ebef9b060a59f4e21dbe64 Mon Sep 17 00:00:00 2001 From: Duke Date: Thu, 15 Jun 2023 15:43:08 -0400 Subject: [PATCH 15/36] Take into account ac_name to calculate total txs --- util/checkpoints.pl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/util/checkpoints.pl b/util/checkpoints.pl index 910f0abae..cb8301d61 100755 --- a/util/checkpoints.pl +++ b/util/checkpoints.pl @@ -33,6 +33,8 @@ if ($acname) { $cli .= " -ac_name=$acname"; # TODO: assumes all HSC's will have a blocktime of 60s $perday = 1440; +} else { + $acname = 'HUSH3'; } my $gethash = "$cli getblockhash"; @@ -64,8 +66,8 @@ while (1) { my $time = qx{$cli getblock $last |grep time|cut -d: -f2| sed 's/,//g'}; chomp($time); # TODO: This is Linux-only and assumes new (not legacy) dir -my $line1 = qx{grep --text height=$prev ~/.hush/HUSH3/debug.log}; -my $line2 = qx{grep --text height=$blocks ~/.hush/HUSH3/debug.log}; +my $line1 = qx{grep --text height=$prev ~/.hush/$acname/debug.log}; +my $line2 = qx{grep --text height=$blocks ~/.hush/$acname/debug.log}; my $txs_per_day = 2 * $perday; # default estimate is 2 txs per block, on average my $total_txs = 0; #print "line1: $line1\n"; From 97c7e814cffae13bc1de06cba214f4026f9b01e5 Mon Sep 17 00:00:00 2001 From: Duke Date: Thu, 15 Jun 2023 15:47:14 -0400 Subject: [PATCH 16/36] Add checkpoints for DRAGONX --- src/chainparams.cpp | 520 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 516 insertions(+), 4 deletions(-) diff --git a/src/chainparams.cpp b/src/chainparams.cpp index 787148986..ef9213bb4 100644 --- a/src/chainparams.cpp +++ b/src/chainparams.cpp @@ -1557,10 +1557,522 @@ void *chainparams_commandline() { checkpointData = //(Checkpoints::CCheckpointData) { boost::assign::map_list_of - (0, pCurrentParams->consensus.hashGenesisBlock), - (int64_t)1231006505, - (int64_t)1, - (double)2555 + // Generated at 1686858269 via hush3 util/checkpoints.pl by Duke Leto + (1000, uint256S("0x000bffdae30339fad4ed82a2d2bfc0846f12fb9aeef5e33bb563f4cdd376dc08")) + (2000, uint256S("0x0003578c68350c7afacdc940c87ea9255681a135a0a9b2c13a075485d96155ed")) + (3000, uint256S("0x0001fef5443794fe61e0d397897f0a45a66c5473a70819608504f1395aed1d8c")) + (4000, uint256S("0x000197510698c8fc50133971744d1dd49aae371366d3986c412a189e9c617974")) + (5000, uint256S("0x00000094754d610b08b801545dbdbf57433e7c4d2a48818ff499f8fab05b0927")) + (6000, uint256S("0x0002116377d2d0c04344f0ed7eec63814b54bae740562ccede0c3d9404900cdb")) + (7000, uint256S("0x0001c74d83479bf05a3d9181555ff4ed373a642b1b4cb9cc633c090a522c10e0")) + (8000, uint256S("0x00011c3cd9aeadb039ba28547f232391ded0329ab6b7ec454aeb671246c94b58")) + (9000, uint256S("0x00005b1b0187ba523b6670e65262d1b028a140582301c7ea65065cd47a679c6d")) + (10000, uint256S("0x0000f32ac2bd4581ef4b651f72b27d92dfca04d4dc721c505214f113e209b10e")) + (11000, uint256S("0x000086e271117d75ac85fd00fbec94bbc53a5b990ccb362a8a2f064a97cdf7b2")) + (12000, uint256S("0x000098431effc021e44f867cffa2e309d7bbcc34201ea8d3bc7b08faeca556e3")) + (13000, uint256S("0x000194c6d37ebd00f7746536a7f3a891866954c1020f61be5573b055ea991fa1")) + (14000, uint256S("0x0001102d2b0c1efe8c07768b3bd540e8b2ef8c03e2f8271a58def634a51c576f")) + (15000, uint256S("0x0000c616068d8730adbd87b2bc9d4d5322610e52da6806b9cb2f1894af37d933")) + (16000, uint256S("0x0000049f6a5818a48aafb52781f91f8eca4d05c29c537a85c34b6fa342996a27")) + (17000, uint256S("0x000079bf17272dc67ca18df9f7c5b817c37bd2d103ee76d3b2271511c5aa0b82")) + (18000, uint256S("0x00005f4d742dc1b0e12200c4da8080d75973b18b6d2bdf748f149be72a313627")) + (19000, uint256S("0x0000368eaee2a6f22d64c66c0e3cfc7fe2709f7ced31a589ac8b4c461eca2fff")) + (20000, uint256S("0x0001b4057aebdc835c63dfb581235d5917af697fff962ecfe47e8a26c0b3ac55")) + (21000, uint256S("0x00010a339a0830471d384741ff24161252fdfab8ecfb493b6e8d1f1e7ce342b7")) + (22000, uint256S("0x000013c834a72926969cf8ed88b79175aa3ea952e67b7054c4fa06cc4e5209c4")) + (23000, uint256S("0x0000386a639d79d35972576b55787a80986a27c7415949dc645dc50522f6487a")) + (24000, uint256S("0x000075055db90559920ac02c2de8e1622533b7532b84fe702baf05082161e011")) + (25000, uint256S("0x0001b866113317839d2f6fa608f98f798db1570b4f84e36789126edda9b75d35")) + (26000, uint256S("0x00012ce8394b99c4fff5c052a0abb142c8c1eaa58b830699222a8eacb95298af")) + (27000, uint256S("0x000058bbe34298518632e0522d3ba10e050a5a31e2c4fd862a576f300e9f5c1d")) + (28000, uint256S("0x000163c608d28f1c3a10f8425b5469099b7fff50e25424659887e011d2c0281e")) + (29000, uint256S("0x0000c3baca291f20849d96de3436dad0efc24aa5b44bbdd466ea841b28d70a2e")) + (30000, uint256S("0x000075d2e08eafd62f4633cc1cabf281de17e7e0bba7965db75f3cf268b9a980")) + (31000, uint256S("0x00010cc563eef842749ea14412e922bad6e3515c049f639612a07b221aff4de2")) + (32000, uint256S("0x000150dee2380f76bb144f8c5433bd27e049c54feaaeadeb8bfc3948293453a9")) + (33000, uint256S("0x0000ec245f9808c6792915ae2a467593a1675efce42a2d0ee486e091913159d8")) + (34000, uint256S("0x000166dbcd4f262032e7a981207ac709f7be88a037650ca454db43018286c8f8")) + (35000, uint256S("0x0001a5c13dd9333a4ec60bc6af488ef7e3738aaf2170c70b716a30597b8e2d70")) + (36000, uint256S("0x00018e4fe65c96f0e187c265fa3faa49156ad07991284920beaef3b3b499dcbe")) + (37000, uint256S("0x00017e952f47ea070893b41a76468fee7db3073184eab10c960e2aead6fddf7e")) + (38000, uint256S("0x00010e3c64c0127fb995ab10d45bb281e5c78239c0303c825d81bb4cf994c7c0")) + (39000, uint256S("0x0001db8de504639d87029c9be04acdfef038601af58ea38ba307a7cc0ce8fdf7")) + (40000, uint256S("0x00015fc2f6953e67578c6484c3a5342d883fd3ef051456edc55064e544f04df2")) + (41000, uint256S("0x000200e23bc81ee9e9a9b29eb9c478c035d52de845c118a1645a3876d0f0f7ec")) + (42000, uint256S("0x00018b8b952e0268ee7007ca2bfe3499f1c78911e5d308d877aa3829a8ddfa95")) + (43000, uint256S("0x00005cc6dc81cdd3ad3c1bc5675064b8d6d01ac85348c116f4db28c61df5cb52")) + (44000, uint256S("0x0002a71c4a45353eeed81519d1f4b78e4be13702907bc872fd605c094eb5c8fe")) + (45000, uint256S("0x00005c3e9bdb78fa205f39a6f4fff5c547775ee90e79fedebecb17336c03e868")) + (46000, uint256S("0x00024017e7985c841e8b607624f74f3efe46f915d272f9f8c07a93353858d92b")) + (47000, uint256S("0x0000d29c58bb338aa55bb017d8fbbe3b7c3bed83f212094a18ef7fde7f8eb675")) + (48000, uint256S("0x00024b1c2d6131f7ec9748c763c3168d2d761c7617e10d09fb93aff2b4a29ca3")) + (49000, uint256S("0x000120f81110878ca7ec75d155badf2348bda20a9034b24b8317ba0f16568788")) + (50000, uint256S("0x000207bddb3ebb7cb8000f84e63ae7be40e74dde52c8bfa4f0cc913b048e5767")) + (51000, uint256S("0x0001c8554ac45a19684c7328056420d7b27c1c5c9f03059c095ca4a2749b29f4")) + (52000, uint256S("0x000104d93b769e9e7190b031f6250445b05750a36231f8ea7f2dce8c8a0487be")) + (53000, uint256S("0x00002ab5a1e72ef163242f4be6a26063f26cef6f1eccb4cfe44a099ba710fdc4")) + (54000, uint256S("0x000117645f0ee76f12601abe5554729ca9241c65e49cbefae77e67d18204795f")) + (55000, uint256S("0x0000ab7cf81435f26f56b9687b8f6feaaed95ed8090a1dac8a690a39b9a89c8b")) + (56000, uint256S("0x000134d8809fb2222a3ed76958f998589ac69d6d08d534309ecf569b6d448cb3")) + (57000, uint256S("0x00003daaec8c3d9c31b32163cef47c4883ad9b12b85a641eefbd02b06c4b6083")) + (58000, uint256S("0x000096456c3f1af39489df84dbf0a0975c9cc29fa1f524e72cf4421fd6465b82")) + (59000, uint256S("0x00016202a3cdcb3b0c27e75f84cebcf576bc7869abf0fab13c68abd3b111fb9e")) + (60000, uint256S("0x000071cd818c3fa9f155ec8ac65333f43e0d86b4f6ea98fc702ae0fe1ec3126f")) + (61000, uint256S("0x0000d1654355ba77105cc07e7cf024e0200f39646ea3cbf816737e621857ff36")) + (62000, uint256S("0x0000f1e6a09effa09329175ee4d8b42fdae3c365f1232fd440d0d41b6c090dc9")) + (63000, uint256S("0x0000ffbceee7b86cb04a37fefeb0452de8305aef4c37b6bfa84cffe4dba168be")) + (64000, uint256S("0x00002db24701b3d6c0d7547c1636b0aae754c050915ba607da1022e859bf0a07")) + (65000, uint256S("0x000102bfa6361b71cc51e231b87c653dfd21a865284fe013d65bac8fb2d96878")) + (66000, uint256S("0x000061e9bf36f9b2d110d7d545d9fa1deaaf39ce91d2d5e3f51b5e8eec37d820")) + (67000, uint256S("0x00000128e4528bae30aae739e7d1d1528e366739878878bdec5e5d5f5639de21")) + (68000, uint256S("0x0000c45a027fe81eb60c60573bffa4558b3d187f7144131eff0b97fc52d8fbcf")) + (69000, uint256S("0x00005fc22d9c90e1c88c5724ea8b45d2b198bd03d77931c4d328e88313d9080e")) + (70000, uint256S("0x0000bbfd71d248074239456adf756eff007bcbe004b8c02eed8dd1b1656d9270")) + (71000, uint256S("0x00003f2d633d303c935554a414ec99443e01f5e626522159d97b7774f939158f")) + (72000, uint256S("0x0001514d0a98b94dbc81f70c59d29ae437a4690beb464d1b92abe7bd1e055a35")) + (73000, uint256S("0x0000807fe075a08da2bb07b8f4bb9a02b7e450fe6e5be062c21b15beed210dfa")) + (74000, uint256S("0x00006bf606a3c548c55c079343183caaebaa2c23d8580abb9eedf2a7e9b2a453")) + (75000, uint256S("0x00016da1e267ef35372482c84a37012e74c136fea0015b48ac7e039a5025b71e")) + (76000, uint256S("0x000029e02c641075abe8adabdb3b59e3696611f37c3da3f3bfcad72a705e7a3c")) + (77000, uint256S("0x000105f3af93470b7076fdfb9a0e9714f596ca4366deb3c35333648257464d67")) + (78000, uint256S("0x000144235c2eb2e871e11eca2ef9c051432bce4e9a1bb346b0b895e8e559286b")) + (79000, uint256S("0x0000b73f9f1a91cacb3c93638fe7ef6fa91072fd76d91cb51f34e794941f7325")) + (80000, uint256S("0x00001d995acdf7ac796829dcc869dae073258e5c608a8daa709b4c512c3a3343")) + (81000, uint256S("0x0000b163da6072538fc53a789dc47228a691b734a74e551e0e2e9e0d26fdbcff")) + (82000, uint256S("0x00012e9491a6d4d2b32f1869eb44672e1833ab718e580bf5609d7f9c58bc0af3")) + (83000, uint256S("0x00017280176966d19319f3c4d67440759e072e0c8b66b93d1f87921743b99fd1")) + (84000, uint256S("0x0000f62cd78630155998d1a64104c2f66328a586988b18874e99364eb60fc0d9")) + (85000, uint256S("0x00000d6fe7b9dec442628066442bd0558ceaa1a8d664d82f122790b2c917f950")) + (86000, uint256S("0x000029a1d545e5b7fdd28617de6195347d719524d5626f12d19924921e7f2359")) + (87000, uint256S("0x000138aea3caee3827eacfea9efd4d41f74958992c3b17a19599c28932aec442")) + (88000, uint256S("0x0000ace521b7b212027faf886832a3858b6b1391face5d9bfa21a58d08577f17")) + (89000, uint256S("0x000054190734e754a5aa58f1cb70753fcba0a88f512185578b8d772918dbf549")) + (90000, uint256S("0x0000d841407e0ac42c190ca65319bf2c4ec056724c75774bbfaaaf28fc022fec")) + (91000, uint256S("0x0000d95e5a72eb25762fd65ed7901ee7c5365d1b7ada72080743f95fe9bfd308")) + (92000, uint256S("0x0000c77b274f557cca7a381b64ccba1412a4f927ae850cc5e0ea3b3fe6a85947")) + (93000, uint256S("0x000006ce04d80995709a8a93da2eaa6c00a7b0c15e7f409a1cbfa64f92ec4aee")) + (94000, uint256S("0x0000e610317357e75beadac9a249f9b1847e26d98dfde191f9e421df0ac009ec")) + (95000, uint256S("0x000039e0566bdb30c72857c5e05afeefefcb4fea69ee24e86fb3506c93c4169a")) + (96000, uint256S("0x00007707c899da1d86457bc55fc614cef6dfc73216d04f26b500728c57b8b7c6")) + (97000, uint256S("0x000133c725bdbbf3c4c3669e32f459f3d0cb6c473b5a9dcfac06c486e1ece294")) + (98000, uint256S("0x00001d75a7c92f3586045b534f5a80c474b9b1ba463acd1462b9494bc9dbc12d")) + (99000, uint256S("0x000070946880c634b930804e55cc2f380fbd897d4d1713e6ab0a86ec66299f44")) + (100000, uint256S("0x00005af032270f04bc9be8072ee0b70820b88303dc25770a8dfb5c6f00341ae8")) + (101000, uint256S("0x00015739048f9cd91a5f5da04d9b1f0b220d719c13a6b03577d60027ba0cf130")) + (102000, uint256S("0x0000ae124051763e3ccdc1beff5d4ba304715e06f6a54124ee4ce4a4424e2925")) + (103000, uint256S("0x0000b46bd79314799b28964e5bc9cfbfd4481fd4148c4775337cc7a3458f411f")) + (104000, uint256S("0x0000546d926811aeaa19b14fb06c919174d73ceb41800f21e8856b940ea0d51e")) + (105000, uint256S("0x00006f831295c6d417a10268beda28ef058a646d68dcf53f6c5197c7c0071144")) + (106000, uint256S("0x0000aa4f504584b2e604186eb4edc1d60caa757ef25db86a35aca9b9e03bab02")) + (107000, uint256S("0x0000e945fef42d3eb4cc606aa888cb9908a9778592470e6630035821b83bf32a")) + (108000, uint256S("0x000042b833a40904ba608c715efca50f3b351924cddc50793af26be698b791b4")) + (109000, uint256S("0x00008b8778ff887a3ae0dc04a9cc546408c8b7cc4f23668b2e38ade6fbe31487")) + (110000, uint256S("0x00007558a72be2b93ff9c32a3c8c8896f4fd7b8d59430a1917755412307bbcde")) + (111000, uint256S("0x00005fcd2934faee4f6cf128a272a03c7001be0f59abe873c4ef5dbd469fee67")) + (112000, uint256S("0x0000ea01486382afa2787d723f80d1073bd8924181f9e0aba2e4a253e4fb571d")) + (113000, uint256S("0x00002e5f65baec8b526c5096351a30bc33cee3692ed4e3b4144229cf9ca6dc83")) + (114000, uint256S("0x0000177996f4e8f436672b0405b1de6bb7335bdc32cea1635d6122c4d6af7563")) + (115000, uint256S("0x00011891d2d508824de7657981c754372a2c2985b2d483fc48003de27f9b5716")) + (116000, uint256S("0x000088d8381d4a1c3b468bedbf6320e7dba41285ae99bcaf0b4750ca9cada4bb")) + (117000, uint256S("0x0000b0dacbd93ed6feb0c83af3f8b57598ca9b59b87c4a0f6f8b7738b37ba280")) + (118000, uint256S("0x000141aa854c151264db40b7fb065d5d6402c03786d1201a428bdb2f3cf4be0d")) + (119000, uint256S("0x00001dcec0e976c13fa307ee80f37a7d188e80b7e18c6aa744948139090ee4c6")) + (120000, uint256S("0x000159aac0c2854248eeaa7717b5f9defed70ec7eb56225f74650e2e4dd14ab0")) + (121000, uint256S("0x0000ffaabd57940430c76493f65b2ea9588ea5d218bf4ab8cd7986a4f36d85ed")) + (122000, uint256S("0x00004997285f83bdf2b84e906a5427d1246d2a9576fe70ba98db0fb1906e2a81")) + (123000, uint256S("0x00011189d192349030a4d667504557de1c6f321c2d2b433f279d83aefd49a88d")) + (124000, uint256S("0x000021e928fa16624a41e6d5d3275ecbf15d4f2e7ac529f411c071090b01a501")) + (125000, uint256S("0x0001678ffaaf26a44aacadf79d4312a1a3269e110df6a25b00371575574c5fd5")) + (126000, uint256S("0x00014435157bc5cf46047a2080a3fac7680635b4bd269404297581b884f26aff")) + (127000, uint256S("0x00005b0ee65fba4d6eb0902766eadf515fb252b86140e9093d249d8f9a54a128")) + (128000, uint256S("0x000021b7d3534640ec2854c0fcc08b1342162770a4e1c37870e9cf0030582d85")) + (129000, uint256S("0x00009fb144dfe588c1ae56ba6e17a6d6b1565c1b27464c5cba79c918b56a1760")) + (130000, uint256S("0x0000674dcced99276e684e9ac19eb2412e55c968a2bb524069384647cb45eefc")) + (131000, uint256S("0x0000ad841440e59715c68856f4011e854031cad19788438bdceaa4ca161f06a1")) + (132000, uint256S("0x00002789aed78f0b29396c9d654c1599b35cae19704d1b15e4f266af109c1f8c")) + (133000, uint256S("0x00002a422e40e72b7a35d4818a59297bfdcc5efcaeaa30d54d1d290e85a6f1de")) + (134000, uint256S("0x00003628a789756f15bb46fd8de99f9baab50f19a935716785dcae0275bf4a05")) + (135000, uint256S("0x000075517e8be4c0ed800d66ad00dd67346ea2b34348e594b769fa9bac3fecb5")) + (136000, uint256S("0x00002b4196ca58d9e2b7c75f1e8de291cf22b7bbc4be8dc2cfb29f54c256d3ba")) + (137000, uint256S("0x0000180d66e02d24330e9ef3d49813136eac06802e2989fa379d7a88e4067e01")) + (138000, uint256S("0x0000ad0a51cac855e0b162fbf069b560cd8d21fb5275f9d06304a740129bc809")) + (139000, uint256S("0x0000219d48ec853516f9262b41d84c5fbc5417b604e3b9001769bd5ac3f59b28")) + (140000, uint256S("0x00012475b06db9b0c4befe66ed3de054b993bc787092488df2383c566155921e")) + (141000, uint256S("0x000061896c62d282efc098341741a1a67c4d9c87fec6f1948a2225bc56c44c78")) + (142000, uint256S("0x0000444880b2e2b46b874fbb0acd44675ce257d2bac4eade4b9b9929a7b39b08")) + (143000, uint256S("0x0000509c13924e0733c5d6fc3bc7a270d2dd3b4c82db7fdfcaf02a410103ca78")) + (144000, uint256S("0x0000dd507d1b7059fb9c41c103ff43190425d567a661a59d704563c9dce1a1c9")) + (145000, uint256S("0x000097e5ebd34461ebcb5fdd3beb6e973fa752817f2ebe9fd3d57a56537e1ec0")) + (146000, uint256S("0x0000afb0eab0639d2623a15d8454cc7464c83f677fa7461259a445304fc3d3a8")) + (147000, uint256S("0x000123ce32adbc6c65e490bcc21554b0afda1476b2a6da11a28e264f1964cda6")) + (148000, uint256S("0x00016278bed29b081e4986de9c6422a89d8aa719dd1ab422c1ea7fa10284094b")) + (149000, uint256S("0x0001484305013531de1e5abda094fb453d5c5fb0d35812327ea01517c9149cdc")) + (150000, uint256S("0x0000da3a58875dc171e5bb9747cff5dfa2880d39e244d3f10acccf5232aac81b")) + (151000, uint256S("0x000006f333c55d2b6ab5f334a6d05f96fe74e301d4110ac92807239873f25671")) + (152000, uint256S("0x00008844695c54bee8e1711ec7e80f474c7a3bf1b78aa272553ca233746c912f")) + (153000, uint256S("0x00011c8bc4ffe00ea899ae19daa572e61e4cb951a594229d67e2af19d6388d21")) + (154000, uint256S("0x000111aaabb95e1cb1a225e5e8b2a6727c11da97c7391800618c7ba11c6ad669")) + (155000, uint256S("0x0001011a4d88acf916da949572a7f1c208bd7d31e0598d4337980c48ed88b18f")) + (156000, uint256S("0x0000651ee0d6bdaeec5bf585fa628e4336e7238974ca90461d38506c34d6f00b")) + (157000, uint256S("0x0000d2ecfe64aa069aeba21fb1bd8995cfad455c296670e3dec13fde989aa1c5")) + (158000, uint256S("0x000113b2ab0d24a2bac410a0155ca9d2fa6b2923c0042c228dd86fe37ad04469")) + (159000, uint256S("0x0000b1741e1d0b841bf0c0d5b3a0b9a906cde8e630e10b71ebfdf18ae5197d9f")) + (160000, uint256S("0x0000419b54cbe8a842b92201996bd74382b63db7ab0b1989b932ecb19bdd6f4a")) + (161000, uint256S("0x000076eac68434f40b6921b251fc2ec5de4748044d849887a70116f344f1477c")) + (162000, uint256S("0x0000fb948303f30cde6c2ed932915e0f6aaa932dc3dec324851b256e82f4f2a0")) + (163000, uint256S("0x000025244341c537faf365bb46626f0283a2fc0cd668c93cb9771da7f7c6be56")) + (164000, uint256S("0x000046fc2919f8ae4b88c1faecea97f6301a27a9a16184934d70b0b305891a14")) + (165000, uint256S("0x000116cc086ac32a24092d39089d2bcf5977bbc08ad916a8fac2aaefb48f2220")) + (166000, uint256S("0x0000dc6455e6eaae079ba6592fe0d5688c696955f00d33dbfc0cf76aac48e10a")) + (167000, uint256S("0x00012685e23a0997797098d047631fe7da1849e763dda0c7a00f47c7dfd13366")) + (168000, uint256S("0x0000b28813965516fe96909418dc72a4ce126401cd7a03919b9888d0da3b37d3")) + (169000, uint256S("0x00014522bcc0fa9995c6b1b6e6ba3ddd4298b0dd59854d25e713c43778d93d77")) + (170000, uint256S("0x0000f8e02172873f12b2b1adf8709b5d1990ef64b674fb0e5ed1ea08db9b6a48")) + (171000, uint256S("0x0000b0d9d1cced1c0396bab1f1003c9a009dc47da63c8220fc23bb3948a82ed2")) + (172000, uint256S("0x000099c8db9b14c2d5f7c685ee8569755bc50306397f749c7e0e31e709bfc4f3")) + (173000, uint256S("0x00007c422bc9f8295deeb35ea5225bc4f8021fee412c9a5127b6067582b356fa")) + (174000, uint256S("0x0001127a0d14aec0b5ba96dfb606cb9a562d5dafe79646076b9c0a7f7bbc8ffa")) + (175000, uint256S("0x000091c16ae7ffb036f716ac975bf6a9572fd9d439abef21036d18c3be0f90c7")) + (176000, uint256S("0x0000f4e7f4a42a9bf0dfe831764ccf9a8116f98e8158d072b8034d6b7a1e0400")) + (177000, uint256S("0x00006a9efe8a6d93dc8d16757a425c2cb8b910195f08fa210bb0bb3daec47080")) + (178000, uint256S("0x000065fdff26f07f13a0e9db44f6847161b360a6dea1cb7ef810c93a62043025")) + (179000, uint256S("0x0001a0a5300ed334e0ada6eb53d762ebcb1bf7ad0b6312905257f7698477ed51")) + (180000, uint256S("0x000131b050c745484f85e2c8422bf4624f23c69969d1c7d2f6760ef62a864746")) + (181000, uint256S("0x0000cf46ed02cc030fa3209a7fdca35a99249a17b241d30849ea094cdc827a49")) + (182000, uint256S("0x0000b16cd4ef9db7e929372be056e12d8422575891d032298cc17853d043a6e8")) + (183000, uint256S("0x0000d5d53dbb045bedbd997855eb931d7e671740e2aa37a84e184b43b90cf1a5")) + (184000, uint256S("0x00010f06fdae2de13519604475ff9412eb67731f9d4d0420c00b1f2530a5fd91")) + (185000, uint256S("0x000145be18021effbc081d0ca8fd549317766b57d828bc946436e84325b17c7c")) + (186000, uint256S("0x00006e592793a9bb5795a4f76b5ed47af4ce51b0d2e6730888c2c38dca5864b2")) + (187000, uint256S("0x0000438bdd8a024ccc008726a1690873039153df76ed254d2d773e55def68742")) + (188000, uint256S("0x00010108fe7c2543e5b258ee511ded17e12f3ed1688164ef78526684c1ea193e")) + (189000, uint256S("0x00005cc59b9b2116afa0e6ecc12769ee5f91efa91d245fc64bfda90479f8c9a7")) + (190000, uint256S("0x0000572751fda233f466c6ad237184ff6a7a15f8d84e5471e3dc5288ad74f592")) + (191000, uint256S("0x0000b5bb7236376176640e75308466cec3c3fa7bde6f24b1d12c96e94df2bb58")) + (192000, uint256S("0x0000620eaa310878ce85d6cd90d2b4724b36236575ff26c2ed6e34c93f6a8625")) + (193000, uint256S("0x00003a8b7d4cc3a92bb3b5301f9d7ca91941150e5bbc10f1204ec0175053bae2")) + (194000, uint256S("0x00007144b1bd53defd4cc1e78832a2bec8d66e094a0f03c22276e846cf8b598e")) + (195000, uint256S("0x00010530fcae36dc749c679366101df5d344243238e0e6dff2cbf57f9e25d5ce")) + (196000, uint256S("0x00002d2b003cc4851f4950cdfe7996f55b26c7564e60feb6e19597db49dd998b")) + (197000, uint256S("0x00011545798a62155ff5aa047a1cb59c0860b187a59bce8976b57f9c3bb35184")) + (198000, uint256S("0x000061433820de56f44eb774c2f54181b0e6d1e6b27e4a8eefef90039bbecd07")) + (199000, uint256S("0x0000403ced11ef43d8324070ddc30fc69a0c2d8186e4551c140a9378f0312d34")) + (200000, uint256S("0x00009ca9950079d5cd882b615fc068df25beed137642b751b224d6a939a87c69")) + (201000, uint256S("0x000015eb67778c671b0fd29016482d42758cc2edd8361f30788ab95c8328efa5")) + (202000, uint256S("0x0000c6e1a58b63e282fdedf31c1da7cc6d8b0a6dad82fc425672ac0eaf737c84")) + (203000, uint256S("0x000078e0e23fa6f7ccf5e8bb8d6703e0d70b7a86fc0c7493f61ef57e945a8250")) + (204000, uint256S("0x0000451704df4c8a94edd50b78540e8852bb55eef42bf2da3e19a173b8c246d5")) + (205000, uint256S("0x0000309772c01eeda1979e18f93a8721bfdd08c1796ea3a5861011c3de0f9fc1")) + (206000, uint256S("0x00001ba8aa17a23a2c6af771063cbe0afba5bed5b9a7b6c12d3cf0240277fa39")) + (207000, uint256S("0x0000bc3893889caddd09c6117bbd6dd044ebff10b28e008f19f7c43a496592fc")) + (208000, uint256S("0x0000684467ca15f917315fbab3fc3f2907c5f30153c5b884d0298a0d1e77815a")) + (209000, uint256S("0x0000a4f86f394beec9c9241e6dcb05b49393653bc5eaf35820403e54a23bcab6")) + (210000, uint256S("0x000097146b9280bac0344dc886cc4c77141b7467e2ef68e657525d789a9cdcc1")) + (211000, uint256S("0x0000298926d49fc5da4f866133c5c1d1e48d10a17b384eac616022057a7a46c9")) + (212000, uint256S("0x0000eca72307d64a15d234ee372e18862a46d6fc7fd2d0ef3d35c0e5ac836cfa")) + (213000, uint256S("0x0000d89ced1ffc0a9fbc0763d6d090bb19e2657f93c43144b359c16804778a89")) + (214000, uint256S("0x00010f939491f8393ddf82118d72bf420c3ebe01788d3cc69163865bcd848738")) + (215000, uint256S("0x00006ad713ab44526e84e11d0400e5619c2415773cf5068f4946d52bf9633f10")) + (216000, uint256S("0x00008410e6c8ecde65179424ec6443ec1b2215d2403d8b6f779da51136ec02a1")) + (217000, uint256S("0x000020ee6b9a6228bbb57a3dbfab949740801149096f7d0633066026e6792ee5")) + (218000, uint256S("0x0000d38defba9427c17c1cb43398593528af10ae6fbec1d445ce2533c4a0228d")) + (219000, uint256S("0x00001066c0c557ad46f0228c6b8ca18f17979032c55ae24ddab15394080987da")) + (220000, uint256S("0x00010f0dfb2aa26bcd90f8769709a91e0948c03b56ca24740a94f59d5822a815")) + (221000, uint256S("0x000058f2dc34a3060aa22edeb91d3a389f0732e479dc2c0d33696fe61ef1c9f0")) + (222000, uint256S("0x0000533b7f73d91cbe609c8626083dc44e8ce65ddc723729a16e9469030ba263")) + (223000, uint256S("0x0000f81efaff06d9a57c42026bc5aabe52a0ff81a37220e16c4c84904e7cab64")) + (224000, uint256S("0x000130f784b48728fa8f619617996b7e99dfb430176f9ba894a68630a851cd4f")) + (225000, uint256S("0x00003c810725d91c1c489ec513ae71f29562fbc4292719babfcc78dcb293a9e2")) + (226000, uint256S("0x0000dd323efe5d0e9adc1389e4c9eb1c4070fb38d932683032910aba746b3c2e")) + (227000, uint256S("0x000132092774885d1ce3ec989f1b199bdc178b7d406ad9b0d23d3e4e6720d3ca")) + (228000, uint256S("0x0000cf429d0c05ce9e009e501d724d8929fc40027a2f78f7e67ec7d86e91cd57")) + (229000, uint256S("0x000061b40ec34dab4fa83698ace103b6caf9271cbca2b8c7ead55fd299f23f1d")) + (230000, uint256S("0x0000ca632b73f5b1ca9d60ede2010290712fc2f2d28d08ecb31b0affc5b8284f")) + (231000, uint256S("0x000025ffb1c37889da722af7ecfe87e3897c813e4b948d30e1647d44f1a2439a")) + (232000, uint256S("0x0000147749add04281819da29a8c6d7d7e30fa9e8307738519d33605bb26772d")) + (233000, uint256S("0x0000b9ef9879f18d47d7248a8404b2f2b38490f1ea2272e2ab5d10e57e687698")) + (234000, uint256S("0x000006a82f41ac94661d4e0a3dd8d5ef790b5c7c3f68b3bbf9b2c0749ff3171d")) + (235000, uint256S("0x000088d9f88a14a5fefcba4bb61c05e43518806bbb489ea4ea3c53e48ed8262b")) + (236000, uint256S("0x000036c1032ea9f7091faa0ba289ef025926e4f012e19a65476ad061d61343dc")) + (237000, uint256S("0x000016076e6dfd0f0de47d77f975823d286c9458f0e9ce851b8a585e442d1503")) + (238000, uint256S("0x0000b228ebfb020faedd5db874ff7c20bf50f33e0ed824ce30da871ef8859a30")) + (239000, uint256S("0x000098f1ed04960ba6dada245c1d954dda785a250f1365b1d46934514b513e6e")) + (240000, uint256S("0x00004827b75431d480812d39ca8e0925e44889c18b08778b2171c78aacc800f9")) + (241000, uint256S("0x000047f75806dff17a4fbdf87a2361ebf325eb3043d3e7cee86cacabc81394d4")) + (242000, uint256S("0x000027fb57cd69593cc13f6e4ba8cc32bf5982f301c2a9e04474abac8313ced6")) + (243000, uint256S("0x0000d6fb59a655b9402dddd35f09e25085ba1a472e3c344b392d5b3ee293db81")) + (244000, uint256S("0x0000913dc99d2bc33a75deae45a155e2b8dd7953dcd87be10be4943d1b20a82f")) + (245000, uint256S("0x000041e52aed642e547ec8895d84d25203b296f871b50a1f0250ca00c5cf01ea")) + (246000, uint256S("0x00000dbbaad4e01e63b8e068a25d0210ad2c5f656f6d77da241b980fbf77932b")) + (247000, uint256S("0x00010edbb33cf3df1dc924eac96ced741f3a735394bc9fed3b8c1ad3692b3ec5")) + (248000, uint256S("0x00008e0bfb7b326a4bfc6a2995a14f357a27f5725d930a62d2d3ba80f59b2ee0")) + (249000, uint256S("0x00000cf51bb1334a730b924430908700a6f6a995bd9dd252d77b7f94a014c8a8")) + (250000, uint256S("0x000090c5798405d73f400657dcc5685172c6b2608809a9ec2e82297716e5f5cd")) + (251000, uint256S("0x000082d84ca93a2211bb870b3dc2865092fba3b772acbe934cb0a6ff99338762")) + (252000, uint256S("0x000090f2de1badb88177db6c3682f0f223196f51a3e054fe6b06caa5d5e914e3")) + (253000, uint256S("0x0000e0f97c745975bbe5050af8fe92637a7d0cd458cd1706221d34af719f995c")) + (254000, uint256S("0x0000b8eb6c3ec95367882780cba0369222a9acbdbd626bbdc2efa5e9806309ee")) + (255000, uint256S("0x00003f05f5e1dbdc2038158fe47ec02994e8cc643a710a513f8f489dd58f61e8")) + (256000, uint256S("0x0000d31f04b719ad5681f7e1b517daccd9694fbc9409ccd286f558455982d261")) + (257000, uint256S("0x0000ed07ac5882e040bb9de0f4ad4d4527ca5c73c4f1a88eb53dc0651ecbd1b4")) + (258000, uint256S("0x000097e6df4db5049fcff2e691c02570d82c7dbd168189c06f31dd94949ba8b1")) + (259000, uint256S("0x0000e2e8b741d28d9a097229d6e5a2ba1732a82fa2ddcfb41f20eebd94c76c32")) + (260000, uint256S("0x0000263c2baec9d5575580a30787d4893c1517b64ff7294e41f2efb16d21ef85")) + (261000, uint256S("0x00008b142681d8cfc53df1ea806f828f9bdf64789eddd8ee3d031bb8ef8acba8")) + (262000, uint256S("0x0000d2482da09b9d9f76fea70205c1de1029074f2b352ce4b44e86188139daef")) + (263000, uint256S("0x00007ab5c28f261713ec133b8543393d556c1a259ca05968bd3075792aab3ca8")) + (264000, uint256S("0x0000a75e0af3d8f54950cdbe04a0d083eab58c4aa5c83151883f1e4ed3b81364")) + (265000, uint256S("0x0000189eb94df3a9cbc293fb896cdd2c0a11a96c6312ebc48dabcc87c1ce77d5")) + (266000, uint256S("0x00006843e067df56f2eda15d3d2f2b0a3ce1f9ccca76267b43b355939538d94f")) + (267000, uint256S("0x000061e5f1d6bec772831bfcdf02331a6cb8824a2cca249ffa49737d19782447")) + (268000, uint256S("0x00007f909a3f437fbef9702678e510ab70af79371ea7810af0ae12fc5e9e014b")) + (269000, uint256S("0x00007de818cb26675fd9edef889f228985951c8654354ff50671f672bc868815")) + (270000, uint256S("0x000027590b1638a77fbcf91aa46bb6fe044bf24a63a79ad6cc74b46d2318368c")) + (271000, uint256S("0x000066e889f46e219dcf0b4406ad481e8fc400bc65bc4de757f8a2cc946ce9cd")) + (272000, uint256S("0x0000380a032fc737f0d643ad61ba707f4c6fe939a2b430b10fa581f5a0679100")) + (273000, uint256S("0x0000126824caa6aae226452aab57a114ffb6afbf8cf261963a3961318a28b419")) + (274000, uint256S("0x00005c4c0b084a1d192dfe12783aa91c778f1e709457e73cf76f5889cc26bb78")) + (275000, uint256S("0x00007dc532c6b377c64462a8b8c16b3eff0096fbd9c6b4006c752ce7d653989e")) + (276000, uint256S("0x000010f0388da6d99966cf52ea61c27d687ebe07e8235725df251ad15ead0dee")) + (277000, uint256S("0x00003e8d6d6063171e835af9113f880af2a5907712d3c0e96350d3851961856c")) + (278000, uint256S("0x000037ba4dbfc93957ec601b00835a98c16ad2ed58c26c61ce4b9c2a3d333ec2")) + (279000, uint256S("0x00006717a9b460b220defcd60216be89ee2c433a2d888bfcab850ad5f209d94c")) + (280000, uint256S("0x000041384c4c769143b1501c7c6f892a4ae5e295ca471499e08c8299f5162099")) + (281000, uint256S("0x00000b03c4c5ebafada3fa92aee6703ddaefaab554f48bb204e358ac0aa97add")) + (282000, uint256S("0x00006be32af84c330c5d7d2d97684f1e3fac9e1f298784cb15b35df6bc606f8a")) + (283000, uint256S("0x00000dc131bd64e0911950eccc6ce708ac27bd7388da64e19d4cf23ef888b5c7")) + (284000, uint256S("0x000075deef6c427d641f480805c5ddcf260481983924be5f6a22af7a934ddaf0")) + (285000, uint256S("0x00007a019cb2e868b90a7c30debd7de1bfb5440e06c5bd8187f921358c7ae781")) + (286000, uint256S("0x00001095ccb8ef1028bf4ef8df40467441167280b6a7a15384ba60708ca4ed29")) + (287000, uint256S("0x000085d7c734a13bebb8057beff8deec794a930bd6300af1becd7de50d425fa4")) + (288000, uint256S("0x00001d8395c53c0fc68e536df49fe942caa67f6d8a3f91cdcc018d15b3fe0593")) + (289000, uint256S("0x000050cee8c1581b2d8214d43f9a8c888bdb390b91352fd5347b48df92828b8b")) + (290000, uint256S("0x00004240e011ef34f0b6015698b4baa2728b2885a69284afab0424fc6b09877d")) + (291000, uint256S("0x00007c90a0da5bd891f8de0a7a09d1b8af3831143926d02e90d29d9d1934b5e6")) + (292000, uint256S("0x000015965fa7e60705a11e595a18875ed065d8b11d8030880e59a5d474e458f0")) + (293000, uint256S("0x00008981da5387cdfb537ec9d4eb8e8bc81bf5f18938eaf04889acf011c96749")) + (294000, uint256S("0x00003810c0f915b3fc12207edc99f7b9226f5572f491e7349e79b228c8e7469a")) + (295000, uint256S("0x000087f128604abe37b8fefd2f098b0e0984e6e7a65e2151889a302a68c06eca")) + (296000, uint256S("0x000062a42664d4c4e88bbdbd991e7fee35f779c126dd27386e5225d2237dc2d7")) + (297000, uint256S("0x00001c42f5f24b38f202527e3c2cfec3f5621ad87e75253b5d431452d786d4c4")) + (298000, uint256S("0x0000198517575016a98ee8b54deb7232c2312f017d60959280060ea3cf92e4f2")) + (299000, uint256S("0x00003a9031fb5b7e9a318c08588f63e52a6c91845b444e515bfde4c9b88bffe0")) + (300000, uint256S("0x00000c72234e026b3ac4be4a972889fe48810cb27d551058b77d4c5e9b32575c")) + (301000, uint256S("0x000099dff2afc7600c8b724dfc3202d0d29d38ebef21ffc02f4e2f2a66ccea99")) + (302000, uint256S("0x000085a79dd00da9a21cff9b4266a8fe5c2e90b5ea53ec1c7792295192a2e37e")) + (303000, uint256S("0x00005798b40b3eb295eeb9be6af8ca5007784beda82d04a4a8b9c3a2ac0b1096")) + (304000, uint256S("0x00004eedbf20eec4f279484eb5c13c266d463475ad2fdbb7447bf0a8acb7ac6c")) + (305000, uint256S("0x000029cab3bf30d2b12ef99eb43ed67bf6f81399938cde4f061dcf1d3a3b8282")) + (306000, uint256S("0x000030648c81f681bc962e698a27f587da62182e555579910c456f723109b42f")) + (307000, uint256S("0x0000085e26e0618a933a35267273dbeec35ef76f83d7543443cd55a2ca0e233c")) + (308000, uint256S("0x0000239ea91faaf5425f65fc585e7fac6dc518869a1a7091450f90ee8bdb2fd1")) + (309000, uint256S("0x00001b62fdf4af7be68cd70b1f982d29260dd1e667ef349314a4bddd73d55496")) + (310000, uint256S("0x0000765eb51eaa30265211672e8311dd40e265ad4142f4a03efd2f4089d9e186")) + (311000, uint256S("0x0000140c77cdf8f9d4b289aebc0310305693f970ec409f2b828c3ed513f3e58e")) + (312000, uint256S("0x00003f6e2f0e82c242e5b0a7e126ad210e53fb0dfbe794ff2d7e1cdd3873e818")) + (313000, uint256S("0x00002e678cd8a3a18a1cdc5c957b6c0c880acc21b801c68cc4d7b37110a83f22")) + (314000, uint256S("0x0000198bbbeec4927abfc60f2becfb96a5b0846962d65b32de3f9243bdf39af8")) + (315000, uint256S("0x00006c90b93d54587dfd63105e063f6ddf43cff500aa9968622df5c93a5b0798")) + (316000, uint256S("0x00004c21c397bf276a5cd62d960e308fcb098ec45bd60a4f1bf023b6edf2e6ad")) + (317000, uint256S("0x000036b7f6b9e2dea52a6067a94f2e2704bc1824c8e11bd300a841c46e7dd2c2")) + (318000, uint256S("0x000025029ef96a105a50a7030fb0d61edeceea25e4effb02b3ce8eb4c6205782")) + (319000, uint256S("0x00003537409e025a8075526fa097882f919ee169606a9368d8c3db2d33119e14")) + (320000, uint256S("0x000023b752e4c077f231d05026220244ca10a603324035b885e1b0dd6443c148")) + (321000, uint256S("0x000003411062d7ec945c786237575766c5ce2e48c4f94ca04f28b1404ba86097")) + (322000, uint256S("0x000022447ebbb48e06508a70746f87b2e55f026b8ae3052a168f29848d3e2aa7")) + (323000, uint256S("0x000057eac2e6c611398b43e8a72b83f5863b104fa66120e707df6e3e6fa1ba8e")) + (324000, uint256S("0x00006fa40d2be13a2ba910156769754eab5d55059729597a02194e5e0f84b336")) + (325000, uint256S("0x000007fcd4dab7c2cfcfea47ce88932d3ced21fa9264c1c8ed9cbf3fee08635e")) + (326000, uint256S("0x000017fdd022300e952d9274c63cffd8c791dcaa4d82e5d1c9615464df19ae13")) + (327000, uint256S("0x00006739a0fc2ad8788ef615aa26d6a9c7c6d6adf9a9e84f7ae68379eca2a0b3")) + (328000, uint256S("0x0000777de98944635470c99ec1652aa2c15ce3ff4b19de17eed5373d2474a6ab")) + (329000, uint256S("0x000042206ddb76bd7efdb14b694543b685771c6c341089f5bd1dbfa04d6eace2")) + (330000, uint256S("0x000069d6c21607c368128d4586255f315c55380759a766f961acc35a2e9cb166")) + (331000, uint256S("0x00005b19671f21015db7011c9702a420bab766d8bb7cf25b8525429eeff36b45")) + (332000, uint256S("0x00002d62d1f4d13ec708f65c04937b86cf86a36f68caec269f598e8835ca362f")) + (333000, uint256S("0x000013ef2283eae4c9631b4bbbe80b4fb06b663e25a569336326d7897d80a9f8")) + (334000, uint256S("0x000018b4c8d94267953a1df06439a1393c903255a58c9152593eb2d369d87399")) + (335000, uint256S("0x000022628e5db36faec4fe5f107deab56c47c61bb29a51177ecd6f86939d83c1")) + (336000, uint256S("0x00000f22f49242eb151276aa5fc84debb67bc632197c448dd23a501923f6cdc9")) + (337000, uint256S("0x00004aea6cad4849f27af16c298a990e242b77e249eff52fc9c955c121d5ea62")) + (338000, uint256S("0x000064b79a8fd98e2c57184d6ac67daad8278419aee044bec13c7d8de0baebba")) + (339000, uint256S("0x00007ed65e7fe77d691f91d1ed0fbc40413f277770c8a5aa389505b2a179f428")) + (340000, uint256S("0x00002d001410cef77057d66b49c1949ca1367e11297a595b13f17ff1676e55e9")) + (341000, uint256S("0x0000544668ada85a8429537011fa53be0a2c2801c6c022289b8b056ee54e96ef")) + (342000, uint256S("0x0000311ec160ae645fdbffa2eccbdd4212d6c7a5de7e78786d37e9341d531f75")) + (343000, uint256S("0x000010a8f4eefa8040add659396d269e245441439e33154a3b7324ba8884a6fa")) + (344000, uint256S("0x0000500a9df05634fe8987d437cd3ccb502fc36c00fdc73195bbce7d63d1a7a9")) + (345000, uint256S("0x000002a979e67ec52d92b87c4637f166c694378a9a57e3f8103c7d8a084f551a")) + (346000, uint256S("0x000026662841a071a8c0cc28bd560b42af3b739db3d494dc9bf2754bba021da5")) + (347000, uint256S("0x000031d4a32cf5e1c4f1b7d7e3556a2ce8de88ad3f5307f5b20cd7e40a2d1401")) + (348000, uint256S("0x00000f91efbd01c0cd21b1ab0e0daf2d014a7e6bab3fda7ef480ab35c80a2421")) + (349000, uint256S("0x0000460718b2aee973f80306a37506f9cbf40123fd1205c26c33b0d9749d524b")) + (350000, uint256S("0x00005953abe841392b72e8fab12e3cbceb18c128f73e1aa4406defd18543fe4c")) + (351000, uint256S("0x000018647cfc45a1524168193e67e6af22e8677ba3428dde5f6a2f76c199532d")) + (352000, uint256S("0x00004d0d3fc72f9d7f9a6712c098eb6cef0a7756886011f036736de200fbe5c9")) + (353000, uint256S("0x00007948b8f6bb2433088cffb4bb18ca1d03aad3068a7ea923475f1aa108fd20")) + (354000, uint256S("0x00000a0072325a23f9afcaff49a8c3bcb04f1fcb01612de33bcb9f0f20ebb356")) + (355000, uint256S("0x00003e0133ccefae6723c9f14bfd290a7aaf60c2bc962c293fb58b5957ed1a2e")) + (356000, uint256S("0x000005b41a41a8ec5c60cad85a03d9fa5025b5d9a088a6bbc2ebd1d8e858189e")) + (357000, uint256S("0x000021655f02625c28257183e5c4639841b11661cf40f00fc5ac4bcfcf1eb072")) + (358000, uint256S("0x00007c3fe61dca2d5c52bd5e9090c91812bab9c6a7407e32ed0a930b421f5b80")) + (359000, uint256S("0x000063f8390cad7ad17cbd18983b923e18a1469d5730dec7a62e12914c66df9c")) + (360000, uint256S("0x00000f11a3a78c71d8a7c722cfb52f51006b3656b707cf94c0b08a80c4fd4dc9")) + (361000, uint256S("0x000008e76b1c141b783936c946af3f121d5b96fb8766d83c58ea7f7602c78386")) + (362000, uint256S("0x00000c92d4b3163c33c0efa3feaf6f4c170f9d6288d2435a09435eac87d04e09")) + (363000, uint256S("0x0000567379ab1430696266da7ee6dd1e7ba0eb91bba09c85f558c181e01625e5")) + (364000, uint256S("0x00000712954e172eef571e8297ea1843aba0a762b31b5b2b40ca2027e7c0b1ec")) + (365000, uint256S("0x0000627358770bbc0bf614acb3d02d996f220562f083d08c75e71aa2e83a7870")) + (366000, uint256S("0x0000404c17107474c2a0704c9920ee16e502c8119581f4707e0959af3004746a")) + (367000, uint256S("0x00006c5d54ad2b5279842e8ee726359064c72a034c5c3d5f261413c2cc6a4e6f")) + (368000, uint256S("0x00000df9f5d119afd39c0654010f1ff492f8e04dc1dbe1cc0d3ad5767601c91b")) + (369000, uint256S("0x00004e47d205ac774a1f6d7d8bcc29d6eba6f11005b75aee6dedca1e46a1c1db")) + (370000, uint256S("0x0000810057e4efa124db97d9433372af35b93ae61ea4b620f7ac3ac26658a5aa")) + (371000, uint256S("0x00007e49d0ae73df2647b33550aad63d79c05e40b08fc1c25cb9450ad2b5e8f3")) + (372000, uint256S("0x0000076bfad90f3f5befd763f0abdfd05077821099e0c33bc3947ed853d0b928")) + (373000, uint256S("0x00000d03d70c31a5ae2d32b66a3528981c88d361cc165512a3d9278ebace0589")) + (374000, uint256S("0x00003e477b6dd1ffc2218862bc18b5a651c82122cdcec0c455613d1891e9a727")) + (375000, uint256S("0x000012ad562f8b65a93cb2eb5f708d55e4c3ac689d2020843c55b34099755233")) + (376000, uint256S("0x0000556b17a0197dbaba33c7f58fee2cc9219b6918d925a4146fa7fd5de0e94b")) + (377000, uint256S("0x00005f1ac71e07fcc4f44fdfef693983a872be58f5b1bc04d13873408a54f2e2")) + (378000, uint256S("0x000014e65f4e30b3097d2ebb33c11ada6abaf81e8ac3ffc2e0b6d4756b59822a")) + (379000, uint256S("0x000021418aa5de171ac72097abad42b7f1af1a2f7e19b4c98c7174d5164fa5bc")) + (380000, uint256S("0x000046b214d061a9c237e42bf42493f9792cf80b95f89ef10f432cacee23eba6")) + (381000, uint256S("0x000068f06f5bf5b288e78d694775cb76cf1ed473f95da29790e4b60133d6bb87")) + (382000, uint256S("0x000008c5632f8e3f8e61aebd686b624c7ad644227639d320c3ad286f71d4e14d")) + (383000, uint256S("0x00003b7fffa7e988b90e05d94d24153b0a22e01d9ee0c56e04e9263c88c558ee")) + (384000, uint256S("0x0000083022ca686c81f5f403743dba37334a0e96f96d3c8bed7353a1bd11e58b")) + (385000, uint256S("0x0000485dc4369a16c2c8bde7577ce99ffd0a15a1d21cdf61c01f0bee17b36b2a")) + (386000, uint256S("0x00006da0099b6f9edb40dab855231677bf4f97b0e7643fccad05cd97a8b76397")) + (387000, uint256S("0x000063ff38ec555dc089900fe0ff5648488421918db713941d6c24cfebad37fe")) + (388000, uint256S("0x000069ca27290d71648678a0c5ebd379a17ffc895fea7b23837093a337563060")) + (389000, uint256S("0x00004a1e13ef7557c9dfe0c7daf3e7483e7d1420afff64a5325af7d5bfe49994")) + (390000, uint256S("0x00001dce3a9cdd42f97d3268d29bdad179375f61f7d4e729919450996917c583")) + (391000, uint256S("0x0000071173926b7f9492e35cf48185c2cb57ffcaff2149dcef5c40148a55255d")) + (392000, uint256S("0x00007c3336097b98f2fbc46dcd4f981e73ddb93c8096015282eba490b773cda4")) + (393000, uint256S("0x00000738869c9b8cf66aaa075ebefc5209c90a0f225b405e1850b0b00343bc2e")) + (394000, uint256S("0x0000537c3d2b6794fc5c2636a3311e1cdb34c019ae2dc09778d0c500e1593f2f")) + (395000, uint256S("0x00000dad4673f1db54a434d106a69af55f494ac29a428ff37f4e4aa3b734a37d")) + (396000, uint256S("0x0000514b509a25edc24df6d94e24e2aac5727c18d361fdd7e64356f2233016b2")) + (397000, uint256S("0x00000eaaf35e4358bee2a8c5981683b15214d7ecc03701438f94f5306d10c6c3")) + (398000, uint256S("0x00007cb707f7132454c53ba8410dbb588c3b23e7d731f824d58da21f4ac62330")) + (399000, uint256S("0x00000cc6edba6cf9dd44204502309c781a1f769e019e42306c785dfd2d3614eb")) + (400000, uint256S("0x000023fc6e679339fa72280568217dee1ea0c26790c13f80d0092f9b12ed5f38")) + (401000, uint256S("0x00004ee2b9c7df597e26a4ee85b56c0842380adf5d15b9f6667a132f7cb0b07c")) + (402000, uint256S("0x000073b711054a260c45b4ad63796949d2a00a0baca00e1a68ed16fc98f45d70")) + (403000, uint256S("0x000070b43d9d52a1f896a13bfdfb445fcc3b1374b7ef123b0cce1488f551a954")) + (404000, uint256S("0x00007864734f9e3f3596d9d92df853d3a9b1172ff747fe5983e09028114404c3")) + (405000, uint256S("0x000075ff54f6af74e69cb36dfd7634dace0c68e00d309da017f81ea5dcc9480d")) + (406000, uint256S("0x00008b908deffb33856ccd1ef6afa73cf8bd01e8c3b5be502829dd64157e3f7e")) + (407000, uint256S("0x000023d28f6b13c134285247c6d8191f16a94463ccd84a506c99ba52706b67e6")) + (408000, uint256S("0x0000723a9c35577d2e56749861ad4e9d3c61b1c650e0c7c832cb1d60346fb46c")) + (409000, uint256S("0x000021a04d41834edb1ebf0c3c09488fb1e3da4c30acfda07ef154de955dbfc0")) + (410000, uint256S("0x00007b63162192a0b9c1015a227df9fe264591b5842aab61a637c06768a5e3d7")) + (411000, uint256S("0x0000064165fbcae2b8c44549630ec47c9504c77ddd0aaea91e846539ce023c6d")) + (412000, uint256S("0x000048d4879eb955e516485f822f2f52fa078f02396fcdbd1e0fc0698a90d577")) + (413000, uint256S("0x00006df51ae354366835450d019ea8a7a59a34060dec74de630bdf8004bbbd18")) + (414000, uint256S("0x0000113f9fa68a6a1acc32aeab61e8ca15e1f53e9f43b9e77bca85fecc7871d8")) + (415000, uint256S("0x000003ec7bf286218a52ceea9a5b8ec460a5a77211679c2b8d1d1e4ff96c03fe")) + (416000, uint256S("0x00000c4a34784e10158b231baa9c35b6aca1cb1d967f65bdeed7480f55df869d")) + (417000, uint256S("0x00004462829936ef1967f6604d00c0e034588642dacc1ec827ec3b4468202ab0")) + (418000, uint256S("0x00005debf20584e6e0adb8c05a73bf4b30484451964d39536f50bb02b426b0b1")) + (419000, uint256S("0x00006357b1afbb6aebcfc778c06ed1fc51fbb51a7fc9b882c4c9bb4a35e0b4ed")) + (420000, uint256S("0x000040207b5dc0f5e2509b1216b549672c58d68bac8224f67492aa803b2f2570")) + (421000, uint256S("0x000042124fbfa2ba3db57f39bfd4f5986969c5c4faf8b1c06cf470a5ea001788")) + (422000, uint256S("0x00003c97f3bdafac16b245ea1f3b941c52388be5bec9c087186ac17088d5cbf5")) + (423000, uint256S("0x00005068310436b42ace3d987e8a10eb858b4a23321dfeeefaef22e9446fa2b0")) + (424000, uint256S("0x00005ef6829528a3504565070d82e425614426ab25b45bca04aa4af3d7e0e29c")) + (425000, uint256S("0x000024123c6a896dfb002e50b4574037d07bb94e0a0e9544e67f8a2e090b6b89")) + (426000, uint256S("0x00004f641099594d32e1880080931343420e8597be3939a4f6628969d4c94a4d")) + (427000, uint256S("0x000078d2859474d6b72acaa6060ced2386028e457743bad4cd9b0ced3f8ab154")) + (428000, uint256S("0x000087e3b407861303f6b32015910f4a3dd0f1f78a4e53f178ca442e9275c317")) + (429000, uint256S("0x000060b5c76252c68f358202b6f6c421d5ca9c705dd28240882258df8a809174")) + (430000, uint256S("0x0000305e76e05f96396d96187e6d35e900a4d735aeee6f105168eb45846d7055")) + (431000, uint256S("0x00002181db7f434ad47bfc295f8ebf8caa382f13829ff70b06263648e0e033ad")) + (432000, uint256S("0x00003e3f8d3848689893840e239619e875db02745d68709a533e30fef16fe9b1")) + (433000, uint256S("0x00007ec0e6150fdeee913a18f5c8f3d7099bc744a218dc6a01c63580aa9c8eb1")) + (434000, uint256S("0x0000415b347418526dbbce15098f2d8d1b5a1dd0446151efcfdd3318d5861351")) + (435000, uint256S("0x0000663b475c89a1ead8cc41c1ed10c8fcdbf417d007a6f0b95580a1165eaa1a")) + (436000, uint256S("0x00001783f2a7362a81e0b49cfdeb7dbb032e6e9ab4f66b3cefb4e52f1c5dfb34")) + (437000, uint256S("0x00008486eaa2a91c1ef5c530065431dbbb0c4240dea7a2101ab0582484003280")) + (438000, uint256S("0x00004fd678f5f493ea4e9ec5b54dd66749350fcd325c5ec677c154bcbca88799")) + (439000, uint256S("0x00009244e5e34e05cfcf1bbf619c8a8b43ceb538fabfa7843be9796a295e49e8")) + (440000, uint256S("0x000036b5b2b13908454ede21c5826af6331b728a66da7fc67bfedca910ff9b80")) + (441000, uint256S("0x000034367b426ed559bb7d0b1046eec735a850c53fce26f8b0716198ff90051e")) + (442000, uint256S("0x000059583a267d919d5bc4c65abf8c304150e45a336b9f34bb35ddaf0bcb1787")) + (443000, uint256S("0x00004f414772200bfaf67651fbc4cc103367a5108a35fe026850a4bfd92d38ff")) + (444000, uint256S("0x00001b9bc79d27709c34a96a5dbd6a259fa1495afdf8fd05c23a2d659602620c")) + (445000, uint256S("0x000061e49c4d2d995a43a2d2b491a023444b70aba5150ee4d2789cfca6018710")) + (446000, uint256S("0x000051f2bc3eb24aa77017476494528e0096a0a1cb1e29b4318ce9b3410c6751")) + (447000, uint256S("0x00002979121255c18f58c5ec1a4267104585577b91e2e61682b44d65930400f5")) + (448000, uint256S("0x00001122c7a9f21b96941e6e074122ce55cb412d659ffbfad8a0bebcbd487533")) + (449000, uint256S("0x00005ed4ab8507e94702e24ce16b257e8eac754be1eb3e743b430bdbe3e2eb14")) + (450000, uint256S("0x00001579df12ce8d38b8f4416f221964af6aa54bd065201c578bee6e03596463")) + (451000, uint256S("0x000057eae48d40b8b59a16f65fa4b5902b27dbe0bb5470cd27214f4045172d87")) + (452000, uint256S("0x00006e7bbad31584a17b7bae4b7555a4807ce276cd5046a309d79f0a402cdbd9")) + (453000, uint256S("0x0000011e661360329ac1ba58e11f2358731abd884d1c590525d074195bfc8ddd")) + (454000, uint256S("0x000065acdfbb8d1e0d66b358f81acd99711adedb85f37fd522b8b515184a073c")) + (455000, uint256S("0x000026888730aacaf408c7b6cdd5a4ebce04f4c2aea22061f5ee832a65c52b24")) + (456000, uint256S("0x0000602cca1d31d8a750c84cda243b6d454d4d93bcc2241cf0ae6982a4716755")) + (457000, uint256S("0x00002d7fd2ac55de783d6f69270fd9e499789185e98eca4561bcfb13be663cee")) + (458000, uint256S("0x000015971c8c8c0d2b2ba9b9c0dd5c97091b77e3bd747cd8f5a1396d7cbc39d0")) + (459000, uint256S("0x00008473ea08a574ab72f3246462ca97fed87478c6e5fb39bb9b340f6c8b0f44")) + (460000, uint256S("0x00006487396edc5cb9bf6f5cd62491d1d5a47e89257ac0286cbcc8f428239fb7")) + (461000, uint256S("0x00004579751a959bf33a7418c872ee533c11dd0db764bdbf800317fcca50db74")) + (462000, uint256S("0x00005e57d635a75aae751e87aa9081218babed5522861be57ca55ea5d91e5cc3")) + (463000, uint256S("0x00000fb2816e0c45b5414b72aa67a918c1ffc6a5e114d4f4aa2c1863f9d7ea7a")) + (464000, uint256S("0x00003c2985800d71f2875169d86d911bbf3ede85eaec083869bcb817d5930407")) + (465000, uint256S("0x000037d41b8dcc82d16da8907512e4c0dd4d98e5f8e1985f6c418d62fe38bf20")) + (466000, uint256S("0x000034e51cc154129c394b6130d3711bf930c47a0943c0e08598353565781e8e")) + (467000, uint256S("0x00004c2bd9c0a4414e9c689b21a8266dcd0ea9f0363559940c77f53dac76a746")) + (468000, uint256S("0x0000097d658883238e26170d0244759a6a0fb53204e392bd5607bff329e52580")) + (469000, uint256S("0x000068c832e7335fa8b095693ede2161463e250a6857171efb34e8b2c858f0cc")) + (470000, uint256S("0x000016f55342090f2f7dd1013c1780daea3e18331b9e481e44cc969e42267c9a")) + (471000, uint256S("0x00002544263ac1d071b15575a1be34f3e220e97b631bbd0a37ca2211da3be579")) + (472000, uint256S("0x000082479a6d345f52f2f6a3a7f8b3e1bde3e31bdf6971ae7e17a4e9ceb9f3d8")) + (473000, uint256S("0x00006af93834d09ba9e22c0e9bcf041df511fa73adc7c3b90b20930c14dc3afc")) + (474000, uint256S("0x000009f5395a0e10bd3467d49468f22a17b96cc56f133742b4b94f81d055a1ed")) + (475000, uint256S("0x00000732dfcbe6c20963da08712f407c0137c686c2c5b8199be7ab93533ca75e")) + (476000, uint256S("0x0000212ee23e893f853ef49641d748435b3a783c12eccfaa9d113ed1039a59aa")) + (477000, uint256S("0x00002eb7f121312d1702a95d23e6058d305bc2fcec6b665918d1f61ccdce3d8a")) + (478000, uint256S("0x00007c3f92685d1ab3a31d4462286825e1edf247b74f0f2acf203cfda160b4b6")) + (479000, uint256S("0x0000387969e04687fa879ecc4b7ef42e94d7702b2adc5c895b91036f2b2b32a5")) + (480000, uint256S("0x00004fcf6a8c13044beef7a176c1b872bbec53cc00aee74a4cbc9f7cb332ad29")) + (481000, uint256S("0x000071ff0caf576084563d6bc15fe7887b261a22cd7f2540a047486dc97cd961")) + (482000, uint256S("0x00000d18b5deb42f4a383a510d5ce92e4ffe84cf12556adb09cfc381eae9343a")) + (483000, uint256S("0x00003045108fd460198ab5db9154df288f796e4714d78bfc030bf32a0d72ece4")) + (484000, uint256S("0x000077ab6ef56dc32d8d78340e0f69e9666914ce0299c16d80c9ed44b95cc74c")) + (485000, uint256S("0x00005641dd3b8af4af4328e7240b2f614d4f9bc02d941f1cb753fd9b9e648ac3")) + (486000, uint256S("0x000045d840594db850fdf19c03b29b2587b225f7c17009b6bc92c3a95d913714")) + (487000, uint256S("0x0000428e6bef96b2cfa2a512d10ff22f459e1c81dfd833935bd2bec9a9401c70")) + (488000, uint256S("0x00004b7a10c67d0bd09058183babec02861c0722b09b75038d3779a586bcee48")) + (489000, uint256S("0x000023557e9510f58a398eeaf0c36753b93ade77ce885f8736011f5eba399340")) + (490000, uint256S("0x000021e70faa40c6b1cd9ed3f91b8ad43e2570a00e34c54c5ed74218ac33bf72")) + (491000, uint256S("0x00002edd58e2126702485fddda9eb55d1d39880c44de8d8c0efdcdecdae2722c")) + (492000, uint256S("0x00004f00c0831ebd6675da2aa83a3352e79affee2786a26dab96cda9336b7ccc")) + (493000, uint256S("0x000064438694b83dc959b20b82cd5da3f4622186404753b97340450be0a15755")) + (494000, uint256S("0x00003607262aef0da4f84721222cfb5cbb915db323ec95e1b4e70bf3ce860c6b")) + (495000, uint256S("0x000024c603dbf750c01c2975ab60624bfe5ed2e44532649917d9645ae6209ebf")) + (496000, uint256S("0x0000191661868f098c37178cebe1c4eea37f311eaeb82e5148f1452b26d1fbca")) + (497000, uint256S("0x000029b3502c67a39247b646f286d925af7d0501f994c4367d8769dadaa9ab1b")) + (498000, uint256S("0x00003e7be1463cf709a8a1fc6b431c442de0f5e972b8b2444fcb2d275287d36c")) + (499000, uint256S("0x00000d00e2075b9de577c9f2b21927ea21f4bc6719734888073e039a43e3f30c")) + (500000, uint256S("0x000038889c413584ecab16aaf0ae8f050fec136484416084187a2fa27ed1efc4")) + (501000, uint256S("0x00003e0981fdee677dbfdffbf5910ab8ccab4d91e2e3f10594668cad35e0fe1b")) + (502000, uint256S("0x00000e08e2495364b7cdd48cd2999e568e92f4ca9b27343af4240f9adc194f9d")) + (503000, uint256S("0x000014996d031f6c0b0d3e0268d22c75ee9bed7e9f845f81b8df5dd38b195995")) + (504000, uint256S("0x0000041a7d55d6e9344faff6af6a60608a4572f3c12adb79a326606e5b168cd2")) + (505000, uint256S("0x00002df16f23a38f3bf6e3e42f5f14ff44bb357a975c8eb43d4985f16e4a7628")) + (506000, uint256S("0x000042c9adeb835a1105e772a9fc637d156cc8eff5d71a78243dbf3fe0ab096f")) + (507000, uint256S("0x000001c27a7bf812eb8ba21e6ce59591b2eaaf50121e5c98fd740629d00a4e2b")) + (508000, uint256S("0x00000716bb09e7513f50d5ea46d15324d892c305a11267306c009c720f51d3bb")) + (509000, uint256S("0x00007358b4d32fac5362839bf3bebdd938905766ef3e853d00ebf8557a724239")) + (510000, uint256S("0x000045c957443966535795a08bc5feffee0f0c59b55d7ba727593dbc459a1c34")) + (511000, uint256S("0x00001d9b8898a1a26bec928ded3b3650b6e0b6cf6589f95072fbff5586057716")) + (512000, uint256S("0x00006c49e4544ce19a6b3e4a4e82e05fbc3ef1ce9d3dee203cf09f047ec92d30")) + ,(int64_t) 1686842247, // time of last checkpointed block + (int64_t) 523914, // total txs + (double) 1454 // txs in the last day before block 512445 }; } else { // all other HSC's with no checkpoints From 5abc550af7c8312519fe543a796599cb7c02a7ad Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 17 Jun 2023 09:52:12 -0400 Subject: [PATCH 17/36] Dragonx has a blocktime of 36s not 60s --- util/checkpoints.pl | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/util/checkpoints.pl b/util/checkpoints.pl index cb8301d61..153c2dcba 100755 --- a/util/checkpoints.pl +++ b/util/checkpoints.pl @@ -31,8 +31,10 @@ my $acname = shift; if ($acname) { # TODO: is acname valid? $cli .= " -ac_name=$acname"; - # TODO: assumes all HSC's will have a blocktime of 60s + # HSC's by default have a blocktime of 60s $perday = 1440; + # Dragonx has a blocktime of 36s + $perday = 2400 if ($acname == 'DRAGONX'); } else { $acname = 'HUSH3'; } From 31cc5ee901c621b3bde2e4987c69c3906a039586 Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 17 Jun 2023 21:22:41 -0400 Subject: [PATCH 18/36] Remove unused code --- src/hush_gateway.h | 97 +---------------- src/hush_globals.h | 1 - src/hush_pax.h | 259 +-------------------------------------------- src/hush_utils.h | 1 - 4 files changed, 2 insertions(+), 356 deletions(-) diff --git a/src/hush_gateway.h b/src/hush_gateway.h index b040d3d48..8068b3259 100644 --- a/src/hush_gateway.h +++ b/src/hush_gateway.h @@ -18,40 +18,9 @@ // paxdeposit equivalent in reverse makes opreturn and HUSH does the same in reverse #include "hush_defs.h" -/*#include "secp256k1/include/secp256k1.h" -#include "secp256k1/include/secp256k1_schnorrsig.h" -#include "secp256k1/include/secp256k1_musig.h" -int32_t dummy_linker_tricker() -{ - secp256k1_context *ctx = 0; std::vector musig64; CPubKey pk; secp256k1_schnorrsig musig; secp256k1_pubkey combined_pk; - if ( secp256k1_schnorrsig_parse((const secp256k1_context *)ctx,&musig,(const uint8_t *)&musig64[0]) > 0 && secp256k1_ec_pubkey_parse(ctx,&combined_pk,pk.begin(),33) > 0 ) - return(1); -}*/ int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base) { - int32_t baseid; struct hush_state *sp; int64_t netliability,maxallowed,maxval; - *available = *deposited = *issued = *withdrawn = *approved = *redeemed = 0; - if ( (baseid= hush_baseid(base)) >= 0 ) - { - if ( (sp= hush_stateptrget(base)) != 0 ) - { - *deposited = sp->deposited; - *issued = sp->issued; - *withdrawn = sp->withdrawn; - *approved = sp->approved; - *redeemed = sp->redeemed; - maxval = sp->approved; - if ( sp->withdrawn > maxval ) - maxval = sp->withdrawn; - netliability = (sp->issued - maxval) - sp->shorted; - maxallowed = hush_maxallowed(baseid); - if ( netliability < maxallowed ) - *available = (maxallowed - netliability); - //printf("%llu - %llu %s %.8f %.8f %.8f %.8f %.8f\n",(long long)maxallowed,(long long)netliability,base,dstr(*deposited),dstr(*issued),dstr(*withdrawn),dstr(*approved),dstr(*redeemed)); - return(0); - } else printf("pax_fiatstatus cant get basesp.%s\n",base); - } // else printf("pax_fiatstatus illegal base.%s\n",base); return(-1); } @@ -210,71 +179,7 @@ int32_t hush_rwapproval(int32_t rwflag,uint8_t *opretbuf,struct pax_transaction int32_t hush_issued_opreturn(char *base,uint256 *txids,uint16_t *vouts,int64_t *values,int64_t *srcvalues,int32_t *hushheights,int32_t *otherheights,int8_t *baseids,uint8_t *rmd160s,uint8_t *opretbuf,int32_t opretlen,int32_t iskomodo) { - struct pax_transaction p,*pax; int32_t i,n=0,j,len=0,incr,height,otherheight; uint8_t type,rmd160[20]; uint64_t fiatoshis; char symbol[HUSH_SMART_CHAIN_MAXLEN]; - //if ( HUSH_PAX == 0 ) - // return(0); - incr = 34 + (iskomodo * (2*sizeof(fiatoshis) + 2*sizeof(height) + 20 + 4)); - //41e77b91cb68dc2aa02fa88550eae6b6d44db676a7e935337b6d1392d9718f03cb0200305c90660400000000fbcbeb1f000000bde801006201000058e7945ad08ddba1eac9c9b6c8e1e97e8016a2d152 - - // 41e94d736ec69d88c08b5d238abeeca609c02357a8317e0d56c328bcb1c259be5d0200485bc80200000000404b4c000000000059470200b80b000061f22ba7d19fe29ac3baebd839af8b7127d1f9075553440046bb4cc7a3b5cd39dffe7206507a3482a00780e617f68b273cce9817ed69298d02001069ca1b0000000080f0fa02000000005b470200b90b000061f22ba7d19fe29ac3baebd839af8b7127d1f90755 - - //for (i=0; i>>>>>> %s: (%s) fiat %.8f hushheight.%d other.%d -> %s %.8f\n",type=='A'?"approvedA":"issuedX",baseids[n]>=0?CURRENCIES[baseids[n]]:"???",dstr(p.fiatoshis),hushheights[n],otherheights[n],coinaddr,dstr(values[n])); - } - } - } - else - { - for (i=0; i<4; i++) - base[i] = opretbuf[opretlen-4+i]; - for (j=0; j<32; j++) - { - ((uint8_t *)&txids[n])[j] = opretbuf[len++]; - //printf("%02x",((uint8_t *)&txids[n])[j]); - } - vouts[n] = opretbuf[len++]; - vouts[n] = (opretbuf[len++] << 8) | vouts[n]; - baseids[n] = hush_baseid(base); - if ( (pax= hush_paxfinds(txids[n],vouts[n])) != 0 ) - { - values[n] = (strcmp("HUSH3",base) == 0) ? pax->puposhis : pax->fiatoshis; - srcvalues[n] = (strcmp("HUSH3",base) == 0) ? pax->fiatoshis : pax->puposhis; - hushheights[n] = pax->height; - otherheights[n] = pax->otherheight; - memcpy(&rmd160s[n * 20],pax->rmd160,20); - } - } - //printf(" hush_issued_opreturn issuedtxid v%d i.%d opretlen.%d\n",vouts[n],n,opretlen); - } - } - return(n); + return 0; } int32_t hush_paxcmp(char *symbol,int32_t hushheight,uint64_t value,uint64_t checkvalue,uint64_t seed) diff --git a/src/hush_globals.h b/src/hush_globals.h index 4ac3060b6..e307f774c 100644 --- a/src/hush_globals.h +++ b/src/hush_globals.h @@ -29,7 +29,6 @@ int32_t hush_chosennotary(int32_t *notaryidp,int32_t height,uint8_t *pubkey33,ui int32_t hush_isrealtime(int32_t *hushheightp); uint64_t hush_paxtotal(); int32_t hush_longestchain(); -uint64_t hush_maxallowed(int32_t baseid); int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts); pthread_mutex_t hush_mutex; diff --git a/src/hush_pax.h b/src/hush_pax.h index 9289ce15d..eba734593 100644 --- a/src/hush_pax.h +++ b/src/hush_pax.h @@ -18,213 +18,13 @@ #include "hush_defs.h" -#define USD 0 -#define EUR 1 -#define JPY 2 -#define GBP 3 -#define AUD 4 -#define CAD 5 -#define CHF 6 -#define NZD 7 - -#define CNY 8 -#define RUB 9 -#define MXN 10 -#define BRL 11 -#define INR 12 -#define HKD 13 -#define TRY 14 -#define ZAR 15 - -#define PLN 16 -#define NOK 17 -#define SEK 18 -#define DKK 19 -#define CZK 20 -#define HUF 21 -#define ILS 22 -#define KRW 23 - -#define MYR 24 -#define PHP 25 -#define RON 26 -#define SGD 27 -#define THB 28 -#define BGN 29 -#define IDR 30 -#define HRK 31 - -#define MAX_CURRENCIES 32 -extern char CURRENCIES[][8]; - -uint64_t M1SUPPLY[] = { 3317900000000, 6991604000000, 667780000000000, 1616854000000, 331000000000, 861909000000, 584629000000, 46530000000, // major currencies - 45434000000000, 16827000000000, 3473357229000, 306435000000, 27139000000000, 2150641000000, 347724099000, 1469583000000, 749543000000, 1826110000000, 2400434000000, 1123925000000, 3125276000000, 13975000000000, 317657000000, 759706000000000, 354902000000, 2797061000000, 162189000000, 163745000000, 1712000000000, 39093000000, 1135490000000000, 80317000000, - 100000000 }; - -#define MIND 1000 -uint32_t MINDENOMS[] = { MIND, MIND, 100*MIND, MIND, MIND, MIND, MIND, MIND, // major currencies - 10*MIND, 100*MIND, 10*MIND, MIND, 100*MIND, 10*MIND, MIND, 10*MIND, MIND, 10*MIND, 10*MIND, 10*MIND, 10*MIND, 100*MIND, MIND, 1000*MIND, MIND, 10*MIND, MIND, MIND, 10*MIND, MIND, 10000*MIND, 10*MIND, // end of currencies -10*MIND, -}; - -int32_t Peggy_inds[539] = {289, 404, 50, 490, 59, 208, 87, 508, 366, 288, 13, 38, 159, 440, 120, 480, 361, 104, 534, 195, 300, 362, 489, 108, 143, 220, 131, 244, 133, 473, 315, 439, 210, 456, 219, 352, 153, 444, 397, 491, 286, 479, 519, 384, 126, 369, 155, 427, 373, 360, 135, 297, 256, 506, 322, 425, 501, 251, 75, 18, 420, 537, 443, 438, 407, 145, 173, 78, 340, 240, 422, 160, 329, 32, 127, 128, 415, 495, 372, 522, 60, 238, 129, 364, 471, 140, 171, 215, 378, 292, 432, 526, 252, 389, 459, 350, 233, 408, 433, 51, 423, 19, 62, 115, 211, 22, 247, 197, 530, 7, 492, 5, 53, 318, 313, 283, 169, 464, 224, 282, 514, 385, 228, 175, 494, 237, 446, 105, 150, 338, 346, 510, 6, 348, 89, 63, 536, 442, 414, 209, 216, 227, 380, 72, 319, 259, 305, 334, 236, 103, 400, 176, 267, 355, 429, 134, 257, 527, 111, 287, 386, 15, 392, 535, 405, 23, 447, 399, 291, 112, 74, 36, 435, 434, 330, 520, 335, 201, 478, 17, 162, 483, 33, 130, 436, 395, 93, 298, 498, 511, 66, 487, 218, 65, 309, 419, 48, 214, 377, 409, 462, 139, 349, 4, 513, 497, 394, 170, 307, 241, 185, 454, 29, 367, 465, 194, 398, 301, 229, 212, 477, 303, 39, 524, 451, 116, 532, 30, 344, 85, 186, 202, 517, 531, 515, 230, 331, 466, 147, 426, 234, 304, 64, 100, 416, 336, 199, 383, 200, 166, 258, 95, 188, 246, 136, 90, 68, 45, 312, 354, 184, 314, 518, 326, 401, 269, 217, 512, 81, 88, 272, 14, 413, 328, 393, 198, 226, 381, 161, 474, 353, 337, 294, 295, 302, 505, 137, 207, 249, 46, 98, 27, 458, 482, 262, 253, 71, 25, 0, 40, 525, 122, 341, 107, 80, 165, 243, 168, 250, 375, 151, 503, 124, 52, 343, 371, 206, 178, 528, 232, 424, 163, 273, 191, 149, 493, 177, 144, 193, 388, 1, 412, 265, 457, 255, 475, 223, 41, 430, 76, 102, 132, 96, 97, 316, 472, 213, 263, 3, 317, 324, 274, 396, 486, 254, 205, 285, 101, 21, 279, 58, 467, 271, 92, 538, 516, 235, 332, 117, 500, 529, 113, 445, 390, 358, 79, 34, 488, 245, 83, 509, 203, 476, 496, 347, 280, 12, 84, 485, 323, 452, 10, 146, 391, 293, 86, 94, 523, 299, 91, 164, 363, 402, 110, 321, 181, 138, 192, 469, 351, 276, 308, 277, 428, 182, 260, 55, 152, 157, 382, 121, 507, 225, 61, 431, 31, 106, 327, 154, 16, 49, 499, 73, 70, 449, 460, 187, 24, 248, 311, 275, 158, 387, 125, 67, 284, 35, 463, 190, 179, 266, 376, 221, 42, 26, 290, 357, 268, 43, 167, 99, 374, 242, 156, 239, 403, 339, 183, 320, 180, 306, 379, 441, 20, 481, 141, 77, 484, 69, 410, 502, 172, 417, 118, 461, 261, 47, 333, 450, 296, 453, 368, 359, 437, 421, 264, 504, 281, 270, 114, 278, 56, 406, 448, 411, 521, 418, 470, 123, 455, 148, 356, 468, 109, 204, 533, 365, 8, 345, 174, 370, 28, 57, 11, 2, 231, 310, 196, 119, 82, 325, 44, 342, 37, 189, 142, 222, 9, 54, }; - -uint64_t peggy_smooth_coeffs[sizeof(Peggy_inds)/sizeof(*Peggy_inds)] = // numprimes.13 -{ - 962714545, 962506087, 962158759, 961672710, 961048151, 960285354, 959384649, 958346426, 957171134, // x.8 - 955859283, 954411438, 952828225, 951110328, 949258485, 947273493, 945156207, 942907532, 940528434, // x.17 - 938019929, 935383089, 932619036, 929728945, 926714044, 923575608, 920314964, 916933485, 913432593, // x.26 - 909813756, 906078486, 902228342, 898264923, 894189872, 890004874, 885711650, 881311964, 876807614, // x.35 - 872200436, 867492300, 862685110, 857780804, 852781347, 847688737, 842505000, 837232189, 831872382, // x.44 - 826427681, 820900212, 815292123, 809605581, 803842772, 798005901, 792097186, 786118864, 780073180, // x.53 - 773962395, 767788778, 761554609, 755262175, 748913768, 742511686, 736058231, 729555707, 723006417, // x.62 - 716412665, 709776755, 703100984, 696387648, 689639036, 682857428, 676045100, 669204315, 662337327, // x.71 - 655446378, 648533696, 641601496, 634651978, 627687325, 620709702, 613721256, 606724115, 599720386, // x.80 - 592712154, 585701482, 578690411, 571680955, 564675105, 557674825, 550682053, 543698699, 536726645, // x.89 - 529767743, 522823816, 515896658, 508988029, 502099660, 495233249, 488390461, 481572928, 474782249, // x.98 - 468019988, 461287675, 454586804, 447918836, 441285195, 434687268, 428126409, 421603932, 415121117, // x.107 - 408679208, 402279408, 395922888, 389610779, 383344175, 377124134, 370951677, 364827785, 358753406, // x.116 - 352729449, 346756785, 340836251, 334968645, 329154729, 323395230, 317690838, 312042206, 306449955, // x.125 - 300914667, 295436891, 290017141, 284655897, 279353604, 274110676, 268927490, 263804394, 258741701, // x.134 - 253739694, 248798623, 243918709, 239100140, 234343077, 229647649, 225013957, 220442073, 215932043, // x.143 - 211483883, 207097585, 202773112, 198510404, 194309373, 190169909, 186091877, 182075118, 178119452, // x.152 - 174224676, 170390565, 166616873, 162903335, 159249664, 155655556, 152120688, 148644718, 145227287, // x.161 - 141868021, 138566528, 135322401, 132135218, 129004542, 125929924, 122910901, 119946997, 117037723, // x.170 - 114182582, 111381062, 108632643, 105936795, 103292978, 100700645, 98159238, 95668194, 93226942, // x.179 - 90834903, 88491495, 86196126, 83948203, 81747126, 79592292, 77483092, 75418916, 73399150, // x.188 - 71423178, 69490383, 67600142, 65751837, 63944844, 62178541, 60452305, 58765515, 57117547, // x.197 - 55507781, 53935597, 52400377, 50901505, 49438366, 48010349, 46616844, 45257246, 43930951, // x.206 - 42637360, 41375878, 40145912, 38946876, 37778185, 36639262, 35529533, 34448428, 33395384, // x.215 - 32369842, 31371249, 30399057, 29452725, 28531717, 27635503, 26763558, 25915365, 25090413, // x.224 - 24288196, 23508216, 22749980, 22013003, 21296806, 20600917, 19924870, 19268206, 18630475, // x.233 - 18011231, 17410035, 16826458, 16260073, 15710466, 15177224, 14659944, 14158231, 13671694, // x.242 - 13199950, 12742625, 12299348, 11869759, 11453500, 11050225, 10659590, 10281262, 9914910, // x.251 - 9560213, 9216856, 8884529, 8562931, 8251764, 7950739, 7659571, 7377984, 7105706, // x.260 - 6842471, 6588020, 6342099, 6104460, 5874861, 5653066, 5438844, 5231969, 5032221, // x.269 - 4839386, 4653254, 4473620, 4300287, 4133059, 3971747, 3816167, 3666139, 3521488, // x.278 - 3382043, 3247640, 3118115, 2993313, 2873079, 2757266, 2645728, 2538325, 2434919, // x.287 - 2335380, 2239575, 2147382, 2058677, 1973342, 1891262, 1812325, 1736424, 1663453, // x.296 - 1593311, 1525898, 1461118, 1398879, 1339091, 1281666, 1226519, 1173569, 1122736, // x.305 - 1073944, 1027117, 982185, 939076, 897725, 858065, 820033, 783568, 748612, // x.314 - 715108, 682999, 652233, 622759, 594527, 567488, 541597, 516808, 493079, // x.323 - 470368, 448635, 427841, 407948, 388921, 370725, 353326, 336692, 320792, // x.332 - 305596, 291075, 277202, 263950, 251292, 239204, 227663, 216646, 206130, // x.341 - 196094, 186517, 177381, 168667, 160356, 152430, 144874, 137671, 130806, // x.350 - 124264, 118031, 112093, 106437, 101050, 95921, 91039, 86391, 81968, // x.359 - 77759, 73755, 69945, 66322, 62877, 59602, 56488, 53528, 50716, // x.368 - 48043, 45505, 43093, 40803, 38629, 36564, 34604, 32745, 30980, // x.377 - 29305, 27717, 26211, 24782, 23428, 22144, 20927, 19774, 18681, // x.386 - 17646, 16665, 15737, 14857, 14025, 13237, 12491, 11786, 11118, // x.395 - 10487, 9890, 9325, 8791, 8287, 7810, 7359, 6933, 6531, // x.404 - 6151, 5792, 5453, 5133, 4831, 4547, 4278, 4024, 3785, // x.413 - 3560, 3347, 3147, 2958, 2779, 2612, 2454, 2305, 2164, // x.422 - 2032, 1908, 1791, 1681, 1577, 1480, 1388, 1302, 1221, // x.431 - 1145, 1073, 1006, 942, 883, 827, 775, 725, 679, // x.440 - 636, 595, 557, 521, 487, 456, 426, 399, 373, // x.449 - 348, 325, 304, 284, 265, 248, 231, 216, 202, // x.458 - 188, 175, 164, 153, 142, 133, 124, 115, 107, // x.467 - 100, 93, 87, 81, 75, 70, 65, 61, 56, // x.476 - 53, 49, 45, 42, 39, 36, 34, 31, 29, // x.485 - 27, 25, 23, 22, 20, 19, 17, 16, 15, // x.494 - 14, 13, 12, 11, 10, 9, 9, 8, 7, // x.503 - 7, 6, 6, 5, 5, 5, 4, 4, 4, // x.512 - 3, 3, 3, 3, 2, 2, 2, 2, 2, // x.521 - 2, 2, 1, 1, 1, 1, 1, 1, 1, // x.530 - 1, 1, 1, 1, 1, 1, 0, 0, // isum 100000000000 -}; - -uint64_t hush_maxallowed(int32_t baseid) -{ - uint64_t mult,val = COIN * (uint64_t)10000; - if ( baseid < 0 || baseid >= 32 ) - return(0); - if ( baseid < 10 ) - val *= 4; - mult = MINDENOMS[baseid] / MIND; - return(mult * val); -} - -uint64_t hush_paxvol(uint64_t volume,uint64_t price) -{ - if ( volume < 10000000000 ) - return((volume * price) / 1000000000); - else if ( volume < (uint64_t)10 * 10000000000 ) - return((volume * (price / 10)) / 100000000); - else if ( volume < (uint64_t)100 * 10000000000 ) - return(((volume / 10) * (price / 10)) / 10000000); - else if ( volume < (uint64_t)1000 * 10000000000 ) - return(((volume / 10) * (price / 100)) / 1000000); - else if ( volume < (uint64_t)10000 * 10000000000 ) - return(((volume / 100) * (price / 100)) / 100000); - else if ( volume < (uint64_t)100000 * 10000000000 ) - return(((volume / 100) * (price / 1000)) / 10000); - else if ( volume < (uint64_t)1000000 * 10000000000 ) - return(((volume / 1000) * (price / 1000)) / 1000); - else if ( volume < (uint64_t)10000000 * 10000000000 ) - return(((volume / 1000) * (price / 10000)) / 100); - else return(((volume / 10000) * (price / 10000)) / 10); -} - -void pax_rank(uint64_t *ranked,uint32_t *pvals) -{ - int32_t i; uint64_t vals[32],sum = 0; - for (i=0; i<32; i++) - { - vals[i] = hush_paxvol(M1SUPPLY[i] / MINDENOMS[i],pvals[i]); - sum += vals[i]; - } - for (i=0; i<32; i++) - { - ranked[i] = (vals[i] * 1000000000) / sum; - //printf("%.6f ",(double)ranked[i]/1000000000.); - } - //printf("sum %llu\n",(long long)sum); -}; - -#define BTCFACTOR_HEIGHT 466266 - -double PAX_BTCUSD(int32_t height,uint32_t btcusd) -{ - double btcfactor,BTCUSD; - if ( height >= BTCFACTOR_HEIGHT ) - btcfactor = 100000.; - else btcfactor = 1000.; - BTCUSD = ((double)btcusd / (1000000000. / btcfactor)); - if ( height >= BTCFACTOR_HEIGHT && height < 500000 && BTCUSD > 20000 && btcfactor == 100000. ) - BTCUSD /= 100; - return(BTCUSD); -} - int32_t PAX_pubkey(int32_t rwflag,uint8_t *pubkey33,uint8_t *addrtypep,uint8_t rmd160[20],char fiat[4],uint8_t *shortflagp,int64_t *fiatoshisp) { - if ( rwflag != 0 ) - { - memset(pubkey33,0,33); - pubkey33[0] = 0x02 | (*shortflagp != 0); - memcpy(&pubkey33[1],fiat,3); - dragon_rwnum(rwflag,&pubkey33[4],sizeof(*fiatoshisp),(void *)fiatoshisp); - pubkey33[12] = *addrtypep; - memcpy(&pubkey33[13],rmd160,20); - } - else - { - *shortflagp = (pubkey33[0] == 0x03); - memcpy(fiat,&pubkey33[1],3); - fiat[3] = 0; - dragon_rwnum(rwflag,&pubkey33[4],sizeof(*fiatoshisp),(void *)fiatoshisp); - if ( *shortflagp != 0 ) - *fiatoshisp = -(*fiatoshisp); - *addrtypep = pubkey33[12]; - memcpy(rmd160,&pubkey33[13],20); - } return(33); } double PAX_val(uint32_t pval,int32_t baseid) { - //printf("PAX_val baseid.%d pval.%u\n",baseid,pval); - if ( baseid >= 0 && baseid < MAX_CURRENCIES ) - return(((double)pval / 1000000000.) / MINDENOMS[baseid]); return(0.); } @@ -234,64 +34,7 @@ void hush_pvals(int32_t height,uint32_t *pvals,uint8_t numpvals) uint64_t hush_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed) { - int32_t i,j,k,ind,zeroes,wt,nonz; int64_t delta; uint64_t lastprice,tolerance,den,densum,sum=0; - for (sum=i=zeroes=nonz=0; i> 2) ) - return(0); - sum /= nonz; - lastprice = sum; - for (i=0; i (numvotes >> 1) ) - break; - } - } - } - } - if ( wt > (numvotes >> 1) ) - { - ind = i; - for (densum=sum=j=0; j= 0 && baseid < 32 ) { - //hush_maxallowed(baseid); if(fDebug) printf("baseid.%d MAX_MONEY.%s %.8f\n",baseid,SMART_CHAIN_SYMBOL,(double)MAX_MONEY/SATOSHIDEN); } From b03c8f3108adf837c682cc0ddcf8f36828fc9e65 Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 17 Jun 2023 21:31:05 -0400 Subject: [PATCH 19/36] Remove unused code --- src/rpc/blockchain.cpp | 71 ----------------------------------- src/rpc/client.cpp | 3 -- src/rpc/server.cpp | 3 -- src/rpc/server.h | 5 --- src/wallet/rpcwallet.cpp | 81 ---------------------------------------- 5 files changed, 163 deletions(-) diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp index 1c34cd1b0..7bdf840da 100644 --- a/src/rpc/blockchain.cpp +++ b/src/rpc/blockchain.cpp @@ -1061,79 +1061,8 @@ UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk) } int32_t hush_pending_withdraws(char *opretstr); -int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base); extern char CURRENCIES[][8]; -UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk) -{ - UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR); char opretbuf[10000*2]; int32_t opretlen,baseid; uint64_t available,deposited,issued,withdrawn,approved,redeemed; - if ( fHelp || params.size() != 0 ) - throw runtime_error("paxpending needs no args\n"); - LOCK(cs_main); - if ( (opretlen= hush_pending_withdraws(opretbuf)) > 0 ) - ret.push_back(Pair("withdraws", opretbuf)); - else ret.push_back(Pair("withdraws", (char *)"")); - for (baseid=0; baseid<32; baseid++) - { - UniValue item(UniValue::VOBJ); UniValue obj(UniValue::VOBJ); - if ( pax_fiatstatus(&available,&deposited,&issued,&withdrawn,&approved,&redeemed,CURRENCIES[baseid]) == 0 ) - { - if ( deposited != 0 || issued != 0 || withdrawn != 0 || approved != 0 || redeemed != 0 ) - { - item.push_back(Pair("available", ValueFromAmount(available))); - item.push_back(Pair("deposited", ValueFromAmount(deposited))); - item.push_back(Pair("issued", ValueFromAmount(issued))); - item.push_back(Pair("withdrawn", ValueFromAmount(withdrawn))); - item.push_back(Pair("approved", ValueFromAmount(approved))); - item.push_back(Pair("redeemed", ValueFromAmount(redeemed))); - obj.push_back(Pair(CURRENCIES[baseid],item)); - a.push_back(obj); - } - } - } - ret.push_back(Pair("fiatstatus", a)); - return ret; -} - -UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk) -{ - if ( fHelp || params.size() > 4 || params.size() < 2 ) - throw runtime_error("paxprice \"base\" \"rel\" height\n"); - LOCK(cs_main); - UniValue ret(UniValue::VOBJ); uint64_t basevolume=0,relvolume,seed; - std::string base = params[0].get_str(); - std::string rel = params[1].get_str(); - int32_t height; - if ( params.size() == 2 ) - height = chainActive.LastTip()->GetHeight(); - else height = atoi(params[2].get_str().c_str()); - //if ( params.size() == 3 || (basevolume= COIN * atof(params[3].get_str().c_str())) == 0 ) - basevolume = 100000; - relvolume = hush_paxprice(&seed,height,(char *)base.c_str(),(char *)rel.c_str(),basevolume); - ret.push_back(Pair("base", base)); - ret.push_back(Pair("rel", rel)); - ret.push_back(Pair("height", height)); - char seedstr[32]; - sprintf(seedstr,"%llu",(long long)seed); - ret.push_back(Pair("seed", seedstr)); - if ( height < 0 || height > chainActive.Height() ) - throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range"); - else - { - CBlockIndex *pblockindex = chainActive[height]; - if ( pblockindex != 0 ) - ret.push_back(Pair("timestamp", (int64_t)pblockindex->nTime)); - if ( basevolume != 0 && relvolume != 0 ) - { - ret.push_back(Pair("price",((double)relvolume / (double)basevolume))); - ret.push_back(Pair("invprice",((double)basevolume / (double)relvolume))); - ret.push_back(Pair("basevolume",ValueFromAmount(basevolume))); - ret.push_back(Pair("relvolume",ValueFromAmount(relvolume))); - } else ret.push_back(Pair("error", "overflow or error in one or more of parameters")); - } - return ret; -} - UniValue gettxout(const UniValue& params, bool fHelp, const CPubKey& mypk) { if (fHelp || params.size() < 2 || params.size() > 3) diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp index 9e9178f25..563864c12 100644 --- a/src/rpc/client.cpp +++ b/src/rpc/client.cpp @@ -154,9 +154,6 @@ static const CRPCConvertParam vRPCConvertParams[] = { "z_shieldcoinbase", 3}, { "z_getoperationstatus", 0}, { "z_getoperationresult", 0}, - { "paxprice", 4 }, - { "paxprices", 3 }, - { "paxpending", 0 }, { "notaries", 2 }, { "minerids", 1 }, { "kvsearch", 1 }, diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp index e81ad19e6..703cdc7b9 100644 --- a/src/rpc/server.cpp +++ b/src/rpc/server.cpp @@ -332,9 +332,6 @@ static const CRPCCommand vRPCCommands[] = { "blockchain", "gettxoutsetinfo", &gettxoutsetinfo, true }, { "blockchain", "verifychain", &verifychain, true }, { "blockchain", "getspentinfo", &getspentinfo, false }, - //{ "blockchain", "paxprice", &paxprice, true }, - //{ "blockchain", "paxpending", &paxpending, true }, - //{ "blockchain", "paxprices", &paxprices, true }, { "blockchain", "notaries", ¬aries, true }, //{ "blockchain", "height_MoM", &height_MoM, true }, //{ "blockchain", "txMoMproof", &txMoMproof, true }, diff --git a/src/rpc/server.h b/src/rpc/server.h index 87b46610d..3bfc0654e 100644 --- a/src/rpc/server.h +++ b/src/rpc/server.h @@ -502,10 +502,5 @@ extern UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk extern UniValue minerids(const UniValue& params, bool fHelp, const CPubKey& mypk); extern UniValue kvsearch(const UniValue& params, bool fHelp, const CPubKey& mypk); extern UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk); -extern UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk); -extern UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk); -extern UniValue paxprices(const UniValue& params, bool fHelp, const CPubKey& mypk); -extern UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk); -extern UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk); #endif // HUSH_RPCSERVER_H diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp index 87d8ed64f..db2250a66 100644 --- a/src/wallet/rpcwallet.cpp +++ b/src/wallet/rpcwallet.cpp @@ -612,7 +612,6 @@ extern int32_t HUSH_PAX; int32_t hush_is_issuer(); int32_t dragon_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp); int32_t hush_isrealtime(int32_t *hushheightp); -int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base); int32_t hush_kvsearch(uint256 *refpubkeyp,int32_t current_height,uint32_t *flagsp,int32_t *heightp,uint8_t value[DRAGON_MAXSCRIPTSIZE],uint8_t *key,int32_t keylen); int32_t hush_kvcmp(uint8_t *refvalue,uint16_t refvaluesize,uint8_t *value,uint16_t valuesize); uint64_t hush_kvfee(uint32_t flags,int32_t opretlen,int32_t keylen); @@ -763,86 +762,6 @@ UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk) return ret; } -UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk) -{ - uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,puposhis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33]; - bool fSubtractFeeFromAmount = false; - if ( HUSH_PAX == 0 ) - { - throw runtime_error("paxdeposit disabled without -pax"); - } - if ( hush_is_issuer() != 0 ) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "paxdeposit only from KYC"); - if (!EnsureWalletIsAvailable(fHelp)) - throw runtime_error("paxdeposit needs wallet"); //return Value::null; - if (fHelp || params.size() != 3) - throw runtime_error("paxdeposit address fiatoshis base"); - LOCK2(cs_main, pwalletMain->cs_wallet); - CBitcoinAddress address(params[0].get_str()); - if (!address.IsValid()) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address"); - int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN; - std::string base = params[2].get_str(); - std::string dest; - height = chainActive.LastTip()->GetHeight(); - if ( pax_fiatstatus(&available,&deposited,&issued,&withdrawn,&approved,&redeemed,(char *)base.c_str()) != 0 || available < fiatoshis ) - { - fprintf(stderr,"available %llu vs fiatoshis %llu\n",(long long)available,(long long)fiatoshis); - throw runtime_error("paxdeposit not enough available inventory"); - } - puposhis = PAX_fiatdest(&seed,0,destaddr,pubkey37,(char *)params[0].get_str().c_str(),height,(char *)base.c_str(),fiatoshis); - dest.append(destaddr); - CBitcoinAddress destaddress(CRYPTO555_HUSHADDR); - if (!destaddress.IsValid()) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address"); - for (i=0; i<33; i++) - fprintf(stderr,"%02x",pubkey37[i]); - fprintf(stderr," ht.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",height,(char *)params[0].get_str().c_str(),(char *)base.c_str(),(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed); - EnsureWalletIsUnlocked(); - CWalletTx wtx; - uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = puposhis / 1000; - if ( fee < 10000 ) - fee = 10000; - dragon_rwnum(1,&pubkey37[33],sizeof(height),&height); - opretlen = hush_opreturnscript(opretbuf,'D',pubkey37,37); - SendMoney(address.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,puposhis); - return wtx.GetHash().GetHex(); -} - -UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk) -{ - CWalletTx wtx; std::string dest; int32_t hushheight; uint64_t seed,puposhis = 0; char destaddr[64]; uint8_t i,pubkey37[37]; bool fSubtractFeeFromAmount = false; - if ( SMART_CHAIN_SYMBOL[0] == 0 ) - return(0); - if (!EnsureWalletIsAvailable(fHelp)) - return 0; - throw runtime_error("paxwithdraw deprecated"); - if (fHelp || params.size() != 2) - throw runtime_error("paxwithdraw address fiatamount"); - if ( hush_isrealtime(&hushheight) == 0 ) - return(0); - LOCK2(cs_main, pwalletMain->cs_wallet); - CBitcoinAddress address(params[0].get_str()); - if (!address.IsValid()) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address"); - int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN; - puposhis = PAX_fiatdest(&seed,1,destaddr,pubkey37,(char *)params[0].get_str().c_str(),hushheight,SMART_CHAIN_SYMBOL,fiatoshis); - dest.append(destaddr); - CBitcoinAddress destaddress(CRYPTO555_HUSHADDR); - if (!destaddress.IsValid()) - throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address"); - for (i=0; i<33; i++) - printf("%02x",pubkey37[i]); - printf(" hushheight.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",hushheight,(char *)params[0].get_str().c_str(),SMART_CHAIN_SYMBOL,(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed); - EnsureWalletIsUnlocked(); - uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = fiatoshis / 1000; - if ( fee < 10000 ) - fee = 10000; - dragon_rwnum(1,&pubkey37[33],sizeof(hushheight),&hushheight); - opretlen = hush_opreturnscript(opretbuf,'W',pubkey37,37); - SendMoney(destaddress.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,fiatoshis); - return wtx.GetHash().GetHex(); -} UniValue listaddressgroupings(const UniValue& params, bool fHelp, const CPubKey& mypk) { From fc69220e78d24e5f275853d5e4e535d50fa45779 Mon Sep 17 00:00:00 2001 From: Duke Date: Sat, 17 Jun 2023 21:38:39 -0400 Subject: [PATCH 20/36] Remove unused code --- src/hush_pax.h | 5 ----- src/wallet/rpcwallet.cpp | 1 - 2 files changed, 6 deletions(-) diff --git a/src/hush_pax.h b/src/hush_pax.h index eba734593..029f6e31f 100644 --- a/src/hush_pax.h +++ b/src/hush_pax.h @@ -32,11 +32,6 @@ void hush_pvals(int32_t height,uint32_t *pvals,uint8_t numpvals) { } -uint64_t hush_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed) -{ - return(0); -} - uint64_t hush_paxpriceB(uint64_t seed,int32_t height,char *base,char *rel,uint64_t basevolume) { return 0; diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp index db2250a66..cdf16c695 100644 --- a/src/wallet/rpcwallet.cpp +++ b/src/wallet/rpcwallet.cpp @@ -606,7 +606,6 @@ UniValue sendtoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk) #define HUSH_KVBINARY 2 #define HUSH_KVDURATION 1440 #define DRAGON_MAXSCRIPTSIZE 10001 -uint64_t PAX_fiatdest(uint64_t *seedp,int32_t tokomodo,char *destaddr,uint8_t pubkey37[37],char *coinaddr,int32_t height,char *base,int64_t fiatoshis); int32_t hush_opreturnscript(uint8_t *script,uint8_t type,uint8_t *opret,int32_t opretlen); extern int32_t HUSH_PAX; int32_t hush_is_issuer(); From 95080951861e7756f7e9fcb58a20cc174deee2e9 Mon Sep 17 00:00:00 2001 From: Duke Date: Thu, 29 Jun 2023 11:48:30 -0400 Subject: [PATCH 21/36] Remove unused code --- src/cc/CCMarmara.h | 53 --------------------------------------------- src/cc/CCcustom.cpp | 12 ---------- 2 files changed, 65 deletions(-) delete mode 100644 src/cc/CCMarmara.h diff --git a/src/cc/CCMarmara.h b/src/cc/CCMarmara.h deleted file mode 100644 index 58b8072b6..000000000 --- a/src/cc/CCMarmara.h +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright (c) 2016-2023 The Hush developers -// Distributed under the GPLv3 software license, see the accompanying -// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html -/****************************************************************************** - * Copyright © 2014-2019 The SuperNET Developers. * - * * - * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at * - * the top-level directory of this distribution for the individual copyright * - * holder information and the developer policies on copyright and licensing. * - * * - * Unless otherwise agreed in a custom licensing agreement, no part of the * - * SuperNET software, including this file may be copied, modified, propagated * - * or distributed except according to the terms contained in the LICENSE file * - * * - * Removal or modification of this copyright notice is prohibited. * - * * - ******************************************************************************/ - - -#ifndef CC_MARMARA_H -#define CC_MARMARA_H - -/* - -#include "CCinclude.h" -#include "../hush_cJSON.h" - -#define MARMARA_GROUPSIZE 60 -#define MARMARA_MINLOCK (1440 * 3 * 30) -#define MARMARA_MAXLOCK (1440 * 24 * 30) -#define MARMARA_VINS 16 -#define EVAL_MARMARA 0xef - -extern uint8_t ASSETCHAINS_MARMARA; -uint64_t hush_block_prg(uint32_t nHeight); -int32_t MarmaraGetcreatetxid(uint256 &createtxid,uint256 txid); -int32_t MarmaraGetbatontxid(std::vector &creditloop,uint256 &batontxid,uint256 txid); -UniValue MarmaraCreditloop(uint256 txid); -UniValue MarmaraSettlement(uint64_t txfee,uint256 batontxid); -UniValue MarmaraLock(uint64_t txfee,int64_t amount,int32_t height); - -UniValue MarmaraPoolPayout(uint64_t txfee,int32_t firstheight,double perc,char *jsonstr); // [[pk0, shares0], [pk1, shares1], ...] -UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid,bool automaticflag); -UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t amount,std::string currency,int32_t matures,uint256 approvaltxid,uint256 batontxid); -UniValue MarmaraInfo(CPubKey refpk,int32_t firstheight,int32_t lastheight,int64_t minamount,int64_t maxamount,std::string currency); - -bool MarmaraValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn); - -// CCcustom -UniValue MarmaraInfo(); -*/ - -#endif diff --git a/src/cc/CCcustom.cpp b/src/cc/CCcustom.cpp index b463df52b..005fb1def 100644 --- a/src/cc/CCcustom.cpp +++ b/src/cc/CCcustom.cpp @@ -30,7 +30,6 @@ #include "CCOracles.h" #include "CCPrices.h" #include "CCPegs.h" -#include "CCMarmara.h" #include "CCPayments.h" #include "CCGateways.h" #include "CCtokens.h" @@ -192,17 +191,6 @@ uint8_t PegsCCpriv[32] = { 0x52, 0x56, 0x4c, 0x78, 0x87, 0xf7, 0xa2, 0x39, 0xb0, #undef FUNCNAME #undef EVALCODE -// Marmara -#define FUNCNAME IsMarmaraInput -#define EVALCODE EVAL_MARMARA -const char *MarmaraCCaddr = "RGLSRDnUqTB43bYtRtNVgmwSSd1sun2te8"; -const char *MarmaraNormaladdr = "RMN25Tn8NNzcyQDiQNuMp8UmwLMFd9thYc"; -char MarmaraCChexstr[67] = { "03afc5be570d0ff419425cfcc580cc762ab82baad88c148f5b028d7db7bfeee61d" }; -uint8_t MarmaraCCpriv[32] = { 0x7c, 0x0b, 0x54, 0x9b, 0x65, 0xd4, 0x89, 0x57, 0xdf, 0x05, 0xfe, 0xa2, 0x62, 0x41, 0xa9, 0x09, 0x0f, 0x2a, 0x6b, 0x11, 0x2c, 0xbe, 0xbd, 0x06, 0x31, 0x8d, 0xc0, 0xb9, 0x96, 0x76, 0x3f, 0x24 }; -#include "CCcustom.inc" -#undef FUNCNAME -#undef EVALCODE - // Payments #define FUNCNAME IsPaymentsInput #define EVALCODE EVAL_PAYMENTS From 03071ef0cdf4cb1d854b3fcffbddde787f24a86e Mon Sep 17 00:00:00 2001 From: nullfekt <118863467+nullfekt@users.noreply.github.com> Date: Thu, 29 Jun 2023 20:23:28 -0400 Subject: [PATCH 22/36] Bump version --- configure.ac | 2 +- src/clientversion.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/configure.ac b/configure.ac index aa424d534..728795f41 100644 --- a/configure.ac +++ b/configure.ac @@ -3,7 +3,7 @@ AC_PREREQ([2.60]) define(_CLIENT_VERSION_MAJOR, 3) dnl Must be kept in sync with src/clientversion.h , ugh! define(_CLIENT_VERSION_MINOR, 9) -define(_CLIENT_VERSION_REVISION, 3) +define(_CLIENT_VERSION_REVISION, 4) define(_CLIENT_VERSION_BUILD, 50) define(_ZC_BUILD_VAL, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, m4_incr(_CLIENT_VERSION_BUILD), m4_eval(_CLIENT_VERSION_BUILD < 50), 1, m4_eval(_CLIENT_VERSION_BUILD - 24), m4_eval(_CLIENT_VERSION_BUILD == 50), 1, , m4_eval(_CLIENT_VERSION_BUILD - 50))) define(_CLIENT_VERSION_SUFFIX, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, _CLIENT_VERSION_REVISION-beta$1, m4_eval(_CLIENT_VERSION_BUILD < 50), 1, _CLIENT_VERSION_REVISION-rc$1, m4_eval(_CLIENT_VERSION_BUILD == 50), 1, _CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION-$1))) diff --git a/src/clientversion.h b/src/clientversion.h index 86489bafb..235661630 100644 --- a/src/clientversion.h +++ b/src/clientversion.h @@ -30,7 +30,7 @@ // Must be kept in sync with configure.ac , ugh! #define CLIENT_VERSION_MAJOR 3 #define CLIENT_VERSION_MINOR 9 -#define CLIENT_VERSION_REVISION 3 +#define CLIENT_VERSION_REVISION 4 #define CLIENT_VERSION_BUILD 50 //! Set to true for release, false for prerelease or test build From 27b2a4974078cb037bd5539289ce3add953d0b46 Mon Sep 17 00:00:00 2001 From: nullfekt <118863467+nullfekt@users.noreply.github.com> Date: Thu, 29 Jun 2023 20:38:09 -0400 Subject: [PATCH 23/36] Update README.md --- doc/relnotes/README.md | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/doc/relnotes/README.md b/doc/relnotes/README.md index 39c56e213..2de5dc92a 100644 --- a/doc/relnotes/README.md +++ b/doc/relnotes/README.md @@ -10,6 +10,27 @@ and no longer on Github, since they banned Duke Leto and also because they censor many people around the world and work with evil organizations. +# Hush 3.9.4 "Maniacal Manticore" + +This is an OPTIONAL release. It is recommended for exchanges, solo miners and mining pools to update to this release. + + * New features and improvements + * DragonX now has checkpoints for faster syncing. + * Rate limiting for the processing of incoming addr messages for increased security. + * Removed unused function CWalletTx::GetRequestCount + * Removed mapRequest tracking that only affects Qt display. + * Randomized message processing peer order for increased privacy. + * Removed BIP35 mempool p2p message for increased privacy. + * Build Improvements + * Use custom jobs param when compiling boost for faster compile times + * Now builds with gcc13 thanks to testing from jahway + * We have an aarch64 deb now thanks to jahway + * Bug fixes: + * -stratumallowip works with CIDR and netmask ranges again for solo miners + * Detect missing autoreconf in build.sh + * Various assertions removed from BIP155 changes in previous release. + + # Hush 3.9.3 "Lateral Larvacean" ``` From 44595d5abe6cbf9ed8e74d9e74cc0cdd70725ed0 Mon Sep 17 00:00:00 2001 From: nullfekt <118863467+nullfekt@users.noreply.github.com> Date: Thu, 29 Jun 2023 20:54:20 -0400 Subject: [PATCH 24/36] Add additional community seed node --- contrib/seeds/nodes_main.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/contrib/seeds/nodes_main.txt b/contrib/seeds/nodes_main.txt index 9cd90fe9e..0d5e68fd4 100644 --- a/contrib/seeds/nodes_main.txt +++ b/contrib/seeds/nodes_main.txt @@ -16,6 +16,9 @@ # lite.hushpool.is 149.28.102.219 +# lite2.hushpool.is +155.138.228.68 + # wtfistheinternet.hush.is 107.174.70.251 From b7359ef70e0d736c4584d9e6863656acd6cbd5ed Mon Sep 17 00:00:00 2001 From: fekt Date: Thu, 29 Jun 2023 21:16:46 -0400 Subject: [PATCH 25/36] Update chainparamsseeds.h --- src/chainparamsseeds.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h index 1fd92af93..54125e3c4 100644 --- a/src/chainparamsseeds.h +++ b/src/chainparamsseeds.h @@ -17,6 +17,7 @@ static const uint8_t chainparams_seed_main[] = { 0x01,0x04,0x57,0xfb,0x4c,0x21,0x00,0x00, // 87.251.76.33 0x01,0x04,0x89,0x4a,0x04,0xc6,0x00,0x00, // 137.74.4.198 0x01,0x04,0x95,0x1c,0x66,0xdb,0x00,0x00, // 149.28.102.219 + 0x01,0x04,0x9b,0x8a,0xe4,0x44,0x00,0x00, // 155.138.228.68 0x01,0x04,0x6b,0xae,0x46,0xfb,0x00,0x00, // 107.174.70.251 0x04,0x20,0xef,0xad,0x0c,0x95,0x3e,0x61,0xee,0x69,0x57,0x67,0xdb,0x4f,0xb7,0x8d,0xc2,0x35,0x1c,0x6b,0x96,0xf4,0x1f,0x7a,0xb4,0x06,0x09,0x3a,0x64,0x33,0xf4,0x0b,0x2c,0x94,0x00,0x00, // 56wqzfj6mhxgsv3h3nh3pdocguogxfxud55libqjhjsdh5alfsko2iqd.onion 0x04,0x20,0x3d,0x24,0x7a,0xec,0xfe,0x60,0x6e,0x3d,0x3d,0xf3,0x4f,0x35,0x12,0x29,0xdb,0x48,0x89,0x71,0x19,0xb9,0xee,0x6a,0xfd,0xb2,0x02,0xa7,0x99,0x89,0xbb,0x69,0x39,0xdb,0x00,0x00, // hushv3h6mbxd2pptj42reko3jcexcgnz5zvp3mqcu6myto3jhhn4yzyd.onion From 9e524663e28cfbdeb1c246a54f646206cb612946 Mon Sep 17 00:00:00 2001 From: fekt Date: Thu, 29 Jun 2023 22:28:39 -0400 Subject: [PATCH 26/36] Update manpages --- doc/man/hush-cli.1 | 8 ++++---- doc/man/hush-tx.1 | 8 ++++---- doc/man/hushd.1 | 10 +++++----- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/doc/man/hush-cli.1 b/doc/man/hush-cli.1 index 235409cac..a82565e74 100644 --- a/doc/man/hush-cli.1 +++ b/doc/man/hush-cli.1 @@ -1,9 +1,9 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.13. -.TH HUSH-CLI "1" "February 2023" "hush-cli v3.9.3" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.6. +.TH HUSH-CLI "1" "June 2023" "hush-cli v3.9.4" "User Commands" .SH NAME -hush-cli \- manual page for hush-cli v3.9.3 +hush-cli \- manual page for hush-cli v3.9.4 .SH DESCRIPTION -Hush RPC client version v3.9.3\-1313d39a7 +Hush RPC client version v3.9.4\-44595d5ab .PP In order to ensure you are adequately protecting your privacy when using Hush, please see . diff --git a/doc/man/hush-tx.1 b/doc/man/hush-tx.1 index 0d930a9a4..a4bc4033b 100644 --- a/doc/man/hush-tx.1 +++ b/doc/man/hush-tx.1 @@ -1,9 +1,9 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.13. -.TH HUSH-TX "1" "February 2023" "hush-tx v3.9.3" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.6. +.TH HUSH-TX "1" "June 2023" "hush-tx v3.9.4" "User Commands" .SH NAME -hush-tx \- manual page for hush-tx v3.9.3 +hush-tx \- manual page for hush-tx v3.9.4 .SH DESCRIPTION -hush\-tx utility version v3.9.3\-1313d39a7 +hush\-tx utility version v3.9.4\-44595d5ab .SS "Usage:" .TP hush\-tx [options] [commands] diff --git a/doc/man/hushd.1 b/doc/man/hushd.1 index aad7da4d9..627c9c651 100644 --- a/doc/man/hushd.1 +++ b/doc/man/hushd.1 @@ -1,9 +1,9 @@ -.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.13. -.TH HUSHD "1" "February 2023" "hushd v3.9.3" "User Commands" +.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.6. +.TH HUSHD "1" "June 2023" "hushd v3.9.4" "User Commands" .SH NAME -hushd \- manual page for hushd v3.9.3 +hushd \- manual page for hushd v3.9.4 .SH DESCRIPTION -Hush Daemon version v3.9.3\-1313d39a7 +Hush Daemon version v3.9.4\-44595d5ab .PP In order to ensure you are adequately protecting your privacy when using Hush, please see . @@ -78,7 +78,7 @@ applied) .HP \fB\-par=\fR .IP -Set the number of script verification threads (\fB\-8\fR to 16, 0 = auto, <0 = +Set the number of script verification threads (\fB\-6\fR to 16, 0 = auto, <0 = leave that many cores free, default: 0) .HP \fB\-pid=\fR From 20ee425ece5c8668ca738dd9b0dc44b47cb34a6a Mon Sep 17 00:00:00 2001 From: fekt Date: Thu, 29 Jun 2023 23:31:53 -0400 Subject: [PATCH 27/36] Updated checkpoints --- src/chainparams.cpp | 168 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 165 insertions(+), 3 deletions(-) diff --git a/src/chainparams.cpp b/src/chainparams.cpp index ef9213bb4..ef7ab5d70 100644 --- a/src/chainparams.cpp +++ b/src/chainparams.cpp @@ -1547,9 +1547,171 @@ void *chainparams_commandline() { (1249000, uint256S("0x00000001170d6ae54d494bd2dbf29c5ab7f560f51874987d7dbe129d549c097f")) (1250000, uint256S("0x000000033226eef40d094c8aa88d03bbc9146856c52248760e28c45426787352")) (1251000, uint256S("0x0000000281c7f7ef75ac6539791e26b9744cccd59414b04ddc4697bcd3595209")) - ,(int64_t) 1675926362, // time of last checkpointed block - (int64_t) 2022392, // total txs - (double) 1371 // txs in the last day before block 1251770 + + // Generated at 1688095440 via hush3 util/checkpoints.pl by fekt + (1252000, uint256S("0x00000002a23866c4bc24b6d14b8039eb38530936fd7ba230cd41bbffe457c0eb")) + (1253000, uint256S("0x000000021fb79ebfda0aa2dde15ef1fc669003911bc771d1700f8b6785d86aa9")) + (1254000, uint256S("0x000000020083112cbd6ac00fff2dbbd4c72e3c1d2636138cd42a63b7fc0af798")) + (1255000, uint256S("0x00000000247e68c0c4bd2cffedf9dff84dc67e49f9c90b6df073d4c6e913856a")) + (1256000, uint256S("0x00000002556455ce2059602aa43b7dc0ed5014bc157e78e9283bc2610946720e")) + (1257000, uint256S("0x00000003119deacf7b787311ef767abb173594d22979797a58a2ad01b7bda0a5")) + (1258000, uint256S("0x000000024edab00216ccb7ef39dd16b782e14179f90aace0d812b33ecbefdde0")) + (1259000, uint256S("0x00000003016ee9e404906afe5542afa1b614be768187d8a9f9c7ebf598d76695")) + (1260000, uint256S("0x00000000b7fc90789fca4e53b5966707642d1d9ffcccc99c28fd194135d08618")) + (1261000, uint256S("0x00000001e43bbacba953a662435791e7f4bc1c3fada97d8a279c8b26598fecc7")) + (1262000, uint256S("0x00000002993a7913e93d68bf44bd0f5c0102a7ab196ed6ee4ae9ea790b197854")) + (1263000, uint256S("0x000000016bf7677b49e8df24d03c3ba6ab060356c72501de94938ad2e7be946c")) + (1264000, uint256S("0x00000002c616eed07db9e4695ac9cee6989e42a76c6f61a4e0ebe0bb5abf692f")) + (1265000, uint256S("0x000000024d31a0ef0a466f573bb7c0e0970fc52e895c3b01d95b5b38e81322ca")) + (1266000, uint256S("0x000000011e54e3519dd6ea6af0443e309c8e226e2ccd775b28cc4f12f08c0d39")) + (1267000, uint256S("0x0000000393da90dc30fde8005d7f2d2318f8785e2a32bc865bf8383f7c8ffea8")) + (1268000, uint256S("0x000000027f04b7efb776bd8420de4cc0228561aa773d59cb0b2e9f6025389322")) + (1269000, uint256S("0x000000061807ebcde0469dd2c3b3bf682864b593da8bc8c64d354108961a6514")) + (1270000, uint256S("0x00000000041c198471a04f305344aeae7650140175c97d62765861d6416a4ed1")) + (1271000, uint256S("0x00000001f0e911e3ce304f9785f4c43ae7087eca9c4cadc677c4f49659b121dc")) + (1272000, uint256S("0x000000035098a7b17ae7be1c6decf88dbca85562137c8d2200bd84cb59148788")) + (1273000, uint256S("0x00000005d5d27e58ecb84658d2c3f2d8c87bae08ee0d81c6d4cdfc347ec13ec9")) + (1274000, uint256S("0x00000001623cd2acb0005393f2378a2d1ed5603511ee806b1e04f4e677b7531b")) + (1275000, uint256S("0x0000000140a568b0870d2c6853fe3fdcd94193652ef61ba9d430989e9a521a77")) + (1276000, uint256S("0x000000046e660edfdbae93511bb48f335df7523bae3cd5bfcb77cd81525585bb")) + (1277000, uint256S("0x000000022c296e5406126bbd6040316b2706c489c58d2b7593e1ec1637d31432")) + (1278000, uint256S("0x000000012b5d649609b503398d7af1fa7e14e9e58bd8e6746d6f44bbeb311270")) + (1279000, uint256S("0x000000039deede9e29ba8c7178df43374e83d6691556103a337c58822f2501fc")) + (1280000, uint256S("0x0000000172d327c94631b30e851ada193ad0d4b05a659db7e92cdaf4a5859841")) + (1281000, uint256S("0x00000002cf093cdd98e566534b7b5aaa91ee125e71283d654a75b878f08ba015")) + (1282000, uint256S("0x0000000306c146a88cd6a2cce453ac72d632a9bebf49abf27c684b4957f8380a")) + (1283000, uint256S("0x00000004738db155d0d8b5d95abd4484962c16a40eab2047b5b20fa4c5df890e")) + (1284000, uint256S("0x00000001bba05b8445a32d3856a1e4dbe9f65a96c39ca92c654ac01e675b1076")) + (1285000, uint256S("0x00000002fbc4853d6183b848e5ad32637478358521e87a7c1febfde93c4dcaa8")) + (1286000, uint256S("0x00000002fd09e8f12b1ade668a238b4badda452869f770c20bf3edd0c9a2b984")) + (1287000, uint256S("0x0000000568e3a41c8ac6e4d5ed59630a1aeff0b957494388a4c939f206ecac0c")) + (1288000, uint256S("0x000000024cf90a1150d224e167503dd79d2261de0e5e7a7e35b04949c95b8fd6")) + (1289000, uint256S("0x00000004ecdab6f1bf5f2cfd924afefb167160a49d5aa9a2b4790b4fce190427")) + (1290000, uint256S("0x0000000305db71205f1c622693cc55fee7c3b7c26400e13e82b3855a13c40df7")) + (1291000, uint256S("0x000000032d1115be00930015cb1f6fe824349bd4ff367ec675c4c92d7b268904")) + (1292000, uint256S("0x00000000a0fa63c1264eadb0fd86f1f420c74c2b5593604897c6ebe4aa4691b5")) + (1293000, uint256S("0x00000002bfd681e56afbb24664cd056812d1347bab971b44ff957a7ecd4a54ce")) + (1294000, uint256S("0x00000000ba8ac906a4fea8b779d6272e2648a30a488c4c390f1c761fbf53e76d")) + (1295000, uint256S("0x00000000859df3b6859bdd415b8d1b1fb8c396a279c8ddd6b1f39d41cec89579")) + (1296000, uint256S("0x000000008e62f687dc9899200671a9c595e1626e29477080ab052be584349ba5")) + (1297000, uint256S("0x00000003e9d6c1cce45b1d76a775f3d6e6ebbd5caa62427ae015e954e1f14d05")) + (1298000, uint256S("0x00000000fa5a495e60cfe2c8de8d8e52c2bb1ddf335a891f69be2c7eae901dcc")) + (1299000, uint256S("0x0000000326ff88c4546f65313522fe9466b33e96af50e6a6db09dfe59193bc63")) + (1300000, uint256S("0x00000003f498d56accc70c7257bfd708a22128dda0a038499f0c984f3e9ba2c0")) + (1301000, uint256S("0x00000001313da1129ba7de5f415d211ea1e3f51ae9d910abb2624aeae15b4a56")) + (1302000, uint256S("0x000000034cdf6686f4350dcc4f1f0887bb128746afd7cc3aeba5bf8b000c636f")) + (1303000, uint256S("0x00000003dffb121ae41569ca13d851f3c45668e8ee351680c2db1871f251eb3e")) + (1304000, uint256S("0x00000000c5bb42d8bfe94087c5d129fafe2677e62edadfaa7415b8a7bb4277ff")) + (1305000, uint256S("0x0000000046e1db3cc0047a85b815b745c4a0f4af4244b79d90a57cfafdf85699")) + (1306000, uint256S("0x00000004418d213a0ecced05de5b1fcaca70fe272d37773377e02c1873d27068")) + (1307000, uint256S("0x00000001cce1afda2c61046fd571edf01bdcc5a09260fcc7727caca8e3eb6ed6")) + (1308000, uint256S("0x00000000a453c4fd6f537776b730e5b8ae4d238c2f9215ed4f6e709b8aa177ac")) + (1309000, uint256S("0x000000009c9d7cb8f66d9ccdb7ce77a3c36c8d7df74e21326ef86000627091d4")) + (1310000, uint256S("0x00000000cd97fe334d3be6f3fda419589ebf643bffab3194d5cdeb7d324d123c")) + (1311000, uint256S("0x00000004fd9a887ae0db3333544e3027fe79f59fbdf8116ca516650e165bcd52")) + (1312000, uint256S("0x0000000349b8956bf4cf1b9566580e7362dfdd512ac5f7ef6a300ce2c0cf343e")) + (1313000, uint256S("0x000000030a692fe283bdbc7e1e11f8827da5a1e7b4aa3cca3c089803af547025")) + (1314000, uint256S("0x000000034e3ff90ae3436af4d7e1caec9604c5d347bded5fc6e0b05f3d0902f8")) + (1315000, uint256S("0x000000011044536fe0741ffb747e3b0f0cf826b3103d50b41f392772ed55607c")) + (1316000, uint256S("0x000000022ca70a448e4f6693aafeb5f0eac948064188933a01cd15db835e1bc3")) + (1317000, uint256S("0x00000005b8f471f902a540463c5a8ce962a34da30157bb4c094bbfee85b3ad36")) + (1318000, uint256S("0x000000020bada11214b8cf7784286aa4e5120c14b5b5e47516f619e6411badc0")) + (1319000, uint256S("0x00000001642ce9e76b5ebe167b03fdd00d0e6d595abb09ee9bd6c033f947f2db")) + (1320000, uint256S("0x00000000995d4bafd5b3e9bcc709cf0623090008aa34c9ee6b44c815ad08bc48")) + (1321000, uint256S("0x00000001bd0fff7aff0e313d8b458568a65a395d037b6d2999328798c441d8d3")) + (1322000, uint256S("0x000000015cd85c1fc0fc6877cb6c9ff4d9ab99bc7ece23d96c468c549ee3e368")) + (1323000, uint256S("0x000000033cdd6bc9051d956dc774e7c8066ae6f2272f2cbd23a5cb34a6f21947")) + (1324000, uint256S("0x00000001feaf5da15ade7a2a7f039ef95f506dfa7c8d7a3077dc6b77106a4aa9")) + (1325000, uint256S("0x00000002ed58d3afaa3044dde92a4af3908c154895651c46b8ad24bdcd702021")) + (1326000, uint256S("0x0000000377de030a756db011af1cf8d6ea1cabec0ad4957055de3435ee1102bf")) + (1327000, uint256S("0x00000002b68d85dc8783068c6878f128c048aa85dae10c5e0495768e76b153a8")) + (1328000, uint256S("0x000000022c5ea4c4f470006d99898a1de5d783967dfc4f0759835f60a0f376d9")) + (1329000, uint256S("0x0000000448c2f62ad26c51c3481b702615acf71f40631dc384e081e579993bf2")) + (1330000, uint256S("0x000000004bfdeafb2dcdbb7b0a214c62fc4f03583f3f6f27bbe2dd78c083bc6a")) + (1331000, uint256S("0x0000000008f29e6bfeedea18387ec2df4f1518f03de03073bd402d3d84daa40d")) + (1332000, uint256S("0x00000003b6b0fdb24bcd5b132ab25d97ce116d4fce4edc70037848340f9cd6a0")) + (1333000, uint256S("0x0000000540eb80533c3ad5fb11028ef74e41cf66afeeb49d38c8e91e1b9be071")) + (1334000, uint256S("0x000000024e829222c6b338723ea69a1aaf8ca426db6f1dc5ed6a508aa4eba324")) + (1335000, uint256S("0x00000001c34ef432a6d7c5b537e4157bcdc6a2f4c3d30d25cb9bb47ff395b5a6")) + (1336000, uint256S("0x000000011cda647d4405fbcffc35ce161a057911bc551290848a56a832835c14")) + (1337000, uint256S("0x0000000297dddb61d28cd456b11c6683f5c040ea1d798462cba45ff4d9acb7aa")) + (1338000, uint256S("0x000000031a44d98fee4c721d7cf692b5c6d49c72b9e514a9eea8d7a3a980cb42")) + (1339000, uint256S("0x000000016a3b0d888eaaf488fe99202db0cadabcace4f5606e13a8021e208beb")) + (1340000, uint256S("0x0000000296642fe481256d81da12afbbfc867a6e56f7e88ee575376171a2eb2b")) + (1341000, uint256S("0x000000047f7f7df7d25d0f93873e81f317b4c59970021ff99097b90662b34886")) + (1342000, uint256S("0x00000003dee60bf850c721422ead96876a6479c0e249252cd7a0819756f214f0")) + (1343000, uint256S("0x0000000479b89d6106880dd554c9f0839893680f6aaf1d17bdd353b5ff3b690d")) + (1344000, uint256S("0x000000043e08866b7b3a2fb729934e38ed68a7158aae743dbd67e915cbbe25fa")) + (1345000, uint256S("0x000000010d28f703987f82d284a6ab34eeb9c6cdf528cfd8ea9467377b48f978")) + (1346000, uint256S("0x000000047577df762e1b9d1d36efd124d7c587e8a1b04992d012b48e1da03d1c")) + (1347000, uint256S("0x000000050e60e964649507f0abaa9041969bc292e762179cc48e370d1e85109f")) + (1348000, uint256S("0x0000000458aac55b9a6a7610abf79769ccbd21bccabe262d49313b637f360b7d")) + (1349000, uint256S("0x00000001b36d5248c6632d6f353376991a3d7ce4b6730cd777042e8eef4c2050")) + (1350000, uint256S("0x0000000040bdf5b1900a2d20f6fb7824f7f0ad2117a357ac212388bbe5238f40")) + (1351000, uint256S("0x00000004a5e89800bd3e433dc1c3f36370b14523a219ccc513e9451c6354bb86")) + (1352000, uint256S("0x000000025bda557523475832f119f8d5ebdd02f131c0004f529b0e6b16343a8e")) + (1353000, uint256S("0x000000012e20cd31e7f6eda7d0e1d1777fde4a312a4c2ce6948d629e10b196ab")) + (1354000, uint256S("0x0000000247ea366ee0719df82303d8e74aec615b2c006bb1b7d37c1d42366785")) + (1355000, uint256S("0x0000000038f84260adf0773fa051af3467e0e4bf17adf73c4a9f8cc0ae0eb52f")) + (1356000, uint256S("0x00000001b109fae9d09d98e829e273037a6209d29347485ffdee066f8f32d070")) + (1357000, uint256S("0x00000002c9047e284ad3699ee0ccd158c141ad281fe7c78bcb8cae0012e2a7a5")) + (1358000, uint256S("0x000000046e5f2a9d1b043840165ba292042ca4a6927f9451d8eb379e9f6b479f")) + (1359000, uint256S("0x00000001fe154c692d9a7255fa9657023d213d3a2b0c6025bc2942452ff0bfa7")) + (1360000, uint256S("0x00000002e0a212bc285eef4232f6805f95ef054582a43fd4b926ed23e75ec378")) + (1361000, uint256S("0x0000000170ffed44b6503976cf15289556ec5ac785c63f371990dc1dcd01c0c1")) + (1362000, uint256S("0x00000004b0a51f49dc942a4dac1c8cb7ebc3b5dc70c27488b950033543de9188")) + (1363000, uint256S("0x00000002d39b32395989ff7065d238a9e6ca9643dde76f2c4fa090da64a9dfb0")) + (1364000, uint256S("0x00000003fe2c6dafe4f7c45c2a07307864a85c649738a68fa9736990385aa1b6")) + (1365000, uint256S("0x000000006a96f8887cb0b261ff9c0947ec9a35e388354a088012e0f3587a915d")) + (1366000, uint256S("0x00000000b19f6e3ea6282cad35d25bd45f4a90799ca30de76ebfaa58360102b3")) + (1367000, uint256S("0x00000005a4c7746ba3aa321bf6d0d939b65053fd7b8993541c4382d81b1df164")) + (1368000, uint256S("0x00000005a2f3fac3d68493253cc28762ed0e7d8be207b72e9b3eba49b1301661")) + (1369000, uint256S("0x00000001d963d93ec5f029920cd5ca0f8bfca9c85ce99f84585062d2c08edca3")) + (1370000, uint256S("0x000000033c971fbcf50d26531667597acd4abf989473c10a7ecd23cd4546dc05")) + (1371000, uint256S("0x00000002a277717fd9f5b05370e9c610662ffdb6f5489e96b96bc587dc22dc70")) + (1372000, uint256S("0x00000001ef0f457f58b3523ec79d6ec265928ba5aaec6a5ee282242334883e15")) + (1373000, uint256S("0x000000005911ed4432d3077e7254e35767ca8b00a674a1b047fd0dcc12bb1e6f")) + (1374000, uint256S("0x0000000538363b8b3a25dce0a88990b96dff9787c2ec8189b70b13222008adfc")) + (1375000, uint256S("0x000000021d15ac7123e2dc7ae2de2f045165911151b898063768eca1c27e31fa")) + (1376000, uint256S("0x000000047928c3ff4ca5dec8dd99087df4770abd50469ce2bd3328346858373f")) + (1377000, uint256S("0x0000000271c0b5532f810a9ffb563d09bf74b959fb1939c741dc140ec1874d09")) + (1378000, uint256S("0x0000000048678a71baf3fdb3c5f905a78a75b6ffb02018b186693e87d8172eb4")) + (1379000, uint256S("0x00000003460b8c58481e205f842eb3fda43f313a87a303f64a8f971268fba367")) + (1380000, uint256S("0x000000023a6ce85edc04e5af620930477bea1aaf31ee262678968976717d176e")) + (1381000, uint256S("0x0000000436b6c757c06b32648e510c4249b88928921f4d0bc39371600d0d0824")) + (1382000, uint256S("0x00000001c7fd7b29c040c9c56d641ca219800d234e1eb8c640d86663de6cb335")) + (1383000, uint256S("0x00000002b9cb3b2aca628572ae964b334efc22acc8ed50500d76e834cecb264f")) + (1384000, uint256S("0x0000000550b1b189873d81707719eb1be9e2492f3897f59cf39aad447d12fe7d")) + (1385000, uint256S("0x00000002c778e98b2871165ee43f441496ed6c50e6cd97bccc82448498ca3a2b")) + (1386000, uint256S("0x000000037b6d4f8ed38297729f65b7dda39a0e297d0dff2b7ab11c31b784b5ce")) + (1387000, uint256S("0x00000002aa3edc372bb3030959ee6eda0fc188b0837d8409c073553124e31ca3")) + (1388000, uint256S("0x00000004c2ad445251b1faf327fcc6d4364d941e8b95377588d764845ce98e14")) + (1389000, uint256S("0x00000003730f20a59c6c6bfb8ee168145113eab1db437a1683c782ad59a593cc")) + (1390000, uint256S("0x00000001f4f78ddb8d92d00fea207be21bed937c632a70681a522f2b21257f30")) + (1391000, uint256S("0x0000000252c913ab26a7d67b1ef969399edc40c0cb89c564a90bca7478511d06")) + (1392000, uint256S("0x00000001a4fd677cd1510d2253223d62f3c1adc493ce88178663698aaae85ad4")) + (1393000, uint256S("0x0000000326c759d56837a8ded29af2f0628c89ea018f45f44ccc27539cda123c")) + (1394000, uint256S("0x00000006e8c60ec3bf6dbe664da6b86e29c0a6220706617b8bc024f313f600e5")) + (1395000, uint256S("0x00000001a089c52a4740433d3395e9faedca3d80bba38a5c1d51bfa5d61a82a7")) + (1396000, uint256S("0x00000009cb3a07fbfb926a75481ab04db3d1a108c73782272e184a66d55e5de9")) + (1397000, uint256S("0x00000004aa55ca33c9e6fc43f9ddd0b0f32cade6a3c0dc120c7faf60d72903ff")) + (1398000, uint256S("0x00000006091fd1a0d34b6dd29c590ba69569f910b96bcbc8434758c177f04022")) + (1399000, uint256S("0x00000003c85038020294c7c58ea8a4bec845cf6494bdf63222b31f4748fea77a")) + (1400000, uint256S("0x00000008d0941b9a5b394d19cff188a665cb8a57b89de8ad06f58fd08c6fcb8e")) + (1401000, uint256S("0x000000013a5e8cd206aad4b6b1c256e567def77a371254f2b33096f315f401f9")) + (1402000, uint256S("0x000000016587d0e9753056f74305dc05d818904248512bdc87dadc624e0be6dc")) + (1403000, uint256S("0x000000015575532cb246eb7c065b955921104a246d4fef43f14009bf2da0d9eb")) + (1404000, uint256S("0x000000055c93b66f7be3213b21f2f77eaf5e76c43060125d6cb3a91ca5ba8bd3")) + (1405000, uint256S("0x00000003df2e2b33cbeeb78d320e273880df4d6deb0e661b576052ddcaccb11c")) + (1406000, uint256S("0x00000003a9e7a1b897857b1df59931eae36855a66e39c4fe872c68440b8a77b6")) + (1407000, uint256S("0x000000007f74d842e9a2923f32a0d64bdf3bfdf9bd742bcd689a8647b487de60")) + (1408000, uint256S("0x000000004a021a23c0c31f2fcd82d757e20f2d7257880dec999061546c0309c9")) + (1409000, uint256S("0x0000000078be552c979aaf660ef8b2d6a7f3d6878975f49f6d24c0c4d70fbe07")) + (1410000, uint256S("0x000000071ffa758ba71f243c8b4106cdabaaa5ec0df9247af03f5dc9221b58b2")) + (1411000, uint256S("0x00000007be4b7695ad2a5ef100899a22efad8b142ecbc8b93d5f8d553f9286d4")) + ,(int64_t) 1688026050, // time of last checkpointed block + (int64_t) 0, // total txs + (double) 2304 // txs in the last day before block 1411911 }; // END HUSH mainnet checkpoint data From 0ee828805e29be670272bb0b03e7209518182502 Mon Sep 17 00:00:00 2001 From: fekt Date: Thu, 29 Jun 2023 23:39:33 -0400 Subject: [PATCH 28/36] Update README --- doc/relnotes/README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/doc/relnotes/README.md b/doc/relnotes/README.md index 2de5dc92a..92a20220b 100644 --- a/doc/relnotes/README.md +++ b/doc/relnotes/README.md @@ -12,6 +12,10 @@ evil organizations. # Hush 3.9.4 "Maniacal Manticore" +``` +67 files changed, 1295 insertions(+), 1343 deletions(-) +``` + This is an OPTIONAL release. It is recommended for exchanges, solo miners and mining pools to update to this release. * New features and improvements @@ -21,6 +25,7 @@ This is an OPTIONAL release. It is recommended for exchanges, solo miners and mi * Removed mapRequest tracking that only affects Qt display. * Randomized message processing peer order for increased privacy. * Removed BIP35 mempool p2p message for increased privacy. + * Additional community seed node * Build Improvements * Use custom jobs param when compiling boost for faster compile times * Now builds with gcc13 thanks to testing from jahway From d3cc17e9bd935848df4a97b8748500a5eff01b00 Mon Sep 17 00:00:00 2001 From: Duke Date: Fri, 30 Jun 2023 06:37:37 -0400 Subject: [PATCH 29/36] Update relnotes for 3.9.4 --- doc/relnotes/README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/relnotes/README.md b/doc/relnotes/README.md index 92a20220b..4dfbc01dc 100644 --- a/doc/relnotes/README.md +++ b/doc/relnotes/README.md @@ -19,7 +19,9 @@ evil organizations. This is an OPTIONAL release. It is recommended for exchanges, solo miners and mining pools to update to this release. * New features and improvements - * DragonX now has checkpoints for faster syncing. + * Hush and DragonX nodes will now sync much faster + * DragonX now has checkpoints for faster better chain security + * Updated to the latest RandomX code * Rate limiting for the processing of incoming addr messages for increased security. * Removed unused function CWalletTx::GetRequestCount * Removed mapRequest tracking that only affects Qt display. From 7017d8e06c5a64a3da1126b272201a6a95d3f8b1 Mon Sep 17 00:00:00 2001 From: Duke Date: Fri, 30 Jun 2023 06:42:33 -0400 Subject: [PATCH 30/36] Add info about DRAGONX checkpoints to release process --- doc/release-process.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/doc/release-process.md b/doc/release-process.md index bd0d70633..93fec2434 100644 --- a/doc/release-process.md +++ b/doc/release-process.md @@ -76,6 +76,7 @@ Install deps on Linux: - Comment out the HUSHVER line and uncomment the line above it with a hardcoded version number - PROTIP: Man page creation must be done after updating the version number and recompiling and before Debian package creation - Update checkpoints in src/chainparams.cpp via util/checkpoints.pl + - Run "./util/checkpoints.pl help" to get example usage - hushd must be running to run this script, since it uses hush-cli to get the data - Look for line which says "END HUSH mainnet checkpoint data" near line 560 in chainparams.cpp , that is where checkpoint data ends - Find the highest block height of checkpoint data, let's call it HEIGHT @@ -95,6 +96,7 @@ Install deps on Linux: - They only provide limited security, because they talk about the past, not future block heights. - Try to generate checkpoints as close to the release as possible, so you can have a recent block height be protected. - For instance, don't update checkpoints and then do a release a month later. You can always update checkpoint data again or multiple times + - DRAGONX now has checkpoints, you can generate them with: `./util/checkpoints.pl 1000 1 DRAGONX` - Update copyright years if applicable. Example: `./util/update-copyrights.h 2022 2023` - Update doc/relnotes/README.md - To get the stats of file changes: `git diff --stat master...dev` From 2ba2122b2636bd90e339c0f50bd8d60b305b5bf6 Mon Sep 17 00:00:00 2001 From: fekt Date: Sun, 2 Jul 2023 11:26:54 -0400 Subject: [PATCH 31/36] Update relnotes --- doc/relnotes/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/relnotes/README.md b/doc/relnotes/README.md index 4dfbc01dc..294f3d299 100644 --- a/doc/relnotes/README.md +++ b/doc/relnotes/README.md @@ -13,7 +13,7 @@ evil organizations. # Hush 3.9.4 "Maniacal Manticore" ``` -67 files changed, 1295 insertions(+), 1343 deletions(-) +68 files changed, 1304 insertions(+), 1343 deletions(-) ``` This is an OPTIONAL release. It is recommended for exchanges, solo miners and mining pools to update to this release. From 8969a9d8fe500e01cb584d3d92aea247fcc16f02 Mon Sep 17 00:00:00 2001 From: Duke Date: Tue, 4 Jul 2023 11:14:56 -0400 Subject: [PATCH 32/36] Put binaries into a properly named subdirectory, fixes #311 --- util/gen-linux-binary-release.sh | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/util/gen-linux-binary-release.sh b/util/gen-linux-binary-release.sh index 3a2b4e235..c9dde8589 100755 --- a/util/gen-linux-binary-release.sh +++ b/util/gen-linux-binary-release.sh @@ -8,7 +8,8 @@ set -x #hardcode and uncomment if hushd is not running on this machine #VERSION=3.6.3 VERSION=$(./src/hushd --version|grep version|cut -d' ' -f4|cut -d- -f1|sed 's/v//g') -FILE="hush-$VERSION-linux-amd64.tar" +DIR="hush-$VERSION-linux-amd64" +FILE="$DIR.tar" TIME=$(perl -e 'print time') if [ -d "build" ] @@ -17,14 +18,17 @@ then echo "Moved existing build/ dir to build.$TIME" fi mkdir build -echo "Created new build/ dir" -cp contrib/asmap/asmap.dat build/ -cp sapling*.params build/ +BUILD="build/$DIR" +mkdir $BUILD +echo "Created new build dir $BUILD" +cp contrib/asmap/asmap.dat $BUILD +cp sapling*.params $BUILD cd src -cp hushd hush-cli hush-tx hush-smart-chain dragonx-cli dragonxd ../build -cd ../build +cp hushd hush-cli hush-tx hush-smart-chain dragonx-cli dragonxd ../$BUILD +cd ../$BUILD strip hushd hush-cli hush-tx -tar -f $FILE -c * +cd .. +tar -f $FILE -c hush-$VERSION-linux-amd64/* gzip -9 $FILE sha256sum *.gz du -sh *.gz From 803e1d0f216ad8718b6d42551e4c494bbb143082 Mon Sep 17 00:00:00 2001 From: fekt Date: Wed, 5 Jul 2023 13:29:36 -0400 Subject: [PATCH 33/36] Use older version of cURL for Windows --- depends/packages/libcurl.mk | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/depends/packages/libcurl.mk b/depends/packages/libcurl.mk index 1ece9ce64..473d8c34f 100644 --- a/depends/packages/libcurl.mk +++ b/depends/packages/libcurl.mk @@ -1,9 +1,17 @@ package=libcurl + +ifeq ($(host_os),mingw32) +$(package)_version=7.67.0 +$(package)_file_name=curl-$($(package)_version).tar.gz +$(package)_sha256_hash=52af3361cf806330b88b4fe6f483b6844209d47ae196ac46da4de59bb361ab02 +else $(package)_version=7.77.0 -$(package)_dependencies=wolfssl -$(package)_download_path=https://curl.haxx.se/download $(package)_file_name=curl-$($(package)_version).tar.gz $(package)_sha256_hash=b0a3428acb60fa59044c4d0baae4e4fc09ae9af1d8a3aa84b2e3fbcd99841f77 +endif + +$(package)_dependencies=wolfssl +$(package)_download_path=https://curl.haxx.se/download $(package)_config_opts_linux=--disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) --host=$(host) $(package)_config_opts_mingw32=--enable-mingw --disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) --host=x86_64-w64-mingw32 $(package)_config_opts_darwin=--disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) From e53220b5f155ce679776624054f9baced13b867c Mon Sep 17 00:00:00 2001 From: fekt Date: Sun, 9 Jul 2023 11:49:55 -0400 Subject: [PATCH 34/36] Save checkpoints as individual .json files --- contrib/sda_checkpoints.pl | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) mode change 100644 => 100755 contrib/sda_checkpoints.pl diff --git a/contrib/sda_checkpoints.pl b/contrib/sda_checkpoints.pl old mode 100644 new mode 100755 index ab468af86..e93c497e7 --- a/contrib/sda_checkpoints.pl +++ b/contrib/sda_checkpoints.pl @@ -12,8 +12,8 @@ my $hush = "./src/hush-cli"; my $getblock= "$hush getblock"; my $gethash = "$hush getblockhash"; my $gettree = "$hush getblockmerkletree"; -my $start = shift || 1190000; -my $end = shift || 1260000; +my $start = shift || 1390000; +my $end = shift || 1422000; my $stride = shift || 10000; my $blocks = qx{$hush getblockcount}; @@ -41,8 +41,12 @@ while (1) { chomp $merkle; chomp $blockhash; chomp $blocktime; - $blocktime =~ s/^\s+|\s+$//g ; - print qq{{\n\t"network": "main",\n\t"height": "$block",\n\t"hash": "$blockhash",\n\t$blocktime\n\t"saplingTree": "$merkle"\n},\n}; + $blocktime =~ s/^\s+|\s+$//g; + my $checkpoint = qq{{\n\t"network": "main",\n\t"height": "$block",\n\t"hash": "$blockhash",\n\t$blocktime\n\t"saplingTree": "$merkle"\n}\n}; + my $filename = "$block.json"; + open(FH, '>', $filename) or die $!; + print FH $checkpoint; + close(FH); $block += $stride; } From 4d3d880036bfc823a1f9dff43f465f392043e7a4 Mon Sep 17 00:00:00 2001 From: Duke Date: Tue, 8 Aug 2023 15:40:52 -0400 Subject: [PATCH 35/36] Add docs for adding a new PoW algo --- doc/developer-notes.md | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/doc/developer-notes.md b/doc/developer-notes.md index 77233221c..eca281a0c 100644 --- a/doc/developer-notes.md +++ b/doc/developer-notes.md @@ -104,6 +104,27 @@ We should also check a recent block height to verify it's working correctly. The * If you stop a node, and restart, are the stats from `getchaintxtstats` correct, i.e. the anonset stats? For instance, `shielded_pool_size` should be close to 500000, if it's close to or exactly 0, something is wrong. * Is there a new file called `zindex.dat` in `~/.hush/HUSH3/` ? * Is `zindex.dat` 149 bytes ? + +# Adding a PoW algorithm + +We will describe here the high-level ideas on how to add a new PoW algorithm to +the Hush codebase. Adding a new PoW algo means adding a new option to the `-ac_algo` +CLI param for HSC's. + + * Add the new value to the end of the `ASSETCHAINS_ALGORITHMS` array in `src/hush_utils.h` + * You cannot add it to the front because the first element is the default "equihash" + * Increase the value of `ASSETCHAINS_NUMALGOS` by one + * This value cannot be automatically be determined by the length of the above array because Equihash has different supported variants of (N,K) values + * Add the new PoW mining library to a subdirectory in src, such as RandomX official code being in `src/RandomX` + * The largest part of adding a new PoW algo is adding a new class to src/miner.cpp + * Originally there was only BitcoinMiner, which was modified from a double-sha256 miner to an equihash miner, without changing the name + * When RandomX was added as an option, many big internals changes were needed to support more than a single miner class + * It is now easier to add PoW algos because the internals support using different miner classes + * Currently BitcoinMiner and RandomXMiner classes have a lot of duplicated code, but this is intentional + * In theory we could refactor the miner classes to share more code, but this means changes to one miner could break another and it is very challenging to test every possibile edge case for mining code + * So code duplication is purposeful, because it isolates the risk of breaking one PoW by changing another. We tried very hard to not break Equihash mining when adding RandomX mining. + * When adding a new mining class, copying the RandomXMiner class is best, since it's newer and does not contain various legacy code that still exists in BitcoinMiner + * So copy RandomXMiner to your new FooMiner, delete all the randomx-specific stuff and add in the PoW mining code # Coding From c6859b676e1198fc27d0b9377fc4a3387ab70086 Mon Sep 17 00:00:00 2001 From: duke Date: Wed, 9 Aug 2023 00:05:00 +0000 Subject: [PATCH 36/36] Update 'doc/developer-notes.md' --- doc/developer-notes.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/doc/developer-notes.md b/doc/developer-notes.md index eca281a0c..d8027f38e 100644 --- a/doc/developer-notes.md +++ b/doc/developer-notes.md @@ -113,6 +113,7 @@ CLI param for HSC's. * Add the new value to the end of the `ASSETCHAINS_ALGORITHMS` array in `src/hush_utils.h` * You cannot add it to the front because the first element is the default "equihash" + * You will also need to add a new constant, such as `ASSETCHAINS_FOOHASH` to `src/hush_globals.h` * Increase the value of `ASSETCHAINS_NUMALGOS` by one * This value cannot be automatically be determined by the length of the above array because Equihash has different supported variants of (N,K) values * Add the new PoW mining library to a subdirectory in src, such as RandomX official code being in `src/RandomX` @@ -125,6 +126,8 @@ CLI param for HSC's. * So code duplication is purposeful, because it isolates the risk of breaking one PoW by changing another. We tried very hard to not break Equihash mining when adding RandomX mining. * When adding a new mining class, copying the RandomXMiner class is best, since it's newer and does not contain various legacy code that still exists in BitcoinMiner * So copy RandomXMiner to your new FooMiner, delete all the randomx-specific stuff and add in the PoW mining code + * Some other changes to src/miner.cpp will be needed + * Update `GenerateBitcoins` function to start mining threads with your new algo with `else if(ASSETCHAINS_ALGO == ASSETCHAINS_FOOHASH) { minerThreads->create_thread(&FooMiner)}` # Coding