edit api for get-work and submit work (#507)

diff --git a/api/api.go b/api/api.go
index 29f2d11..ef755d1 100644 (file)
--- a/api/api.go
+++ b/api/api.go
@@ -16,8 +16,8 @@ import (
        cfg "github.com/bytom/config"
        "github.com/bytom/dashboard"
        "github.com/bytom/errors"
-       "github.com/bytom/net/http/gzip"
        "github.com/bytom/net/http/authn"
+       "github.com/bytom/net/http/gzip"
        "github.com/bytom/net/http/httpjson"
        "github.com/bytom/net/http/static"
        "github.com/bytom/protocol"
@@ -221,8 +221,8 @@ func (a *API) buildHandler() {
 
        m.Handle("/is-mining", jsonHandler(a.isMining))
        m.Handle("/gas-rate", jsonHandler(a.gasRate))
-       m.Handle("/getwork", jsonHandler(a.getWork))
-       m.Handle("/submitwork", jsonHandler(a.submitWork))
+       m.Handle("/get-work", jsonHandler(a.getWork))
+       m.Handle("/submit-work", jsonHandler(a.submitWork))
 
        handler := latencyHandler(m, walletEnable)
        handler = walletRedirectHandler(handler)

diff --git a/api/miner.go b/api/miner.go
index 9bafba4..30220b3 100644 (file)
--- a/api/miner.go
+++ b/api/miner.go
@@ -14,8 +14,15 @@ func (a *API) getWork() Response {
        return NewSuccessResponse(work)
 }
 
-func (a *API) submitWork(bh *types.BlockHeader) Response {
-       return NewSuccessResponse(a.bcr.SubmitWork(bh))
+type SubmitWorkReq struct {
+       BlockHeader *types.BlockHeader `json:"block_header"`
+}
+
+func (a *API) submitWork(ctx context.Context, req *SubmitWorkReq) Response {
+       if err := a.bcr.SubmitWork(req.BlockHeader); err != nil {
+               return NewErrorResponse(err)
+       }
+       return NewSuccessResponse(true)
 }
 
 func (a *API) getBlockHeaderByHeight(ctx context.Context, req struct {

diff --git a/blockchain/miner.go b/blockchain/miner.go
index 4f7bea0..aea626f 100644 (file)
--- a/blockchain/miner.go
+++ b/blockchain/miner.go
@@ -28,6 +28,6 @@ func (bcr *BlockchainReactor) GetWork() (*GetWorkResp, error) {
        }, nil
 }
 
-func (bcr *BlockchainReactor) SubmitWork(bh *types.BlockHeader) bool {
+func (bcr *BlockchainReactor) SubmitWork(bh *types.BlockHeader) error {
        return bcr.miningPool.SubmitWork(bh)
 }

diff --git a/cmd/miner/main.go b/cmd/miner/main.go
index ecccf3e..6b88e91 100644 (file)
--- a/cmd/miner/main.go
+++ b/cmd/miner/main.go
@@ -5,6 +5,7 @@ import (
        "fmt"
        "os"
 
+       "github.com/bytom/api"
        "github.com/bytom/blockchain"
        "github.com/bytom/consensus/difficulty"
        "github.com/bytom/protocol/bc"
@@ -55,7 +56,7 @@ func getBlockHeaderByHeight(height uint64) {
 }
 
 func main() {
-       data, _ := util.ClientCall("/getwork", nil)
+       data, _ := util.ClientCall("/get-work", nil)
        rawData, err := json.Marshal(data)
        if err != nil {
                fmt.Println(err)
@@ -68,7 +69,7 @@ func main() {
        }
 
        if doWork(resp.BlockHeader, resp.Seed) {
-               util.ClientCall("/submitwork", resp.BlockHeader)
+               util.ClientCall("/submit-work", &api.SubmitWorkReq{BlockHeader: resp.BlockHeader})
        }
 
        getBlockHeaderByHeight(resp.BlockHeader.Height)

diff --git a/mining/miningpool/minepool.go b/mining/miningpool/minepool.go
index 58c57da..9df2b86 100644 (file)
--- a/mining/miningpool/minepool.go
+++ b/mining/miningpool/minepool.go
@@ -76,25 +76,26 @@ func (m *MiningPool) GetWork() (*types.BlockHeader, error) {
 }
 
 // SubmitWork will try to submit the result to the blockchain
-func (m *MiningPool) SubmitWork(bh *types.BlockHeader) bool {
+func (m *MiningPool) SubmitWork(bh *types.BlockHeader) error {
        m.mutex.Lock()
        defer m.mutex.Unlock()
 
        if m.block == nil || bh.PreviousBlockHash != m.block.PreviousBlockHash {
-               return false
+               return errors.New("pending mining block has been changed")
        }
 
        m.block.Nonce = bh.Nonce
        m.block.Timestamp = bh.Timestamp
        isOrphan, err := m.chain.ProcessBlock(m.block)
-
        if err != nil {
-               log.Errorf("fail on SubmitWork on ProcessBlock %v", err)
-       } else if isOrphan {
+               return err
+       }
+
+       if isOrphan {
                log.Warning("SubmitWork is orphan")
        }
 
        blockHash := bh.Hash()
        m.newBlockCh <- &blockHash
-       return err == nil
+       return nil
 }

diff --git a/protocol/bc/bctest/tx.go b/protocol/bc/bctest/tx.go
deleted file mode 100644 (file)
index d05e30d..0000000
--- a/protocol/bc/bctest/tx.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Package bctest provides utilities for constructing blockchain data
-// structures.
-package bctest
-
-import (
-       "crypto/rand"
-       "testing"
-
-       "golang.org/x/crypto/sha3"
-
-       "github.com/bytom/crypto/ed25519/chainkd"
-       "github.com/bytom/protocol/bc"
-       "github.com/bytom/protocol/bc/types"
-       "github.com/bytom/protocol/vm"
-       "github.com/bytom/protocol/vm/vmutil"
-       "github.com/bytom/testutil"
-)
-
-// NewIssuanceTx creates a new signed, issuance transaction issuing 100 units
-// of a new asset to a garbage control program. The resulting transaction has
-// one input and one output.
-//
-// The asset issued is created from randomly-generated keys. The resulting
-// transaction is finalized (signed with a TXSIGHASH commitment).
-func NewIssuanceTx(tb testing.TB, initial bc.Hash, opts ...func(*types.Tx)) *types.Tx {
-       // Generate a random key pair for the asset being issued.
-       xprv, xpub, err := chainkd.NewXKeys(nil)
-       if err != nil {
-               testutil.FatalErr(tb, err)
-       }
-       pubkeys := chainkd.XPubKeys([]chainkd.XPub{xpub})
-
-       // Create a corresponding issuance program.
-       sigProg, err := vmutil.P2SPMultiSigProgram(pubkeys, 1)
-       if err != nil {
-               testutil.FatalErr(tb, err)
-       }
-       builder := vmutil.NewBuilder()
-       builder.AddRawBytes(sigProg)
-       issuanceProgram, _ := builder.Build()
-
-       // Create a transaction issuing this new asset.
-       var nonce [8]byte
-       _, err = rand.Read(nonce[:])
-       if err != nil {
-               testutil.FatalErr(tb, err)
-       }
-       assetdef := []byte(`{"type": "prottest issuance"}`)
-       txin := types.NewIssuanceInput(nonce[:], 100, issuanceProgram, nil, assetdef)
-
-       tx := types.NewTx(types.TxData{
-               Version: 1,
-               Inputs:  []*types.TxInput{txin},
-               Outputs: []*types.TxOutput{
-                       types.NewTxOutput(txin.AssetID(), 100, []byte{0xbe, 0xef}),
-               },
-       })
-
-       for _, opt := range opts {
-               opt(tx)
-       }
-
-       // Sign with a simple TXSIGHASH signature.
-       builder = vmutil.NewBuilder()
-       h := tx.SigHash(0)
-       builder.AddData(h.Bytes())
-       builder.AddOp(vm.OP_TXSIGHASH).AddOp(vm.OP_EQUAL)
-       sigprog, _ := builder.Build()
-       sigproghash := sha3.Sum256(sigprog)
-       signature := xprv.Sign(sigproghash[:])
-
-       var witness [][]byte
-       witness = append(witness, vm.Int64Bytes(0)) // 0 args to the sigprog
-       witness = append(witness, signature)
-       witness = append(witness, sigprog)
-       tx.SetInputArguments(0, witness)
-
-       return tx
-}