Merge pull request #235 from ipfs-force-community/fix/record-error

fix: return error message

api/docgen/example.go

@@ -26,8 +26,11 @@ var ExampleValues = map[reflect.Type]interface{}{
 	reflect.TypeOf(auth.Permission("")): auth.Permission("write"),
 	reflect.TypeOf(""):                  "string value",
 	reflect.TypeOf(uint64(42)):          uint64(42),
+	reflect.TypeOf(int(42)):             int(42),
+	reflect.TypeOf(uint(42)):            uint(42),
 	reflect.TypeOf(byte(7)):             byte(7),
 	reflect.TypeOf([]byte{}):            []byte("byte array"),
+	reflect.TypeOf(map[string]string{}): make(map[string]string),
 }
 
 func addExample(v interface{}) {

docs/en/api-v0-methods-miner.md

@@ -10,9 +10,12 @@
   * [CountWinners](#CountWinners)
 * [List](#List)
   * [ListAddress](#ListAddress)
+  * [ListBlocks](#ListBlocks)
 * [Log](#Log)
   * [LogList](#LogList)
   * [LogSetLevel](#LogSetLevel)
+* [Query](#Query)
+  * [QueryRecord](#QueryRecord)
 * [States](#States)
   * [StatesForMining](#StatesForMining)
 * [Update](#Update)
@@ -52,7 +55,7 @@ Response: `{}`
 ### Start
 
 
-Perms: write
+Perms: admin
 
 Inputs:
 ```json
@@ -68,7 +71,7 @@ Response: `{}`
 ### Stop
 
 
-Perms: write
+Perms: admin
 
 Inputs:
 ```json
@@ -149,6 +152,40 @@ Response:
 ]
 ```
 
+### ListBlocks
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Miners": [
+      "t01234"
+    ],
+    "Limit": 42,
+    "Offset": 42
+  }
+]
+```
+
+Response:
+```json
+[
+  {
+    "ParentEpoch": 0,
+    "ParentKey": "",
+    "Epoch": 9,
+    "Miner": "string value",
+    "Cid": "string value",
+    "WinningAt": "0001-01-01T00:00:00Z",
+    "MineState": 0,
+    "Consuming": 9
+  }
+]
+```
+
 ## Log
 
 
@@ -181,6 +218,32 @@ Inputs:
 
 Response: `{}`
 
+## Query
+
+
+### QueryRecord
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Miner": "t01234",
+    "Epoch": 10101,
+    "Limit": 42
+  }
+]
+```
+
+Response:
+```json
+[
+  {}
+]
+```
+
 ## States
 
 

miner/miner_test.go

@@ -4,7 +4,9 @@ package miner
 import (
 	"bufio"
 	"context"
+	rand2 "crypto/rand"
 	_ "embed"
+	"fmt"
 	"math/rand"
 	"strconv"
 	"strings"
@@ -120,6 +122,48 @@ func TestCountWinner(t *testing.T) {
 	}
 }
 
+func TestCountWinnerSignFailed(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	miner, chain, _ := setMiner(ctx, t, 4)
+	chain.keepChainGoing(ctx)
+
+	assert.Nil(t, miner.Start(ctx))
+	defer func() {
+		assert.Nil(t, miner.Stop(ctx))
+	}()
+
+	var once sync.Once
+	for {
+		select {
+		case blk := <-chain.newBlkCh:
+			if blk.Height > 5 {
+				once.Do(func() {
+					// mock sign failed
+					miner.signerFunc = func(ctx context.Context, node *config.GatewayNode) SignFunc {
+						return func(ctx context.Context, signer address.Address, accounts []string, toSign []byte, meta types.MsgMeta) (*crypto.Signature, error) {
+							return nil, fmt.Errorf("%v %w", "sign failed:", types2.WalletSignError)
+						}
+					}
+
+					addrs := chain.pcController.listAddress()
+					winners, err := miner.CountWinners(ctx, addrs, 0, 4)
+					assert.Nil(t, err)
+					for _, minerSt := range winners {
+						for _, sWinfo := range minerSt.WinEpochList {
+							assert.Equal(t, "failed to compute VRF: sign failed: 2", sWinfo.Msg)
+						}
+					}
+				})
+				return
+			}
+		case <-time.After(time.Duration(chain.params.BlockDelaySecs) * time.Second * 10):
+			t.Errorf("wait too long for miner new block")
+			return
+		}
+	}
+}
+
 func TestSuccessNullRoundMinerBlocks(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -503,8 +547,8 @@ func setMiner(ctx context.Context, t *testing.T, minerCount int) (*Miner, *mockC
 
 	api.EXPECT().StateNetworkVersion(mockAny, mockAny).AnyTimes().AnyTimes().Return(network.Version16, nil)
 	api.EXPECT().StateMinerInfo(mockAny, mockAny, mockAny).AnyTimes().Return(types.MinerInfo{}, nil)
-	api.EXPECT().StateMinerDeadlines(mockAny, mockAny, mockAny).AnyTimes().Return([]types.Deadline{types.Deadline{}}, nil)
-	api.EXPECT().StateMinerPartitions(mockAny, mockAny, mockAny, mockAny).AnyTimes().Return([]types.Partition{types.Partition{
+	api.EXPECT().StateMinerDeadlines(mockAny, mockAny, mockAny).AnyTimes().Return([]types.Deadline{{}}, nil)
+	api.EXPECT().StateMinerPartitions(mockAny, mockAny, mockAny, mockAny).AnyTimes().Return([]types.Partition{{
 		ActiveSectors: bitfield.NewFromSet([]uint64{uint64(1), uint64(2)}),
 	}}, nil)
 	api.EXPECT().StateGetBeaconEntry(mockAny, mockAny).AnyTimes().Return(nil, nil)
@@ -880,7 +924,7 @@ func (m *mockChain) mockFork(lbHeight abi.ChainEpoch, changeTicket bool) {
 	m.lk.Lock()
 	m.additionWeight += 10
 	toHeight := m.head.Height() - lbHeight
-	rand.Seed(build.Clock.Now().Unix())
+	r := rand.New(rand.NewSource(build.Clock.Now().Unix()))
 	var revertTs []*types.TipSet
 	ts := m.head
 	for {
@@ -901,7 +945,7 @@ func (m *mockChain) mockFork(lbHeight abi.ChainEpoch, changeTicket bool) {
 			blkCopy.ParentWeight = types.NewInt(100 + uint64(len(ts.Parents().Cids())) + uint64(blk.Height)*5 + m.additionWeight)
 			if changeTicket {
 				ticket := make([]byte, 32)
-				rand.Read(ticket)
+				r.Read(ticket)
 				blkCopy.Ticket = &types.Ticket{VRFProof: ticket}
 			}
 			m.blockStore[blkCopy.Cid()] = &blkCopy
@@ -920,14 +964,14 @@ func (m *mockChain) mockFork(lbHeight abi.ChainEpoch, changeTicket bool) {
 func (m *mockChain) fallBack(lbHeight abi.ChainEpoch) {
 	head := m.getHead()
 	ts := m.getTipsetByHeight(head.Height() - lbHeight)
-	rand.Seed(build.Clock.Now().Unix())
+	r := rand.New(rand.NewSource(build.Clock.Now().Unix()))
 	var blks []*types.BlockHeader
 	for _, blk := range ts.Blocks() {
 		blkCopy := *blk
 		blkCopy.Miner = m.createMiner()
 		blkCopy.ParentWeight = big.Add(head.ParentWeight(), big.NewInt(1000))
 		ticket := make([]byte, 32)
-		rand.Read(ticket)
+		r.Read(ticket)
 		blkCopy.Ticket = &types.Ticket{VRFProof: ticket}
 		m.blockStore[blkCopy.Cid()] = &blkCopy
 		blks = append(blks, &blkCopy)
@@ -949,7 +993,8 @@ func (m *mockChain) nextBlock() {
 
 	epoch := head.Height() + abi.ChainEpoch(nullRounds)
 	ticket := make([]byte, 32)
-	rand.Read(ticket)
+	_, err := rand2.Read(ticket)
+	assert.Nil(m.t, err)
 	next := &types.BlockHeader{
 		Miner:                 m.createMiner(),
 		ParentWeight:          types.NewInt(100 + uint64(len(head.Cids())) + uint64(epoch)*5 + m.additionWeight),
@@ -1098,9 +1143,8 @@ func (r *randGen) Cid() cid.Cid {
 	r.lk.Lock()
 	defer r.lk.Unlock()
 	r.count++
-	rand.Seed(r.count)
 	data := make([]byte, 32)
-	rand.Read(data[:])
+	rand.New(rand.NewSource(r.count)).Read(data[:])
 	c, _ := abi.CidBuilder.Sum(data)
 	return c
 }

miner/miningmgr.go

@@ -2,6 +2,7 @@ package miner
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"sync"
 	"time"
@@ -129,7 +130,7 @@ func (m *Miner) StatesForMining(ctx context.Context, addrs []address.Address) ([
 func (m *Miner) winCountInRound(ctx context.Context, account string, mAddr address.Address, api SignFunc, epoch abi.ChainEpoch) (*sharedTypes.ElectionProof, error) {
 	ts, err := m.api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(epoch), sharedTypes.EmptyTSK)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%v (%w)", err, types.CallNodeRPCError)
 	}
 
 	var nullRounds abi.ChainEpoch
@@ -140,7 +141,7 @@ func (m *Miner) winCountInRound(ctx context.Context, account string, mAddr addre
 
 	mbi, err := m.api.MinerGetBaseInfo(ctx, mAddr, round, ts.Key())
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%v (%w)", err, types.CallNodeRPCError)
 	}
 
 	if mbi == nil {
@@ -219,7 +220,13 @@ func (m *Miner) CountWinners(ctx context.Context, addrs []address.Address, start
 
 						winner, err := m.winCountInRound(ctx, tWpp.account, tAddr, sign, epoch)
 						if err != nil {
-							log.Errorf("generate winner met error %s", err)
+							if errors.Is(err, types.ConnectGatewayError) || errors.Is(err, types.WalletSignError) ||
+								errors.Is(err, types.CallNodeRPCError) {
+								winInfoLk.Lock()
+								winInfo = append(winInfo, types.SimpleWinInfo{Epoch: epoch + 1, Msg: err.Error()})
+								winInfoLk.Unlock()
+							}
+							log.Errorf("generate winner met failed address: %s, epoch: %d, err: %v", tAddr, epoch, err)
 							return
 						}
 

miner/multiminer.go

@@ -112,11 +112,15 @@ func NewMiner(
 			return func(ctx context.Context, signer address.Address, accounts []string, toSign []byte, meta sharedTypes.MsgMeta) (*crypto.Signature, error) {
 				walletAPI, closer, err := client.NewGatewayRPC(ctx, cfg)
 				if err != nil {
-					return nil, fmt.Errorf("new gateway rpc failed:%w", err)
+					return nil, fmt.Errorf("new gateway rpc failed:%v (%w)", err, types.ConnectGatewayError)
 				}
-
 				defer closer()
-				return walletAPI.WalletSign(ctx, signer, accounts, toSign, meta)
+
+				sig, err := walletAPI.WalletSign(ctx, signer, accounts, toSign, meta)
+				if err != nil {
+					return nil, fmt.Errorf("wallet sign failed:%v (%w)", err, types.CallNodeRPCError)
+				}
+				return sig, nil
 			}
 		},
 

types/miner.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/filecoin-project/go-address"
@@ -25,6 +26,7 @@ type MinerState struct {
 type SimpleWinInfo struct {
 	Epoch    abi.ChainEpoch `json:"epoch"`
 	WinCount int64          `json:"winCount"`
+	Msg      string         `json:"msg"`
 }
 
 type CountWinners struct {
@@ -84,35 +86,33 @@ type BlocksQueryParams struct {
 	Offset int
 }
 
-// type Record map[string]string
-
-// type Record struct {
-// 	Miner  address.Address
-// 	Worker address.Address
-// 	Epoch  abi.ChainEpoch
-
-// 	MinerPower   abi.StoragePower
-// 	NetworkPower abi.StoragePower
-
-// 	TimeTable
-// 	ErrorInfo string
-// }
-
-// type TimeTable struct {
-// 	Start time.Time
-// 	End   time.Time
-
-// 	GetMinerBaseINfo time.Duration
-// 	Ticket           time.Duration
-// 	ElectionProof    time.Duration
-// 	Seed             time.Duration
-// 	PoStProof        time.Duration
-// 	SelectMsg        time.Duration
-// 	CreateBlock      time.Duration
-// }
-
 type QueryRecordParams struct {
 	Miner address.Address
 	Epoch abi.ChainEpoch
 	Limit uint
 }
+
+type ErrorCode int
+
+const (
+	ConnectGatewayError ErrorCode = iota
+	CallNodeRPCError
+	WalletSignError
+)
+
+func (e ErrorCode) String() string {
+	switch e {
+	case ConnectGatewayError:
+		return "ConnectGatewayError"
+	case CallNodeRPCError:
+		return "CallNodeRPCError"
+	case WalletSignError:
+		return "WalletSignError"
+	default:
+		return "unknown"
+	}
+}
+
+func (e ErrorCode) Error() string {
+	return fmt.Sprintf("%d", e)
+}