Move remote mining agent to XEth

pull/551/head
Taylor Gerring 10 years ago
parent d76e8cb1f1
commit ab6311c1bd
  1. 13
      rpc/api.go
  2. 81
      xeth/miner_agent.go
  3. 8
      xeth/xeth.go

@ -17,20 +17,15 @@ type EthereumApi struct {
eth *xeth.XEth
xethMu sync.RWMutex
db common.Database
// Miner agent
agent *Agent
}
func NewEthereumApi(xeth *xeth.XEth, dataDir string) *EthereumApi {
// What about when dataDir is empty?
db, _ := ethdb.NewLDBDatabase(path.Join(dataDir, "dapps"))
api := &EthereumApi{
eth: xeth,
db: db,
agent: NewAgent(),
eth: xeth,
db: db,
}
xeth.Backend().Miner().Register(api.agent)
return api
}
@ -349,13 +344,13 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
*reply = NewLogsRes(api.xeth().AllLogs(opts))
case "eth_getWork":
api.xeth().SetMining(true)
*reply = api.agent.GetWork()
*reply = api.xeth().RemoteMining().GetWork()
case "eth_submitWork":
args := new(SubmitWorkArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
*reply = api.agent.SetResult(args.Nonce, args.Digest, args.Header)
*reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, args.Digest, args.Header)
case "db_putString":
args := new(DbArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {

@ -0,0 +1,81 @@
package xeth
import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/miner"
)
type Agent struct {
work *types.Block
currentWork *types.Block
quit chan struct{}
workCh chan *types.Block
returnCh chan<- miner.Work
}
func NewAgent() *Agent {
agent := &Agent{}
go agent.run()
return agent
}
func (a *Agent) Work() chan<- *types.Block {
return a.workCh
}
func (a *Agent) SetWorkCh(returnCh chan<- miner.Work) {
a.returnCh = returnCh
}
func (a *Agent) Start() {
a.quit = make(chan struct{})
a.workCh = make(chan *types.Block, 1)
}
func (a *Agent) Stop() {
close(a.quit)
close(a.workCh)
}
func (a *Agent) GetHashRate() int64 { return 0 }
func (a *Agent) run() {
out:
for {
select {
case <-a.quit:
break out
case work := <-a.workCh:
a.work = work
}
}
}
func (a *Agent) GetWork() [3]string {
// TODO return HashNoNonce, DAGSeedHash, Difficulty
var res [3]string
// XXX Wait here untill work != nil ?.
if a.work != nil {
res[0] = a.work.HashNoNonce().Hex() // Header Hash No Nonce
res[1] = common.Hash{}.Hex() // DAG Seed
res[2] = common.Hash{}.Hex() // Difficulty
}
return res
}
func (a *Agent) SubmitWork(nonce uint64, mixDigest, seedHash common.Hash) bool {
// Return true or false, but does not indicate if the PoW was correct
// Make sure the external miner was working on the right hash
if a.currentWork != nil && a.work != nil && a.currentWork.Hash() == a.work.Hash() {
a.returnCh <- miner.Work{a.currentWork.Number().Uint64(), nonce, mixDigest.Bytes(), seedHash.Bytes()}
return true
}
return false
}

@ -100,6 +100,9 @@ type XEth struct {
// regmut sync.Mutex
// register map[string][]*interface{} // TODO improve return type
// Miner agent
agent *Agent
}
// New creates an XEth that uses the given frontend.
@ -117,7 +120,10 @@ func New(eth Backend, frontend Frontend) *XEth {
frontend: frontend,
logs: make(map[int]*logFilter),
messages: make(map[int]*whisperFilter),
agent: NewAgent(),
}
eth.Miner().Register(xeth.agent)
if frontend == nil {
xeth.frontend = dummyFrontend{}
}
@ -164,6 +170,8 @@ func (self *XEth) stop() {
func (self *XEth) DefaultGas() *big.Int { return defaultGas }
func (self *XEth) DefaultGasPrice() *big.Int { return defaultGasPrice }
func (self *XEth) RemoteMining() *Agent { return self.agent }
func (self *XEth) AtStateNum(num int64) *XEth {
chain := self.Backend().ChainManager()
var block *types.Block

Loading…
Cancel
Save