LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

chore: fix all linting (#24101)

Browse Source
This commit is contained in:
Alex | Interchain Labs 2025-03-21 18:04:36 -04:00 committed by GitHub
parent b7fb7f4858
commit 7fd79df4e1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
329 changed files with 1282 additions and 1251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.golangci.yml
View File

@ -37,6 +37,8 @@ linters:
issues:
exclude-dirs:
- testutil/testdata
- x/params
- x/crisis
exclude-files:
- server/grpc/gogoreflection/fix_registration.go
- "fix_registration.go"

8
Makefile
View File

@ -382,19 +382,13 @@ benchmark:
### Linting ###
###############################################################################
golangci_version=v1.64.7
golangci_version=v1.64.8
lint-install:
@echo "--> Installing golangci-lint $(golangci_version)"
@go install github.com/golangci/golangci-lint/cmd/golangci-lint@$(golangci_version)
lint:
@echo "--> Running linter on diffed files only."
$(MAKE) lint-install
@./scripts/go-lint-changes.bash --timeout=15m
lint-all:
@echo "--> Running linter on all files"
$(MAKE) lint-install
@./scripts/go-lint-all.bash --timeout=15m

2
UPGRADING.md
View File

@ -65,7 +65,7 @@ If you are still using the legacy wiring, you must enable unordered transactions
if manager := app.SnapshotManager(); manager != nil {
err := manager.RegisterExtensions(unorderedtx.NewSnapshotter(app.UnorderedTxManager))
if err != nil {
panic(fmt.Errorf("failed to register snapshot extension: %s", err))
panic(fmt.Errorf("failed to register snapshot extension: %w", err))
}
}
```

23
baseapp/abci_test.go
View File

@ -716,7 +716,7 @@ func TestABCI_FinalizeBlock_MultiMsg(t *testing.T) {
msgs = append(msgs, &baseapptestutil.MsgCounter2{Counter: 0, Signer: addr.String()})
msgs = append(msgs, &baseapptestutil.MsgCounter2{Counter: 1, Signer: addr.String()})
builder.SetMsgs(msgs...)
require.NoError(t, builder.SetMsgs(msgs...))
builder.SetMemo(tx.GetMemo())
setTxSignature(t, builder, 0)
@ -888,7 +888,7 @@ func TestABCI_InvalidTransaction(t *testing.T) {
{
txBuilder := suite.txConfig.NewTxBuilder()
_, _, addr := testdata.KeyTestPubAddr()
txBuilder.SetMsgs(&baseapptestutil.MsgCounter2{Signer: addr.String()})
require.NoError(t, txBuilder.SetMsgs(&baseapptestutil.MsgCounter2{Signer: addr.String()}))
setTxSignature(t, txBuilder, 0)
unknownRouteTx := txBuilder.GetTx()
@ -901,10 +901,10 @@ func TestABCI_InvalidTransaction(t *testing.T) {
require.EqualValues(t, sdkerrors.ErrUnknownRequest.ABCICode(), code, err)
txBuilder = suite.txConfig.NewTxBuilder()
txBuilder.SetMsgs(
require.NoError(t, txBuilder.SetMsgs(
&baseapptestutil.MsgCounter{Signer: addr.String()},
&baseapptestutil.MsgCounter2{Signer: addr.String()},
)
))
setTxSignature(t, txBuilder, 0)
unknownRouteTx = txBuilder.GetTx()
@ -920,7 +920,7 @@ func TestABCI_InvalidTransaction(t *testing.T) {
// Transaction with an unregistered message
{
txBuilder := suite.txConfig.NewTxBuilder()
txBuilder.SetMsgs(&testdata.MsgCreateDog{})
require.NoError(t, txBuilder.SetMsgs(&testdata.MsgCreateDog{}))
tx := txBuilder.GetTx()
_, _, err := suite.baseApp.SimDeliver(suite.txConfig.TxEncoder(), tx)
@ -1543,10 +1543,11 @@ func TestABCI_Proposals_WithVE(t *testing.T) {
suite := NewBaseAppSuite(t, setInitChainerOpt, prepareOpt)
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
InitialHeight: 1,
ConsensusParams: &cmtproto.ConsensusParams{},
})
require.NoError(t, err)
reqPrepareProposal := abci.RequestPrepareProposal{
MaxTxBytes: 100000,
@ -1683,11 +1684,12 @@ func TestABCI_PrepareProposal_MaxGas(t *testing.T) {
baseapptestutil.RegisterCounterServer(suite.baseApp.MsgServiceRouter(), NoopCounterServerImpl{})
// set max block gas limit to 100
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
ConsensusParams: &cmtproto.ConsensusParams{
Block: &cmtproto.BlockParams{MaxGas: 100},
},
})
require.NoError(t, err)
// insert 100 txs, each with a gas limit of 10
_, _, addr := testdata.KeyTestPubAddr()
@ -1696,7 +1698,7 @@ func TestABCI_PrepareProposal_MaxGas(t *testing.T) {
msgs := []sdk.Msg{msg}
builder := suite.txConfig.NewTxBuilder()
builder.SetMsgs(msgs...)
require.NoError(t, builder.SetMsgs(msgs...))
builder.SetMemo("counter=" + strconv.FormatInt(i, 10) + "&failOnAnte=false")
builder.SetGasLimit(10)
setTxSignature(t, builder, uint64(i))
@ -2010,13 +2012,14 @@ func TestABCI_HaltChain(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
suite := NewBaseAppSuite(t, baseapp.SetHaltHeight(tc.haltHeight), baseapp.SetHaltTime(tc.haltTime))
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
ConsensusParams: &cmtproto.ConsensusParams{},
InitialHeight: tc.blockHeight,
})
require.NoError(t, err)
app := suite.baseApp
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: tc.blockHeight,
Time: time.Unix(tc.blockTime, 0),
})

4
baseapp/abci_utils.go
View File

@ -4,7 +4,7 @@ import (
"bytes"
"context"
"fmt"
"slices" //nolint: gci // ignore this line for this linter
"slices"
"github.com/cockroachdb/errors"
abci "github.com/cometbft/cometbft/abci/types"
@ -13,7 +13,7 @@ import (
cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
cmttypes "github.com/cometbft/cometbft/types"
protoio "github.com/cosmos/gogoproto/io"
"github.com/cosmos/gogoproto/proto" //nolint: gci // ignore this line for this linter
"github.com/cosmos/gogoproto/proto"
"cosmossdk.io/core/comet"

26
baseapp/baseapp_test.go
View File

@ -62,6 +62,8 @@ type (
)
func NewBaseAppSuite(t *testing.T, opts ...func(*baseapp.BaseApp)) *BaseAppSuite {
t.Helper()
cdc := codectestutil.CodecOptions{}.NewCodec()
baseapptestutil.RegisterInterfaces(cdc.InterfaceRegistry())
@ -112,6 +114,8 @@ func getQueryBaseapp(t *testing.T) *baseapp.BaseApp {
}
func NewBaseAppSuiteWithSnapshots(t *testing.T, cfg SnapshotsConfig, opts ...func(*baseapp.BaseApp)) *BaseAppSuite {
t.Helper()
snapshotTimeout := 1 * time.Minute
snapshotStore, err := snapshots.NewStore(dbm.NewMemDB(), testutil.GetTempDir(t))
require.NoError(t, err)
@ -140,7 +144,7 @@ func NewBaseAppSuiteWithSnapshots(t *testing.T, cfg SnapshotsConfig, opts ...fun
_, _, addr := testdata.KeyTestPubAddr()
txs := [][]byte{}
for txNum := 0; txNum < cfg.blockTxs; txNum++ {
msgs := []sdk.Msg{}
var msgs []sdk.Msg
for msgNum := 0; msgNum < 100; msgNum++ {
key := []byte(fmt.Sprintf("%v", keyCounter))
value := make([]byte, 10000)
@ -153,7 +157,7 @@ func NewBaseAppSuiteWithSnapshots(t *testing.T, cfg SnapshotsConfig, opts ...fun
}
builder := suite.txConfig.NewTxBuilder()
builder.SetMsgs(msgs...)
require.NoError(t, builder.SetMsgs(msgs...))
setTxSignature(t, builder, 0)
txBytes, err := suite.txConfig.TxEncoder()(builder.GetTx())
@ -294,6 +298,8 @@ func TestSetLoader(t *testing.T) {
}
initStore := func(t *testing.T, db dbm.DB, storeKey string, k, v []byte) {
t.Helper()
rs := rootmulti.NewStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics())
rs.SetPruning(pruningtypes.NewPruningOptions(pruningtypes.PruningNothing))
@ -314,6 +320,8 @@ func TestSetLoader(t *testing.T) {
}
checkStore := func(t *testing.T, db dbm.DB, ver int64, storeKey string, k, v []byte) {
t.Helper()
rs := rootmulti.NewStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics())
rs.SetPruning(pruningtypes.NewPruningOptions(pruningtypes.PruningDefault))
@ -549,7 +557,8 @@ func TestCustomRunTxPanicHandler(t *testing.T) {
require.PanicsWithValue(t, customPanicMsg, func() {
bz, err := suite.txConfig.TxEncoder()(tx)
require.NoError(t, err)
suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: 1, Txs: [][]byte{bz}})
_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: 1, Txs: [][]byte{bz}})
require.Error(t, err)
})
}
}
@ -623,7 +632,8 @@ func TestBaseAppAnteHandler(t *testing.T) {
require.Equal(t, int64(2), getIntFromStore(t, store, anteKey))
require.Equal(t, int64(1), getIntFromStore(t, store, deliverKey))
suite.baseApp.Commit()
_, err = suite.baseApp.Commit()
require.NoError(t, err)
}
func TestBaseAppPostHandler(t *testing.T) {
@ -869,16 +879,16 @@ func TestGetMaximumBlockGas(t *testing.T) {
ctx := suite.baseApp.NewContext(true)
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 0}})
require.NoError(t, suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 0}}))
require.Equal(t, uint64(0), suite.baseApp.GetMaximumBlockGas(ctx))
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -1}})
require.NoError(t, suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -1}}))
require.Equal(t, uint64(0), suite.baseApp.GetMaximumBlockGas(ctx))
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 5000000}})
require.NoError(t, suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 5000000}}))
require.Equal(t, uint64(5000000), suite.baseApp.GetMaximumBlockGas(ctx))
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -5000000}})
require.NoError(t, suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -5000000}}))
require.Panics(t, func() { suite.baseApp.GetMaximumBlockGas(ctx) })
}

1
baseapp/grpcrouter_test.go
View File

@ -162,6 +162,7 @@ func TestQueryDataRaces_uniqueConnectionsToSameHandler(t *testing.T) {
}
func testQueryDataRacesSameHandler(t *testing.T, makeClientConn func(*baseapp.GRPCQueryRouter) *baseapp.QueryServiceTestHelper) {
t.Helper()
t.Parallel()
qr := baseapp.NewGRPCQueryRouter()

1
baseapp/snapshot_test.go
View File

@ -245,7 +245,6 @@ func TestABCI_OfferSnapshot_Errors(t *testing.T) {
}, abci.ResponseOfferSnapshot_REJECT},
}
for name, tc := range testCases {
tc := tc
t.Run(name, func(t *testing.T) {
resp, err := suite.baseApp.OfferSnapshot(&abci.RequestOfferSnapshot{Snapshot: tc.snapshot})
require.NoError(t, err)

15
baseapp/streaming_test.go
View File

@ -51,11 +51,12 @@ func TestABCI_MultiListener_StateChanges(t *testing.T) {
addListenerOpt := func(bapp *baseapp.BaseApp) { bapp.CommitMultiStore().AddListeners([]storetypes.StoreKey{distKey1}) }
suite := NewBaseAppSuite(t, anteOpt, distOpt, streamingManagerOpt, addListenerOpt)
suite.baseApp.InitChain(
_, err := suite.baseApp.InitChain(
&abci.RequestInitChain{
ConsensusParams: &tmproto.ConsensusParams{},
},
)
require.NoError(t, err)
deliverKey := []byte("deliver-key")
baseapptestutil.RegisterCounterServer(suite.baseApp.MsgServiceRouter(), CounterServerImpl{t, capKey1, deliverKey})
@ -103,7 +104,8 @@ func TestABCI_MultiListener_StateChanges(t *testing.T) {
// require.Equal(t, sdk.MarkEventsToIndex(counterEvent(sdk.EventTypeMessage, counter).ToABCIEvents(), map[string]struct{}{})[0], events[2], "msg handler update counter event")
}
suite.baseApp.Commit()
_, err = suite.baseApp.Commit()
require.NoError(t, err)
require.Equal(t, expectedChangeSet, mockListener1.ChangeSet, "should contain the same changeSet")
require.Equal(t, expectedChangeSet, mockListener2.ChangeSet, "should contain the same changeSet")
@ -119,9 +121,10 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
addListenerOpt := func(bapp *baseapp.BaseApp) { bapp.CommitMultiStore().AddListeners([]storetypes.StoreKey{distKey1}) }
suite := NewBaseAppSuite(t, streamingManagerOpt, addListenerOpt)
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
ConsensusParams: &tmproto.ConsensusParams{},
})
require.NoError(t, err)
ctx := getFinalizeBlockStateCtx(suite.baseApp)
sm := ctx.StreamingManager()
@ -133,7 +136,8 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
for blockN := 0; blockN < nBlocks; blockN++ {
suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: int64(blockN) + 1})
_, err := suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: int64(blockN) + 1})
require.NoError(t, err)
ctx := getFinalizeBlockStateCtx(suite.baseApp)
sm := ctx.StreamingManager()
@ -141,6 +145,7 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
require.Equal(t, listeners, sm.ABCIListeners, fmt.Sprintf("should contain same listeners: %v", listeners))
require.Equal(t, true, sm.StopNodeOnErr, "should contain StopNodeOnErr = true")
suite.baseApp.Commit()
_, err = suite.baseApp.Commit()
require.NoError(t, err)
}
}

28
baseapp/utils_test.go
View File

@ -168,6 +168,8 @@ func incrementCounter(ctx context.Context,
deliverKey []byte,
msg sdk.Msg,
) (*baseapptestutil.MsgCreateCounterResponse, error) {
t.Helper()
sdkCtx := sdk.UnwrapSDKContext(ctx)
store := sdkCtx.KVStore(capKey)
@ -210,6 +212,8 @@ func counterEvent(evType string, msgCount int64) sdk.Events {
}
func anteHandlerTxTest(t *testing.T, capKey storetypes.StoreKey, storeKey []byte) sdk.AnteHandler {
t.Helper()
return func(ctx sdk.Context, tx sdk.Tx, simulate bool) (sdk.Context, error) {
store := ctx.KVStore(capKey)
counter, failOnAnte := parseTxMemo(t, tx)
@ -233,6 +237,8 @@ func anteHandlerTxTest(t *testing.T, capKey storetypes.StoreKey, storeKey []byte
}
func incrementingCounter(t *testing.T, store storetypes.KVStore, counterKey []byte, counter int64) (*sdk.Result, error) {
t.Helper()
storedCounter := getIntFromStore(t, store, counterKey)
require.Equal(t, storedCounter, counter)
setIntOnStore(store, counterKey, counter+1)
@ -283,6 +289,8 @@ func (ps paramStore) Get(_ context.Context) (cmtproto.ConsensusParams, error) {
}
func setTxSignature(t *testing.T, builder client.TxBuilder, nonce uint64) {
t.Helper()
privKey := secp256k1.GenPrivKeyFromSecret([]byte("test"))
pubKey := privKey.PubKey()
err := builder.SetSignatures(
@ -296,6 +304,8 @@ func setTxSignature(t *testing.T, builder client.TxBuilder, nonce uint64) {
}
func testLoadVersionHelper(t *testing.T, app *baseapp.BaseApp, expectedHeight int64, expectedID storetypes.CommitID) {
t.Helper()
lastHeight := app.LastBlockHeight()
lastID := app.LastCommitID()
require.Equal(t, expectedHeight, lastHeight)
@ -317,6 +327,8 @@ func getFinalizeBlockStateCtx(app *baseapp.BaseApp) sdk.Context {
}
func parseTxMemo(t *testing.T, tx sdk.Tx) (counter int64, failOnAnte bool) {
t.Helper()
txWithMemo, ok := tx.(sdk.TxWithMemo)
require.True(t, ok)
@ -332,6 +344,8 @@ func parseTxMemo(t *testing.T, tx sdk.Tx) (counter int64, failOnAnte bool) {
}
func newTxCounter(t *testing.T, cfg client.TxConfig, counter int64, msgCounters ...int64) signing.Tx {
t.Helper()
_, _, addr := testdata.KeyTestPubAddr()
msgs := make([]sdk.Msg, 0, len(msgCounters))
for _, c := range msgCounters {
@ -340,7 +354,7 @@ func newTxCounter(t *testing.T, cfg client.TxConfig, counter int64, msgCounters
}
builder := cfg.NewTxBuilder()
builder.SetMsgs(msgs...)
require.NoError(t, builder.SetMsgs(msgs...))
builder.SetMemo("counter=" + strconv.FormatInt(counter, 10) + "&failOnAnte=false")
setTxSignature(t, builder, uint64(counter))
@ -348,6 +362,8 @@ func newTxCounter(t *testing.T, cfg client.TxConfig, counter int64, msgCounters
}
func getIntFromStore(t *testing.T, store storetypes.KVStore, key []byte) int64 {
t.Helper()
bz := store.Get(key)
if len(bz) == 0 {
return 0
@ -360,8 +376,10 @@ func getIntFromStore(t *testing.T, store storetypes.KVStore, key []byte) int64 {
}
func setFailOnAnte(t *testing.T, cfg client.TxConfig, tx signing.Tx, failOnAnte bool) signing.Tx {
t.Helper()
builder := cfg.NewTxBuilder()
builder.SetMsgs(tx.GetMsgs()...)
require.NoError(t, builder.SetMsgs(tx.GetMsgs()...))
memo := tx.GetMemo()
vals, err := url.ParseQuery(memo)
@ -387,12 +405,16 @@ func setFailOnHandler(cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx
}
}
builder.SetMsgs(msgs...)
if err := builder.SetMsgs(msgs...); err != nil {
panic(err)
}
return builder.GetTx()
}
// wonkyMsg is to be used to run a MsgCounter2 message when the MsgCounter2 handler is not registered.
func wonkyMsg(t *testing.T, cfg client.TxConfig, tx signing.Tx) signing.Tx {
t.Helper()
t.Helper()
builder := cfg.NewTxBuilder()
builder.SetMemo(tx.GetMemo())

8
client/config/config.go
View File

@ -75,7 +75,7 @@ func ReadFromClientConfig(ctx client.Context) (client.Context, error) {
// when client.toml does not exist create and init with default values
if _, err := os.Stat(configFilePath); os.IsNotExist(err) {
if err := os.MkdirAll(configPath, os.ModePerm); err != nil {
return ctx, fmt.Errorf("couldn't make client config: %v", err)
return ctx, fmt.Errorf("couldn't make client config: %w", err)
}
if ctx.ChainID != "" {
@ -83,13 +83,13 @@ func ReadFromClientConfig(ctx client.Context) (client.Context, error) {
}
if err := writeConfigToFile(configFilePath, conf); err != nil {
return ctx, fmt.Errorf("could not write client config to the file: %v", err)
return ctx, fmt.Errorf("could not write client config to the file: %w", err)
}
}
conf, err := getClientConfig(configPath, ctx.Viper)
if err != nil {
return ctx, fmt.Errorf("couldn't get client config: %v", err)
return ctx, fmt.Errorf("couldn't get client config: %w", err)
}
// we need to update KeyringDir field on Client Context first cause it is used in NewKeyringFromBackend
ctx = ctx.WithOutputFormat(conf.Output).
@ -106,7 +106,7 @@ func ReadFromClientConfig(ctx client.Context) (client.Context, error) {
// https://github.com/cosmos/cosmos-sdk/issues/8986
client, err := client.NewClientFromNode(conf.Node)
if err != nil {
return ctx, fmt.Errorf("couldn't get client from nodeURI: %v", err)
return ctx, fmt.Errorf("couldn't get client from nodeURI: %w", err)
}
ctx = ctx.WithNodeURI(conf.Node).

14
client/debug/main.go
View File

@ -16,7 +16,7 @@ import (
"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
sdk "github.com/cosmos/cosmos-sdk/types"
legacybech32 "github.com/cosmos/cosmos-sdk/types/bech32/legacybech32" //nolint:staticcheck // we do old keys, they're keys after all.
"github.com/cosmos/cosmos-sdk/types/bech32/legacybech32" //nolint:staticcheck // retain for debug purposes
"github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/version"
)
@ -157,17 +157,17 @@ func getPubKeyFromRawString(pkstr, keytype string) (cryptotypes.PubKey, error) {
}
}
pk, err := legacybech32.UnmarshalPubKey(legacybech32.AccPK, pkstr) //nolint:staticcheck // we do old keys, they're keys after all.
pk, err := legacybech32.UnmarshalPubKey(legacybech32.AccPK, pkstr)
if err == nil {
return pk, nil
}
pk, err = legacybech32.UnmarshalPubKey(legacybech32.ValPK, pkstr) //nolint:staticcheck // we do old keys, they're keys after all.
pk, err = legacybech32.UnmarshalPubKey(legacybech32.ValPK, pkstr)
if err == nil {
return pk, nil
}
pk, err = legacybech32.UnmarshalPubKey(legacybech32.ConsPK, pkstr) //nolint:staticcheck // we do old keys, they're keys after all.
pk, err = legacybech32.UnmarshalPubKey(legacybech32.ConsPK, pkstr)
if err == nil {
return pk, nil
}
@ -206,7 +206,7 @@ func PubkeyRawCmd() *cobra.Command {
var consensusPub string
edPK, ok := pk.(*ed25519.PubKey)
if ok && pubkeyType == ed {
consensusPub, err = legacybech32.MarshalPubKey(legacybech32.ConsPK, edPK) //nolint:staticcheck // we do old keys, they're keys after all.
consensusPub, err = legacybech32.MarshalPubKey(legacybech32.ConsPK, edPK)
if err != nil {
return err
}
@ -219,11 +219,11 @@ func PubkeyRawCmd() *cobra.Command {
if err != nil {
return err
}
accPub, err := legacybech32.MarshalPubKey(legacybech32.AccPK, pk) //nolint:staticcheck // we do old keys, they're keys after all.
accPub, err := legacybech32.MarshalPubKey(legacybech32.AccPK, pk)
if err != nil {
return err
}
valPub, err := legacybech32.MarshalPubKey(legacybech32.ValPK, pk) //nolint:staticcheck // we do old keys, they're keys after all.
valPub, err := legacybech32.MarshalPubKey(legacybech32.ValPK, pk)
if err != nil {
return err
}

1
client/flags/flags_test.go
View File

@ -22,7 +22,6 @@ func TestParseGasSetting(t *testing.T) {
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
gs, err := flags.ParseGasSetting(tc.input)

2
client/grpc/cmtservice/autocli.go
View File

@ -51,7 +51,7 @@ var CometBFTAutoCLIDescriptor = &autocliv1.ServiceCommandDescriptor{
// NewCometBFTCommands is a fake `appmodule.Module` to be considered as a module
// and be added in AutoCLI.
func NewCometBFTCommands() *cometModule { //nolint:revive // fake module and limiting import of core
func NewCometBFTCommands() *cometModule {
return &cometModule{}
}

9
client/grpc_query_test.go
View File

@ -83,18 +83,19 @@ func (s *IntegrationTestSuite) SetupSuite() {
s.NoError(err)
// init chain will set the validator set and initialize the genesis accounts
app.InitChain(&abci.RequestInitChain{
_, err = app.InitChain(&abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
ConsensusParams: sims.DefaultConsensusParams,
AppStateBytes: stateBytes,
},
)
})
s.NoError(err)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
NextValidatorsHash: valSet.Hash(),
})
s.NoError(err)
// end of app init

2
client/keys/add.go
View File

@ -375,7 +375,7 @@ func printCreate(cmd *cobra.Command, k *keyring.Record, showMnemonic bool, mnemo
// print mnemonic unless requested not to.
if showMnemonic {
if _, err := fmt.Fprintf(cmd.ErrOrStderr(), "\n**Important** write this mnemonic phrase in a safe place.\nIt is the only way to recover your account if you ever forget your password.\n\n%s\n", mnemonic); err != nil {
return fmt.Errorf("failed to print mnemonic: %v", err)
return fmt.Errorf("failed to print mnemonic: %w", err)
}
}
case flags.OutputFormatJSON:

1
client/keys/add_ledger_test.go
View File

@ -163,7 +163,6 @@ func Test_runAddCmdLedgerDryRun(t *testing.T) {
}
for _, tt := range testData {
tt := tt
t.Run(tt.name, func(t *testing.T) {
cmd := AddKeyCommand()
cmd.Flags().AddFlagSet(Commands().PersistentFlags())

1
client/keys/add_test.go
View File

@ -202,7 +202,6 @@ func Test_runAddCmdDryRun(t *testing.T) {
},
}
for _, tt := range testData {
tt := tt
t.Run(tt.name, func(t *testing.T) {
cmd := AddKeyCommand()
cmd.Flags().AddFlagSet(Commands().PersistentFlags())

3
client/keys/list_test.go
View File

@ -20,6 +20,8 @@ import (
)
func cleanupKeys(t *testing.T, kb keyring.Keyring, keys ...string) func() {
t.Helper()
return func() {
for _, k := range keys {
if err := kb.Delete(k); err != nil {
@ -59,7 +61,6 @@ func Test_runListCmd(t *testing.T) {
{"keybase: w/key", kbHome2, false},
}
for _, tt := range testData {
tt := tt
t.Run(tt.name, func(t *testing.T) {
cmd.SetArgs([]string{
fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, tt.kbDir),

1
client/keys/parse_test.go
View File

@ -25,7 +25,6 @@ func TestParseKey(t *testing.T) {
{"hex", []string{hexstr}, false},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
require.Equal(t, tt.wantErr, doParseKey(ParseKeyStringCommand(), config, tt.args) != nil)
})

4
client/keys/show.go
View File

@ -66,14 +66,14 @@ func runShowCmd(cmd *cobra.Command, args []string) (err error) {
if len(args) == 1 {
k, err = fetchKey(clientCtx.Keyring, args[0])
if err != nil {
return fmt.Errorf("%s is not a valid name or address: %v", args[0], err)
return fmt.Errorf("%s is not a valid name or address: %w", args[0], err)
}
} else {
pks := make([]cryptotypes.PubKey, len(args))
for i, keyref := range args {
k, err := fetchKey(clientCtx.Keyring, keyref)
if err != nil {
return fmt.Errorf("%s is not a valid name or address: %v", keyref, err)
return fmt.Errorf("%s is not a valid name or address: %w", keyref, err)
}
key, err := k.GetPubKey()
if err != nil {

2
client/keys/show_test.go
View File

@ -215,7 +215,6 @@ func Test_validateMultisigThreshold(t *testing.T) {
{"1-2", args{2, 1}, true},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
if err := validateMultisigThreshold(tt.args.k, tt.args.nKeys); (err != nil) != tt.wantErr {
t.Errorf("validateMultisigThreshold() error = %v, wantErr %v", err, tt.wantErr)
@ -241,7 +240,6 @@ func Test_getBechKeyOut(t *testing.T) {
{"cons", args{sdk.PrefixConsensus}, MkConsKeyOutput, false},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
got, err := getBechKeyOut(tt.args.bechPrefix)
if tt.wantErr {

3
client/snapshot/load.go
View File

@ -4,6 +4,7 @@ import (
"archive/tar"
"bytes"
"compress/gzip"
"errors"
"fmt"
"io"
"os"
@ -77,7 +78,7 @@ func LoadArchiveCmd() *cobra.Command {
for i := uint32(0); i < snapshot.Chunks; i++ {
hdr, err = tr.Next()
if err != nil {
if err == io.EOF {
if errors.Is(err, io.EOF) {
break
}
return err

2
client/tx/aux_builder_test.go
View File

@ -229,6 +229,8 @@ func TestAuxTxBuilder(t *testing.T) {
// checkCorrectData that the auxSignerData's content matches the inputs we gave.
func checkCorrectData(t *testing.T, cdc codec.Codec, auxSignerData typestx.AuxSignerData, signMode signing.SignMode) {
t.Helper()
pkAny, err := codectypes.NewAnyWithValue(pub1)
require.NoError(t, err)
msgAny, err := codectypes.NewAnyWithValue(msg1)

11
client/tx/tx_test.go
View File

@ -74,7 +74,6 @@ func TestCalculateGas(t *testing.T) {
}
for _, tc := range testCases {
stc := tc
txCfg, _ := newTestTxConfig()
defaultSignMode, err := signing.APISignModeToInternal(txCfg.SignModeHandler().DefaultMode())
require.NoError(t, err)
@ -83,16 +82,16 @@ func TestCalculateGas(t *testing.T) {
WithChainID("test-chain").
WithTxConfig(txCfg).WithSignMode(defaultSignMode)
t.Run(stc.name, func(t *testing.T) {
t.Run(tc.name, func(t *testing.T) {
mockClientCtx := mockContext{
gasUsed: tc.args.mockGasUsed,
wantErr: tc.args.mockWantErr,
}
simRes, gotAdjusted, err := CalculateGas(mockClientCtx, txf.WithGasAdjustment(stc.args.adjustment))
if stc.expPass {
simRes, gotAdjusted, err := CalculateGas(mockClientCtx, txf.WithGasAdjustment(tc.args.adjustment))
if tc.expPass {
require.NoError(t, err)
require.Equal(t, simRes.GasInfo.GasUsed, stc.wantEstimate)
require.Equal(t, gotAdjusted, stc.wantAdjusted)
require.Equal(t, simRes.GasInfo.GasUsed, tc.wantEstimate)
require.Equal(t, gotAdjusted, tc.wantAdjusted)
require.NotNil(t, simRes.Result)
} else {
require.Error(t, err)

1
client/utils_test.go
View File

@ -67,7 +67,6 @@ func TestPaginate(t *testing.T) {
}
for i, tc := range testCases {
i, tc := i, tc
t.Run(tc.name, func(t *testing.T) {
start, end := client.Paginate(tc.numObjs, tc.page, tc.limit, tc.defLimit)
require.Equal(t, tc.expectedStart, start, "invalid result; test case #%d", i)

2
client/v2/autocli/common_test.go
View File

@ -48,7 +48,7 @@ func initFixture(t *testing.T) *fixture {
}
}()
clientConn, err := grpc.Dial(listener.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
clientConn, err := grpc.NewClient(listener.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
assert.NilError(t, err)
encodingConfig := moduletestutil.MakeTestEncodingConfig(bank.AppModuleBasic{})

5
client/v2/autocli/keyring/keyring.go
View File

@ -14,13 +14,14 @@ var KeyringContextKey struct{}
var _ Keyring = &KeyringImpl{}
type KeyringImpl struct { //nolint:revive // stuttering is fine
type KeyringImpl struct {
k Keyring
}
// NewKeyringInContext returns a new context with the keyring set.
func NewKeyringInContext(ctx context.Context, k Keyring) context.Context {
return context.WithValue(ctx, KeyringContextKey, NewKeyringImpl(k))
// TODO: should this be fixed?
return context.WithValue(ctx, KeyringContextKey, NewKeyringImpl(k)) //nolint:staticcheck // we can ignore this safely until we make a fix for this
}
func NewKeyringImpl(k Keyring) *KeyringImpl {

6
client/v2/internal/strcase/kebab_test.go
View File

@ -8,7 +8,9 @@ import (
"cosmossdk.io/client/v2/internal/strcase"
)
func toKebab(t testing.TB) {
func toKebab(tb testing.TB) {
tb.Helper()
cases := [][]string{
{"testCase", "test-case"},
{"TestCase", "test-case"},
@ -28,7 +30,7 @@ func toKebab(t testing.TB) {
in := i[0]
out := i[1]
result := strcase.ToKebab(in)
assert.Equal(t, out, result, "ToKebab(%s) = %s, want %s", in, result, out)
assert.Equal(tb, out, result, "ToKebab(%s) = %s, want %s", in, result, out)
}
}

1
codec/amino_codec_test.go
View File

@ -71,7 +71,6 @@ func TestAminoCodecMarshalJSONIndent(t *testing.T) {
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
cdc := codec.NewAminoCodec(createTestCodec())
bz, err := cdc.MarshalJSONIndent(tc.input, "", " ")

8
codec/codec_common_test.go
View File

@ -92,7 +92,9 @@ func testMarshaling(t *testing.T, cdc interface {
codec.JSONCodec
},
) {
any, err := types.NewAnyWithValue(&testdata.Dog{Name: "rufus"})
t.Helper()
cdcAny, err := types.NewAnyWithValue(&testdata.Dog{Name: "rufus"})
require.NoError(t, err)
testCases := []testCase{
@ -113,8 +115,8 @@ func testMarshaling(t *testing.T, cdc interface {
if _, ok := cdc.(*codec.AminoCodec); ok {
testCases = append(testCases, testCase{
"any marshaling",
&testdata.HasAnimal{Animal: any},
&testdata.HasAnimal{Animal: any},
&testdata.HasAnimal{Animal: cdcAny},
&testdata.HasAnimal{Animal: cdcAny},
false,
false,
})

1
codec/types/any.go
View File

@ -11,7 +11,6 @@ import (
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
// nolint:revive // XXX is reqired for proto compatibility
type Any struct {
// A URL/resource name that uniquely identifies the type of the serialized
// protocol buffer message. This string must contain at least

2
codec/types/any_internal_test.go
View File

@ -17,7 +17,7 @@ func (d Dog) Greet() string { return d.Name }
func (d *Dog) Reset() { d.Name = "" }
func (d *Dog) String() string { return d.Name }
func (d *Dog) ProtoMessage() {}
func (d *Dog) XXX_MessageName() string { return "tests/dog" } //nolint:revive // XXX_ prefix is required
func (d *Dog) XXX_MessageName() string { return "tests/dog" }
type Animal interface {
Greet() string

2
codec/types/any_test.go
View File

@ -19,7 +19,7 @@ var _ proto.Message = (*errOnMarshal)(nil)
var errAlways = fmt.Errorf("always erroring")
func (eom *errOnMarshal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { //nolint:revive // XXX_ prefix is intentional
func (eom *errOnMarshal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return nil, errAlways
}

2
codec/types/types_test.go
View File

@ -44,7 +44,7 @@ var (
func (dog FakeDog) Reset() {}
func (dog FakeDog) String() string { return "fakedog" }
func (dog FakeDog) ProtoMessage() {}
func (dog FakeDog) XXX_MessageName() string { return proto.MessageName(&testdata.Dog{}) } //nolint:revive // XXX_ prefix is intentional
func (dog FakeDog) XXX_MessageName() string { return proto.MessageName(&testdata.Dog{}) }
func (dog FakeDog) Greet() string { return "fakedog" }
func TestRegister(t *testing.T) {

2
codec/unknownproto/benchmarks_test.go
View File

@ -51,6 +51,7 @@ func BenchmarkRejectUnknownFields_parallel(b *testing.B) {
}
func benchmarkRejectUnknownFields(b *testing.B, parallel bool) {
b.Helper()
b.ReportAllocs()
if !parallel {
@ -89,6 +90,7 @@ func BenchmarkProtoUnmarshal_parallel(b *testing.B) {
}
func benchmarkProtoUnmarshal(b *testing.B, parallel bool) {
b.Helper()
b.ReportAllocs()
if !parallel {

1
codec/unknownproto/unit_helpers_test.go
View File

@ -22,7 +22,6 @@ func TestWireTypeToString(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(fmt.Sprintf("wireType=%d", tt.typ), func(t *testing.T) {
if g, w := wireTypeToString(tt.typ), tt.want; g != w {
t.Fatalf("Mismatch:\nGot: %q\nWant: %q\n", g, w)

4
codec/unknownproto/unknown_fields_test.go
View File

@ -223,7 +223,6 @@ func TestRejectUnknownFieldsRepeated(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
protoBlob, err := proto.Marshal(tt.in)
if err != nil {
@ -280,7 +279,6 @@ func TestRejectUnknownFields_allowUnknownNonCriticals(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
blob, err := proto.Marshal(tt.in)
if err != nil {
@ -483,7 +481,6 @@ func TestRejectUnknownFieldsNested(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
protoBlob, err := proto.Marshal(tt.in)
if err != nil {
@ -634,7 +631,6 @@ func TestRejectUnknownFieldsFlat(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
blob, err := proto.Marshal(tt.in)
if err != nil {

11
crypto/armor.go
View File

@ -3,6 +3,7 @@ package crypto
import (
"bytes"
"encoding/hex"
"errors"
"fmt"
"io"
@ -104,7 +105,7 @@ func UnarmorInfoBytes(armorStr string) ([]byte, error) {
func UnarmorPubKeyBytes(armorStr string) (bz []byte, algo string, err error) {
bz, header, err := unarmorBytes(armorStr, blockTypePubKey)
if err != nil {
return nil, "", fmt.Errorf("couldn't unarmor bytes: %v", err)
return nil, "", fmt.Errorf("couldn't unarmor bytes: %w", err)
}
switch header[headerVersion] {
@ -240,7 +241,7 @@ func decryptPrivKey(saltBytes, encBytes []byte, passphrase, kdf string) (privKey
key = crypto.Sha256(key) // Get 32 bytes
privKeyBytes, err = xsalsa20symmetric.DecryptSymmetric(encBytes, key)
if err == xsalsa20symmetric.ErrCiphertextDecrypt {
if errors.Is(err, xsalsa20symmetric.ErrCiphertextDecrypt) {
return privKey, sdkerrors.ErrWrongPassword
}
default:
@ -261,15 +262,15 @@ func EncodeArmor(blockType string, headers map[string]string, data []byte) strin
buf := new(bytes.Buffer)
w, err := armor.Encode(buf, blockType, headers)
if err != nil {
panic(fmt.Errorf("could not encode ascii armor: %s", err))
panic(fmt.Errorf("could not encode ascii armor: %w", err))
}
_, err = w.Write(data)
if err != nil {
panic(fmt.Errorf("could not encode ascii armor: %s", err))
panic(fmt.Errorf("could not encode ascii armor: %w", err))
}
err = w.Close()
if err != nil {
panic(fmt.Errorf("could not encode ascii armor: %s", err))
panic(fmt.Errorf("could not encode ascii armor: %w", err))
}
return buf.String()
}

4
crypto/armor_test.go
View File

@ -43,7 +43,7 @@ func TestArmorUnarmorPrivKey(t *testing.T) {
// empty string
decrypted, algo, err = crypto.UnarmorDecryptPrivKey("", "passphrase")
require.Error(t, err)
require.True(t, errors.Is(io.EOF, err))
require.True(t, errors.Is(err, io.EOF))
require.Nil(t, decrypted)
require.Empty(t, algo)
@ -165,7 +165,7 @@ func TestArmorInfoBytes(t *testing.T) {
func TestUnarmorInfoBytesErrors(t *testing.T) {
unarmoredBytes, err := crypto.UnarmorInfoBytes("")
require.Error(t, err)
require.True(t, errors.Is(io.EOF, err))
require.True(t, errors.Is(err, io.EOF))
require.Nil(t, unarmoredBytes)
header := map[string]string{

2
crypto/hd/fundraiser_test.go
View File

@ -29,6 +29,8 @@ func TestFullFundraiserPath(t *testing.T) {
}
func initFundraiserTestVectors(t *testing.T) []addrData {
t.Helper()
// NOTE: atom fundraiser address
// var hdPath string = "m/44'/118'/0'/0/0"
var hdToAddrTable []addrData

4
crypto/hd/hdpath_test.go
View File

@ -106,9 +106,7 @@ func TestCreateHDPath(t *testing.T) {
{"m/44'/114'/1'/1/0", args{114, 1, 1}, hd.BIP44Params{Purpose: 44, CoinType: 114, Account: 1, AddressIndex: 1}},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
tt := tt
require.Equal(t, tt.want, *hd.CreateHDPath(tt.args.coinType, tt.args.account, tt.args.index))
})
}
@ -169,7 +167,6 @@ func TestDeriveHDPathRange(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.path, func(t *testing.T) {
master, ch := hd.ComputeMastersFromSeed(seed)
_, err := hd.DerivePrivateKeyForPath(master, ch, tt.path)
@ -298,7 +295,6 @@ func TestDerivePrivateKeyForPathDoNotCrash(t *testing.T) {
}
for _, path := range paths {
path := path
t.Run(path, func(t *testing.T) {
_, _ = hd.DerivePrivateKeyForPath([32]byte{}, [32]byte{}, path)
})

4
crypto/keyring/keyring.go
View File

@ -530,7 +530,7 @@ func (ks keystore) KeyByAddress(address sdk.Address) (*Record, error) {
}
func wrapKeyNotFound(err error, msg string) error {
if err == keyring.ErrKeyNotFound {
if errors.Is(err, keyring.ErrKeyNotFound) {
return errorsmod.Wrap(sdkerrors.ErrKeyNotFound, msg)
}
return err
@ -628,7 +628,7 @@ func SignWithLedger(k *Record, msg []byte, signMode signing.SignMode) (sig []byt
priv, err := ledger.NewPrivKeySecp256k1Unsafe(*path)
if err != nil {
return
return nil, nil, err
}
ledgerPubKey := priv.PubKey()
pubKey, err := k.GetPubKey()

11
crypto/keyring/keyring_test.go
View File

@ -930,7 +930,8 @@ func TestImportPubKey(t *testing.T) {
if tt.expectedErr == nil {
require.NoError(t, err)
} else {
require.Equal(t, err, tt.expectedErr)
require.Error(t, err)
require.Contains(t, err.Error(), tt.expectedErr.Error())
}
})
}
@ -2037,6 +2038,8 @@ func TestChangeBcrypt(t *testing.T) {
}
func requireEqualRenamedKey(t *testing.T, key, mnemonic *Record, nameMatch bool) {
t.Helper()
if nameMatch {
require.Equal(t, key.Name, mnemonic.Name)
}
@ -2055,6 +2058,8 @@ func requireEqualRenamedKey(t *testing.T, key, mnemonic *Record, nameMatch bool)
}
func newKeyring(t *testing.T, name string) Keyring {
t.Helper()
cdc := getCodec()
kr, err := New(name, "test", t.TempDir(), nil, cdc)
require.NoError(t, err)
@ -2062,12 +2067,16 @@ func newKeyring(t *testing.T, name string) Keyring {
}
func newKeyRecord(t *testing.T, kr Keyring, name string) *Record {
t.Helper()
k, _, err := kr.NewMnemonic(name, English, sdk.FullFundraiserPath, DefaultBIP39Passphrase, hd.Secp256k1)
require.NoError(t, err)
return k
}
func assertKeysExist(t *testing.T, kr Keyring, names ...string) {
t.Helper()
for _, n := range names {
_, err := kr.Key(n)
require.NoError(t, err)

1
crypto/keyring/signing_algorithms_test.go
View File

@ -36,7 +36,6 @@ func TestNewSigningAlgoByString(t *testing.T) {
list := SigningAlgoList{hd.Secp256k1}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
algorithm, err := NewSigningAlgoFromString(tt.algoStr, list)
if tt.isSupported {

2
crypto/keys/multisig/amino.go
View File

@ -66,7 +66,7 @@ func tmToProto(tmPk tmMultisig) (*LegacyAminoPubKey, error) {
}
// MarshalAminoJSON overrides amino JSON unmarshaling.
func (m LegacyAminoPubKey) MarshalAminoJSON() (tmMultisig, error) { //nolint:golint,revive // we need to override the default amino JSON marshaling
func (m LegacyAminoPubKey) MarshalAminoJSON() (tmMultisig, error) {
return protoToTm(&m)
}

8
crypto/keys/secp256k1/secp256k1.go
View File

@ -10,7 +10,7 @@ import (
"github.com/cometbft/cometbft/crypto"
secp256k1 "github.com/decred/dcrd/dcrec/secp256k1/v4"
"golang.org/x/crypto/ripemd160" //nolint: staticcheck // keep around for backwards compatibility
"golang.org/x/crypto/ripemd160" //nolint // using just for backwards compat
errorsmod "cosmossdk.io/errors"
@ -158,9 +158,9 @@ func (pubKey *PubKey) Address() crypto.Address {
}
sha := sha256.Sum256(pubKey.Key)
hasherRIPEMD160 := ripemd160.New()
hasherRIPEMD160.Write(sha[:]) // does not error
return crypto.Address(hasherRIPEMD160.Sum(nil))
hasherRIPEMD160 := ripemd160.New() //nolint:gosec // keeping around for backwards compatibility
hasherRIPEMD160.Write(sha[:]) // does not error
return hasherRIPEMD160.Sum(nil)
}
// Bytes returns the pubkey byte format.

1
crypto/keys/secp256k1/secp256k1_internal_test.go
View File

@ -27,7 +27,6 @@ func Test_genPrivKey(t *testing.T) {
{"valid because 0 < 1 < N", validOne, false},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
if tt.shouldPanic {
require.Panics(t, func() {

1
crypto/keys/secp256k1/secp256k1_test.go
View File

@ -255,7 +255,6 @@ func TestGenPrivKeyFromSecret(t *testing.T) {
{"another seed used in cosmos tests #3", []byte("")},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
gotPrivKey := secp256k1.GenPrivKeyFromSecret(tt.secret)
require.NotNil(t, gotPrivKey)

2
crypto/ledger/encode_test.go
View File

@ -9,6 +9,8 @@ import (
)
func checkAminoJSON(t *testing.T, src, dst interface{}, isNil bool) {
t.Helper()
// Marshal to JSON bytes.
js, err := cdc.MarshalJSON(src)
require.Nil(t, err, "%+v", err)

2
crypto/ledger/ledger_mock.go
View File

@ -74,7 +74,7 @@ func (mock LedgerSECP256K1Mock) GetAddressPubKeySECP256K1(derivationPath []uint3
// re-serialize in the 33-byte compressed format
cmp, err := secp.ParsePubKey(pk)
if err != nil {
return nil, "", fmt.Errorf("error parsing public key: %v", err)
return nil, "", fmt.Errorf("error parsing public key: %w", err)
}
compressedPublicKey := make([]byte, csecp256k1.PubKeySize)

6
crypto/ledger/ledger_secp256k1.go
View File

@ -316,13 +316,13 @@ func sign(device SECP256K1, pkl PrivKeyLedgerSecp256k1, msg []byte, p2 byte) ([]
func getPubKeyUnsafe(device SECP256K1, path hd.BIP44Params) (types.PubKey, error) {
publicKey, err := device.GetPublicKeySECP256K1(path.DerivationPath())
if err != nil {
return nil, fmt.Errorf("please open the %v app on the Ledger device - error: %v", options.appName, err)
return nil, fmt.Errorf("please open the %v app on the Ledger device - error: %w", options.appName, err)
}
// re-serialize in the 33-byte compressed format
cmp, err := secp.ParsePubKey(publicKey)
if err != nil {
return nil, fmt.Errorf("error parsing public key: %v", err)
return nil, fmt.Errorf("error parsing public key: %w", err)
}
compressedPublicKey := make([]byte, secp256k1.PubKeySize)
@ -352,7 +352,7 @@ func getPubKeyAddrSafe(device SECP256K1, path hd.BIP44Params, hrp string) (types
// re-serialize in the 33-byte compressed format
cmp, err := secp.ParsePubKey(publicKey)
if err != nil {
return nil, "", fmt.Errorf("error parsing public key: %v", err)
return nil, "", fmt.Errorf("error parsing public key: %w", err)
}
compressedPublicKey := make([]byte, secp256k1.PubKeySize)

2
crypto/ledger/ledger_test.go
View File

@ -32,6 +32,8 @@ func TestPublicKeyUnsafe(t *testing.T) {
}
func checkDefaultPubKey(t *testing.T, priv types.LedgerPrivKey) {
t.Helper()
require.NotNil(t, priv)
expectedPkStr := "PubKeySecp256k1{034FEF9CD7C4C63588D3B03FEB5281B9D232CBA34D6F3D71AEE59211FFBFE1FE87}"
require.Equal(t, "eb5ae98721034fef9cd7c4c63588d3b03feb5281b9d232cba34d6f3d71aee59211ffbfe1fe87",

3
crypto/types/compact_bit_array_test.go
View File

@ -206,8 +206,6 @@ func TestCompactBitArrayNumOfTrueBitsBefore(t *testing.T) {
{`"______________xx"`, []int{14, 15}, []int{0, 1}},
}
for tcIndex, tc := range testCases {
tcIndex := tcIndex
t.Run(tc.marshalledBA, func(t *testing.T) {
var bA *CompactBitArray
err := json.Unmarshal([]byte(tc.marshalledBA), &bA)
@ -280,7 +278,6 @@ func TestNewCompactBitArrayCrashWithLimits(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(fmt.Sprintf("%d", tt.in), func(t *testing.T) {
got := NewCompactBitArray(tt.in)
if g := got != nil; g != tt.mustPass {

6
depinject/internal/codegen/file.go
View File

@ -39,11 +39,11 @@ func NewFileGen(file *ast.File, codegenPkgPath string) (*FileGen, error) {
g.idents[decl.Name.Name] = true
case *ast.GenDecl:
for _, spec := range decl.Specs {
switch spec := spec.(type) {
switch specType := spec.(type) {
case *ast.TypeSpec:
g.idents[spec.Name.Name] = true
g.idents[specType.Name.Name] = true
case *ast.ValueSpec:
for _, name := range spec.Names {
for _, name := range specType.Names {
g.idents[name.Name] = true
}
}

2
internal/util.go
View File

@ -7,7 +7,7 @@ import (
func CombineErrors(ret, also error, desc string) error {
if also != nil {
if ret != nil {
ret = fmt.Errorf("%w; %v: %v", ret, desc, also)
ret = fmt.Errorf("%w; %v: %w", ret, desc, also)
} else {
ret = also
}

8
runtime/app.go
View File

@ -82,8 +82,8 @@ func (a *App) RegisterModules(modules ...module.AppModule) error {
if module, ok := appModule.(module.HasServices); ok {
module.RegisterServices(a.configurator)
} else if module, ok := appModule.(appmodule.HasServices); ok {
if err := module.RegisterServices(a.configurator); err != nil {
} else if innerMod, ok := appModule.(appmodule.HasServices); ok {
if err := innerMod.RegisterServices(a.configurator); err != nil {
return err
}
}
@ -178,12 +178,12 @@ func (a *App) EndBlocker(ctx sdk.Context) (sdk.EndBlock, error) {
// Precommiter application updates every commit
func (a *App) Precommiter(ctx sdk.Context) {
a.ModuleManager.Precommit(ctx)
_ = a.ModuleManager.Precommit(ctx)
}
// PrepareCheckStater application updates every commit
func (a *App) PrepareCheckStater(ctx sdk.Context) {
a.ModuleManager.PrepareCheckState(ctx)
_ = a.ModuleManager.PrepareCheckState(ctx)
}
// InitChainer initializes the chain.

41
scripts/go-lint-changes.bash
View File

@ -1,41 +0,0 @@
#!/usr/bin/env bash
set -e -o pipefail
LINT_TAGS="e2e,ledger,test_ledger_mock,system_test,sims"
export LINT_TAGS
REPO_ROOT="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )/.." &> /dev/null && pwd )"
export REPO_ROOT
lint_module() {
local root="$1"
shift
cd "$(dirname "$root")" &&
echo "linting $(grep "^module" go.mod) [$(date -Iseconds -u)]" &&
golangci-lint run ./... -c "${REPO_ROOT}/.golangci.yml" "$@" --new --build-tags=${LINT_TAGS}
}
export -f lint_module
# if LINT_DIFF env is set, only lint the files in the current commit otherwise lint all files
if [[ -z "${LINT_DIFF:-}" ]]; then
find "${REPO_ROOT}" -type f -name go.mod -print0 |
xargs -0 -I{} bash -c 'lint_module "$@"' _ {} "$@"
else
if [[ -z $GIT_DIFF ]]; then
GIT_DIFF=$(git diff --name-only --diff-filter=d | grep \.go$ | grep -v \.pb\.go$) || true
fi
if [[ -z "$GIT_DIFF" ]]; then
echo "no files to lint"
exit 0
fi
for f in $(dirname $(echo "$GIT_DIFF" | tr -d "'") | uniq); do
echo "linting $f [$(date -Iseconds -u)]" &&
cd $f &&
golangci-lint run ./... -c "${REPO_ROOT}/.golangci.yml" "$@" --new --build-tags=${LINT_TAGS} &&
cd $REPO_ROOT
done
fi

11
server/api/server_test.go
View File

@ -5,6 +5,7 @@ import (
"bytes"
"encoding/base64"
"encoding/binary"
"errors"
"fmt"
"io"
"net/http"
@ -221,18 +222,18 @@ func (s *GRPCWebTestSuite) makeGrpcRequest(
for {
grpcPreamble := []byte{0, 0, 0, 0, 0}
readCount, err := reader.Read(grpcPreamble)
if err == io.EOF {
if errors.Is(err, io.EOF) {
break
}
if readCount != 5 || err != nil {
return nil, Trailer{}, nil, fmt.Errorf("Unexpected end of body in preamble: %v", err)
return nil, Trailer{}, nil, fmt.Errorf("unexpected end of body in preamble: %w", err)
}
payloadLength := binary.BigEndian.Uint32(grpcPreamble[1:])
payloadBytes := make([]byte, payloadLength)
readCount, err = reader.Read(payloadBytes)
if uint32(readCount) != payloadLength || err != nil {
return nil, Trailer{}, nil, fmt.Errorf("Unexpected end of msg: %v", err)
return nil, Trailer{}, nil, fmt.Errorf("unexpected end of msg: %w", err)
}
if grpcPreamble[0]&(1<<7) == (1 << 7) { // MSB signifies the trailer parser
trailers = readTrailersFromBytes(s.T(), payloadBytes)
@ -244,6 +245,8 @@ func (s *GRPCWebTestSuite) makeGrpcRequest(
}
func readTrailersFromBytes(t *testing.T, dataBytes []byte) Trailer {
t.Helper()
bufferReader := bytes.NewBuffer(dataBytes)
tp := textproto.NewReader(bufio.NewReader(bufferReader))
@ -262,7 +265,7 @@ func readTrailersFromBytes(t *testing.T, dataBytes []byte) Trailer {
// Second, replace header names because gRPC Web trailer names must be lower-case.
for {
line, err := tp.ReadLine()
if err == io.EOF {
if errors.Is(err, io.EOF) {
break
}
require.NoError(t, err, "failed to read header line")

2
server/export_test.go
View File

@ -93,6 +93,8 @@ func (s *ExportSystem) Run(args ...string) cmdtest.RunResult {
// MustRun wraps (*cmdtest.System).MustRunC, providing e's context.
func (s *ExportSystem) MustRun(t *testing.T, args ...string) cmdtest.RunResult {
t.Helper()
return s.sys.MustRunC(t, s.Ctx, args...)
}

17
server/grpc/gogoreflection/serverreflection.go
View File

@ -39,6 +39,7 @@ package gogoreflection // import "google.golang.org/grpc/reflection"
import (
"bytes"
"compress/gzip"
"errors"
"fmt"
"io"
"log"
@ -188,7 +189,7 @@ func fqn(prefix, name string) string {
// fileDescForType gets the file descriptor for the given type.
// The given type should be a proto message.
func (s *serverReflectionServer) fileDescForType(st reflect.Type) (*dpb.FileDescriptorProto, error) {
m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(protoMessage)
m, ok := reflect.Zero(reflect.PointerTo(st)).Interface().(protoMessage)
if !ok {
return nil, fmt.Errorf("failed to create message from type: %v", st)
}
@ -202,12 +203,12 @@ func (s *serverReflectionServer) fileDescForType(st reflect.Type) (*dpb.FileDesc
func decodeFileDesc(enc []byte) (*dpb.FileDescriptorProto, error) {
raw, err := decompress(enc)
if err != nil {
return nil, fmt.Errorf("failed to decompress enc: %v", err)
return nil, fmt.Errorf("failed to decompress enc: %w", err)
}
fd := new(dpb.FileDescriptorProto)
if err := proto.Unmarshal(raw, fd); err != nil {
return nil, fmt.Errorf("bad descriptor: %v", err)
return nil, fmt.Errorf("bad descriptor: %w", err)
}
return fd, nil
}
@ -216,11 +217,11 @@ func decodeFileDesc(enc []byte) (*dpb.FileDescriptorProto, error) {
func decompress(b []byte) ([]byte, error) {
r, err := gzip.NewReader(bytes.NewReader(b))
if err != nil {
return nil, fmt.Errorf("bad gzipped descriptor: %v", err)
return nil, fmt.Errorf("bad gzipped descriptor: %w", err)
}
out, err := io.ReadAll(r)
if err != nil {
return nil, fmt.Errorf("bad gzipped descriptor: %v", err)
return nil, fmt.Errorf("bad gzipped descriptor: %w", err)
}
return out, nil
}
@ -236,7 +237,7 @@ func typeForName(name string) (reflect.Type, error) {
}
func fileDescContainingExtension(st reflect.Type, ext int32) (*dpb.FileDescriptorProto, error) {
m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(proto.Message)
m, ok := reflect.Zero(reflect.PointerTo(st)).Interface().(proto.Message)
if !ok {
return nil, fmt.Errorf("failed to create message from type: %v", st)
}
@ -251,7 +252,7 @@ func fileDescContainingExtension(st reflect.Type, ext int32) (*dpb.FileDescripto
}
func (s *serverReflectionServer) allExtensionNumbersForType(st reflect.Type) ([]int32, error) {
m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(proto.Message)
m, ok := reflect.Zero(reflect.PointerTo(st)).Interface().(proto.Message)
if !ok {
return nil, fmt.Errorf("failed to create message from type: %v", st)
}
@ -380,7 +381,7 @@ func (s *serverReflectionServer) ServerReflectionInfo(stream rpb.ServerReflectio
sentFileDescriptors := make(map[string]bool)
for {
in, err := stream.Recv()
if err == io.EOF {
if errors.Is(err, io.EOF) {
return nil
}
if err != nil {

2
server/mock/app.go
View File

@ -153,7 +153,7 @@ type MsgServerImpl struct {
capKeyMainStore *storetypes.KVStoreKey
}
func MsgTestHandler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { // nolint: revive // refactor this in a followup pr
func MsgTestHandler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(KVStoreTx)
if err := dec(in); err != nil {
return nil, err

13
server/mock/app_test.go
View File

@ -37,16 +37,19 @@ func TestInitApp(t *testing.T) {
appState, err := AppGenState(nil, genutiltypes.AppGenesis{}, nil)
require.NoError(t, err)
req := abci.RequestInitChain{
res, err := app.InitChain(&abci.RequestInitChain{
AppStateBytes: appState,
}
res, err := app.InitChain(&req)
})
require.NoError(t, err)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Hash: res.AppHash,
Height: 1,
})
app.Commit()
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
// make sure we can query these values
query := abci.RequestQuery{

2
server/pruning_test.go
View File

@ -49,8 +49,6 @@ func TestGetPruningOptionsFromFlags(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(j *testing.T) {
viper.Reset()
viper.SetDefault(FlagPruning, pruningtypes.PruningOptionDefault)

6
server/start.go
View File

@ -242,7 +242,7 @@ func startStandAlone(svrCtx *Context, svrCfg serverconfig.Config, clientCtx clie
cmtApp := NewCometABCIWrapper(app)
svr, err := server.NewServer(addr, transport, cmtApp)
if err != nil {
return fmt.Errorf("error creating listener: %v", err)
return fmt.Errorf("error creating listener: %w", err)
}
svr.SetLogger(servercmtlog.CometLoggerWrapper{Logger: svrCtx.Logger.With("module", "abci-server")})
@ -803,11 +803,11 @@ func testnetify(ctx *Context, testnetAppCreator types.AppCreator, db dbm.DB, tra
_, _, _, _, proxyMetrics, _, _ := metrics(genDoc.ChainID)
proxyApp := proxy.NewAppConns(clientCreator, proxyMetrics)
if err := proxyApp.Start(); err != nil {
return nil, fmt.Errorf("error starting proxy app connections: %v", err)
return nil, fmt.Errorf("error starting proxy app connections: %w", err)
}
res, err := proxyApp.Query().Info(context, proxy.RequestInfo)
if err != nil {
return nil, fmt.Errorf("error calling Info: %v", err)
return nil, fmt.Errorf("error calling Info: %w", err)
}
err = proxyApp.Stop()
if err != nil {

22
server/util_test.go
View File

@ -59,7 +59,7 @@ func TestInterceptConfigsPreRunHandlerCreatesConfigFilesWhenMissing(t *testing.T
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -136,7 +136,7 @@ func TestInterceptConfigsPreRunHandlerReadsConfigToml(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -173,7 +173,7 @@ func TestInterceptConfigsPreRunHandlerReadsAppToml(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -201,7 +201,7 @@ func TestInterceptConfigsPreRunHandlerReadsFlags(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -236,7 +236,7 @@ func TestInterceptConfigsPreRunHandlerReadsEnvVars(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -265,6 +265,8 @@ type precedenceCommon struct {
}
func newPrecedenceCommon(t *testing.T) precedenceCommon {
t.Helper()
retval := precedenceCommon{}
// Determine the env. var. name based off the executable name
@ -306,6 +308,8 @@ func newPrecedenceCommon(t *testing.T) precedenceCommon {
}
func (v precedenceCommon) setAll(t *testing.T, setFlag, setEnvVar, setConfigFile *string) {
t.Helper()
if setFlag != nil {
if err := v.cmd.Flags().Set(v.flagName, *setFlag); err != nil {
t.Fatalf("Failed setting flag %q", v.flagName)
@ -340,7 +344,7 @@ func TestInterceptConfigsPreRunHandlerPrecedenceFlag(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := testCommon.cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := testCommon.cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -356,7 +360,7 @@ func TestInterceptConfigsPreRunHandlerPrecedenceEnvVar(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := testCommon.cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := testCommon.cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -372,7 +376,7 @@ func TestInterceptConfigsPreRunHandlerPrecedenceConfigFile(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := testCommon.cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := testCommon.cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}
@ -388,7 +392,7 @@ func TestInterceptConfigsPreRunHandlerPrecedenceConfigDefault(t *testing.T) {
serverCtx := &server.Context{}
ctx := context.WithValue(context.Background(), server.ServerContextKey, serverCtx)
if err := testCommon.cmd.ExecuteContext(ctx); err != errCanceledInPreRun {
if err := testCommon.cmd.ExecuteContext(ctx); !errors.Is(err, errCanceledInPreRun) {
t.Fatalf("function failed with [%T] %v", err, err)
}

4
simapp/app.go
View File

@ -457,7 +457,7 @@ func NewSimApp(
app.GovKeeper = *govKeeper.SetHooks(
govtypes.NewMultiGovHooks(
// register the governance hooks
// register the governance hooks
),
)
@ -487,7 +487,7 @@ func NewSimApp(
app.EpochsKeeper.SetHooks(
epochstypes.NewMultiEpochHooks(
// insert epoch hooks receivers here
// insert epoch hooks receivers here
),
)

1
simapp/genesis_account_test.go
View File

@ -81,7 +81,6 @@ func TestSimGenesisAccountValidate(t *testing.T) {
}
for _, tc := range testCases {
tc := tc
t.Run(tc.name, func(t *testing.T) {
require.Equal(t, tc.wantErr, tc.sga.Validate() != nil)
})

2
simapp/sim_bench_test.go
View File

@ -13,7 +13,6 @@ import (
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/server"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
"github.com/cosmos/cosmos-sdk/testutils/sims"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
@ -45,7 +44,6 @@ func BenchmarkFullAppSimulation(b *testing.B) {
appOptions := viper.New()
appOptions.SetDefault(flags.FlagHome, DefaultNodeHome)
appOptions.SetDefault(server.FlagInvCheckPeriod, simcli.FlagPeriodValue)
app := NewSimApp(logger, db, nil, true, appOptions, interBlockCacheOpt(), baseapp.SetChainID(sims.SimAppChainID))

2
store/cache/cache.go vendored
View File

@ -43,7 +43,7 @@ type (
func NewCommitKVStoreCache(store types.CommitKVStore, size uint) *CommitKVStoreCache {
cache, err := lru.NewARC(int(size))
if err != nil {
panic(fmt.Errorf("failed to create KVStore cache: %s", err))
panic(fmt.Errorf("failed to create KVStore cache: %w", err))
}
return &CommitKVStoreCache{

2
store/cachekv/search_test.go
View File

@ -60,7 +60,6 @@ func TestFindStartIndex(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
body := tt.sortedL
got := findStartIndex(body, tt.query)
@ -129,7 +128,6 @@ func TestFindEndIndex(t *testing.T) {
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
body := tt.sortedL
got := findEndIndex(body, tt.query)

10
store/cachekv/store_test.go
View File

@ -464,7 +464,7 @@ func randInt(n int) int {
return unsafe.NewRand().Int() % n
}
// useful for replaying a error case if we find one
// useful for replaying an error case if we find one
func doOp(t *testing.T, st types.CacheKVStore, truth dbm.DB, op int, args ...int) {
t.Helper()
switch op {
@ -474,8 +474,9 @@ func doOp(t *testing.T, st types.CacheKVStore, truth dbm.DB, op int, args ...int
err := truth.Set(keyFmt(k), valFmt(k))
require.NoError(t, err)
case opSetRange:
require.True(t, len(args) > 1)
start := args[0]
end := args[1]
end := args[1] //nolint:gosec // this is not out of range
setRange(t, st, truth, start, end)
case opDel:
k := args[0]
@ -483,8 +484,9 @@ func doOp(t *testing.T, st types.CacheKVStore, truth dbm.DB, op int, args ...int
err := truth.Delete(keyFmt(k))
require.NoError(t, err)
case opDelRange:
require.True(t, len(args) > 1)
start := args[0]
end := args[1]
end := args[1] //nolint:gosec // this is not out of range
deleteRange(t, st, truth, start, end)
case opWrite:
st.Write()
@ -543,7 +545,6 @@ func assertIterateDomainCheck(t *testing.T, st types.KVStore, mem dbm.DB, r []ke
require.NoError(t, err)
krc := newKeyRangeCounter(r)
i := 0
for ; krc.valid(); krc.next() {
require.True(t, itr.Valid())
@ -560,7 +561,6 @@ func assertIterateDomainCheck(t *testing.T, st types.KVStore, mem dbm.DB, r []ke
itr.Next()
itr2.Next()
i++
}
require.False(t, itr.Valid())

1
store/iavl/store_test.go
View File

@ -639,7 +639,6 @@ func TestSetInitialVersion(t *testing.T) {
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
db := dbm.NewMemDB()
store := tc.storeFn(db)

2
store/rootmulti/snapshot_test.go
View File

@ -141,7 +141,6 @@ func TestMultistoreSnapshot_Checksum(t *testing.T) {
}},
}
for _, tc := range testcases {
tc := tc
t.Run(fmt.Sprintf("Format %v", tc.format), func(t *testing.T) {
ch := make(chan io.ReadCloser)
go func() {
@ -176,7 +175,6 @@ func TestMultistoreSnapshot_Errors(t *testing.T) {
"unknown height": {9, nil},
}
for name, tc := range testcases {
tc := tc
t.Run(name, func(t *testing.T) {
err := store.Snapshot(tc.height, nil)
require.Error(t, err)

5
store/rootmulti/store.go
View File

@ -873,7 +873,7 @@ func (rs *Store) Snapshot(height uint64, protoWriter protoio.Writer) error {
nodeCount := 0
for {
node, err := exporter.Next()
if err == iavltree.ErrorExportDone {
if errors.Is(err, iavltree.ErrorExportDone) {
rs.logger.Debug("snapshot Done", "store", store.name, "nodeCount", nodeCount)
break
} else if err != nil {
@ -897,7 +897,6 @@ func (rs *Store) Snapshot(height uint64, protoWriter protoio.Writer) error {
return nil
}()
if err != nil {
return err
}
@ -920,7 +919,7 @@ loop:
for {
snapshotItem = snapshottypes.SnapshotItem{}
err := protoReader.ReadMsg(&snapshotItem)
if err == io.EOF {
if errors.Is(err, io.EOF) {
break
} else if err != nil {
return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "invalid protobuf message")

2
store/rootmulti/store_test.go
View File

@ -520,8 +520,6 @@ func TestMultiStore_Pruning(t *testing.T) {
}
for _, tc := range testCases {
tc := tc
t.Run(tc.name, func(t *testing.T) {
db := dbm.NewMemDB()
ms := newMultiStoreWithMounts(db, tc.po)

13
store/snapshots/chunk.go
View File

@ -1,10 +1,11 @@
package snapshots
import (
"errors"
"io"
"math"
"cosmossdk.io/errors"
sdkerrors "cosmossdk.io/errors"
snapshottypes "cosmossdk.io/store/snapshots/types"
storetypes "cosmossdk.io/store/types"
)
@ -72,7 +73,7 @@ func (w *ChunkWriter) CloseWithError(err error) {
// Write implements io.Writer.
func (w *ChunkWriter) Write(data []byte) (int, error) {
if w.closed {
return 0, errors.Wrap(storetypes.ErrLogic, "cannot write to closed ChunkWriter")
return 0, sdkerrors.Wrap(storetypes.ErrLogic, "cannot write to closed ChunkWriter")
}
nTotal := 0
for len(data) > 0 {
@ -149,7 +150,7 @@ func (r *ChunkReader) Read(p []byte) (int, error) {
}
}
n, err := r.reader.Read(p)
if err == io.EOF {
if errors.Is(err, io.EOF) {
err = r.reader.Close()
r.reader = nil
if err != nil {
@ -170,14 +171,14 @@ func DrainChunks(chunks <-chan io.ReadCloser) {
// ValidRestoreHeight will check height is valid for snapshot restore or not
func ValidRestoreHeight(format uint32, height uint64) error {
if format != snapshottypes.CurrentFormat {
return errors.Wrapf(snapshottypes.ErrUnknownFormat, "format %v", format)
return sdkerrors.Wrapf(snapshottypes.ErrUnknownFormat, "format %v", format)
}
if height == 0 {
return errors.Wrap(storetypes.ErrLogic, "cannot restore snapshot at height 0")
return sdkerrors.Wrap(storetypes.ErrLogic, "cannot restore snapshot at height 0")
}
if height > uint64(math.MaxInt64) {
return errors.Wrapf(snapshottypes.ErrInvalidMetadata,
return sdkerrors.Wrapf(snapshottypes.ErrInvalidMetadata,
"snapshot height %v cannot exceed %v", height, int64(math.MaxInt64))
}

6
store/snapshots/helpers_test.go
View File

@ -127,7 +127,7 @@ func (m *mockSnapshotter) Restore(
for {
item.Reset()
err := protoReader.ReadMsg(&item)
if err == io.EOF {
if errors.Is(err, io.EOF) {
break
} else if err != nil {
return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "invalid protobuf message")
@ -309,10 +309,10 @@ func (s *extSnapshotter) SnapshotExtension(height uint64, payloadWriter snapshot
return nil
}
func (s *extSnapshotter) RestoreExtension(height uint64, format uint32, payloadReader snapshottypes.ExtensionPayloadReader) error {
func (s *extSnapshotter) RestoreExtension(_ uint64, _ uint32, payloadReader snapshottypes.ExtensionPayloadReader) error {
for {
payload, err := payloadReader()
if err == io.EOF {
if errors.Is(err, io.EOF) {
break
} else if err != nil {
return err

1
store/types/gas_test.go
View File

@ -47,7 +47,6 @@ func TestGasMeter(t *testing.T) {
used := uint64(0)
for unum, usage := range tc.usage {
usage := usage
used += usage
require.NotPanics(t, func() { meter.ConsumeGas(usage, "") }, "Not exceeded limit but panicked. tc #%d, usage #%d", tcnum, unum)
require.Equal(t, used, meter.GasConsumed(), "Gas consumption not match. tc #%d, usage #%d", tcnum, unum)

6
tests/e2e/auth/cli_test.go
View File

@ -6,9 +6,11 @@ package auth
import (
"testing"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
)
func TestE2ETestSuite(t *testing.T) {

9
tests/e2e/auth/suite.go
View File

@ -340,7 +340,6 @@ func (s *E2ETestSuite) TestCLIQueryTxCmdByHash() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := authcli.QueryTxCmd()
clientCtx := val.ClientCtx
@ -470,7 +469,6 @@ func (s *E2ETestSuite) TestCLIQueryTxCmdByEvents() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := authcli.QueryTxCmd()
clientCtx := val.ClientCtx
@ -548,7 +546,6 @@ func (s *E2ETestSuite) TestCLIQueryTxsCmdByEvents() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := authcli.QueryTxsByEventsCmd()
clientCtx := val.ClientCtx
@ -1339,10 +1336,10 @@ func (s *E2ETestSuite) TestSignWithMultiSignersAminoJSON() {
// because DIRECT doesn't support multi signers via the CLI.
// Since we use amino, we don't need to pre-populate signer_infos.
txBuilder := val0.ClientCtx.TxConfig.NewTxBuilder()
txBuilder.SetMsgs(
require.NoError(txBuilder.SetMsgs(
banktypes.NewMsgSend(val0.Address, addr1, sdk.NewCoins(val0Coin)),
banktypes.NewMsgSend(val1.Address, addr1, sdk.NewCoins(val1Coin)),
)
))
txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))))
txBuilder.SetGasLimit(testdata.NewTestGasLimit() * 2)
signers, err := txBuilder.GetTx().GetSigners()
@ -1436,7 +1433,6 @@ func (s *E2ETestSuite) TestAuxSigner() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
_, err := govtestutil.MsgSubmitLegacyProposal(
val.ClientCtx,
@ -1658,7 +1654,6 @@ func (s *E2ETestSuite) TestAuxToFeeWithTips() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := govtestutil.MsgSubmitLegacyProposal(
val.ClientCtx,

4
tests/e2e/authz/grpc.go
View File

@ -63,7 +63,6 @@ func (s *E2ETestSuite) TestQueryGrantGRPC() {
},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, _ := testutil.GetRequest(tc.url)
require := s.Require()
@ -74,7 +73,7 @@ func (s *E2ETestSuite) TestQueryGrantGRPC() {
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &g)
require.NoError(err)
require.Len(g.Grants, 1)
g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry)
require.NoError(g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry))
auth, err := g.Grants[0].GetAuthorization()
require.NoError(err)
require.Equal(auth.MsgTypeURL(), banktypes.SendAuthorization{}.MsgTypeURL())
@ -150,7 +149,6 @@ func (s *E2ETestSuite) TestQueryGrantsGRPC() {
},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
tc.preRun()
resp, err := testutil.GetRequest(tc.url)

7
tests/e2e/authz/tx.go
View File

@ -308,7 +308,6 @@ func (s *E2ETestSuite) TestCmdRevokeAuthorizations() {
},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdRevokeAuthorization(addresscodec.NewBech32Codec("cosmos"))
clientCtx := val.ClientCtx
@ -455,7 +454,6 @@ func (s *E2ETestSuite) TestNewExecGenericAuthorized() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdExecAuthorization()
clientCtx := val.ClientCtx
@ -561,7 +559,6 @@ func (s *E2ETestSuite) TestNewExecGrantAuthorized() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdExecAuthorization()
clientCtx := val.ClientCtx
@ -760,7 +757,6 @@ func (s *E2ETestSuite) TestExecDelegateAuthorization() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdExecAuthorization()
clientCtx := val.ClientCtx
@ -827,7 +823,6 @@ func (s *E2ETestSuite) TestExecDelegateAuthorization() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdExecAuthorization()
clientCtx := val.ClientCtx
@ -985,7 +980,6 @@ func (s *E2ETestSuite) TestExecUndelegateAuthorization() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdExecAuthorization()
clientCtx := val.ClientCtx
@ -1053,7 +1047,6 @@ func (s *E2ETestSuite) TestExecUndelegateAuthorization() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdExecAuthorization()
clientCtx := val.ClientCtx

7
tests/e2e/bank/cli_test.go
View File

@ -6,10 +6,11 @@ package client
import (
"testing"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
)
func TestE2ETestSuite(t *testing.T) {

3
tests/e2e/bank/grpc.go
View File

@ -89,7 +89,6 @@ func (s *E2ETestSuite) TestTotalSupplyGRPCHandler() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Require().NoError(err)
@ -210,7 +209,6 @@ func (s *E2ETestSuite) TestDenomMetadataGRPCHandler() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Require().NoError(err)
@ -274,7 +272,6 @@ func (s *E2ETestSuite) TestBalancesGRPCHandler() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)

4
tests/e2e/bank/suite.go
View File

@ -234,8 +234,6 @@ func (s *E2ETestSuite) TestNewSendTxCmd() {
}
for _, tc := range testCases {
tc := tc
s.Require().NoError(s.network.WaitForNextBlock())
s.Run(tc.name, func() {
clientCtx := val.ClientCtx
@ -369,8 +367,6 @@ func (s *E2ETestSuite) TestNewMultiSendTxCmd() {
}
for _, tc := range testCases {
tc := tc
s.Require().NoError(s.network.WaitForNextBlock())
s.Run(tc.name, func() {
clientCtx := val.ClientCtx

11
tests/e2e/client/grpc/cmtservice/service_test.go
View File

@ -8,9 +8,10 @@ import (
"fmt"
"testing"
"cosmossdk.io/simapp"
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/client/grpc/cmtservice"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
@ -92,7 +93,7 @@ func (s *E2ETestSuite) TestQueryLatestBlock() {
s.Require().NoError(err)
var blockInfoRes cmtservice.GetLatestBlockResponse
s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(restRes, &blockInfoRes))
s.Require().Equal(types.ConsAddress(blockInfoRes.Block.Header.ProposerAddress).String(), blockInfoRes.SdkBlock.Header.ProposerAddress)
s.Require().Equal(types.ConsAddress(blockInfoRes.Block.Header.ProposerAddress).String(), blockInfoRes.SdkBlock.Header.ProposerAddress) //nolint:staticcheck // this test is for checking equality from the old and new types
s.Require().Contains(blockInfoRes.SdkBlock.Header.ProposerAddress, "cosmosvalcons")
}
@ -156,7 +157,6 @@ func (s *E2ETestSuite) TestLatestValidatorSet_GRPC() {
{"with pagination", &cmtservice.GetLatestValidatorSetRequest{Pagination: &qtypes.PageRequest{Offset: 0, Limit: uint64(len(vals))}}, false, ""},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
grpcRes, err := s.queryClient.GetLatestValidatorSet(context.Background(), tc.req)
if tc.expErr {
@ -187,7 +187,6 @@ func (s *E2ETestSuite) TestLatestValidatorSet_GRPCGateway() {
{"with pagination", fmt.Sprintf("%s/cosmos/base/tendermint/v1beta1/validatorsets/latest?pagination.offset=0&pagination.limit=2", vals[0].APIAddress), false, ""},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -220,7 +219,6 @@ func (s *E2ETestSuite) TestValidatorSetByHeight_GRPC() {
{"with pagination", &cmtservice.GetValidatorSetByHeightRequest{Height: 1, Pagination: &qtypes.PageRequest{Offset: 0, Limit: 1}}, false, ""},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
grpcRes, err := s.queryClient.GetValidatorSetByHeight(context.Background(), tc.req)
if tc.expErr {
@ -249,7 +247,6 @@ func (s *E2ETestSuite) TestValidatorSetByHeight_GRPCGateway() {
{"with pagination", fmt.Sprintf("%s/cosmos/base/tendermint/v1beta1/validatorsets/%d?pagination.offset=0&pagination.limit=2", vals[0].APIAddress, 1), false, ""},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -328,8 +325,6 @@ func (s *E2ETestSuite) TestABCIQuery() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := s.queryClient.ABCIQuery(context.Background(), tc.req)
if tc.expectErr {

9
tests/e2e/distribution/grpc_query_suite.go
View File

@ -64,7 +64,6 @@ func (s *GRPCQueryTestSuite) TestQueryParamsGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequest(tc.url)
s.Run(tc.name, func() {
s.Require().NoError(err)
@ -99,7 +98,6 @@ func (s *GRPCQueryTestSuite) TestQueryValidatorDistributionInfoGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequest(tc.url)
s.Run(tc.name, func() {
if tc.expErr {
@ -152,7 +150,6 @@ func (s *GRPCQueryTestSuite) TestQueryOutstandingRewardsGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Run(tc.name, func() {
if tc.expErr {
@ -206,7 +203,6 @@ func (s *GRPCQueryTestSuite) TestQueryValidatorCommissionGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Run(tc.name, func() {
if tc.expErr {
@ -264,7 +260,6 @@ func (s *GRPCQueryTestSuite) TestQuerySlashesGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequest(tc.url)
s.Run(tc.name, func() {
@ -340,7 +335,6 @@ func (s *GRPCQueryTestSuite) TestQueryDelegatorRewardsGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Run(tc.name, func() {
@ -392,7 +386,6 @@ func (s *GRPCQueryTestSuite) TestQueryDelegatorValidatorsGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequest(tc.url)
s.Run(tc.name, func() {
@ -444,7 +437,6 @@ func (s *GRPCQueryTestSuite) TestQueryWithdrawAddressGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequest(tc.url)
s.Run(tc.name, func() {
@ -489,7 +481,6 @@ func (s *GRPCQueryTestSuite) TestQueryValidatorCommunityPoolGRPC() {
}
for _, tc := range testCases {
tc := tc
resp, err := sdktestutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Run(tc.name, func() {

8
tests/e2e/distribution/suite.go
View File

@ -129,8 +129,6 @@ func (s *E2ETestSuite) TestNewWithdrawRewardsCmd() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
clientCtx := val.ClientCtx
@ -224,8 +222,6 @@ func (s *E2ETestSuite) TestNewWithdrawAllRewardsCmd() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewWithdrawAllRewardsCmd(address.NewBech32Codec("cosmosvaloper"), address.NewBech32Codec("cosmos"))
clientCtx := val.ClientCtx
@ -309,8 +305,6 @@ func (s *E2ETestSuite) TestNewSetWithdrawAddrCmd() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewSetWithdrawAddrCmd(address.NewBech32Codec("cosmos"))
clientCtx := val.ClientCtx
@ -364,8 +358,6 @@ func (s *E2ETestSuite) TestNewFundCommunityPoolCmd() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewFundCommunityPoolCmd(address.NewBech32Codec("cosmos"))
clientCtx := val.ClientCtx

6
tests/e2e/gov/cli_test.go
View File

@ -7,13 +7,13 @@ import (
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)
func TestE2ETestSuite(t *testing.T) {

8
tests/e2e/gov/grpc.go
View File

@ -38,7 +38,6 @@ func (s *E2ETestSuite) TestGetProposalGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -92,7 +91,6 @@ func (s *E2ETestSuite) TestGetProposalsGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequestWithHeaders(tc.url, tc.headers)
s.Require().NoError(err)
@ -159,7 +157,6 @@ func (s *E2ETestSuite) TestGetProposalVoteGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -203,7 +200,6 @@ func (s *E2ETestSuite) TestGetProposalVotesGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -252,7 +248,6 @@ func (s *E2ETestSuite) TestGetProposalDepositGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -291,7 +286,6 @@ func (s *E2ETestSuite) TestGetProposalDepositsGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -336,7 +330,6 @@ func (s *E2ETestSuite) TestGetTallyGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)
@ -398,7 +391,6 @@ func (s *E2ETestSuite) TestGetParamsGRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
resp, err := testutil.GetRequest(tc.url)
s.Require().NoError(err)

6
tests/e2e/gov/tx.go
View File

@ -165,8 +165,6 @@ func (s *E2ETestSuite) TestNewCmdSubmitProposal() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdSubmitProposal()
clientCtx := val.ClientCtx
@ -261,8 +259,6 @@ func (s *E2ETestSuite) TestNewCmdSubmitLegacyProposal() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdSubmitLegacyProposal()
clientCtx := val.ClientCtx
@ -446,7 +442,6 @@ func (s *E2ETestSuite) TestNewCmdVote() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdVote()
clientCtx := val.ClientCtx
@ -543,7 +538,6 @@ func (s *E2ETestSuite) TestNewCmdWeightedVote() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
cmd := cli.NewCmdWeightedVote()
clientCtx := val.ClientCtx

7
tests/e2e/group/cli_test.go
View File

@ -6,10 +6,11 @@ package group
import (
"testing"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
)
func TestE2ETestSuite(t *testing.T) {

1
tests/e2e/mint/cli_test.go
View File

@ -9,6 +9,7 @@ import (
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
)

21
tests/e2e/server/export_test.go
View File

@ -20,6 +20,7 @@ import (
"cosmossdk.io/log"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/server"
@ -95,10 +96,12 @@ func TestExportCmd_Height(t *testing.T) {
// Fast forward to block `tc.fastForward`.
for i := int64(2); i <= tc.fastForward; i++ {
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: i,
})
app.Commit()
assert.NilError(t, err)
_, err = app.Commit()
assert.NilError(t, err)
}
output := &bytes.Buffer{}
@ -182,16 +185,20 @@ func setupApp(t *testing.T, tempDir string) (*simapp.SimApp, context.Context, ge
err = genutil.ExportGenesisFile(&appGenesis, serverCtx.Config.GenesisFile())
assert.NilError(t, err)
app.InitChain(&abci.RequestInitChain{
_, err = app.InitChain(&abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
ConsensusParams: simtestutil.DefaultConsensusParams,
AppStateBytes: appGenesis.AppState,
},
)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
})
assert.NilError(t, err)
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: 1,
})
app.Commit()
assert.NilError(t, err)
_, err = app.Commit()
assert.NilError(t, err)
cmd := server.ExportCmd(
func(_ log.Logger, _ dbm.DB, _ io.Writer, height int64, forZeroHeight bool, jailAllowedAddrs []string, appOptions types.AppOptions, modulesToExport []string) (types.ExportedApp, error) {

6
tests/e2e/staking/cli_test.go
View File

@ -6,9 +6,11 @@ package testutil
import (
"testing"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
)
func TestE2ETestSuite(t *testing.T) {

3
tests/e2e/staking/suite.go
View File

@ -133,7 +133,7 @@ func (s *E2ETestSuite) TestBlockResults() {
// Loop until we find a block result with the correct validator updates.
// By experience, it happens around 2 blocks after `delHeight`.
s.network.RetryForBlocks(func() error {
_ = s.network.RetryForBlocks(func() error {
latestHeight, err := s.network.LatestHeight()
require.NoError(err)
res, err := rpcClient.BlockResults(context.Background(), &latestHeight)
@ -153,4 +153,5 @@ func (s *E2ETestSuite) TestBlockResults() {
return nil
}, 10)
// TODO: revisit if this test is doing anything useful
}

6
tests/e2e/tx/service_test.go
View File

@ -174,7 +174,6 @@ func (s *E2ETestSuite) TestSimulateTx_GRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
// Broadcast the tx via gRPC via the validator's clientCtx (which goes
// through Tendermint).
@ -505,7 +504,6 @@ func (s *E2ETestSuite) TestBroadcastTx_GRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
// Broadcast the tx via gRPC via the validator's clientCtx (which goes
// through Tendermint).
@ -765,7 +763,6 @@ func (s *E2ETestSuite) TestTxEncode_GRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := s.queryClient.TxEncode(context.Background(), tc.req)
if tc.expErr {
@ -844,7 +841,6 @@ func (s *E2ETestSuite) TestTxDecode_GRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := s.queryClient.TxDecode(context.Background(), tc.req)
if tc.expErr {
@ -934,7 +930,6 @@ func (s *E2ETestSuite) TestTxEncodeAmino_GRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := s.queryClient.TxEncodeAmino(context.Background(), tc.req)
if tc.expErr {
@ -1020,7 +1015,6 @@ func (s *E2ETestSuite) TestTxDecodeAmino_GRPC() {
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
res, err := s.queryClient.TxDecodeAmino(context.Background(), tc.req)
if tc.expErr {

4
tests/fuzz/tests/crypto_hd_deriveprivatekeyforpath_test.go
View File

@ -6,7 +6,7 @@ import (
"bytes"
"testing"
bip39 "github.com/cosmos/go-bip39"
"github.com/cosmos/go-bip39"
"github.com/cosmos/cosmos-sdk/crypto/hd"
)
@ -30,6 +30,6 @@ func FuzzCryptoHDDerivePrivateKeyForPath(f *testing.F) {
}
seed := mnemonicToSeed(string(mnemonic))
master, ch := hd.ComputeMastersFromSeed(seed)
hd.DerivePrivateKeyForPath(master, ch, string(path))
_, _ = hd.DerivePrivateKeyForPath(master, ch, string(path))
})
}

2
tests/fuzz/tests/crypto_hd_newparamsfrompath_test.go
View File

@ -10,6 +10,6 @@ import (
func FuzzCryptoHDNewParamsFromPath(f *testing.F) {
f.Fuzz(func(t *testing.T, data []byte) {
hd.NewParamsFromPath(string(data))
_, _ = hd.NewParamsFromPath(string(data))
})
}

Some files were not shown because too many files have changed in this diff Show More