@ -118,7 +118,7 @@ public:
} ;
extern int8_t ASSETCHAINS_ADAPTIVEPOW ;
extern uint32_t ASSETCHAINS_RANDOMX ;
extern uint32_t ASSETCHAINS_RANDOMX , ASSETCHAINS_MEMHASH ;
extern bool fRandomXDebug ;
void UpdateTime ( CBlockHeader * pblock , const Consensus : : Params & consensusParams , const CBlockIndex * pindexPrev )
@ -1412,6 +1412,172 @@ void static RandomXMiner()
c . disconnect ( ) ;
}
# ifdef ENABLE_WALLET
void static MemhashMiner ( CWallet * pwallet )
# else
void static MemhashMiner ( )
# endif
{
LogPrintf ( " HushMemhashMiner started \n " ) ;
SetThreadPriority ( THREAD_PRIORITY_LOWEST ) ;
RenameThread ( " hush-memhash " ) ;
const CChainParams & chainparams = Params ( ) ;
# ifdef ENABLE_WALLET
// Each thread has its own key
CReserveKey reservekey ( pwallet ) ;
# endif
// Each thread has its own counter
unsigned int nExtraNonce = 0 ;
uint8_t * script ; uint64_t total ; int32_t i , j , gpucount = HUSH_MAXGPUCOUNT , notaryid = - 1 ;
while ( ( ASSETCHAIN_INIT = = 0 | | HUSH_INITDONE = = 0 ) )
{
sleep ( 1 ) ;
if ( hush_baseid ( SMART_CHAIN_SYMBOL ) < 0 )
break ;
}
std : : mutex m_cs ;
bool cancelSolver = false ;
boost : : signals2 : : connection c = uiInterface . NotifyBlockTip . connect (
[ & m_cs , & cancelSolver ] ( const uint256 & hashNewTip ) mutable {
std : : lock_guard < std : : mutex > lock { m_cs } ;
cancelSolver = true ;
}
) ;
miningTimer . start ( ) ;
// TODO: Start actual memhash stuff
try {
fprintf ( stderr , " MemhashMiner: mining %s with memhash \n " , SMART_CHAIN_SYMBOL ) ;
while ( true ) {
fprintf ( stderr , " MemhashMiner: beginning mining loop on %s with nExtraNonce=%u \n " , SMART_CHAIN_SYMBOL , nExtraNonce ) ;
if ( chainparams . MiningRequiresPeers ( ) ) {
miningTimer . stop ( ) ;
do {
bool fvNodesEmpty ;
{
fvNodesEmpty = vNodes . empty ( ) ;
}
if ( ! fvNodesEmpty )
break ;
MilliSleep ( 15000 ) ;
} while ( true ) ;
miningTimer . start ( ) ;
}
// Create new block
unsigned int nTransactionsUpdatedLast = mempool . GetTransactionsUpdated ( ) ;
CBlockIndex * pindexPrev = chainActive . LastTip ( ) ;
// If we don't have a valid chain tip to work from, wait and try again.
if ( pindexPrev = = nullptr ) {
fprintf ( stderr , " %s: null pindexPrev, trying again... \n " , __func__ ) ;
MilliSleep ( 1000 ) ;
continue ;
}
if ( Mining_height ! = pindexPrev - > GetHeight ( ) + 1 )
{
Mining_height = pindexPrev - > GetHeight ( ) + 1 ;
Mining_start = ( uint32_t ) time ( NULL ) ;
}
# ifdef ENABLE_WALLET
CBlockTemplate * ptr = CreateNewBlockWithKey ( reservekey , pindexPrev - > GetHeight ( ) + 1 , gpucount , 0 ) ;
# else
CBlockTemplate * ptr = CreateNewBlockWithKey ( ) ;
# endif
if ( ptr = = 0 )
{
if ( ! GetBoolArg ( " -gen " , false ) )
{
miningTimer . stop ( ) ;
c . disconnect ( ) ;
LogPrintf ( " HushMemhashMiner terminated \n " ) ;
return ;
}
static uint32_t counter ;
if ( counter + + < 10 )
fprintf ( stderr , " MemhashMiner: created illegal blockB, retry with counter=%u \n " , counter ) ;
sleep ( 1 ) ;
continue ;
}
unique_ptr < CBlockTemplate > pblocktemplate ( ptr ) ;
if ( ! pblocktemplate . get ( ) )
{
if ( GetArg ( " -mineraddress " , " " ) . empty ( ) ) {
LogPrintf ( " Error in HushMemhashMiner: Keypool ran out, please call keypoolrefill before restarting the mining thread \n " ) ;
} else {
// Should never reach here, because -mineraddress validity is checked in init.cpp
LogPrintf ( " Error in HushMemhashMiner: Invalid -mineraddress \n " ) ;
}
return ;
}
CBlock * pblock = & pblocktemplate - > block ;
if ( ASSETCHAINS_REWARD [ 0 ] = = 0 & & ! ASSETCHAINS_LASTERA )
{
if ( pblock - > vtx . size ( ) = = 1 & & pblock - > vtx [ 0 ] . vout . size ( ) = = 1 & & Mining_height > ASSETCHAINS_MINHEIGHT )
{
static uint32_t counter ;
if ( counter + + < 10 )
fprintf ( stderr , " skip generating %s on-demand block, no tx avail \n " , SMART_CHAIN_SYMBOL ) ;
sleep ( 10 ) ;
continue ;
} else fprintf ( stderr , " %s vouts.%d mining.%d vs %d \n " , SMART_CHAIN_SYMBOL , ( int32_t ) pblock - > vtx [ 0 ] . vout . size ( ) , Mining_height , ASSETCHAINS_MINHEIGHT ) ;
}
IncrementExtraNonce ( pblock , pindexPrev , nExtraNonce ) ;
LogPrintf ( " Running HushMemhashMiner with %u transactions in block (%u bytes) \n " , pblock - > vtx . size ( ) , : : GetSerializeSize ( * pblock , SER_NETWORK , PROTOCOL_VERSION ) ) ;
// Search
uint8_t pubkeys [ 66 ] [ 33 ] ; arith_uint256 bnMaxPoSdiff ; uint32_t blocktimes [ 66 ] ; int mids [ 256 ] , nonzpkeys , i , j , externalflag ;
uint32_t savebits ;
int64_t nStart = GetTime ( ) ;
pblock - > nBits = GetNextWorkRequired ( pindexPrev , pblock , Params ( ) . GetConsensus ( ) ) ;
savebits = pblock - > nBits ;
HASHTarget = arith_uint256 ( ) . SetCompact ( savebits ) ;
roundrobin_delay = ROUNDROBIN_DELAY ;
Mining_start = 0 ;
gotinvalid = 0 ;
while ( true )
{
if ( gotinvalid ! = 0 ) {
fprintf ( stderr , " HushMemhashMiner: gotinvalid=%d \n " , gotinvalid ) ;
break ;
}
hush_longestchain ( ) ;
fprintf ( stderr , " HushMemhashMiner: solving with nNonce = %s \n " , pblock - > nNonce . ToString ( ) . c_str ( ) ) ;
arith_uint256 hashTarget ;
hashTarget = HASHTarget ;
CDataStream memhashInput ( SER_NETWORK , PROTOCOL_VERSION ) ;
// Use the current block as input
memhashInput < < pblocktemplate - > block ;
//TODO: calculate actual memhash hash with input
//TODO: Use hash to build a valid block
}
}
} catch ( const boost : : thread_interrupted & ) {
miningTimer . stop ( ) ;
c . disconnect ( ) ;
LogPrintf ( " HushRandomXMiner terminated \n " ) ;
throw ;
} catch ( const std : : runtime_error & e ) {
miningTimer . stop ( ) ;
c . disconnect ( ) ;
fprintf ( stderr , " RandomXMiner: runtime error: %s \n " , e . what ( ) ) ;
return ;
}
miningTimer . stop ( ) ;
c . disconnect ( ) ;
}
# ifdef ENABLE_WALLET
void static BitcoinMiner ( CWallet * pwallet )
# else
@ -1869,12 +2035,16 @@ void static BitcoinMiner()
minerThreads - > create_thread ( boost : : bind ( & BitcoinMiner , pwallet ) ) ;
} else if ( ASSETCHAINS_ALGO = = ASSETCHAINS_RANDOMX ) {
minerThreads - > create_thread ( boost : : bind ( & RandomXMiner , pwallet ) ) ;
} else if ( ASSETCHAINS_ALGO = = ASSETCHAINS_MEMHASH ) {
minerThreads - > create_thread ( boost : : bind ( & MemhashMiner , pwallet ) ) ;
}
# else
if ( ASSETCHAINS_ALGO = = ASSETCHAINS_EQUIHASH ) {
minerThreads - > create_thread ( & BitcoinMiner ) ;
} else if ( ASSETCHAINS_ALGO = = ASSETCHAINS_RANDOMX ) {
minerThreads - > create_thread ( & RandomXMiner ) ;
} else if ( ASSETCHAINS_ALGO = = ASSETCHAINS_MEMHASH ) {
minerThreads - > create_thread ( boost : : bind ( & MemhashMiner ) ) ;
}
# endif
}