Merge pull request #29 from wam-rd/fishhash

KarlsenHashV2-Fishhash Karlsen Node & CPU miner for Testnet-1

app/app.go

@@ -7,6 +7,7 @@ import (
 	"runtime"
 	"time"
 
+	"github.com/karlsen-network/karlsend/domain/consensus/utils/pow"
 	"github.com/karlsen-network/karlsend/infrastructure/config"
 	"github.com/karlsen-network/karlsend/infrastructure/db/database"
 	"github.com/karlsen-network/karlsend/infrastructure/db/database/ldb"
@@ -82,6 +83,12 @@ func (app *karlsendApp) main(startedChan chan<- struct{}) error {
 
 	// Show version at startup.
 	log.Infof("Version %s", version.Version())
+	log.Infof("Using KarlsenHashV2 impl: %s", pow.GetHashingAlgoVersion())
+	if !app.cfg.Testnet && !app.cfg.Devnet && !app.cfg.Simnet {
+		log.Warnf("You are trying to connect to Mainnet")
+		log.Errorf("This version is using KarlsenHashV2, please add --testnet parameter")
+		os.Exit(42)
+	}
 
 	// Enable http profiling server if requested.
 	if app.cfg.Profile != "" {

cmd/karlsenminer/main.go

@@ -12,6 +12,7 @@ import (
 
 	_ "net/http/pprof"
 
+	"github.com/karlsen-network/karlsend/domain/consensus/utils/pow"
 	"github.com/karlsen-network/karlsend/infrastructure/os/signal"
 	"github.com/karlsen-network/karlsend/util/panics"
 	"github.com/karlsen-network/karlsend/util/profiling"
@@ -29,6 +30,12 @@ func main() {
 
 	// Show version at startup.
 	log.Infof("Version %s", version.Version())
+	log.Infof("Using KarlsenHashV2 impl: %s", pow.GetHashingAlgoVersion())
+	if !cfg.Testnet && !cfg.Devnet && !cfg.Simnet {
+		log.Warnf("You are trying to connect to Mainnet")
+		log.Errorf("This version is using KarlsenHashV2, please add --testnet parameter")
+		os.Exit(42)
+	}
 
 	// Enable http profiling server if requested.
 	if cfg.Profile != "" {

cmd/karlsenminer/mineloop.go

@@ -19,6 +19,7 @@ import (
 )
 
 var hashesTried uint64
+var dagReady = false
 
 const logHashRateInterval = 10 * time.Second
 
@@ -97,6 +98,12 @@ func logHashRate() {
 	spawn("logHashRate", func() {
 		lastCheck := time.Now()
 		for range time.Tick(logHashRateInterval) {
+
+			if !dagReady {
+				log.Infof("Generating DAG, please wait ...")
+				continue
+			}
+
 			currentHashesTried := atomic.LoadUint64(&hashesTried)
 			currentTime := time.Now()
 			kiloHashesTried := float64(currentHashesTried) / 1000.0
@@ -138,7 +145,11 @@ func handleFoundBlock(client *minerClient, block *externalapi.DomainBlock) error
 func mineNextBlock(mineWhenNotSynced bool) *externalapi.DomainBlock {
 	nonce := rand.Uint64() // Use the global concurrent-safe random source.
 	for {
+		if !dagReady {
+			continue
+		}
 		nonce++
+		//fmt.Printf("mineNextBlock -- log1\n")
 		// For each nonce we try to build a block from the most up to date
 		// block template.
 		// In the rare case where the nonce space is exhausted for a specific
@@ -165,7 +176,6 @@ func getBlockForMining(mineWhenNotSynced bool) (*externalapi.DomainBlock, *pow.S
 
 	for {
 		tryCount++
-
 		shouldLog := (tryCount-1)%10 == 0
 		template, state, isSynced := templatemanager.Get()
 		if template == nil {
@@ -207,7 +217,10 @@ func templatesLoop(client *minerClient, miningAddr util.Address, errChan chan er
 			errChan <- errors.Wrapf(err, "Error getting block template from %s", client.Address())
 			return
 		}
-		err = templatemanager.Set(template)
+		err = templatemanager.Set(template, backendLog)
+		// after first template DAG is supposed to be ready
+		// TODO: refresh dag status in real time
+		dagReady = true
 		if err != nil {
 			errChan <- errors.Wrapf(err, "Error setting block template from %s", client.Address())
 			return

cmd/karlsenminer/templatemanager/templatemanager.go

@@ -6,6 +6,7 @@ import (
 	"github.com/karlsen-network/karlsend/app/appmessage"
 	"github.com/karlsen-network/karlsend/domain/consensus/model/externalapi"
 	"github.com/karlsen-network/karlsend/domain/consensus/utils/pow"
+	"github.com/karlsen-network/karlsend/infrastructure/logger"
 )
 
 var currentTemplate *externalapi.DomainBlock
@@ -27,15 +28,16 @@ func Get() (*externalapi.DomainBlock, *pow.State, bool) {
 }
 
 // Set sets the current template to work on
-func Set(template *appmessage.GetBlockTemplateResponseMessage) error {
+func Set(template *appmessage.GetBlockTemplateResponseMessage, backendLog *logger.Backend) error {
 	block, err := appmessage.RPCBlockToDomainBlock(template.Block)
 	if err != nil {
 		return err
 	}
 	lock.Lock()
 	defer lock.Unlock()
 	currentTemplate = block
-	currentState = pow.NewState(block.Header.ToMutable())
+	pow.SetLogger(backendLog, logger.LevelTrace)
+	currentState = pow.NewState(block.Header.ToMutable(), true)
 	isSynced = template.IsSynced
 	return nil
 }

domain/consensus/processes/blockvalidator/pruning_violation_proof_of_work_and_difficulty.go

@@ -150,7 +150,7 @@ func (v *blockValidator) validateDifficulty(stagingArea *model.StagingArea,
 //     difficulty is not performed.
 func (v *blockValidator) checkProofOfWork(header externalapi.BlockHeader) error {
 	// The target difficulty must be larger than zero.
-	state := pow.NewState(header.ToMutable())
+	state := pow.NewState(header.ToMutable(), false)
 	target := &state.Target
 	if target.Sign() <= 0 {
 		return errors.Wrapf(ruleerrors.ErrNegativeTarget, "block target difficulty of %064x is too low",

domain/consensus/processes/blockvalidator/pruning_violation_proof_of_work_and_difficulty_test.go

@@ -115,7 +115,7 @@ func TestPOW(t *testing.T) {
 // solveBlockWithWrongPOW increments the given block's nonce until it gets wrong POW (for test!).
 func solveBlockWithWrongPOW(block *externalapi.DomainBlock) *externalapi.DomainBlock {
 	header := block.Header.ToMutable()
-	state := pow.NewState(header)
+	state := pow.NewState(header, false)
 	for i := uint64(0); i < math.MaxUint64; i++ {
 		state.Nonce = i
 		if !state.CheckProofOfWork() {

domain/consensus/utils/mining/solve.go

@@ -12,7 +12,7 @@ import (
 // SolveBlock increments the given block's nonce until it matches the difficulty requirements in its bits field
 func SolveBlock(block *externalapi.DomainBlock, rd *rand.Rand) {
 	header := block.Header.ToMutable()
-	state := pow.NewState(header)
+	state := pow.NewState(header, false)
 	for state.Nonce = rd.Uint64(); state.Nonce < math.MaxUint64; state.Nonce++ {
 		if state.CheckProofOfWork() {
 			header.SetNonce(state.Nonce)