update chain33

vendor/github.com/33cn/chain33/blockchain/chain_test.go

@@ -116,6 +116,7 @@ func TestBlockChain(t *testing.T) {
 	testProcDelParaChainBlockMsg(t, mock33, blockchain)
 
 	testProcAddParaChainBlockMsg(t, mock33, blockchain)
+	testProcGetBlockBySeqMsg(t, mock33, blockchain)
 	testProcBlockChainFork(t, blockchain)
 	testDelBlock(t, blockchain, curBlock)
 
@@ -895,6 +896,28 @@ func testProcAddParaChainBlockMsg(t *testing.T, mock33 *testnode.Chain33Mock, bl
 	chainlog.Info("testProcAddParaChainBlockMsg end --------------------")
 }
 
+func testProcGetBlockBySeqMsg(t *testing.T, mock33 *testnode.Chain33Mock, blockchain *blockchain.BlockChain) {
+	chainlog.Info("testProcGetBlockBySeqMsg begin --------------------")
+
+	seq, err := blockchain.GetStore().LoadBlockLastSequence()
+	assert.Nil(t, err)
+
+	//block, err := blockchain.GetBlock(curheight)
+	//require.NoError(t, err)
+
+	msgGen := mock33.GetClient().NewMessage("blockchain", types.EventGetBlockBySeq, &types.Int64{Data: seq})
+
+	mock33.GetClient().Send(msgGen, true)
+	msg, err := mock33.GetClient().Wait(msgGen)
+	if err != nil {
+		t.Log(err)
+		//t.Error("testProcAddParaChainBlockMsg  only in parachain ")
+	}
+	blockseq := msg.Data.(*types.BlockSeq)
+	assert.Equal(t, seq, blockseq.Num)
+	chainlog.Info("testProcGetBlockBySeqMsg end --------------------")
+}
+
 func testProcBlockChainFork(t *testing.T, blockchain *blockchain.BlockChain) {
 	chainlog.Info("testProcBlockChainFork begin --------------------")
 

vendor/github.com/33cn/chain33/blockchain/proc.go

@@ -73,6 +73,9 @@ func (chain *BlockChain) ProcRecvMsg() {
 		case types.EventGetBlockByHashes:
 			go chain.processMsg(msg, reqnum, chain.getBlockByHashes)
 
+		case types.EventGetBlockBySeq:
+			go chain.processMsg(msg, reqnum, chain.getBlockBySeq)
+
 		case types.EventDelParaChainBlockDetail:
 			go chain.processMsg(msg, reqnum, chain.delParaChainBlockDetail)
 
@@ -418,6 +421,32 @@ func (chain *BlockChain) getBlockByHashes(msg queue.Message) {
 	}
 }
 
+func (chain *BlockChain) getBlockBySeq(msg queue.Message) {
+	seq := (msg.Data).(*types.Int64)
+	req := &types.ReqBlocks{Start: seq.Data, End: seq.Data, IsDetail: false, Pid: []string{}}
+	sequences, err := chain.GetBlockSequences(req)
+	if err != nil {
+		chainlog.Error("getBlockBySeq", "seq err", err.Error())
+		msg.Reply(chain.client.NewMessage("rpc", types.EventGetBlockBySeq, err))
+		return
+	}
+	reqHashes := &types.ReqHashes{Hashes: [][]byte{sequences.Items[0].Hash}}
+	blocks, err := chain.GetBlockByHashes(reqHashes.Hashes)
+	if err != nil {
+		chainlog.Error("getBlockBySeq", "hash err", err.Error())
+		msg.Reply(chain.client.NewMessage("rpc", types.EventGetBlockBySeq, err))
+		return
+	}
+
+	blockSeq := &types.BlockSeq{
+		Num:    seq.Data,
+		Seq:    sequences.Items[0],
+		Detail: blocks.Items[0],
+	}
+	msg.Reply(chain.client.NewMessage("rpc", types.EventGetBlockBySeq, blockSeq))
+
+}
+
 //平行链del block的处理
 func (chain *BlockChain) delParaChainBlockDetail(msg queue.Message) {
 	var parablockDetail *types.ParaChainBlockDetail

vendor/github.com/33cn/chain33/client/mock_blockchain_test.go

@@ -104,6 +104,14 @@ func (m *mockBlockChain) SetQueueClient(q queue.Queue) {
 
 			case types.EventGetSeqByHash:
 				msg.Reply(client.NewMessage(blockchainKey, types.EventReplyQuery, &types.Int64{Data: 1}))
+			case types.EventGetBlockBySeq:
+				if req, ok := msg.GetData().(*types.Int64); ok {
+					// just for cover
+					if req.Data == 10 {
+						msg.Reply(client.NewMessage(blockchainKey, types.EventReplyQuery, &types.Reply{IsOk: false, Msg: []byte("not support")}))
+					}
+					msg.Reply(client.NewMessage(blockchainKey, types.EventReplyQuery, &types.BlockSeq{Num: 1}))
+				}
 			case types.EventIsSync:
 				msg.Reply(client.NewMessage(blockchainKey, types.EventReplyIsSync, &types.IsCaughtUp{}))
 			case types.EventIsNtpClockSync:

vendor/github.com/33cn/chain33/client/mocks/api.go

@@ -200,21 +200,21 @@ func (_m *QueueProtocolAPI) GetBlockByHashes(param *types.ReqHashes) (*types.Blo
 	return r0, r1
 }
 
-// GetBlockHash provides a mock function with given fields: param
-func (_m *QueueProtocolAPI) GetBlockHash(param *types.ReqInt) (*types.ReplyHash, error) {
+// GetBlockBySeq provides a mock function with given fields: param
+func (_m *QueueProtocolAPI) GetBlockBySeq(param *types.Int64) (*types.BlockSeq, error) {
 	ret := _m.Called(param)
 
-	var r0 *types.ReplyHash
-	if rf, ok := ret.Get(0).(func(*types.ReqInt) *types.ReplyHash); ok {
+	var r0 *types.BlockSeq
+	if rf, ok := ret.Get(0).(func(*types.Int64) *types.BlockSeq); ok {
 		r0 = rf(param)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ReplyHash)
+			r0 = ret.Get(0).(*types.BlockSeq)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(*types.ReqInt) error); ok {
+	if rf, ok := ret.Get(1).(func(*types.Int64) error); ok {
 		r1 = rf(param)
 	} else {
 		r1 = ret.Error(1)
@@ -223,21 +223,21 @@ func (_m *QueueProtocolAPI) GetBlockHash(param *types.ReqInt) (*types.ReplyHash,
 	return r0, r1
 }
 
-// GetBlockOverview provides a mock function with given fields: param
-func (_m *QueueProtocolAPI) GetBlockOverview(param *types.ReqHash) (*types.BlockOverview, error) {
+// GetBlockHash provides a mock function with given fields: param
+func (_m *QueueProtocolAPI) GetBlockHash(param *types.ReqInt) (*types.ReplyHash, error) {
 	ret := _m.Called(param)
 
-	var r0 *types.BlockOverview
-	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.BlockOverview); ok {
+	var r0 *types.ReplyHash
+	if rf, ok := ret.Get(0).(func(*types.ReqInt) *types.ReplyHash); ok {
 		r0 = rf(param)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.BlockOverview)
+			r0 = ret.Get(0).(*types.ReplyHash)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
+	if rf, ok := ret.Get(1).(func(*types.ReqInt) error); ok {
 		r1 = rf(param)
 	} else {
 		r1 = ret.Error(1)
@@ -246,21 +246,21 @@ func (_m *QueueProtocolAPI) GetBlockOverview(param *types.ReqHash) (*types.Block
 	return r0, r1
 }
 
-// GetBlockSequences provides a mock function with given fields: param
-func (_m *QueueProtocolAPI) GetBlockSequences(param *types.ReqBlocks) (*types.BlockSequences, error) {
+// GetBlockOverview provides a mock function with given fields: param
+func (_m *QueueProtocolAPI) GetBlockOverview(param *types.ReqHash) (*types.BlockOverview, error) {
 	ret := _m.Called(param)
 
-	var r0 *types.BlockSequences
-	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) *types.BlockSequences); ok {
+	var r0 *types.BlockOverview
+	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.BlockOverview); ok {
 		r0 = rf(param)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.BlockSequences)
+			r0 = ret.Get(0).(*types.BlockOverview)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(*types.ReqBlocks) error); ok {
+	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
 		r1 = rf(param)
 	} else {
 		r1 = ret.Error(1)

vendor/github.com/33cn/chain33/client/queueprotocol.go

@@ -950,24 +950,22 @@ func (q *QueueProtocol) GetBlockByHashes(param *types.ReqHashes) (*types.BlockDe
 	return nil, err
 }
 
-// GetBlockSequences block执行序列号
-func (q *QueueProtocol) GetBlockSequences(param *types.ReqBlocks) (*types.BlockSequences, error) {
+// GetBlockBySeq get block detail and hash by seq
+func (q *QueueProtocol) GetBlockBySeq(param *types.Int64) (*types.BlockSeq, error) {
 	if param == nil {
 		err := types.ErrInvalidParam
-		log.Error("GetBlockSequences", "Error", err)
+		log.Error("GetBlockBySeq", "Error", err)
 		return nil, err
 	}
-	msg, err := q.query(blockchainKey, types.EventGetBlockSequences, param)
+	msg, err := q.query(blockchainKey, types.EventGetBlockBySeq, param)
 	if err != nil {
-		log.Error("GetBlockSequences", "Error", err.Error())
+		log.Error("GetBlockBySeq", "Error", err.Error())
 		return nil, err
 	}
-	if reply, ok := msg.GetData().(*types.BlockSequences); ok {
+	if reply, ok := msg.GetData().(*types.BlockSeq); ok {
 		return reply, nil
 	}
-	err = types.ErrTypeAsset
-	log.Error("GetBlockSequences", "Error", err)
-	return nil, err
+	return nil, types.ErrTypeAsset
 }
 
 // QueryChain query chain

vendor/github.com/33cn/chain33/client/queueprotocol_test.go

@@ -807,6 +807,7 @@ func TestGRPC(t *testing.T) {
 	testGetAddrOverviewGRPC(t, &grpcMock)
 	testGetBlockHashGRPC(t, &grpcMock)
 	testGetSequenceByHashGRPC(t, &grpcMock)
+	testGetBlockBySeqGRPC(t, &grpcMock)
 	testGenSeedGRPC(t, &grpcMock)
 	testGetSeedGRPC(t, &grpcMock)
 	testSaveSeedGRPC(t, &grpcMock)
@@ -818,6 +819,7 @@ func TestGRPC(t *testing.T) {
 	testIsSyncGRPC(t, &grpcMock)
 	testIsNtpClockSyncGRPC(t, &grpcMock)
 	testNetInfoGRPC(t, &grpcMock)
+
 }
 
 func testNetInfoGRPC(t *testing.T, rpc *mockGRPCSystem) {
@@ -1140,3 +1142,21 @@ func testGetSequenceByHashGRPC(t *testing.T, rpc *mockGRPCSystem) {
 		t.Error("Call GetSequenceByHash Failed.", err)
 	}
 }
+
+func testGetBlockBySeqGRPC(t *testing.T, rpc *mockGRPCSystem) {
+	var res types.BlockSeq
+	//just for coverage
+	err := rpc.newRpcCtx("GetBlockBySeq", &types.Int64{Data: 1}, &res)
+	assert.Nil(t, err)
+
+	err = rpc.newRpcCtx("GetBlockBySeq", &types.Int64{Data: 10}, &res)
+	assert.NotNil(t, err)
+
+}
+
+func TestGetBlockBySeq(t *testing.T) {
+	q := client.QueueProtocol{}
+	_, err := q.GetBlockBySeq(nil)
+	assert.NotNil(t, err)
+
+}

vendor/github.com/33cn/chain33/client/queueprotocolapi.go

@@ -107,10 +107,11 @@ type QueueProtocolAPI interface {
 
 	//types.EventGetLastBlockSequence:
 	GetLastBlockSequence() (*types.Int64, error)
-	//types.EventGetBlockSequences:
-	GetBlockSequences(param *types.ReqBlocks) (*types.BlockSequences, error)
+
 	//types.EventGetBlockByHashes:
 	GetBlockByHashes(param *types.ReqHashes) (*types.BlockDetails, error)
+	//types.EventGetBlockBySeq:
+	GetBlockBySeq(param *types.Int64) (*types.BlockSeq, error)
 	//types.EventGetSequenceByHash:
 	GetSequenceByHash(param *types.ReqHash) (*types.Int64, error)
 

vendor/github.com/33cn/chain33/client/rpc_ctx_test.go

@@ -321,6 +321,12 @@ func (c *GrpcCtx) Run() (err error) {
 			*c.Res.(*types.Int64) = *reply
 		}
 		errRet = err
+	case "GetBlockBySeq":
+		reply, err := rpc.GetBlockBySeq(context.Background(), c.Params.(*types.Int64))
+		if err == nil {
+			*c.Res.(*types.BlockSeq) = *reply
+		}
+		errRet = err
 	default:
 		errRet = errors.New(fmt.Sprintf("Unsupport method %v", c.Method))
 	}

vendor/github.com/33cn/chain33/rpc/grpchandler.go

@@ -344,11 +344,6 @@ func (g *Grpc) GetLastBlockSequence(ctx context.Context, in *pb.ReqNil) (*pb.Int
 	return g.cli.GetLastBlockSequence()
 }
 
-// GetBlockSequences get block sequeces
-func (g *Grpc) GetBlockSequences(ctx context.Context, in *pb.ReqBlocks) (*pb.BlockSequences, error) {
-	return g.cli.GetBlockSequences(in)
-}
-
 // GetBlockByHashes get block by hashes
 func (g *Grpc) GetBlockByHashes(ctx context.Context, in *pb.ReqHashes) (*pb.BlockDetails, error) {
 	return g.cli.GetBlockByHashes(in)
@@ -359,6 +354,11 @@ func (g *Grpc) GetSequenceByHash(ctx context.Context, in *pb.ReqHash) (*pb.Int64
 	return g.cli.GetSequenceByHash(in)
 }
 
+// GetBlockBySeq get block with hash by seq
+func (g *Grpc) GetBlockBySeq(ctx context.Context, in *pb.Int64) (*pb.BlockSeq, error) {
+	return g.cli.GetBlockBySeq(in)
+}
+
 // SignRawTx signature rawtransaction
 func (g *Grpc) SignRawTx(ctx context.Context, in *pb.ReqSignRawTx) (*pb.ReplySignRawTx, error) {
 	return g.cli.SignRawTx(in)
@@ -372,3 +372,8 @@ func (g *Grpc) QueryRandNum(ctx context.Context, in *pb.ReqRandHash) (*pb.ReplyH
 	}
 	return reply.(*pb.ReplyHash), nil
 }
+
+// GetFork get fork height by fork key
+func (g *Grpc) GetFork(ctx context.Context, in *pb.ReqKey) (*pb.Int64, error) {
+	return &pb.Int64{Data: pb.GetFork(string(in.Key))}, nil
+}

vendor/github.com/33cn/chain33/rpc/jrpchandler.go

@@ -1051,22 +1051,6 @@ func (c *Chain33) GetLastBlockSequence(in *types.ReqNil, result *interface{}) er
 	return nil
 }
 
-// GetBlockSequences get the block loading sequence number information for the specified interval
-func (c *Chain33) GetBlockSequences(in rpctypes.BlockParam, result *interface{}) error {
-	resp, err := c.cli.GetBlockSequences(&types.ReqBlocks{Start: in.Start, End: in.End, IsDetail: in.Isdetail, Pid: []string{""}})
-	if err != nil {
-		return err
-	}
-	var BlkSeqs rpctypes.ReplyBlkSeqs
-	items := resp.GetItems()
-	for _, item := range items {
-		BlkSeqs.BlkSeqInfos = append(BlkSeqs.BlkSeqInfos, &rpctypes.ReplyBlkSeq{Hash: common.ToHex(item.GetHash()),
-			Type: item.GetType()})
-	}
-	*result = &BlkSeqs
-	return nil
-}
-
 // GetBlockByHashes get block information by hashes
 func (c *Chain33) GetBlockByHashes(in rpctypes.ReqHashes, result *interface{}) error {
 	log.Warn("GetBlockByHashes", "hashes", in)

vendor/github.com/33cn/chain33/rpc/jrpchandler_test.go

@@ -1214,26 +1214,6 @@ func TestChain33_GetLastBlockSequence(t *testing.T) {
 	assert.Equal(t, int64(1), result2)
 }
 
-func TestChain33_GetBlockSequences(t *testing.T) {
-	api := new(mocks.QueueProtocolAPI)
-	client := newTestChain33(api)
-	var result interface{}
-	api.On("GetBlockSequences", mock.Anything).Return(nil, types.ErrInvalidParam)
-	err := client.GetBlockSequences(rpctypes.BlockParam{}, &result)
-	assert.NotNil(t, err)
-
-	api = new(mocks.QueueProtocolAPI)
-	client = newTestChain33(api)
-	var result2 interface{}
-	blocks := types.BlockSequences{}
-	blocks.Items = make([]*types.BlockSequence, 0)
-	blocks.Items = append(blocks.Items, &types.BlockSequence{Hash: []byte("h1"), Type: 1})
-	api.On("GetBlockSequences", mock.Anything).Return(&blocks, nil)
-	err = client.GetBlockSequences(rpctypes.BlockParam{}, &result2)
-	assert.Nil(t, err)
-	assert.Equal(t, 1, len(result2.(*rpctypes.ReplyBlkSeqs).BlkSeqInfos))
-}
-
 func TestChain33_GetBlockByHashes(t *testing.T) {
 	api := new(mocks.QueueProtocolAPI)
 	client := newTestChain33(api)

vendor/github.com/33cn/chain33/rpc/server_test.go

@@ -175,6 +175,15 @@ func TestGrpc_Call(t *testing.T) {
 	assert.Equal(t, ret.IsOk, result.IsOk)
 	assert.Equal(t, ret.Msg, result.Msg)
 
+	rst, err := client.GetFork(ctx, &types.ReqKey{Key: []byte("ForkBlockHash")})
+	assert.Nil(t, err)
+	assert.Equal(t, int64(1), rst.Data)
+
+	api.On("GetBlockBySeq", mock.Anything).Return(&types.BlockSeq{}, nil)
+	blockSeq, err := client.GetBlockBySeq(ctx, &types.Int64{Data: 1})
+	assert.Nil(t, err)
+	assert.Equal(t, &types.BlockSeq{}, blockSeq)
+
 	server.Close()
 	mock.AssertExpectationsForObjects(t, api)
 }

vendor/github.com/33cn/chain33/types/event.go

@@ -138,6 +138,7 @@ const (
 	EventStoreListReply          = 131
 	EventListBlockSeqCB          = 132
 	EventGetSeqCBLastNum         = 133
+	EventGetBlockBySeq           = 134
 
 	//exec
 	EventBlockChainQuery = 212
@@ -276,4 +277,6 @@ var eventName = map[int]string{
 	// Token
 	EventBlockChainQuery: "EventBlockChainQuery",
 	EventConsensusQuery:  "EventConsensusQuery",
+
+	EventGetBlockBySeq: "EventGetBlockBySeq",
 }

vendor/github.com/33cn/chain33/types/mocks/chain33client.go

@@ -402,6 +402,36 @@ func (_m *Chain33Client) GetBlockByHashes(ctx context.Context, in *types.ReqHash
 	return r0, r1
 }
 
+// GetBlockBySeq provides a mock function with given fields: ctx, in, opts
+func (_m *Chain33Client) GetBlockBySeq(ctx context.Context, in *types.Int64, opts ...grpc.CallOption) (*types.BlockSeq, error) {
+	_va := make([]interface{}, len(opts))
+	for _i := range opts {
+		_va[_i] = opts[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, in)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	var r0 *types.BlockSeq
+	if rf, ok := ret.Get(0).(func(context.Context, *types.Int64, ...grpc.CallOption) *types.BlockSeq); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.BlockSeq)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *types.Int64, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // GetBlockHash provides a mock function with given fields: ctx, in, opts
 func (_m *Chain33Client) GetBlockHash(ctx context.Context, in *types.ReqInt, opts ...grpc.CallOption) (*types.ReplyHash, error) {
 	_va := make([]interface{}, len(opts))
@@ -462,8 +492,8 @@ func (_m *Chain33Client) GetBlockOverview(ctx context.Context, in *types.ReqHash
 	return r0, r1
 }
 
-// GetBlockSequences provides a mock function with given fields: ctx, in, opts
-func (_m *Chain33Client) GetBlockSequences(ctx context.Context, in *types.ReqBlocks, opts ...grpc.CallOption) (*types.BlockSequences, error) {
+// GetBlocks provides a mock function with given fields: ctx, in, opts
+func (_m *Chain33Client) GetBlocks(ctx context.Context, in *types.ReqBlocks, opts ...grpc.CallOption) (*types.Reply, error) {
 	_va := make([]interface{}, len(opts))
 	for _i := range opts {
 		_va[_i] = opts[_i]
@@ -473,12 +503,12 @@ func (_m *Chain33Client) GetBlockSequences(ctx context.Context, in *types.ReqBlo
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *types.BlockSequences
-	if rf, ok := ret.Get(0).(func(context.Context, *types.ReqBlocks, ...grpc.CallOption) *types.BlockSequences); ok {
+	var r0 *types.Reply
+	if rf, ok := ret.Get(0).(func(context.Context, *types.ReqBlocks, ...grpc.CallOption) *types.Reply); ok {
 		r0 = rf(ctx, in, opts...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.BlockSequences)
+			r0 = ret.Get(0).(*types.Reply)
 		}
 	}
 
@@ -492,8 +522,8 @@ func (_m *Chain33Client) GetBlockSequences(ctx context.Context, in *types.ReqBlo
 	return r0, r1
 }
 
-// GetBlocks provides a mock function with given fields: ctx, in, opts
-func (_m *Chain33Client) GetBlocks(ctx context.Context, in *types.ReqBlocks, opts ...grpc.CallOption) (*types.Reply, error) {
+// GetFatalFailure provides a mock function with given fields: ctx, in, opts
+func (_m *Chain33Client) GetFatalFailure(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*types.Int32, error) {
 	_va := make([]interface{}, len(opts))
 	for _i := range opts {
 		_va[_i] = opts[_i]
@@ -503,17 +533,17 @@ func (_m *Chain33Client) GetBlocks(ctx context.Context, in *types.ReqBlocks, opt
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *types.Reply
-	if rf, ok := ret.Get(0).(func(context.Context, *types.ReqBlocks, ...grpc.CallOption) *types.Reply); ok {
+	var r0 *types.Int32
+	if rf, ok := ret.Get(0).(func(context.Context, *types.ReqNil, ...grpc.CallOption) *types.Int32); ok {
 		r0 = rf(ctx, in, opts...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.Reply)
+			r0 = ret.Get(0).(*types.Int32)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *types.ReqBlocks, ...grpc.CallOption) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *types.ReqNil, ...grpc.CallOption) error); ok {
 		r1 = rf(ctx, in, opts...)
 	} else {
 		r1 = ret.Error(1)
@@ -522,8 +552,8 @@ func (_m *Chain33Client) GetBlocks(ctx context.Context, in *types.ReqBlocks, opt
 	return r0, r1
 }
 
-// GetFatalFailure provides a mock function with given fields: ctx, in, opts
-func (_m *Chain33Client) GetFatalFailure(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*types.Int32, error) {
+// GetFork provides a mock function with given fields: ctx, in, opts
+func (_m *Chain33Client) GetFork(ctx context.Context, in *types.ReqKey, opts ...grpc.CallOption) (*types.Int64, error) {
 	_va := make([]interface{}, len(opts))
 	for _i := range opts {
 		_va[_i] = opts[_i]
@@ -533,17 +563,17 @@ func (_m *Chain33Client) GetFatalFailure(ctx context.Context, in *types.ReqNil,
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *types.Int32
-	if rf, ok := ret.Get(0).(func(context.Context, *types.ReqNil, ...grpc.CallOption) *types.Int32); ok {
+	var r0 *types.Int64
+	if rf, ok := ret.Get(0).(func(context.Context, *types.ReqKey, ...grpc.CallOption) *types.Int64); ok {
 		r0 = rf(ctx, in, opts...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.Int32)
+			r0 = ret.Get(0).(*types.Int64)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *types.ReqNil, ...grpc.CallOption) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *types.ReqKey, ...grpc.CallOption) error); ok {
 		r1 = rf(ctx, in, opts...)
 	} else {
 		r1 = ret.Error(1)

vendor/github.com/33cn/chain33/types/proto/rpc.proto

@@ -122,14 +122,15 @@ service chain33 {
     rpc GetFatalFailure(types.ReqNil) returns (Int32) {}
     rpc GetLastBlockSequence(ReqNil) returns (Int64) {}
 
-    //获取指定区间的block加载序列号信息
-    rpc GetBlockSequences(ReqBlocks) returns (BlockSequences) {}
-
     // get add block's sequence by hash
     rpc GetSequenceByHash(ReqHash) returns (Int64) {}
 
     //通过block hash 获取对应的blocks信息
     rpc GetBlockByHashes(ReqHashes) returns (BlockDetails) {}
+
+    //通过block seq 获取对应的blocks hash 信息
+    rpc GetBlockBySeq(Int64) returns (BlockSeq) {}
+
     //关闭chain33
     rpc CloseQueue(ReqNil) returns (Reply) {}
 
@@ -142,4 +143,7 @@ service chain33 {
 
     // 获取随机HASH
     rpc QueryRandNum(ReqRandHash) returns (ReplyHash) {}
+
+    // 获取是否达到fork高度
+    rpc GetFork(ReqKey) returns (Int64) {}
 }

vendor/github.com/33cn/chain33/types/rpc.pb.go

@@ -26,72 +26,73 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
 
 var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 1031 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xdd, 0x6f, 0xe2, 0x46,
-	0x10, 0xf7, 0x43, 0x1b, 0x8e, 0x3d, 0x20, 0x64, 0x43, 0xa2, 0x3b, 0xab, 0xa7, 0x93, 0x2c, 0x55,
-	0x7d, 0xa8, 0x0e, 0x7a, 0xd0, 0xa6, 0x1f, 0xd7, 0x56, 0x0a, 0x49, 0x21, 0x48, 0x1c, 0xe5, 0x62,
-	0xd2, 0x4a, 0x7d, 0x5b, 0xcc, 0x94, 0x58, 0x31, 0x6b, 0xc7, 0xbb, 0x0e, 0xe6, 0xcf, 0xeb, 0x7f,
-	0x56, 0xed, 0xda, 0xeb, 0x6f, 0x92, 0xdc, 0x9b, 0x77, 0x66, 0x7e, 0xf3, 0xe1, 0xfd, 0xcd, 0xcc,
-	0xa2, 0xba, 0xef, 0x59, 0x5d, 0xcf, 0x77, 0xb9, 0x8b, 0xbf, 0xe4, 0x3b, 0x0f, 0x98, 0xde, 0xb0,
-	0xdc, 0xcd, 0xc6, 0xa5, 0x91, 0x50, 0x3f, 0xe2, 0x3e, 0xa1, 0x8c, 0x58, 0xdc, 0x4e, 0x44, 0xed,
-	0xa5, 0xe3, 0x5a, 0x77, 0xd6, 0x2d, 0xb1, 0x95, 0xa4, 0xb1, 0x25, 0x8e, 0x03, 0x3c, 0x3e, 0xd5,
-	0xbd, 0xbe, 0x17, 0x7f, 0x36, 0x89, 0x65, 0xb9, 0x01, 0x55, 0x9a, 0x16, 0x84, 0x60, 0x05, 0xdc,
-	0xf5, 0xa3, 0x73, 0xff, 0xbf, 0x53, 0x54, 0x93, 0x7e, 0x06, 0x03, 0xfc, 0x0e, 0xd5, 0xc7, 0xc0,
-	0x87, 0xc2, 0x35, 0xc3, 0xed, 0xae, 0xcc, 0xa5, 0x7b, 0x0d, 0xf7, 0x91, 0x44, 0x6f, 0x24, 0x12,
-	0xcf, 0xd9, 0x19, 0x1a, 0xee, 0xa1, 0xe6, 0x18, 0xf8, 0x94, 0x30, 0x7e, 0x05, 0x64, 0x05, 0x3e,
-	0x6e, 0xa6, 0x90, 0x99, 0xed, 0xe8, 0xea, 0x18, 0x69, 0x0d, 0x0d, 0xff, 0x82, 0x3a, 0x17, 0x3e,
-	0x10, 0x0e, 0xd7, 0x64, 0xbb, 0x48, 0x6b, 0xc2, 0x87, 0xb1, 0x61, 0xa4, 0x5c, 0x84, 0xba, 0x12,
-	0xdc, 0x50, 0x66, 0xaf, 0xe9, 0x22, 0x34, 0x34, 0x7c, 0x89, 0xda, 0x29, 0x36, 0x1c, 0xfb, 0x6e,
-	0xe0, 0xe1, 0x37, 0x79, 0x5c, 0xea, 0x51, 0xaa, 0xab, 0xbc, 0xfc, 0x80, 0xb0, 0x09, 0x74, 0xb5,
-	0x27, 0xbe, 0x69, 0xaf, 0x29, 0xac, 0x16, 0x61, 0xa9, 0xd2, 0xdf, 0x51, 0xfb, 0x53, 0x00, 0xfe,
-	0x2e, 0x0b, 0x6a, 0xa5, 0xc5, 0x5e, 0x11, 0x76, 0xab, 0xbf, 0x8a, 0xcf, 0x19, 0x9b, 0x4b, 0xe0,
-	0xc4, 0x76, 0x64, 0xd8, 0x43, 0x11, 0x36, 0x0b, 0xc7, 0x65, 0xf3, 0x52, 0xd8, 0xdf, 0x50, 0x67,
-	0x0c, 0x3c, 0x63, 0x31, 0xdc, 0x9d, 0xaf, 0x56, 0x7e, 0x36, 0xb4, 0x38, 0xeb, 0xc7, 0x59, 0xdc,
-	0x22, 0x9c, 0xd0, 0x7f, 0x5d, 0x66, 0x68, 0x78, 0x8c, 0x4e, 0x8b, 0x70, 0x91, 0x29, 0xe4, 0xee,
-	0x36, 0x92, 0xe8, 0xaf, 0xf7, 0x65, 0x2f, 0x1c, 0xbd, 0x47, 0x68, 0x0c, 0xfc, 0x23, 0x6c, 0xe6,
-	0xae, 0xeb, 0x14, 0x6f, 0x19, 0xe7, 0x83, 0x4f, 0x6d, 0xc6, 0x65, 0xc5, 0x2f, 0xc7, 0xc0, 0xcf,
-	0x23, 0xea, 0xb1, 0x22, 0xe6, 0x24, 0x3e, 0xfe, 0x2d, 0x39, 0xab, 0xac, 0x24, 0x43, 0xd0, 0x0c,
-	0xb6, 0xb1, 0x00, 0x77, 0x32, 0xa8, 0x44, 0xaa, 0x77, 0xaa, 0xc0, 0x86, 0x86, 0xaf, 0xd1, 0x49,
-	0x24, 0xca, 0xd4, 0x20, 0xb2, 0xc1, 0x6f, 0x53, 0x37, 0x95, 0x06, 0xfa, 0x69, 0xce, 0xe3, 0x22,
-	0x4c, 0x2b, 0x1f, 0xa1, 0xe6, 0x64, 0xe3, 0xb9, 0x3e, 0x9f, 0xfb, 0xf6, 0xc3, 0x1d, 0xec, 0x12,
-	0xca, 0x25, 0xbe, 0x72, 0xea, 0xbd, 0xb9, 0x0d, 0x51, 0x53, 0x12, 0xc0, 0x15, 0xf7, 0x05, 0x8c,
-	0x95, 0xfd, 0xe4, 0xd4, 0x7a, 0x3b, 0xfb, 0x53, 0xc5, 0x15, 0x19, 0x1a, 0xee, 0xa3, 0x17, 0xa6,
-	0xc8, 0x6e, 0x04, 0x80, 0x4f, 0xcb, 0x70, 0x3e, 0x02, 0x28, 0x31, 0xe8, 0x03, 0xaa, 0x99, 0xa2,
-	0x45, 0x97, 0x0e, 0x7e, 0x55, 0x01, 0x99, 0x92, 0x25, 0x38, 0x8f, 0x24, 0xdd, 0xf8, 0x08, 0xfe,
-	0x1a, 0x86, 0xc4, 0x21, 0xd4, 0x02, 0xfc, 0x55, 0xd1, 0x43, 0x56, 0x9b, 0xe7, 0x41, 0xc4, 0x2a,
-	0x43, 0xc3, 0x67, 0xa8, 0x6e, 0x02, 0x9f, 0x13, 0xc6, 0xb6, 0x2b, 0xfc, 0xba, 0x22, 0x85, 0x48,
-	0x55, 0x4a, 0xfc, 0x6b, 0xf4, 0xc5, 0xd4, 0xb5, 0xee, 0x8a, 0xc4, 0x29, 0x9a, 0xbd, 0x43, 0x07,
-	0x37, 0x54, 0x1a, 0x1e, 0xe7, 0x8a, 0x88, 0x84, 0x15, 0x13, 0x4b, 0xb0, 0x72, 0x0e, 0xe0, 0x8b,
-	0x1e, 0x29, 0x3a, 0x57, 0x63, 0x40, 0xe8, 0x13, 0x1a, 0xb7, 0xe2, 0x11, 0xf7, 0x59, 0xec, 0xff,
-	0x11, 0x1d, 0x8e, 0x81, 0xc7, 0x35, 0x72, 0xc2, 0x83, 0x52, 0x07, 0xe4, 0xd3, 0x8d, 0x6c, 0x24,
-	0xff, 0xdb, 0x6a, 0x02, 0xff, 0xf9, 0x00, 0xfe, 0x83, 0x0d, 0xdb, 0xd2, 0xa0, 0x51, 0xd7, 0x95,
-	0xb3, 0x32, 0x34, 0xfc, 0x93, 0x0c, 0x2a, 0x18, 0x54, 0x05, 0xcd, 0x0d, 0x8a, 0xac, 0x91, 0xec,
-	0xef, 0x86, 0x8a, 0x2a, 0x22, 0x64, 0x73, 0x9d, 0x50, 0x5e, 0x49, 0xc6, 0xf7, 0xa8, 0x36, 0x06,
-	0x6a, 0x02, 0xac, 0x92, 0x49, 0x16, 0x9f, 0xa7, 0x84, 0xae, 0xf3, 0x10, 0x21, 0x55, 0x10, 0x5e,
-	0x80, 0xc8, 0xf3, 0x70, 0x37, 0xdf, 0x56, 0x42, 0x7a, 0xe8, 0x85, 0x49, 0x1e, 0x40, 0x62, 0x54,
-	0xee, 0x4a, 0x20, 0x41, 0xc5, 0x0b, 0xee, 0xcb, 0x49, 0xa5, 0x08, 0x7b, 0x94, 0x59, 0x61, 0x31,
-	0x4b, 0xd5, 0x1d, 0x67, 0x66, 0x4e, 0x1f, 0x21, 0x39, 0xdc, 0x2f, 0xc4, 0x16, 0x4c, 0x66, 0x8e,
-	0x3c, 0xfd, 0x11, 0xef, 0xca, 0xaa, 0x38, 0x42, 0x17, 0xdd, 0xde, 0x33, 0x31, 0x67, 0xa8, 0x15,
-	0xc5, 0x71, 0x29, 0x03, 0xca, 0x02, 0xf6, 0x4c, 0xdc, 0xcf, 0xe8, 0xa8, 0xb4, 0xe0, 0x92, 0xd2,
-	0xd4, 0xca, 0x9c, 0xd0, 0xaa, 0x75, 0xf7, 0x9d, 0xa4, 0xef, 0x15, 0x84, 0x8b, 0x30, 0x9a, 0xfd,
-	0x25, 0x32, 0x35, 0x92, 0x1d, 0x1d, 0xc6, 0x0b, 0xf2, 0xe5, 0x65, 0xb0, 0xf1, 0xd4, 0xb8, 0xcb,
-	0x2c, 0x0a, 0x93, 0xfb, 0x36, 0x5d, 0xe7, 0x09, 0x1f, 0xc9, 0x0c, 0x0d, 0x77, 0x51, 0xed, 0x2f,
-	0xf0, 0x99, 0xc8, 0x6c, 0x4f, 0x83, 0xc4, 0x6a, 0xd1, 0x77, 0x86, 0x86, 0xbf, 0x41, 0x07, 0x13,
-	0x66, 0xee, 0xa8, 0xf5, 0x54, 0x83, 0xf7, 0x50, 0x6b, 0xc2, 0x66, 0xdc, 0xbb, 0x10, 0xe4, 0x7c,
-	0x0e, 0xa0, 0x8b, 0x6a, 0x33, 0xe0, 0x55, 0xed, 0xad, 0x32, 0x99, 0xb9, 0x2b, 0x88, 0x4d, 0xe4,
-	0x2f, 0x12, 0x5d, 0x33, 0x22, 0x9c, 0x38, 0x23, 0x62, 0x3b, 0x81, 0x0f, 0xfb, 0x22, 0x4c, 0x28,
-	0x1f, 0xf4, 0xe5, 0x2f, 0xea, 0xc4, 0x33, 0x41, 0x76, 0x8c, 0x09, 0xf7, 0x01, 0x08, 0xb6, 0xed,
-	0x87, 0x9d, 0x7d, 0x2f, 0xdf, 0x10, 0x47, 0xaa, 0xc9, 0x14, 0xa4, 0xea, 0x91, 0x75, 0x92, 0xed,
-	0xee, 0xc4, 0xd0, 0xd0, 0xf0, 0x40, 0xe2, 0x95, 0xe4, 0x89, 0xeb, 0x54, 0x41, 0x3f, 0xa4, 0xf3,
-	0xe4, 0x91, 0xe5, 0x7f, 0x9c, 0x8d, 0x99, 0x2e, 0xbf, 0x6f, 0x11, 0xba, 0x70, 0x5c, 0x06, 0x9f,
-	0x02, 0x08, 0xe0, 0xa9, 0xff, 0xfe, 0xab, 0x4c, 0xef, 0xdc, 0x71, 0x04, 0x8f, 0x55, 0x03, 0x16,
-	0xe7, 0x8f, 0x2a, 0x2e, 0x6f, 0x26, 0x39, 0x5e, 0x17, 0x8f, 0x2f, 0xf9, 0xb6, 0xc3, 0xc7, 0x19,
-	0xd2, 0x29, 0x61, 0x02, 0x8d, 0x78, 0xa7, 0xc4, 0x86, 0x86, 0x27, 0x48, 0x8f, 0x9a, 0x60, 0xe6,
-	0xc6, 0xfe, 0xaa, 0x9e, 0x59, 0xa9, 0xf2, 0x11, 0x57, 0x67, 0xa8, 0x21, 0x3b, 0xf4, 0x9a, 0xd0,
-	0xd5, 0x2c, 0xd8, 0xe0, 0x94, 0xeb, 0xf7, 0x42, 0x24, 0xff, 0x70, 0xc5, 0x30, 0x1c, 0xbe, 0xfd,
-	0xe7, 0xcd, 0xda, 0xe6, 0xb7, 0xc1, 0xb2, 0x6b, 0xb9, 0x9b, 0xde, 0x60, 0x60, 0xd1, 0x5e, 0xfc,
-	0xa4, 0xee, 0x49, 0xe3, 0xe5, 0x81, 0x7c, 0x6b, 0x0f, 0xfe, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x2a,
-	0x38, 0xe4, 0x13, 0xea, 0x0b, 0x00, 0x00,
+	// 1049 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x6d, 0x6f, 0xdb, 0x36,
+	0x10, 0xd6, 0x87, 0xad, 0x69, 0x58, 0xc7, 0x71, 0x18, 0x37, 0x68, 0x85, 0x15, 0x05, 0x04, 0x0c,
+	0x1b, 0x30, 0xd4, 0x6e, 0xed, 0x2d, 0x7b, 0xe9, 0x36, 0x20, 0x4e, 0x66, 0xc7, 0x98, 0xeb, 0xb9,
+	0x91, 0xbb, 0x01, 0xfb, 0x46, 0xcb, 0x37, 0x47, 0x88, 0x4c, 0x2a, 0x22, 0x15, 0xcb, 0x3f, 0x76,
+	0xff, 0x65, 0x20, 0x25, 0xea, 0xdd, 0x49, 0xf6, 0xcd, 0xbc, 0xbb, 0xe7, 0x5e, 0x7c, 0xcf, 0xdd,
+	0x09, 0xed, 0x07, 0xbe, 0xd3, 0xf1, 0x03, 0x26, 0x18, 0xfe, 0x5c, 0x6c, 0x7d, 0xe0, 0x66, 0xc3,
+	0x61, 0xeb, 0x35, 0xa3, 0xb1, 0xd0, 0x3c, 0x12, 0x01, 0xa1, 0x9c, 0x38, 0xc2, 0x4d, 0x45, 0xad,
+	0x85, 0xc7, 0x9c, 0x1b, 0xe7, 0x9a, 0xb8, 0x5a, 0xd2, 0xd8, 0x10, 0xcf, 0x03, 0x91, 0xbc, 0xf6,
+	0xfd, 0x9e, 0x9f, 0xfc, 0x3c, 0x20, 0x8e, 0xc3, 0x42, 0xaa, 0x35, 0x4d, 0x88, 0xc0, 0x09, 0x05,
+	0x0b, 0xe2, 0x77, 0xef, 0xdf, 0x13, 0xb4, 0xa7, 0xfc, 0xf4, 0xfb, 0xf8, 0x0d, 0xda, 0x1f, 0x81,
+	0x18, 0x48, 0xd7, 0x1c, 0xb7, 0x3a, 0x2a, 0x97, 0xce, 0x15, 0xdc, 0xc6, 0x12, 0xb3, 0x91, 0x4a,
+	0x7c, 0x6f, 0x6b, 0x19, 0xb8, 0x8b, 0x0e, 0x46, 0x20, 0x26, 0x84, 0x8b, 0x4b, 0x20, 0x4b, 0x08,
+	0xf0, 0x41, 0x06, 0x99, 0xba, 0x9e, 0xa9, 0x9f, 0xb1, 0xd6, 0x32, 0xf0, 0x4f, 0xa8, 0x7d, 0x1e,
+	0x00, 0x11, 0x70, 0x45, 0x36, 0xf3, 0xac, 0x26, 0x7c, 0x98, 0x18, 0xc6, 0xca, 0x79, 0x64, 0x6a,
+	0xc1, 0x27, 0xca, 0xdd, 0x15, 0x9d, 0x47, 0x96, 0x81, 0x2f, 0x50, 0x2b, 0xc3, 0x46, 0xa3, 0x80,
+	0x85, 0x3e, 0x7e, 0x55, 0xc4, 0x65, 0x1e, 0x95, 0xba, 0xce, 0xcb, 0x77, 0x08, 0xdb, 0x40, 0x97,
+	0x3b, 0xe2, 0xdb, 0xee, 0x8a, 0xc2, 0x72, 0x1e, 0x55, 0x2a, 0xfd, 0x15, 0xb5, 0x3e, 0x86, 0x10,
+	0x6c, 0xf3, 0xa0, 0x66, 0x56, 0xec, 0x25, 0xe1, 0xd7, 0xe6, 0x8b, 0xe4, 0x9d, 0xb3, 0xb9, 0x00,
+	0x41, 0x5c, 0x4f, 0x85, 0x3d, 0x94, 0x61, 0xf3, 0x70, 0x5c, 0x35, 0xaf, 0x84, 0xfd, 0x05, 0xb5,
+	0x47, 0x20, 0x72, 0x16, 0x83, 0xed, 0xd9, 0x72, 0x19, 0xe4, 0x43, 0xcb, 0xb7, 0x79, 0x9c, 0xc7,
+	0xcd, 0xa3, 0x31, 0xfd, 0x87, 0x71, 0xcb, 0xc0, 0x23, 0x74, 0x52, 0x86, 0xcb, 0x4c, 0xa1, 0xd0,
+	0xdb, 0x58, 0x62, 0xbe, 0xdc, 0x95, 0xbd, 0x74, 0xf4, 0x0e, 0xa1, 0x11, 0x88, 0x0f, 0xb0, 0x9e,
+	0x31, 0xe6, 0x95, 0xbb, 0x8c, 0x8b, 0xc1, 0x27, 0x2e, 0x17, 0xaa, 0xe2, 0x67, 0x23, 0x10, 0x67,
+	0x31, 0xf5, 0x78, 0x19, 0xf3, 0x3c, 0x79, 0xfe, 0xa5, 0x38, 0xab, 0xad, 0x14, 0x43, 0xd0, 0x14,
+	0x36, 0x89, 0x00, 0xb7, 0x73, 0xa8, 0x54, 0x6a, 0xb6, 0xeb, 0xc0, 0x96, 0x81, 0xaf, 0xd0, 0xf3,
+	0x58, 0x94, 0xab, 0x41, 0x66, 0x83, 0x5f, 0x67, 0x6e, 0x6a, 0x0d, 0xcc, 0x93, 0x82, 0xc7, 0x79,
+	0x94, 0x55, 0x3e, 0x44, 0x07, 0xe3, 0xb5, 0xcf, 0x02, 0x31, 0x0b, 0xdc, 0xbb, 0x1b, 0xd8, 0xa6,
+	0x94, 0x4b, 0x7d, 0x15, 0xd4, 0x3b, 0x73, 0x1b, 0xa0, 0x03, 0x45, 0x00, 0x26, 0xfb, 0x05, 0x9c,
+	0x57, 0xfd, 0x14, 0xd4, 0x66, 0x2b, 0xff, 0xa7, 0xca, 0x16, 0x59, 0x06, 0xee, 0xa1, 0xa7, 0xb6,
+	0xcc, 0x6e, 0x08, 0x80, 0x4f, 0xaa, 0x70, 0x31, 0x04, 0xa8, 0x30, 0xe8, 0x3d, 0xda, 0xb3, 0xe5,
+	0x88, 0x2e, 0x3c, 0xfc, 0xa2, 0x06, 0x32, 0x21, 0x0b, 0xf0, 0xee, 0x49, 0xba, 0xf1, 0x01, 0x82,
+	0x15, 0x0c, 0x88, 0x47, 0xa8, 0x03, 0xf8, 0x8b, 0xb2, 0x87, 0xbc, 0xb6, 0xc8, 0x83, 0x98, 0x55,
+	0x96, 0x81, 0x4f, 0xd1, 0xbe, 0x0d, 0x62, 0x46, 0x38, 0xdf, 0x2c, 0xf1, 0xcb, 0x9a, 0x14, 0x62,
+	0x55, 0x25, 0xf1, 0x2f, 0xd1, 0x67, 0x13, 0xe6, 0xdc, 0x94, 0x89, 0x53, 0x36, 0x7b, 0x83, 0x9e,
+	0x7c, 0xa2, 0xca, 0xf0, 0xb8, 0x50, 0x44, 0x2c, 0xac, 0xd9, 0x58, 0x92, 0x95, 0x33, 0x80, 0x40,
+	0xce, 0x48, 0xd9, 0xb9, 0x5e, 0x03, 0x52, 0x9f, 0xd2, 0xb8, 0x99, 0xac, 0xb8, 0xff, 0xc5, 0xfe,
+	0xef, 0xd1, 0xe1, 0x08, 0x44, 0x52, 0xa3, 0x20, 0x22, 0xac, 0x4c, 0x40, 0x31, 0xdd, 0xd8, 0x46,
+	0xf1, 0xbf, 0xa5, 0x37, 0xf0, 0x1f, 0x77, 0x10, 0xdc, 0xb9, 0xb0, 0xa9, 0x2c, 0x1a, 0xdd, 0xae,
+	0x82, 0x95, 0x65, 0xe0, 0x1f, 0x54, 0x50, 0xc9, 0xa0, 0x3a, 0x68, 0x61, 0x51, 0xe4, 0x8d, 0xd4,
+	0x7c, 0x37, 0x74, 0x54, 0x19, 0x21, 0x9f, 0xeb, 0x98, 0x8a, 0x5a, 0x32, 0xbe, 0x43, 0x7b, 0x23,
+	0xa0, 0x36, 0xc0, 0x32, 0xdd, 0x64, 0xc9, 0x7b, 0x42, 0xe8, 0xaa, 0x08, 0x91, 0x52, 0x0d, 0x11,
+	0x25, 0x88, 0x7a, 0x0f, 0xb6, 0xb3, 0x4d, 0x2d, 0xa4, 0x8b, 0x9e, 0xda, 0xe4, 0x0e, 0x14, 0x46,
+	0xe7, 0xae, 0x05, 0x0a, 0x54, 0x6e, 0x70, 0x4f, 0x6d, 0x2a, 0x4d, 0xd8, 0xa3, 0xdc, 0x09, 0x4b,
+	0x58, 0xaa, 0x7b, 0x9c, 0xdb, 0x39, 0x3d, 0x84, 0xd4, 0x72, 0x3f, 0x97, 0x57, 0x30, 0xdd, 0x39,
+	0xea, 0xf5, 0x5b, 0x72, 0x2b, 0xeb, 0xe2, 0x48, 0x5d, 0xdc, 0xbd, 0x47, 0x62, 0x4e, 0x51, 0x33,
+	0x8e, 0xc3, 0x28, 0x07, 0xca, 0x43, 0xfe, 0x48, 0xdc, 0x8f, 0xe8, 0xa8, 0x72, 0xe0, 0xd2, 0xd2,
+	0xf4, 0xc9, 0x1c, 0xd3, 0xba, 0x73, 0xf7, 0x56, 0xd1, 0xf7, 0x12, 0xa2, 0x79, 0x14, 0xef, 0xfe,
+	0x0a, 0x99, 0x1a, 0xe9, 0x8d, 0x8e, 0x92, 0x03, 0xf9, 0xec, 0x22, 0x5c, 0xfb, 0x7a, 0xdd, 0xe5,
+	0x0e, 0x85, 0x2d, 0x02, 0x97, 0xae, 0x8a, 0x84, 0x8f, 0x65, 0x96, 0x81, 0x3b, 0x68, 0xef, 0x4f,
+	0x08, 0xb8, 0xcc, 0x6c, 0xc7, 0x80, 0x24, 0x6a, 0x39, 0x77, 0x96, 0x81, 0xbf, 0x42, 0x4f, 0xc6,
+	0xdc, 0xde, 0x52, 0xe7, 0xa1, 0x01, 0xef, 0xa2, 0xe6, 0x98, 0x4f, 0x85, 0x7f, 0x2e, 0xc9, 0xf9,
+	0x18, 0x40, 0x07, 0xed, 0x4d, 0x41, 0xd4, 0x8d, 0xb7, 0xce, 0x64, 0xca, 0x96, 0x90, 0x98, 0xa8,
+	0xbf, 0x48, 0x4e, 0xcd, 0x90, 0x08, 0xe2, 0x0d, 0x89, 0xeb, 0x85, 0x01, 0xec, 0x8a, 0x30, 0xa6,
+	0xa2, 0xdf, 0x53, 0x7f, 0x51, 0x3b, 0xd9, 0x09, 0x6a, 0x62, 0x6c, 0xb8, 0x0d, 0x41, 0xb2, 0x6d,
+	0x37, 0xec, 0xf4, 0x5b, 0xcb, 0xc0, 0x7d, 0x74, 0xa4, 0xe8, 0x1e, 0x5b, 0x3f, 0xd0, 0x0e, 0x0d,
+	0x7a, 0x9f, 0xed, 0x83, 0x7b, 0x8e, 0xf7, 0x71, 0x7e, 0x23, 0x64, 0xc7, 0xeb, 0xad, 0xfa, 0x3e,
+	0x4b, 0xc0, 0x36, 0xdc, 0xe2, 0x82, 0xf7, 0x94, 0x2f, 0xba, 0x0a, 0xcb, 0xc0, 0xdf, 0x20, 0x74,
+	0xee, 0x31, 0x0e, 0x1f, 0x43, 0x08, 0xe1, 0xa1, 0x7f, 0xfa, 0x67, 0x55, 0xd0, 0x99, 0xe7, 0x49,
+	0xe6, 0xea, 0x91, 0x2b, 0x6f, 0x1c, 0x7d, 0xe9, 0x8b, 0x66, 0x8a, 0xd5, 0xfb, 0xf2, 0x73, 0x4b,
+	0x7d, 0xcd, 0xe1, 0xe3, 0x1c, 0xcd, 0xb4, 0x30, 0x85, 0xc6, 0x4c, 0xd3, 0x62, 0xcb, 0xc0, 0x63,
+	0x64, 0xc6, 0xb4, 0x9f, 0xb2, 0xc4, 0x5f, 0xdd, 0x87, 0x55, 0xa6, 0xbc, 0xc7, 0xd5, 0x29, 0x6a,
+	0xa8, 0x99, 0xbc, 0x22, 0x74, 0x39, 0x0d, 0xd7, 0x38, 0x63, 0xf7, 0xad, 0x14, 0xa9, 0x9e, 0xd4,
+	0xad, 0xbf, 0xaf, 0xd5, 0x2e, 0x1b, 0xb2, 0xa0, 0x70, 0xa1, 0x7e, 0x87, 0x6d, 0xb9, 0x83, 0x83,
+	0xd7, 0x7f, 0xbf, 0x5a, 0xb9, 0xe2, 0x3a, 0x5c, 0x74, 0x1c, 0xb6, 0xee, 0xf6, 0xfb, 0x0e, 0xed,
+	0x26, 0x9f, 0xdb, 0x5d, 0x65, 0xb8, 0x78, 0xa2, 0xbe, 0xc3, 0xfb, 0xff, 0x05, 0x00, 0x00, 0xff,
+	0xff, 0xf5, 0xb2, 0x51, 0x39, 0x06, 0x0c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -189,12 +190,12 @@ type Chain33Client interface {
 	//获取系统致命故障信息
 	GetFatalFailure(ctx context.Context, in *ReqNil, opts ...grpc.CallOption) (*Int32, error)
 	GetLastBlockSequence(ctx context.Context, in *ReqNil, opts ...grpc.CallOption) (*Int64, error)
-	//获取指定区间的block加载序列号信息
-	GetBlockSequences(ctx context.Context, in *ReqBlocks, opts ...grpc.CallOption) (*BlockSequences, error)
 	// get add block's sequence by hash
 	GetSequenceByHash(ctx context.Context, in *ReqHash, opts ...grpc.CallOption) (*Int64, error)
 	//通过block hash 获取对应的blocks信息
 	GetBlockByHashes(ctx context.Context, in *ReqHashes, opts ...grpc.CallOption) (*BlockDetails, error)
+	//通过block seq 获取对应的blocks hash 信息
+	GetBlockBySeq(ctx context.Context, in *Int64, opts ...grpc.CallOption) (*BlockSeq, error)
 	//关闭chain33
 	CloseQueue(ctx context.Context, in *ReqNil, opts ...grpc.CallOption) (*Reply, error)
 	//获取地址所以合约下的余额
@@ -204,6 +205,8 @@ type Chain33Client interface {
 	CreateNoBalanceTransaction(ctx context.Context, in *NoBalanceTx, opts ...grpc.CallOption) (*ReplySignRawTx, error)
 	// 获取随机HASH
 	QueryRandNum(ctx context.Context, in *ReqRandHash, opts ...grpc.CallOption) (*ReplyHash, error)
+	// 获取是否达到fork高度
+	GetFork(ctx context.Context, in *ReqKey, opts ...grpc.CallOption) (*Int64, error)
 }
 
 type chain33Client struct {
@@ -601,15 +604,6 @@ func (c *chain33Client) GetLastBlockSequence(ctx context.Context, in *ReqNil, op
 	return out, nil
 }
 
-func (c *chain33Client) GetBlockSequences(ctx context.Context, in *ReqBlocks, opts ...grpc.CallOption) (*BlockSequences, error) {
-	out := new(BlockSequences)
-	err := c.cc.Invoke(ctx, "/types.chain33/GetBlockSequences", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *chain33Client) GetSequenceByHash(ctx context.Context, in *ReqHash, opts ...grpc.CallOption) (*Int64, error) {
 	out := new(Int64)
 	err := c.cc.Invoke(ctx, "/types.chain33/GetSequenceByHash", in, out, opts...)
@@ -628,6 +622,15 @@ func (c *chain33Client) GetBlockByHashes(ctx context.Context, in *ReqHashes, opt
 	return out, nil
 }
 
+func (c *chain33Client) GetBlockBySeq(ctx context.Context, in *Int64, opts ...grpc.CallOption) (*BlockSeq, error) {
+	out := new(BlockSeq)
+	err := c.cc.Invoke(ctx, "/types.chain33/GetBlockBySeq", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *chain33Client) CloseQueue(ctx context.Context, in *ReqNil, opts ...grpc.CallOption) (*Reply, error) {
 	out := new(Reply)
 	err := c.cc.Invoke(ctx, "/types.chain33/CloseQueue", in, out, opts...)
@@ -673,6 +676,15 @@ func (c *chain33Client) QueryRandNum(ctx context.Context, in *ReqRandHash, opts
 	return out, nil
 }
 
+func (c *chain33Client) GetFork(ctx context.Context, in *ReqKey, opts ...grpc.CallOption) (*Int64, error) {
+	out := new(Int64)
+	err := c.cc.Invoke(ctx, "/types.chain33/GetFork", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Chain33Server is the server API for Chain33 service.
 type Chain33Server interface {
 	// chain33 对外提供服务的接口
@@ -758,12 +770,12 @@ type Chain33Server interface {
 	//获取系统致命故障信息
 	GetFatalFailure(context.Context, *ReqNil) (*Int32, error)
 	GetLastBlockSequence(context.Context, *ReqNil) (*Int64, error)
-	//获取指定区间的block加载序列号信息
-	GetBlockSequences(context.Context, *ReqBlocks) (*BlockSequences, error)
 	// get add block's sequence by hash
 	GetSequenceByHash(context.Context, *ReqHash) (*Int64, error)
 	//通过block hash 获取对应的blocks信息
 	GetBlockByHashes(context.Context, *ReqHashes) (*BlockDetails, error)
+	//通过block seq 获取对应的blocks hash 信息
+	GetBlockBySeq(context.Context, *Int64) (*BlockSeq, error)
 	//关闭chain33
 	CloseQueue(context.Context, *ReqNil) (*Reply, error)
 	//获取地址所以合约下的余额
@@ -773,6 +785,8 @@ type Chain33Server interface {
 	CreateNoBalanceTransaction(context.Context, *NoBalanceTx) (*ReplySignRawTx, error)
 	// 获取随机HASH
 	QueryRandNum(context.Context, *ReqRandHash) (*ReplyHash, error)
+	// 获取是否达到fork高度
+	GetFork(context.Context, *ReqKey) (*Int64, error)
 }
 
 func RegisterChain33Server(s *grpc.Server, srv Chain33Server) {
@@ -1553,56 +1567,56 @@ func _Chain33_GetLastBlockSequence_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Chain33_GetBlockSequences_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ReqBlocks)
+func _Chain33_GetSequenceByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReqHash)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(Chain33Server).GetBlockSequences(ctx, in)
+		return srv.(Chain33Server).GetSequenceByHash(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/types.chain33/GetBlockSequences",
+		FullMethod: "/types.chain33/GetSequenceByHash",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(Chain33Server).GetBlockSequences(ctx, req.(*ReqBlocks))
+		return srv.(Chain33Server).GetSequenceByHash(ctx, req.(*ReqHash))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Chain33_GetSequenceByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ReqHash)
+func _Chain33_GetBlockByHashes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReqHashes)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(Chain33Server).GetSequenceByHash(ctx, in)
+		return srv.(Chain33Server).GetBlockByHashes(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/types.chain33/GetSequenceByHash",
+		FullMethod: "/types.chain33/GetBlockByHashes",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(Chain33Server).GetSequenceByHash(ctx, req.(*ReqHash))
+		return srv.(Chain33Server).GetBlockByHashes(ctx, req.(*ReqHashes))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Chain33_GetBlockByHashes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ReqHashes)
+func _Chain33_GetBlockBySeq_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(Int64)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(Chain33Server).GetBlockByHashes(ctx, in)
+		return srv.(Chain33Server).GetBlockBySeq(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/types.chain33/GetBlockByHashes",
+		FullMethod: "/types.chain33/GetBlockBySeq",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(Chain33Server).GetBlockByHashes(ctx, req.(*ReqHashes))
+		return srv.(Chain33Server).GetBlockBySeq(ctx, req.(*Int64))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -1697,6 +1711,24 @@ func _Chain33_QueryRandNum_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Chain33_GetFork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReqKey)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(Chain33Server).GetFork(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.chain33/GetFork",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(Chain33Server).GetFork(ctx, req.(*ReqKey))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Chain33_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "types.chain33",
 	HandlerType: (*Chain33Server)(nil),
@@ -1874,10 +1906,6 @@ var _Chain33_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Chain33_GetLastBlockSequence_Handler,
 		},
 		{
-			MethodName: "GetBlockSequences",
-			Handler:    _Chain33_GetBlockSequences_Handler,
-		},
-		{
 			MethodName: "GetSequenceByHash",
 			Handler:    _Chain33_GetSequenceByHash_Handler,
 		},
@@ -1886,6 +1914,10 @@ var _Chain33_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Chain33_GetBlockByHashes_Handler,
 		},
 		{
+			MethodName: "GetBlockBySeq",
+			Handler:    _Chain33_GetBlockBySeq_Handler,
+		},
+		{
 			MethodName: "CloseQueue",
 			Handler:    _Chain33_CloseQueue_Handler,
 		},
@@ -1905,6 +1937,10 @@ var _Chain33_serviceDesc = grpc.ServiceDesc{
 			MethodName: "QueryRandNum",
 			Handler:    _Chain33_QueryRandNum_Handler,
 		},
+		{
+			MethodName: "GetFork",
+			Handler:    _Chain33_GetFork_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "rpc.proto",