github.com/bloxroute-labs/bor@v0.1.4/consensus/ethash/sealer.go (about) 1 // Copyright 2017 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package ethash 18 19 import ( 20 "bytes" 21 crand "crypto/rand" 22 "encoding/json" 23 "errors" 24 "math" 25 "math/big" 26 "math/rand" 27 "net/http" 28 "runtime" 29 "sync" 30 "time" 31 32 "github.com/maticnetwork/bor/common" 33 "github.com/maticnetwork/bor/common/hexutil" 34 "github.com/maticnetwork/bor/consensus" 35 "github.com/maticnetwork/bor/core/types" 36 "github.com/maticnetwork/bor/log" 37 ) 38 39 const ( 40 // staleThreshold is the maximum depth of the acceptable stale but valid ethash solution. 41 staleThreshold = 7 42 ) 43 44 var ( 45 errNoMiningWork = errors.New("no mining work available yet") 46 errInvalidSealResult = errors.New("invalid or stale proof-of-work solution") 47 ) 48 49 // Seal implements consensus.Engine, attempting to find a nonce that satisfies 50 // the block's difficulty requirements. 51 func (ethash *Ethash) Seal(chain consensus.ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { 52 // If we're running a fake PoW, simply return a 0 nonce immediately 53 if ethash.config.PowMode == ModeFake || ethash.config.PowMode == ModeFullFake { 54 header := block.Header() 55 header.Nonce, header.MixDigest = types.BlockNonce{}, common.Hash{} 56 select { 57 case results <- block.WithSeal(header): 58 default: 59 log.Warn("Sealing result is not read by miner", "mode", "fake", "sealhash", ethash.SealHash(block.Header())) 60 } 61 return nil 62 } 63 // If we're running a shared PoW, delegate sealing to it 64 if ethash.shared != nil { 65 return ethash.shared.Seal(chain, block, results, stop) 66 } 67 // Create a runner and the multiple search threads it directs 68 abort := make(chan struct{}) 69 70 ethash.lock.Lock() 71 threads := ethash.threads 72 if ethash.rand == nil { 73 seed, err := crand.Int(crand.Reader, big.NewInt(math.MaxInt64)) 74 if err != nil { 75 ethash.lock.Unlock() 76 return err 77 } 78 ethash.rand = rand.New(rand.NewSource(seed.Int64())) 79 } 80 ethash.lock.Unlock() 81 if threads == 0 { 82 threads = runtime.NumCPU() 83 } 84 if threads < 0 { 85 threads = 0 // Allows disabling local mining without extra logic around local/remote 86 } 87 // Push new work to remote sealer 88 if ethash.workCh != nil { 89 ethash.workCh <- &sealTask{block: block, results: results} 90 } 91 var ( 92 pend sync.WaitGroup 93 locals = make(chan *types.Block) 94 ) 95 for i := 0; i < threads; i++ { 96 pend.Add(1) 97 go func(id int, nonce uint64) { 98 defer pend.Done() 99 ethash.mine(block, id, nonce, abort, locals) 100 }(i, uint64(ethash.rand.Int63())) 101 } 102 // Wait until sealing is terminated or a nonce is found 103 go func() { 104 var result *types.Block 105 select { 106 case <-stop: 107 // Outside abort, stop all miner threads 108 close(abort) 109 case result = <-locals: 110 // One of the threads found a block, abort all others 111 select { 112 case results <- result: 113 default: 114 log.Warn("Sealing result is not read by miner", "mode", "local", "sealhash", ethash.SealHash(block.Header())) 115 } 116 close(abort) 117 case <-ethash.update: 118 // Thread count was changed on user request, restart 119 close(abort) 120 if err := ethash.Seal(chain, block, results, stop); err != nil { 121 log.Error("Failed to restart sealing after update", "err", err) 122 } 123 } 124 // Wait for all miners to terminate and return the block 125 pend.Wait() 126 }() 127 return nil 128 } 129 130 // mine is the actual proof-of-work miner that searches for a nonce starting from 131 // seed that results in correct final block difficulty. 132 func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan struct{}, found chan *types.Block) { 133 // Extract some data from the header 134 var ( 135 header = block.Header() 136 hash = ethash.SealHash(header).Bytes() 137 target = new(big.Int).Div(two256, header.Difficulty) 138 number = header.Number.Uint64() 139 dataset = ethash.dataset(number, false) 140 ) 141 // Start generating random nonces until we abort or find a good one 142 var ( 143 attempts = int64(0) 144 nonce = seed 145 ) 146 logger := log.New("miner", id) 147 logger.Trace("Started ethash search for new nonces", "seed", seed) 148 search: 149 for { 150 select { 151 case <-abort: 152 // Mining terminated, update stats and abort 153 logger.Trace("Ethash nonce search aborted", "attempts", nonce-seed) 154 ethash.hashrate.Mark(attempts) 155 break search 156 157 default: 158 // We don't have to update hash rate on every nonce, so update after after 2^X nonces 159 attempts++ 160 if (attempts % (1 << 15)) == 0 { 161 ethash.hashrate.Mark(attempts) 162 attempts = 0 163 } 164 // Compute the PoW value of this nonce 165 digest, result := hashimotoFull(dataset.dataset, hash, nonce) 166 if new(big.Int).SetBytes(result).Cmp(target) <= 0 { 167 // Correct nonce found, create a new header with it 168 header = types.CopyHeader(header) 169 header.Nonce = types.EncodeNonce(nonce) 170 header.MixDigest = common.BytesToHash(digest) 171 172 // Seal and return a block (if still needed) 173 select { 174 case found <- block.WithSeal(header): 175 logger.Trace("Ethash nonce found and reported", "attempts", nonce-seed, "nonce", nonce) 176 case <-abort: 177 logger.Trace("Ethash nonce found but discarded", "attempts", nonce-seed, "nonce", nonce) 178 } 179 break search 180 } 181 nonce++ 182 } 183 } 184 // Datasets are unmapped in a finalizer. Ensure that the dataset stays live 185 // during sealing so it's not unmapped while being read. 186 runtime.KeepAlive(dataset) 187 } 188 189 // remote is a standalone goroutine to handle remote mining related stuff. 190 func (ethash *Ethash) remote(notify []string, noverify bool) { 191 var ( 192 works = make(map[common.Hash]*types.Block) 193 rates = make(map[common.Hash]hashrate) 194 195 results chan<- *types.Block 196 currentBlock *types.Block 197 currentWork [4]string 198 199 notifyTransport = &http.Transport{} 200 notifyClient = &http.Client{ 201 Transport: notifyTransport, 202 Timeout: time.Second, 203 } 204 notifyReqs = make([]*http.Request, len(notify)) 205 ) 206 // notifyWork notifies all the specified mining endpoints of the availability of 207 // new work to be processed. 208 notifyWork := func() { 209 work := currentWork 210 blob, _ := json.Marshal(work) 211 212 for i, url := range notify { 213 // Terminate any previously pending request and create the new work 214 if notifyReqs[i] != nil { 215 notifyTransport.CancelRequest(notifyReqs[i]) 216 } 217 notifyReqs[i], _ = http.NewRequest("POST", url, bytes.NewReader(blob)) 218 notifyReqs[i].Header.Set("Content-Type", "application/json") 219 220 // Push the new work concurrently to all the remote nodes 221 go func(req *http.Request, url string) { 222 res, err := notifyClient.Do(req) 223 if err != nil { 224 log.Warn("Failed to notify remote miner", "err", err) 225 } else { 226 log.Trace("Notified remote miner", "miner", url, "hash", log.Lazy{Fn: func() common.Hash { return common.HexToHash(work[0]) }}, "target", work[2]) 227 res.Body.Close() 228 } 229 }(notifyReqs[i], url) 230 } 231 } 232 // makeWork creates a work package for external miner. 233 // 234 // The work package consists of 3 strings: 235 // result[0], 32 bytes hex encoded current block header pow-hash 236 // result[1], 32 bytes hex encoded seed hash used for DAG 237 // result[2], 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty 238 // result[3], hex encoded block number 239 makeWork := func(block *types.Block) { 240 hash := ethash.SealHash(block.Header()) 241 242 currentWork[0] = hash.Hex() 243 currentWork[1] = common.BytesToHash(SeedHash(block.NumberU64())).Hex() 244 currentWork[2] = common.BytesToHash(new(big.Int).Div(two256, block.Difficulty()).Bytes()).Hex() 245 currentWork[3] = hexutil.EncodeBig(block.Number()) 246 247 // Trace the seal work fetched by remote sealer. 248 currentBlock = block 249 works[hash] = block 250 } 251 // submitWork verifies the submitted pow solution, returning 252 // whether the solution was accepted or not (not can be both a bad pow as well as 253 // any other error, like no pending work or stale mining result). 254 submitWork := func(nonce types.BlockNonce, mixDigest common.Hash, sealhash common.Hash) bool { 255 if currentBlock == nil { 256 log.Error("Pending work without block", "sealhash", sealhash) 257 return false 258 } 259 // Make sure the work submitted is present 260 block := works[sealhash] 261 if block == nil { 262 log.Warn("Work submitted but none pending", "sealhash", sealhash, "curnumber", currentBlock.NumberU64()) 263 return false 264 } 265 // Verify the correctness of submitted result. 266 header := block.Header() 267 header.Nonce = nonce 268 header.MixDigest = mixDigest 269 270 start := time.Now() 271 if !noverify { 272 if err := ethash.verifySeal(nil, header, true); err != nil { 273 log.Warn("Invalid proof-of-work submitted", "sealhash", sealhash, "elapsed", common.PrettyDuration(time.Since(start)), "err", err) 274 return false 275 } 276 } 277 // Make sure the result channel is assigned. 278 if results == nil { 279 log.Warn("Ethash result channel is empty, submitted mining result is rejected") 280 return false 281 } 282 log.Trace("Verified correct proof-of-work", "sealhash", sealhash, "elapsed", common.PrettyDuration(time.Since(start))) 283 284 // Solutions seems to be valid, return to the miner and notify acceptance. 285 solution := block.WithSeal(header) 286 287 // The submitted solution is within the scope of acceptance. 288 if solution.NumberU64()+staleThreshold > currentBlock.NumberU64() { 289 select { 290 case results <- solution: 291 log.Debug("Work submitted is acceptable", "number", solution.NumberU64(), "sealhash", sealhash, "hash", solution.Hash()) 292 return true 293 default: 294 log.Warn("Sealing result is not read by miner", "mode", "remote", "sealhash", sealhash) 295 return false 296 } 297 } 298 // The submitted block is too old to accept, drop it. 299 log.Warn("Work submitted is too old", "number", solution.NumberU64(), "sealhash", sealhash, "hash", solution.Hash()) 300 return false 301 } 302 303 ticker := time.NewTicker(5 * time.Second) 304 defer ticker.Stop() 305 306 for { 307 select { 308 case work := <-ethash.workCh: 309 // Update current work with new received block. 310 // Note same work can be past twice, happens when changing CPU threads. 311 results = work.results 312 313 makeWork(work.block) 314 315 // Notify and requested URLs of the new work availability 316 notifyWork() 317 318 case work := <-ethash.fetchWorkCh: 319 // Return current mining work to remote miner. 320 if currentBlock == nil { 321 work.errc <- errNoMiningWork 322 } else { 323 work.res <- currentWork 324 } 325 326 case result := <-ethash.submitWorkCh: 327 // Verify submitted PoW solution based on maintained mining blocks. 328 if submitWork(result.nonce, result.mixDigest, result.hash) { 329 result.errc <- nil 330 } else { 331 result.errc <- errInvalidSealResult 332 } 333 334 case result := <-ethash.submitRateCh: 335 // Trace remote sealer's hash rate by submitted value. 336 rates[result.id] = hashrate{rate: result.rate, ping: time.Now()} 337 close(result.done) 338 339 case req := <-ethash.fetchRateCh: 340 // Gather all hash rate submitted by remote sealer. 341 var total uint64 342 for _, rate := range rates { 343 // this could overflow 344 total += rate.rate 345 } 346 req <- total 347 348 case <-ticker.C: 349 // Clear stale submitted hash rate. 350 for id, rate := range rates { 351 if time.Since(rate.ping) > 10*time.Second { 352 delete(rates, id) 353 } 354 } 355 // Clear stale pending blocks 356 if currentBlock != nil { 357 for hash, block := range works { 358 if block.NumberU64()+staleThreshold <= currentBlock.NumberU64() { 359 delete(works, hash) 360 } 361 } 362 } 363 364 case errc := <-ethash.exitCh: 365 // Exit remote loop if ethash is closed and return relevant error. 366 errc <- nil 367 log.Trace("Ethash remote sealer is exiting") 368 return 369 } 370 } 371 }