fix linting.

committee/committee_test.go

@@ -10,14 +10,14 @@ import (
 )
 
 func copyValidator(val *validator.Validator) *validator.Validator {
-	copy := validator.NewValidator(val.PublicKey(), val.Number())
-	copy.UpdateLastBondingHeight(val.LastBondingHeight())
-	copy.UpdateLastJoinedHeight(val.LastJoinedHeight())
-	copy.UpdateUnbondingHeight(val.UnbondingHeight())
+	clone := validator.NewValidator(val.PublicKey(), val.Number())
+	clone.UpdateLastBondingHeight(val.LastBondingHeight())
+	clone.UpdateLastJoinedHeight(val.LastJoinedHeight())
+	clone.UpdateUnbondingHeight(val.UnbondingHeight())
 
 	// Stake can't be changes as long as validator is inside committee
 	// Check Bond executor
-	return copy
+	return clone
 }
 func TestContains(t *testing.T) {
 	committee, signers := GenerateTestCommittee(21)

consensus/change_proposer.go

@@ -36,11 +36,11 @@ func (s *changeProposerState) onAddVote(v *vote.Vote) {
 	}
 }
 
-func (s *changeProposerState) onSetProposal(p *proposal.Proposal) {
+func (s *changeProposerState) onSetProposal(_ *proposal.Proposal) {
 	// Ignore proposals
 }
 
-func (s *changeProposerState) onTimeout(t *ticker) {
+func (s *changeProposerState) onTimeout(_ *ticker) {
 	// Ignore timeouts
 }
 

consensus/commit.go

@@ -62,7 +62,7 @@ func (s *commitState) onSetProposal(p *proposal.Proposal) {
 	s.decide()
 }
 
-func (s *commitState) onTimeout(t *ticker) {
+func (s *commitState) onTimeout(_ *ticker) {
 	// Ignore timeouts
 }
 

consensus/height.go

@@ -52,7 +52,7 @@ func (s *newHeightState) onAddVote(v *vote.Vote) {
 	s.doAddVote(v)
 }
 
-func (s *newHeightState) onSetProposal(p *proposal.Proposal) {
+func (s *newHeightState) onSetProposal(_ *proposal.Proposal) {
 }
 
 func (s *newHeightState) onTimeout(t *ticker) {

consensus/precommit.go

@@ -78,7 +78,7 @@ func (s *precommitState) onSetProposal(p *proposal.Proposal) {
 	}
 }
 
-func (s *precommitState) onTimeout(t *ticker) {
+func (s *precommitState) onTimeout(_ *ticker) {
 	// Ignore timeouts
 }
 

consensus/propose.go

@@ -45,15 +45,15 @@ func (s *proposeState) createProposal(height uint32, round int16) {
 	s.broadcastProposal(proposal)
 }
 
-func (s *proposeState) onAddVote(v *vote.Vote) {
+func (s *proposeState) onAddVote(_ *vote.Vote) {
 	panic("Unreachable")
 }
 
-func (s *proposeState) onSetProposal(p *proposal.Proposal) {
+func (s *proposeState) onSetProposal(_ *proposal.Proposal) {
 	panic("Unreachable")
 }
 
-func (s *proposeState) onTimeout(t *ticker) {
+func (s *proposeState) onTimeout(_ *ticker) {
 	panic("Unreachable")
 }
 func (s *proposeState) name() string {

network/mock.go

@@ -56,7 +56,7 @@ func (mock *MockNetwork) SendTo(data []byte, pid lp2pcore.PeerID) error {
 	}
 	return nil
 }
-func (mock *MockNetwork) Broadcast(data []byte, tid TopicID) error {
+func (mock *MockNetwork) Broadcast(data []byte, _ TopicID) error {
 	mock.BroadcastCh <- BroadcastData{
 		Data:   data,
 		Target: nil, // Send to all

sandbox/sandbox.go

@@ -79,9 +79,9 @@ func (sb *sandbox) Account(addr crypto.Address) *account.Account {
 
 	s, ok := sb.accounts[addr]
 	if ok {
-		copy := new(account.Account)
-		*copy = s.Account
-		return copy
+		clone := new(account.Account)
+		*clone = s.Account
+		return clone
 	}
 
 	acc, err := sb.store.Account(addr)
@@ -130,9 +130,9 @@ func (sb *sandbox) Validator(addr crypto.Address) *validator.Validator {
 
 	s, ok := sb.validators[addr]
 	if ok {
-		copy := new(validator.Validator)
-		*copy = s.Validator
-		return copy
+		clone := new(validator.Validator)
+		*clone = s.Validator
+		return clone
 	}
 
 	val, err := sb.store.Validator(addr)

state/mock.go

@@ -100,11 +100,11 @@ func (m *MockState) CommitBlock(h uint32, b *block.Block, cert *block.Certificat
 func (m *MockState) Close() error {
 	return nil
 }
-func (m *MockState) ProposeBlock(round int16) (*block.Block, error) {
+func (m *MockState) ProposeBlock(_ int16) (*block.Block, error) {
 	b := block.GenerateTestBlock(nil, nil)
 	return b, nil
 }
-func (m *MockState) ValidateBlock(block *block.Block) error {
+func (m *MockState) ValidateBlock(_ *block.Block) error {
 	return nil
 }
 func (m *MockState) CommitteeValidators() []*validator.Validator {

state/state.go

@@ -362,11 +362,7 @@ func (st *state) ValidateBlock(block *block.Block) error {
 	}
 
 	sb := st.concreteSandbox()
-	if err := st.executeBlock(block, sb); err != nil {
-		return err
-	}
-
-	return nil
+	return st.executeBlock(block, sb)
 }
 
 func (st *state) CommitBlock(height uint32, block *block.Block, cert *block.Certificate) error {

sync/bundle/message/block_announce.go

@@ -24,11 +24,7 @@ func (m *BlockAnnounceMessage) SanityCheck() error {
 	if err := m.Block.SanityCheck(); err != nil {
 		return err
 	}
-	if err := m.Certificate.SanityCheck(); err != nil {
-		return err
-	}
-
-	return nil
+	return m.Certificate.SanityCheck()
 }
 
 func (m *BlockAnnounceMessage) Type() Type {

sync/bundle/message/hello.go

@@ -47,10 +47,7 @@ func (m *HelloMessage) SanityCheck() error {
 	if m.PublicKey == nil {
 		return errors.Error(errors.ErrInvalidPublicKey)
 	}
-	if err := m.PublicKey.Verify(m.SignBytes(), m.Signature); err != nil {
-		return err
-	}
-	return nil
+	return m.PublicKey.Verify(m.SignBytes(), m.Signature)
 }
 
 func (m *HelloMessage) SignBytes() []byte {

sync/bundle/message/proposal.go

@@ -15,11 +15,7 @@ func NewProposalMessage(p *proposal.Proposal) *ProposalMessage {
 }
 
 func (m *ProposalMessage) SanityCheck() error {
-	if err := m.Proposal.SanityCheck(); err != nil {
-		return err
-	}
-
-	return nil
+	return m.Proposal.SanityCheck()
 }
 
 func (m *ProposalMessage) Type() Type {

sync/bundle/message/vote.go

@@ -15,10 +15,7 @@ func NewVoteMessage(v *vote.Vote) *VoteMessage {
 }
 
 func (m *VoteMessage) SanityCheck() error {
-	if err := m.Vote.SanityCheck(); err != nil {
-		return err
-	}
-	return nil
+	return m.Vote.SanityCheck()
 }
 
 func (m *VoteMessage) Type() Type {

sync/handler_proposal.go

@@ -16,7 +16,7 @@ func newProposalHandler(sync *synchronizer) messageHandler {
 	}
 }
 
-func (handler *proposalHandler) ParsMessage(m message.Message, initiator peer.ID) error {
+func (handler *proposalHandler) ParsMessage(m message.Message, _ peer.ID) error {
 	msg := m.(*message.ProposalMessage)
 	handler.logger.Trace("parsing Proposal message", "message", msg)
 

sync/handler_transactions.go

@@ -16,7 +16,7 @@ func newTransactionsHandler(sync *synchronizer) messageHandler {
 	}
 }
 
-func (handler *transactionsHandler) ParsMessage(m message.Message, initiator peer.ID) error {
+func (handler *transactionsHandler) ParsMessage(m message.Message, _ peer.ID) error {
 	msg := m.(*message.TransactionsMessage)
 	handler.logger.Trace("parsing Transactions message", "message", msg)
 

sync/handler_vote.go

@@ -16,7 +16,7 @@ func newVoteHandler(sync *synchronizer) messageHandler {
 	}
 }
 
-func (handler *voteHandler) ParsMessage(m message.Message, initiator peer.ID) error {
+func (handler *voteHandler) ParsMessage(m message.Message, _ peer.ID) error {
 	msg := m.(*message.VoteMessage)
 	handler.logger.Trace("parsing Vote message", "message", msg)
 

txpool/mock.go

@@ -19,7 +19,7 @@ func MockingTxPool() *MockTxPool {
 		Txs: make([]*tx.Tx, 0),
 	}
 }
-func (m *MockTxPool) SetNewSandboxAndRecheck(sb sandbox.Sandbox) {}
+func (m *MockTxPool) SetNewSandboxAndRecheck(_ sandbox.Sandbox) {}
 func (m *MockTxPool) PendingTx(id tx.ID) *tx.Tx {
 	for _, t := range m.Txs {
 		if t.ID().EqualsTo(id) {
@@ -59,7 +59,7 @@ func (m *MockTxPool) AppendTxAndBroadcast(trx *tx.Tx) error {
 	return nil
 }
 
-func (m *MockTxPool) RemoveTx(id hash.Hash) {
+func (m *MockTxPool) RemoveTx(_ hash.Hash) {
 	// This test pools is shared between different test objects
 	//delete(m.Txs, id)
 }

types/block/block.go

@@ -182,12 +182,12 @@ func (b *Block) Decode(r io.Reader) error {
 			return err
 		}
 	}
-	len, err := encoding.ReadVarInt(r)
+	length, err := encoding.ReadVarInt(r)
 	if err != nil {
 		return err
 	}
-	b.data.Txs = make([]*tx.Tx, len)
-	for i := 0; i < int(len); i++ {
+	b.data.Txs = make([]*tx.Tx, length)
+	for i := 0; i < int(length); i++ {
 		tx := new(tx.Tx)
 		if err := tx.Decode(r); err != nil {
 			return err

types/block/block_test.go

@@ -69,23 +69,23 @@ func TestCBORMarshaling(t *testing.T) {
 
 func TestEncodingBlock(t *testing.T) {
 	blk := GenerateTestBlock(nil, nil)
-	len := blk.SerializeSize()
+	length := blk.SerializeSize()
 
-	for i := 0; i < len; i++ {
+	for i := 0; i < length; i++ {
 		w := util.NewFixedWriter(i)
 		assert.Error(t, blk.Encode(w), "encode test %v failed", i)
 	}
-	w := util.NewFixedWriter(len)
+	w := util.NewFixedWriter(length)
 	assert.NoError(t, blk.Encode(w))
 
-	for i := 0; i < len; i++ {
+	for i := 0; i < length; i++ {
 		blk2 := new(Block)
 		r := util.NewFixedReader(i, w.Bytes())
 		assert.Error(t, blk2.Decode(r), "decode test %v failed", i)
 	}
 
 	blk2 := new(Block)
-	r := util.NewFixedReader(len, w.Bytes())
+	r := util.NewFixedReader(length, w.Bytes())
 	assert.NoError(t, blk2.Decode(r))
 	assert.Equal(t, blk.Hash(), blk2.Hash())
 	assert.Equal(t, blk.Header(), blk2.Header())

types/block/certificate.go

@@ -125,11 +125,8 @@ func (cert *Certificate) Encode(w io.Writer) error {
 			return err
 		}
 	}
-	if err := cert.data.Signature.Encode(w); err != nil {
-		return err
-	}
 
-	return nil
+	return cert.data.Signature.Encode(w)
 }
 
 func (cert *Certificate) Decode(r io.Reader) error {

types/tx/payload/send.go

@@ -30,11 +30,7 @@ func (p *SendPayload) SanityCheck() error {
 	if err := p.Sender.SanityCheck(); err != nil {
 		return err
 	}
-	if err := p.Receiver.SanityCheck(); err != nil {
-		return err
-	}
-
-	return nil
+	return p.Receiver.SanityCheck()
 }
 
 func (p *SendPayload) SerializeSize() int {

types/tx/tx_test.go

@@ -29,23 +29,23 @@ func TestCBORMarshaling(t *testing.T) {
 
 func TestEncodingTx(t *testing.T) {
 	tx1, _ := GenerateTestSendTx()
-	len := tx1.SerializeSize()
+	length := tx1.SerializeSize()
 
-	for i := 0; i < len; i++ {
+	for i := 0; i < length; i++ {
 		w := util.NewFixedWriter(i)
 		assert.Error(t, tx1.Encode(w), "encode test %v failed", i)
 	}
-	w := util.NewFixedWriter(len)
+	w := util.NewFixedWriter(length)
 	assert.NoError(t, tx1.Encode(w))
 
-	for i := 0; i < len; i++ {
+	for i := 0; i < length; i++ {
 		tx2 := new(Tx)
 		r := util.NewFixedReader(i, w.Bytes())
 		assert.Error(t, tx2.Decode(r), "decode test %v failed", i)
 	}
 
 	tx2 := new(Tx)
-	r := util.NewFixedReader(len, w.Bytes())
+	r := util.NewFixedReader(length, w.Bytes())
 	assert.NoError(t, tx2.Decode(r))
 	assert.Equal(t, tx1.ID(), tx2.ID())
 }

wallet/client_test.go

@@ -18,27 +18,27 @@ var tValidatorRequest *pactus.GetValidatorRequest
 var tValidatorResponse *pactus.GetValidatorResponse
 
 func (s *blockchainServer) GetBlockchainInfo(_ context.Context,
-	req *pactus.GetBlockchainInfoRequest) (*pactus.GetBlockchainInfoResponse, error) {
+	_ *pactus.GetBlockchainInfoRequest) (*pactus.GetBlockchainInfoResponse, error) {
 	return tBlockchainInfoResponse, nil
 }
 
 func (s *blockchainServer) GetConsensusInfo(_ context.Context,
-	req *pactus.GetConsensusInfoRequest) (*pactus.GetConsensusInfoResponse, error) {
+	_ *pactus.GetConsensusInfoRequest) (*pactus.GetConsensusInfoResponse, error) {
 	return nil, nil
 }
 
 func (s *blockchainServer) GetBlockHash(_ context.Context,
-	req *pactus.GetBlockHashRequest) (*pactus.GetBlockHashResponse, error) {
+	_ *pactus.GetBlockHashRequest) (*pactus.GetBlockHashResponse, error) {
 	return nil, nil
 }
 
 func (s *blockchainServer) GetBlockHeight(_ context.Context,
-	req *pactus.GetBlockHeightRequest) (*pactus.GetBlockHeightResponse, error) {
+	_ *pactus.GetBlockHeightRequest) (*pactus.GetBlockHeightResponse, error) {
 	return nil, nil
 }
 
 func (s *blockchainServer) GetBlock(_ context.Context,
-	req *pactus.GetBlockRequest) (*pactus.GetBlockResponse, error) {
+	_ *pactus.GetBlockRequest) (*pactus.GetBlockResponse, error) {
 	return nil, nil
 }
 
@@ -51,7 +51,7 @@ func (s *blockchainServer) GetAccount(_ context.Context,
 }
 
 func (s *blockchainServer) GetValidatorByNumber(_ context.Context,
-	req *pactus.GetValidatorByNumberRequest) (*pactus.GetValidatorResponse, error) {
+	_ *pactus.GetValidatorByNumberRequest) (*pactus.GetValidatorResponse, error) {
 	return nil, nil
 }
 
@@ -64,16 +64,16 @@ func (s *blockchainServer) GetValidator(_ context.Context,
 }
 
 func (s *blockchainServer) GetValidators(_ context.Context,
-	req *pactus.GetValidatorsRequest) (*pactus.GetValidatorsResponse, error) {
+	_ *pactus.GetValidatorsRequest) (*pactus.GetValidatorsResponse, error) {
 	return nil, nil
 }
 
-func (s *transactionServer) GetTransaction(ctx context.Context,
-	req *pactus.GetTransactionRequest) (*pactus.GetTransactionResponse, error) {
+func (s *transactionServer) GetTransaction(_ context.Context,
+	_ *pactus.GetTransactionRequest) (*pactus.GetTransactionResponse, error) {
 	return nil, nil
 }
 
-func (s *transactionServer) SendRawTransaction(ctx context.Context,
+func (s *transactionServer) SendRawTransaction(_ context.Context,
 	req *pactus.SendRawTransactionRequest) (*pactus.SendRawTransactionResponse, error) {
 	trx, _ := tx.FromBytes(req.Data)
 	return &pactus.SendRawTransactionResponse{