由于对区块链的喜爱，个人最近对矿池以及挖矿做了一点点研究。
首先先说下对于矿池的主要结构，如图
1525254093070.jpg
pool
pool为矿池的中心服务器，用来跟链与miner通信的。
运行pool程序的电脑上必须要有一个ETH或者OF的全节点。
他的主要功能包括两个
一：更新工作
func updateWork() {
for true {
currWorkNew, err := callArray("eth_getWork", []interface{}{})
if err == nil {
if currWorkNew.Result == nil {
time.Sleep(time.Millisecond * 200)
continue
}
if currHash == currWorkNew.Result[0].(string) {
//logInfo.Println("新的任务跟当前任务一致")
time.Sleep(time.Millisecond * 200)
continue
}
currWork = currWorkNew
currHash = currWork.Result[0].(string)
} else {
currWork = nil
logError.Println("update work error: ", err)
}
//fmt.Println("Current work", currWork.Result[0])
time.Sleep(time.Millisecond * 200)
}
}
二、提交工作
func submitWork(params []interface{}) (*ResponseBool, error) {
result, err := callBool("eth_submitWork", params)
return result, err
}
miner
miner为矿工方，主要用来挖矿，挖矿算法这里用的是eth公开的算法，我加以个人想法优化的。
首先是更新工作
// 更新区块
func updatePendingBlock() {
var (
//threads int = runtime.NumCPU()
currHashNew int64
//difficulty uint64
)
for true {
time.Sleep(time.Millisecond * 500)
//var pend sync.WaitGroup
currWorkNew, err := callArray("ofbank_getWork", []interface{}{})
//fmt.Println(currWorkNew)
//logInfo.Println(currWorkNew)
if err != nil {
logInfo.Println("new work info", currWorkNew)
logError.Println("get new work error: ", err)
} else {
if currWorkNew.Result == nil {
fmt.Println("获取的任务为空")
continue
}
currHashNew, err = strconv.ParseInt(currWorkNew.Result[2].(string), 0, 64)
if err != nil {
logError.Println("get difficulty error: ", err,currHashNew)
continue
}
if currHash == currHashNew {
continue
}
if mining {
abort <- struct{}{}
}
currHash = currHashNew
currWork = currWorkNew
fmt.Println("开始工作",currHash,currWork.Result[0])
go sealWork(currWorkNew, abort)
}
}
}
这里在获取工作后，执行sealWork，这里有一个终止的通道，用来停止之前的工作，以免做无用功。
func sealWork(currWork *ResponseArray, abort chan struct{}) {
var (
blockDifficulty int64
err error
threads int = runtime.NumCPU()
)
//fmt.Println(currWork)
blockDifficulty, err = strconv.ParseInt(currWork.Result[2].(string), 0, 64)
if err != nil {
logError.Printf("seal work error: %+v", err)
mining = false
return
}
myBlock := &block{
//number: number,
difficulty: big.NewInt(blockDifficulty),
hashNoNonce: common.HexToHash(currWork.Result[0].(string)),
}
var stop = make(chan struct{}, threads)
var l = sync.Mutex{}
var th = 0
mining = true
for i := 0; i < threads; i++ {
th++
//fmt.Println("第",th,"线程")
go func() {
currNonce, md := hasher.Search(myBlock, stop, 0)
l.Lock()
th--
if th < 0 {
th = 0
}
l.Unlock()
myBlock.nonce = currNonce
myBlock.mixDigest = common.BytesToHash(md)
if hasher.Verify(myBlock) {
if mining {
// 挖矿中
l.Lock()
mining = false
l.Unlock()
submitTask := make([]interface{}, 3)
// nonce 必须为偶数位长度
nonceStr := strconv.FormatUint(currNonce, 16)
if len(nonceStr)%2 != 0 {
nonceStr = "0" + nonceStr
}
submitTask[0] = fmt.Sprintf("0x%s", nonceStr)
submitTask[1] = currWork.Result[0].(string)
//submitTask[1] = currWork.Result[0]
submitTask[2] = common.BytesToHash(md).Hex()
fmt.Println("提交工作")
abort <- struct{}{}
submitWork(submitTask)
}
}
}()
}
L:
for {
select {
case <-abort:
l.Lock()
var t = th - 1
mining = false
currWork = nil
currHash = 0
for i := 0; i < t; i ++ {
th--
stop <- struct{}{}
}
l.Unlock()
break L
}
}
}
然后是sealWork方法，这里根据CPU核心数创建线程，以达到最大CPU利用率。
在算到相应的工作后，向pool提交工作，等待下个工作。
使用攻略
简单写下windows系统下的使用攻略：
在有全节点的电脑上执行pool.exe 即可。
1525256636299.jpg
然后在查看当前电脑的IP地址，这里可以自行百度，有很多种方法，
然后在挖矿的电脑上执行miner.exe程序，
1525256671691.jpg
在这里输入刚刚查到的ip地址，回车，就可以了。
demo下载地址
demo里面有可执行程序.