optimize trojan chunk mining

[mortelli]

(issue stemming from unresolved thread in #2148)

@zelig's suggestion:

so here we can do parallelisation

func mine(f func(nonce []byte) (interface{}, bool)) (interface{}) {
    seeds := [8]uint32
    for i, _ := range seeds {
        seeds[i] = rand.Uint32()
    }
    initnonce := make([]byte, 32)
    for i:=0; i<32; i+=4 {
        binary.PutUint32(initnonce[i:i+4], seeds[i])
    }
    quit := make(chan struct{})
    result := make(chan interface{})
    for i:=0; i<8; i++ {
        nonce :=  make([]byte,32)
        copy(nonce, initnonce)
        go func(seed uint32) {
            for ;;seed++{
                binary.PutUint32(nonce[i:i+4], seed)
                if res, ok := f(nonce); ok {
                    result <- res
                    return
                }
                select {
                    case <- quit:
                    return
                    default:
                }
            }
        }(seeds[i])
    }
    defer close(quit)
    return <-result
}

see thread here

---

additionally, some sort of timeout should be implemented for the mining.