fix ci.toml and lint

crypto/secp256k1/secp256k1_test.go

@@ -36,8 +36,7 @@ func TestPubKeySecp256k1Address(t *testing.T) {
 		addrBbz, _, _ := base58.CheckDecode(d.addr)
 		addrB := crypto.Address(addrBbz)
 
-		var priv secp256k1.PrivKey = secp256k1.PrivKey(privB)
-
+		priv := secp256k1.PrivKey(privB)
 		pubKey := priv.PubKey()
 		pubT, _ := pubKey.(secp256k1.PubKey)
 		pub := pubT

internal/evidence/pool.go

@@ -608,7 +608,7 @@ func prefixToBytes(prefix int64) []byte {
 }
 
 func keyCommitted(evidence types.Evidence) []byte {
-	var height int64 = evidence.Height()
+	var height = evidence.Height()
 	key, err := orderedcode.Append(nil, prefixCommitted, height, string(evidence.Hash()))
 	if err != nil {
 		panic(err)
@@ -617,7 +617,7 @@ func keyCommitted(evidence types.Evidence) []byte {
 }
 
 func keyPending(evidence types.Evidence) []byte {
-	var height int64 = evidence.Height()
+	var height = evidence.Height()
 	key, err := orderedcode.Append(nil, prefixPending, height, string(evidence.Hash()))
 	if err != nil {
 		panic(err)

internal/statesync/dispatcher.go

@@ -149,24 +149,24 @@ func (d *Dispatcher) Stop() {
 
 //----------------------------------------------------------------
 
-// blockProvider is a p2p based light provider which uses a dispatcher connected
+// BlockProvider is a p2p based light provider which uses a dispatcher connected
 // to the state sync reactor to serve light blocks to the light client
 //
 // TODO: This should probably be moved over to the light package but as we're
 // not yet officially supporting p2p light clients we'll leave this here for now.
 //
-// NOTE: blockProvider will return an error with concurrent calls. However, we don't
+// NOTE: BlockProvider will return an error with concurrent calls. However, we don't
 // need a mutex because a light client (and the backfill process) will never call a
 // method more than once at the same time
-type blockProvider struct {
+type BlockProvider struct {
 	peer       types.NodeID
 	chainID    string
 	dispatcher *Dispatcher
 }
 
 // Creates a block provider which implements the light client Provider interface.
-func NewBlockProvider(peer types.NodeID, chainID string, dispatcher *Dispatcher) *blockProvider {
-	return &blockProvider{
+func NewBlockProvider(peer types.NodeID, chainID string, dispatcher *Dispatcher) *BlockProvider {
+	return &BlockProvider{
 		peer:       peer,
 		chainID:    chainID,
 		dispatcher: dispatcher,
@@ -175,7 +175,7 @@ func NewBlockProvider(peer types.NodeID, chainID string, dispatcher *Dispatcher)
 
 // LightBlock fetches a light block from the peer at a specified height returning either a light block
 // or an appropriate error. Concurrently unsafe
-func (p *blockProvider) LightBlock(ctx context.Context, height int64) (*types.LightBlock, error) {
+func (p *BlockProvider) LightBlock(ctx context.Context, height int64) (*types.LightBlock, error) {
 	lb, err := p.dispatcher.LightBlock(ctx, height, p.peer)
 	switch err {
 	case nil:
@@ -211,12 +211,12 @@ func (p *blockProvider) LightBlock(ctx context.Context, height int64) (*types.Li
 // attacks. This is a no op as there currently isn't a way to wire this up to
 // the evidence reactor (we should endeavor to do this in the future but for now
 // it's not critical for backwards verification)
-func (p *blockProvider) ReportEvidence(ctx context.Context, ev types.Evidence) error {
+func (p *BlockProvider) ReportEvidence(ctx context.Context, ev types.Evidence) error {
 	return nil
 }
 
 // String implements stringer interface
-func (p *blockProvider) String() string { return string(p.peer) }
+func (p *BlockProvider) String() string { return string(p.peer) }
 
 //----------------------------------------------------------------
 

internal/statesync/dispatcher_test.go

@@ -114,7 +114,7 @@ func TestDispatcherProviders(t *testing.T) {
 	go handleRequests(t, d, ch, closeCh)
 
 	peers := createPeerSet(5)
-	providers := make([]*blockProvider, len(peers))
+	providers := make([]*BlockProvider, len(peers))
 	for idx, peer := range peers {
 		providers[idx] = NewBlockProvider(peer, chainID, d)
 	}

internal/statesync/reactor.go

@@ -63,7 +63,7 @@ var (
 			MsgType: new(ssproto.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(LightBlockChannel),
-				Priority:            11,
+				Priority:            5,
 				SendQueueCapacity:   10,
 				RecvMessageCapacity: lightBlockMsgSize,
 				RecvBufferCapacity:  128,
@@ -156,7 +156,7 @@ type Reactor struct {
 	// providers.
 	mtx           tmsync.RWMutex
 	syncer        *syncer
-	providers     map[types.NodeID]*blockProvider
+	providers     map[types.NodeID]*BlockProvider
 	stateProvider StateProvider
 }
 
@@ -193,7 +193,7 @@ func NewReactor(
 		blockStore:  blockStore,
 		peers:       newPeerList(),
 		dispatcher:  NewDispatcher(blockCh.Out, lightBlockResponseTimeout),
-		providers:   make(map[types.NodeID]*blockProvider),
+		providers:   make(map[types.NodeID]*BlockProvider),
 	}
 
 	r.BaseService = *service.NewBaseService(logger, "StateSync", r)

internal/statesync/stateprovider.go

@@ -347,7 +347,7 @@ func (s *stateProviderP2P) addProvider(p lightprovider.Provider) {
 func (s *stateProviderP2P) consensusParams(ctx context.Context, height int64) (types.ConsensusParams, error) {
 	providers := s.lc.Witnesses()
 	for _, provider := range providers {
-		p, ok := provider.(*blockProvider)
+		p, ok := provider.(*BlockProvider)
 		if !ok {
 			panic("expected p2p state provider to use p2p block providers")
 		}

test/e2e/networks/ci.toml

@@ -63,6 +63,7 @@ perturb = ["pause"]
 [node.validator05]
 database = "cleveldb" 
 block_sync = "v0" 
+state_sync = "p2p"
 seeds = ["seed01"] 
 start_at = 1005 # Becomes part of the validator set at 1010
 abci_protocol = "grpc"
@@ -77,7 +78,7 @@ block_sync = "v0"
 persistent_peers = ["validator01", "validator02", "validator03", "validator04", "validator05"]
 perturb = ["restart"]
 retain_blocks = 7
-state_sync = true
+state_sync = "rpc"
 
 [node.light01]
 mode = "light"