From 5d367b72ff47793823225b3eae26782fb79942dc Mon Sep 17 00:00:00 2001 From: Jacob Gadikian Date: Sat, 6 May 2023 23:56:20 +0700 Subject: [PATCH] adopt the errors module to reduce the changeset for 47 --- app/consumer-democracy/ante_handler.go | 7 +++-- app/consumer/ante_handler.go | 7 +++-- app/provider/ante_handler.go | 7 +++-- go.mod | 2 ++ go.sum | 2 ++ legacy_ibc_testing/testing/chain.go | 4 +-- testutil/simibc/relay_util.go | 4 +-- x/ccv/consumer/ibc_module.go | 25 ++++++++------- x/ccv/consumer/keeper/distribution.go | 4 +-- x/ccv/consumer/keeper/keeper.go | 12 +++---- x/ccv/consumer/keeper/relay.go | 4 +-- x/ccv/consumer/types/errors.go | 4 +-- x/ccv/consumer/types/genesis.go | 42 ++++++++++++------------- x/ccv/consumer/types/validator.go | 3 +- x/ccv/provider/handler.go | 3 +- x/ccv/provider/ibc_module.go | 19 +++++------ x/ccv/provider/keeper/grpc_query.go | 4 +-- x/ccv/provider/keeper/keeper.go | 24 +++++++------- x/ccv/provider/keeper/key_assignment.go | 8 ++--- x/ccv/provider/keeper/msg_server.go | 6 ++-- x/ccv/provider/keeper/proposal.go | 11 ++++--- x/ccv/provider/keeper/relay.go | 6 ++-- x/ccv/provider/proposal_handler.go | 3 +- x/ccv/provider/types/errors.go | 28 ++++++++--------- x/ccv/provider/types/genesis.go | 16 +++++----- x/ccv/provider/types/key_assignment.go | 18 +++++------ x/ccv/provider/types/proposal.go | 28 ++++++++--------- x/ccv/types/ccv.go | 12 +++---- x/ccv/types/errors.go | 40 +++++++++++------------ x/ccv/types/utils.go | 8 ++--- 30 files changed, 187 insertions(+), 174 deletions(-) diff --git a/app/consumer-democracy/ante_handler.go b/app/consumer-democracy/ante_handler.go index af809944f4..8182b51095 100644 --- a/app/consumer-democracy/ante_handler.go +++ b/app/consumer-democracy/ante_handler.go @@ -1,6 +1,7 @@ package app import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/ante" @@ -22,13 +23,13 @@ type HandlerOptions struct { func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) { if options.AccountKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for AnteHandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "account keeper is required for AnteHandler") } if options.BankKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for AnteHandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "bank keeper is required for AnteHandler") } if options.SignModeHandler == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") } sigGasConsumer := options.SigGasConsumer diff --git a/app/consumer/ante_handler.go b/app/consumer/ante_handler.go index 66fcae73c7..a070967551 100644 --- a/app/consumer/ante_handler.go +++ b/app/consumer/ante_handler.go @@ -1,6 +1,7 @@ package app import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/ante" @@ -21,13 +22,13 @@ type HandlerOptions struct { func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) { if options.AccountKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for AnteHandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "account keeper is required for AnteHandler") } if options.BankKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for AnteHandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "bank keeper is required for AnteHandler") } if options.SignModeHandler == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") } sigGasConsumer := options.SigGasConsumer diff --git a/app/provider/ante_handler.go b/app/provider/ante_handler.go index 7e306ddd00..3b1a3b7d38 100644 --- a/app/provider/ante_handler.go +++ b/app/provider/ante_handler.go @@ -1,6 +1,7 @@ package app import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/ante" @@ -18,13 +19,13 @@ type HandlerOptions struct { func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) { if options.AccountKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for AnteHandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "account keeper is required for AnteHandler") } if options.BankKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for AnteHandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "bank keeper is required for AnteHandler") } if options.SignModeHandler == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") } sigGasConsumer := options.SigGasConsumer diff --git a/go.mod b/go.mod index 52c881b697..188820956c 100644 --- a/go.mod +++ b/go.mod @@ -31,6 +31,8 @@ require ( gopkg.in/yaml.v2 v2.4.0 ) +require cosmossdk.io/errors v1.0.0-beta.7 + require ( cosmossdk.io/api v0.2.6 // indirect cosmossdk.io/core v0.5.1 // indirect diff --git a/go.sum b/go.sum index 03e0962615..5eee90f2d9 100644 --- a/go.sum +++ b/go.sum @@ -44,6 +44,8 @@ cosmossdk.io/core v0.5.1 h1:vQVtFrIYOQJDV3f7rw4pjjVqc1id4+mE0L9hHP66pyI= cosmossdk.io/core v0.5.1/go.mod h1:KZtwHCLjcFuo0nmDc24Xy6CRNEL9Vl/MeimQ2aC7NLE= cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z+zfw= cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= +cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= +cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= filippo.io/edwards25519 v1.0.0-rc.1 h1:m0VOOB23frXZvAOK44usCgLWvtsxIoMCTBGJZlpmGfU= filippo.io/edwards25519 v1.0.0-rc.1/go.mod h1:N1IkdkCkiLB6tki+MYJoSx2JTY9NUlxZE7eHn5EwJns= diff --git a/legacy_ibc_testing/testing/chain.go b/legacy_ibc_testing/testing/chain.go index 6664757136..abea4131d9 100644 --- a/legacy_ibc_testing/testing/chain.go +++ b/legacy_ibc_testing/testing/chain.go @@ -6,12 +6,12 @@ import ( "testing" "time" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper" @@ -455,7 +455,7 @@ func (chain *TestChain) ConstructUpdateTMClientHeaderWithTrustedHeight(counterpa // NextValidatorsHash tmTrustedVals, ok = counterparty.GetValsAtHeight(int64(trustedHeight.RevisionHeight + 1)) if !ok { - return nil, sdkerrors.Wrapf(ibctmtypes.ErrInvalidHeaderHeight, "could not retrieve trusted validators at trustedHeight: %d", trustedHeight) + return nil, errorsmod.Wrapf(ibctmtypes.ErrInvalidHeaderHeight, "could not retrieve trusted validators at trustedHeight: %d", trustedHeight) } } // inject trusted fields into last header diff --git a/testutil/simibc/relay_util.go b/testutil/simibc/relay_util.go index 5a9cf17e99..267ec33a4b 100644 --- a/testutil/simibc/relay_util.go +++ b/testutil/simibc/relay_util.go @@ -1,8 +1,8 @@ package simibc import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" clienttypes "github.com/cosmos/ibc-go/v4/modules/core/02-client/types" channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types" host "github.com/cosmos/ibc-go/v4/modules/core/24-host" @@ -160,7 +160,7 @@ func augmentHeader(sender *ibctesting.TestChain, receiver *ibctesting.TestChain, // NextValidatorsHash tmTrustedVals, ok = sender.GetValsAtHeight(int64(trustedHeight.RevisionHeight + 1)) if !ok { - return sdkerrors.Wrapf(ibctmtypes.ErrInvalidHeaderHeight, "could not retrieve trusted validators at trustedHeight: %d", trustedHeight) + return errorsmod.Wrapf(ibctmtypes.ErrInvalidHeaderHeight, "could not retrieve trusted validators at trustedHeight: %d", trustedHeight) } } trustedVals, err := tmTrustedVals.ToProto() diff --git a/x/ccv/consumer/ibc_module.go b/x/ccv/consumer/ibc_module.go index 87c876097b..ab2dad74dc 100644 --- a/x/ccv/consumer/ibc_module.go +++ b/x/ccv/consumer/ibc_module.go @@ -4,6 +4,7 @@ import ( "fmt" "strings" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types" @@ -38,7 +39,7 @@ func (am AppModule) OnChanOpenInit( // ensure provider channel hasn't already been created if providerChannel, ok := am.keeper.GetProviderChannel(ctx); ok { - return "", sdkerrors.Wrapf(types.ErrDuplicateChannel, + return "", errorsmod.Wrapf(types.ErrDuplicateChannel, "provider channel: %s already set", providerChannel) } @@ -51,7 +52,7 @@ func (am AppModule) OnChanOpenInit( // ensure the counterparty port ID matches the expected provider port ID if counterparty.PortId != types.ProviderPortID { - return "", sdkerrors.Wrapf(porttypes.ErrInvalidPort, + return "", errorsmod.Wrapf(porttypes.ErrInvalidPort, "invalid counterparty port: %s, expected %s", counterparty.PortId, types.ProviderPortID) } @@ -79,18 +80,18 @@ func validateCCVChannelParams( ) error { // Only ordered channels allowed if order != channeltypes.ORDERED { - return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.ORDERED, order) + return errorsmod.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.ORDERED, order) } // the port ID must match the port ID the CCV module is bounded to boundPort := keeper.GetPort(ctx) if boundPort != portID { - return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) + return errorsmod.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) } // the version must match the expected version if version != types.Version { - return sdkerrors.Wrapf(types.ErrInvalidVersion, "got %s, expected %s", version, types.Version) + return errorsmod.Wrapf(types.ErrInvalidVersion, "got %s, expected %s", version, types.Version) } return nil } @@ -106,7 +107,7 @@ func (am AppModule) OnChanOpenTry( counterparty channeltypes.Counterparty, counterpartyVersion string, ) (string, error) { - return "", sdkerrors.Wrap(types.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") + return "", errorsmod.Wrap(types.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") } // OnChanOpenAck implements the IBCModule interface @@ -119,18 +120,18 @@ func (am AppModule) OnChanOpenAck( ) error { // ensure provider channel has not already been created if providerChannel, ok := am.keeper.GetProviderChannel(ctx); ok { - return sdkerrors.Wrapf(types.ErrDuplicateChannel, + return errorsmod.Wrapf(types.ErrDuplicateChannel, "provider channel: %s already established", providerChannel) } var md providertypes.HandshakeMetadata if err := (&md).Unmarshal([]byte(counterpartyMetadata)); err != nil { - return sdkerrors.Wrapf(types.ErrInvalidHandshakeMetadata, + return errorsmod.Wrapf(types.ErrInvalidHandshakeMetadata, "error unmarshalling ibc-ack metadata: \n%v; \nmetadata: %v", err, counterpartyMetadata) } if md.Version != types.Version { - return sdkerrors.Wrapf(types.ErrInvalidVersion, + return errorsmod.Wrapf(types.ErrInvalidVersion, "invalid counterparty version: %s, expected %s", md.Version, types.Version) } @@ -194,7 +195,7 @@ func (am AppModule) OnChanOpenConfirm( portID, channelID string, ) error { - return sdkerrors.Wrap(types.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") + return errorsmod.Wrap(types.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") } // OnChanCloseInit implements the IBCModule interface @@ -207,7 +208,7 @@ func (am AppModule) OnChanCloseInit( if providerChannel, ok := am.keeper.GetProviderChannel(ctx); ok && providerChannel != channelID { return nil } - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "user cannot close channel") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "user cannot close channel") } // OnChanCloseConfirm implements the IBCModule interface @@ -258,7 +259,7 @@ func (am AppModule) OnAcknowledgementPacket( ) error { var ack channeltypes.Acknowledgement if err := types.ModuleCdc.UnmarshalJSON(acknowledgement, &ack); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal consumer packet acknowledgement: %v", err) + return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal consumer packet acknowledgement: %v", err) } if err := am.keeper.OnAcknowledgementPacket(ctx, packet, ack); err != nil { diff --git a/x/ccv/consumer/keeper/distribution.go b/x/ccv/consumer/keeper/distribution.go index 140e135c12..8400ae9c63 100644 --- a/x/ccv/consumer/keeper/distribution.go +++ b/x/ccv/consumer/keeper/distribution.go @@ -4,8 +4,8 @@ import ( "fmt" "strconv" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" transfertypes "github.com/cosmos/ibc-go/v4/modules/apps/transfer/types" clienttypes "github.com/cosmos/ibc-go/v4/modules/core/02-client/types" @@ -186,7 +186,7 @@ func (k Keeper) TransferChannelExists(ctx sdk.Context, channelID string) bool { func (k Keeper) GetConnectionHops(ctx sdk.Context, srcPort, srcChan string) ([]string, error) { ch, found := k.channelKeeper.GetChannel(ctx, srcPort, srcChan) if !found { - return []string{}, sdkerrors.Wrapf(ccv.ErrChannelNotFound, + return []string{}, errorsmod.Wrapf(ccv.ErrChannelNotFound, "cannot get connection hops from non-existent channel") } return ch.ConnectionHops, nil diff --git a/x/ccv/consumer/keeper/keeper.go b/x/ccv/consumer/keeper/keeper.go index c3216d2459..d24f5fbd39 100644 --- a/x/ccv/consumer/keeper/keeper.go +++ b/x/ccv/consumer/keeper/keeper.go @@ -6,8 +6,8 @@ import ( "reflect" "time" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/codec" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -143,7 +143,7 @@ func (k Keeper) ChanCloseInit(ctx sdk.Context, portID, channelID string) error { capName := host.ChannelCapabilityPath(portID, channelID) chanCap, ok := k.scopedKeeper.GetCapability(ctx, capName) if !ok { - return sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName) + return errorsmod.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName) } return k.channelKeeper.ChanCloseInit(ctx, portID, channelID, chanCap) } @@ -402,20 +402,20 @@ func (k Keeper) DeletePacketMaturityTimes(ctx sdk.Context, vscId uint64, maturit // is the expected provider chain. func (k Keeper) VerifyProviderChain(ctx sdk.Context, connectionHops []string) error { if len(connectionHops) != 1 { - return sdkerrors.Wrap(channeltypes.ErrTooManyConnectionHops, "must have direct connection to provider chain") + return errorsmod.Wrap(channeltypes.ErrTooManyConnectionHops, "must have direct connection to provider chain") } connectionID := connectionHops[0] conn, ok := k.connectionKeeper.GetConnection(ctx, connectionID) if !ok { - return sdkerrors.Wrapf(conntypes.ErrConnectionNotFound, "connection not found for connection ID: %s", connectionID) + return errorsmod.Wrapf(conntypes.ErrConnectionNotFound, "connection not found for connection ID: %s", connectionID) } // Verify that client id is expected clientID expectedClientId, ok := k.GetProviderClientID(ctx) if !ok { - return sdkerrors.Wrapf(clienttypes.ErrInvalidClient, "could not find provider client id") + return errorsmod.Wrapf(clienttypes.ErrInvalidClient, "could not find provider client id") } if expectedClientId != conn.ClientId { - return sdkerrors.Wrapf(clienttypes.ErrInvalidClient, "invalid client: %s, channel must be built on top of client: %s", conn.ClientId, expectedClientId) + return errorsmod.Wrapf(clienttypes.ErrInvalidClient, "invalid client: %s, channel must be built on top of client: %s", conn.ClientId, expectedClientId) } return nil diff --git a/x/ccv/consumer/keeper/relay.go b/x/ccv/consumer/keeper/relay.go index 072adf2438..c690ef3701 100644 --- a/x/ccv/consumer/keeper/relay.go +++ b/x/ccv/consumer/keeper/relay.go @@ -4,8 +4,8 @@ import ( "fmt" "strconv" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" clienttypes "github.com/cosmos/ibc-go/v4/modules/core/02-client/types" channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types" @@ -232,7 +232,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac // check if there is an established CCV channel to provider channelID, found := k.GetProviderChannel(ctx) if !found { - return sdkerrors.Wrapf(types.ErrNoProposerChannelId, "recv ErrorAcknowledgement on non-established channel %s", packet.SourceChannel) + return errorsmod.Wrapf(types.ErrNoProposerChannelId, "recv ErrorAcknowledgement on non-established channel %s", packet.SourceChannel) } if channelID != packet.SourceChannel { // Close the established CCV channel as well diff --git a/x/ccv/consumer/types/errors.go b/x/ccv/consumer/types/errors.go index 486281139e..9a2a729737 100644 --- a/x/ccv/consumer/types/errors.go +++ b/x/ccv/consumer/types/errors.go @@ -1,10 +1,10 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" ) // Consumer sentinel errors var ( - ErrNoProposerChannelId = sdkerrors.Register(ModuleName, 1, "no established CCV channel") + ErrNoProposerChannelId = errorsmod.Register(ModuleName, 1, "no established CCV channel") ) diff --git a/x/ccv/consumer/types/genesis.go b/x/ccv/consumer/types/genesis.go index 052bc7f822..c3856ab1de 100644 --- a/x/ccv/consumer/types/genesis.go +++ b/x/ccv/consumer/types/genesis.go @@ -1,7 +1,7 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" ibctmtypes "github.com/cosmos/ibc-go/v4/modules/light-clients/07-tendermint/types" ccv "github.com/cosmos/interchain-security/x/ccv/types" @@ -76,7 +76,7 @@ func (gs GenesisState) Validate() error { return nil } if len(gs.InitialValSet) == 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "initial validator set is empty") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "initial validator set is empty") } if err := gs.Params.Validate(); err != nil { return err @@ -84,72 +84,72 @@ func (gs GenesisState) Validate() error { if gs.NewChain { if gs.ProviderClientState == nil { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "provider client state cannot be nil for new chain") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "provider client state cannot be nil for new chain") } if err := gs.ProviderClientState.Validate(); err != nil { - return sdkerrors.Wrapf(ccv.ErrInvalidGenesis, "provider client state invalid for new chain %s", err.Error()) + return errorsmod.Wrapf(ccv.ErrInvalidGenesis, "provider client state invalid for new chain %s", err.Error()) } if gs.ProviderConsensusState == nil { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "provider consensus state cannot be nil for new chain") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "provider consensus state cannot be nil for new chain") } if err := gs.ProviderConsensusState.ValidateBasic(); err != nil { - return sdkerrors.Wrapf(ccv.ErrInvalidGenesis, "provider consensus state invalid for new chain %s", err.Error()) + return errorsmod.Wrapf(ccv.ErrInvalidGenesis, "provider consensus state invalid for new chain %s", err.Error()) } if gs.ProviderClientId != "" { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "provider client id cannot be set for new chain. It must be established on handshake") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "provider client id cannot be set for new chain. It must be established on handshake") } if gs.ProviderChannelId != "" { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "provider channel id cannot be set for new chain. It must be established on handshake") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "provider channel id cannot be set for new chain. It must be established on handshake") } if len(gs.MaturingPackets) != 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "maturing packets must be empty for new chain") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "maturing packets must be empty for new chain") } if len(gs.PendingConsumerPackets.List) != 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "pending consumer packets must be empty for new chain") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "pending consumer packets must be empty for new chain") } if gs.LastTransmissionBlockHeight.Height != 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "last transmission block height must be empty for new chain") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "last transmission block height must be empty for new chain") } } else { // NOTE: For restart genesis, we will verify initial validator set in InitGenesis. if gs.ProviderClientId == "" { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "provider client id must be set for a restarting consumer genesis state") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "provider client id must be set for a restarting consumer genesis state") } // handshake is still in progress handshakeInProgress := gs.ProviderChannelId == "" if handshakeInProgress { if len(gs.MaturingPackets) != 0 { - return sdkerrors.Wrap( + return errorsmod.Wrap( ccv.ErrInvalidGenesis, "maturing packets must be empty when handshake isn't completed") } if len(gs.OutstandingDowntimeSlashing) != 0 { - return sdkerrors.Wrap( + return errorsmod.Wrap( ccv.ErrInvalidGenesis, "outstanding downtime must be empty when handshake isn't completed") } if gs.LastTransmissionBlockHeight.Height != 0 { - return sdkerrors.Wrap( + return errorsmod.Wrap( ccv.ErrInvalidGenesis, "last transmission block height must be zero when handshake isn't completed") } if len(gs.PendingConsumerPackets.List) != 0 { for _, packet := range gs.PendingConsumerPackets.List { if packet.Type == ccv.VscMaturedPacket { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "pending maturing packets must be empty when handshake isn't completed") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "pending maturing packets must be empty when handshake isn't completed") } } } } if gs.HeightToValsetUpdateId == nil { - return sdkerrors.Wrap( + return errorsmod.Wrap( ccv.ErrInvalidGenesis, "empty height to validator set update id mapping", ) } if gs.ProviderClientState != nil || gs.ProviderConsensusState != nil { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "provider client state and consensus state must be nil for a restarting genesis state") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "provider client state and consensus state must be nil for a restarting genesis state") } for _, mat := range gs.MaturingPackets { if err := mat.Validate(); err != nil { - return sdkerrors.Wrap(err, "invalid unbonding sequences") + return errorsmod.Wrap(err, "invalid unbonding sequences") } } } @@ -158,10 +158,10 @@ func (gs GenesisState) Validate() error { func (mat MaturingVSCPacket) Validate() error { if mat.MaturityTime.IsZero() { - return sdkerrors.Wrap(ccv.ErrInvalidVSCMaturedTime, "cannot have 0 maturity time") + return errorsmod.Wrap(ccv.ErrInvalidVSCMaturedTime, "cannot have 0 maturity time") } if mat.VscId == 0 { - return sdkerrors.Wrap(ccv.ErrInvalidVSCMaturedId, "cannot have 0 maturity time") + return errorsmod.Wrap(ccv.ErrInvalidVSCMaturedId, "cannot have 0 maturity time") } return nil } diff --git a/x/ccv/consumer/types/validator.go b/x/ccv/consumer/types/validator.go index 69314b15d3..c546a68440 100644 --- a/x/ccv/consumer/types/validator.go +++ b/x/ccv/consumer/types/validator.go @@ -1,6 +1,7 @@ package types import ( + errorsmod "cosmossdk.io/errors" codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -29,7 +30,7 @@ func (ccv CrossChainValidator) UnpackInterfaces(unpacker codectypes.AnyUnpacker) func (ccv CrossChainValidator) ConsPubKey() (cryptotypes.PubKey, error) { pk, ok := ccv.Pubkey.GetCachedValue().(cryptotypes.PubKey) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expecting cryptotypes.PubKey, got %T", pk) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidType, "expecting cryptotypes.PubKey, got %T", pk) } return pk, nil diff --git a/x/ccv/provider/handler.go b/x/ccv/provider/handler.go index 4751b8460c..10b92c0f71 100644 --- a/x/ccv/provider/handler.go +++ b/x/ccv/provider/handler.go @@ -1,6 +1,7 @@ package provider import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/interchain-security/x/ccv/provider/keeper" @@ -18,7 +19,7 @@ func NewHandler(k *keeper.Keeper) sdk.Handler { res, err := msgServer.AssignConsumerKey(sdk.WrapSDKContext(ctx), msg) return sdk.WrapServiceResult(ctx, res, err) default: - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized %s message type: %T", types.ModuleName, msg) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized %s message type: %T", types.ModuleName, msg) } } } diff --git a/x/ccv/provider/ibc_module.go b/x/ccv/provider/ibc_module.go index 265310d283..06bd9e39f6 100644 --- a/x/ccv/provider/ibc_module.go +++ b/x/ccv/provider/ibc_module.go @@ -3,6 +3,7 @@ package provider import ( "fmt" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types" @@ -29,7 +30,7 @@ func (am AppModule) OnChanOpenInit( counterparty channeltypes.Counterparty, version string, ) (string, error) { - return version, sdkerrors.Wrap(ccv.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") + return version, errorsmod.Wrap(ccv.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") } // OnChanOpenTry implements the IBCModule interface @@ -55,13 +56,13 @@ func (am AppModule) OnChanOpenTry( // ensure the counterparty port ID matches the expected consumer port ID if counterparty.PortId != ccv.ConsumerPortID { - return "", sdkerrors.Wrapf(porttypes.ErrInvalidPort, + return "", errorsmod.Wrapf(porttypes.ErrInvalidPort, "invalid counterparty port: %s, expected %s", counterparty.PortId, ccv.ConsumerPortID) } // ensure the counter party version matches the expected version if counterpartyVersion != ccv.Version { - return "", sdkerrors.Wrapf( + return "", errorsmod.Wrapf( ccv.ErrInvalidVersion, "invalid counterparty version: got: %s, expected %s", counterpartyVersion, ccv.Version) } @@ -89,7 +90,7 @@ func (am AppModule) OnChanOpenTry( } mdBz, err := (&md).Marshal() if err != nil { - return "", sdkerrors.Wrapf(ccv.ErrInvalidHandshakeMetadata, + return "", errorsmod.Wrapf(ccv.ErrInvalidHandshakeMetadata, "error marshalling ibc-try metadata: %v", err) } return string(mdBz), nil @@ -103,13 +104,13 @@ func validateCCVChannelParams( portID string, ) error { if order != channeltypes.ORDERED { - return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.ORDERED, order) + return errorsmod.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.ORDERED, order) } // the port ID must match the port ID the CCV module is bounded to boundPort := keeper.GetPort(ctx) if boundPort != portID { - return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) + return errorsmod.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) } return nil } @@ -125,7 +126,7 @@ func (am AppModule) OnChanOpenAck( counterpartyChannelID string, counterpartyVersion string, ) error { - return sdkerrors.Wrap(ccv.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") + return errorsmod.Wrap(ccv.ErrInvalidChannelFlow, "channel handshake must be initiated by consumer chain") } // OnChanOpenConfirm implements the IBCModule interface @@ -151,7 +152,7 @@ func (am AppModule) OnChanCloseInit( channelID string, ) error { // Disallow user-initiated channel closing for provider channels - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "user cannot close channel") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "user cannot close channel") } // OnChanCloseConfirm implements the IBCModule interface @@ -216,7 +217,7 @@ func (am AppModule) OnAcknowledgementPacket( ) error { var ack channeltypes.Acknowledgement if err := ccv.ModuleCdc.UnmarshalJSON(acknowledgement, &ack); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal provider packet acknowledgement: %v", err) + return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal provider packet acknowledgement: %v", err) } if err := am.keeper.OnAcknowledgementPacket(ctx, packet, ack); err != nil { diff --git a/x/ccv/provider/keeper/grpc_query.go b/x/ccv/provider/keeper/grpc_query.go index caebb91deb..cddae5f8cf 100644 --- a/x/ccv/provider/keeper/grpc_query.go +++ b/x/ccv/provider/keeper/grpc_query.go @@ -4,8 +4,8 @@ import ( "context" "fmt" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/interchain-security/x/ccv/provider/types" ccvtypes "github.com/cosmos/interchain-security/x/ccv/types" "google.golang.org/grpc/codes" @@ -27,7 +27,7 @@ func (k Keeper) QueryConsumerGenesis(c context.Context, req *types.QueryConsumer gen, ok := k.GetConsumerGenesis(ctx, req.ChainId) if !ok { - return nil, sdkerrors.Wrap(types.ErrUnknownConsumerChainId, req.ChainId) + return nil, errorsmod.Wrap(types.ErrUnknownConsumerChainId, req.ChainId) } return &types.QueryConsumerGenesisResponse{GenesisState: gen}, nil diff --git a/x/ccv/provider/keeper/keeper.go b/x/ccv/provider/keeper/keeper.go index 2a6638cfef..34dfa47aa5 100644 --- a/x/ccv/provider/keeper/keeper.go +++ b/x/ccv/provider/keeper/keeper.go @@ -6,9 +6,9 @@ import ( "reflect" "time" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" @@ -272,7 +272,7 @@ func (k Keeper) DeleteConsumerGenesis(ctx sdk.Context, chainID string) { // is the expected consumer chain. func (k Keeper) VerifyConsumerChain(ctx sdk.Context, channelID string, connectionHops []string) error { if len(connectionHops) != 1 { - return sdkerrors.Wrap(channeltypes.ErrTooManyConnectionHops, "must have direct connection to provider chain") + return errorsmod.Wrap(channeltypes.ErrTooManyConnectionHops, "must have direct connection to provider chain") } connectionID := connectionHops[0] clientID, tmClient, err := k.getUnderlyingClient(ctx, connectionID) @@ -281,15 +281,15 @@ func (k Keeper) VerifyConsumerChain(ctx sdk.Context, channelID string, connectio } ccvClientId, found := k.GetConsumerClientId(ctx, tmClient.ChainId) if !found { - return sdkerrors.Wrapf(ccv.ErrClientNotFound, "cannot find client for consumer chain %s", tmClient.ChainId) + return errorsmod.Wrapf(ccv.ErrClientNotFound, "cannot find client for consumer chain %s", tmClient.ChainId) } if ccvClientId != clientID { - return sdkerrors.Wrapf(ccv.ErrInvalidConsumerClient, "CCV channel must be built on top of CCV client. expected %s, got %s", ccvClientId, clientID) + return errorsmod.Wrapf(ccv.ErrInvalidConsumerClient, "CCV channel must be built on top of CCV client. expected %s, got %s", ccvClientId, clientID) } // Verify that there isn't already a CCV channel for the consumer chain if prevChannel, ok := k.GetChainToChannel(ctx, tmClient.ChainId); ok { - return sdkerrors.Wrapf(ccv.ErrDuplicateChannel, "CCV channel with ID: %s already created for consumer chain %s", prevChannel, tmClient.ChainId) + return errorsmod.Wrapf(ccv.ErrDuplicateChannel, "CCV channel with ID: %s already created for consumer chain %s", prevChannel, tmClient.ChainId) } return nil } @@ -304,10 +304,10 @@ func (k Keeper) VerifyConsumerChain(ctx sdk.Context, channelID string, connectio func (k Keeper) SetConsumerChain(ctx sdk.Context, channelID string) error { channel, ok := k.channelKeeper.GetChannel(ctx, ccv.ProviderPortID, channelID) if !ok { - return sdkerrors.Wrapf(channeltypes.ErrChannelNotFound, "channel not found for channel ID: %s", channelID) + return errorsmod.Wrapf(channeltypes.ErrChannelNotFound, "channel not found for channel ID: %s", channelID) } if len(channel.ConnectionHops) != 1 { - return sdkerrors.Wrap(channeltypes.ErrTooManyConnectionHops, "must have direct connection to consumer chain") + return errorsmod.Wrap(channeltypes.ErrTooManyConnectionHops, "must have direct connection to consumer chain") } connectionID := channel.ConnectionHops[0] clientID, tmClient, err := k.getUnderlyingClient(ctx, connectionID) @@ -317,7 +317,7 @@ func (k Keeper) SetConsumerChain(ctx sdk.Context, channelID string) error { // Verify that there isn't already a CCV channel for the consumer chain chainID := tmClient.ChainId if prevChannelID, ok := k.GetChainToChannel(ctx, chainID); ok { - return sdkerrors.Wrapf(ccv.ErrDuplicateChannel, "CCV channel with ID: %s already created for consumer chain %s", prevChannelID, chainID) + return errorsmod.Wrapf(ccv.ErrDuplicateChannel, "CCV channel with ID: %s already created for consumer chain %s", prevChannelID, chainID) } // the CCV channel is established: @@ -603,18 +603,18 @@ func (k Keeper) getUnderlyingClient(ctx sdk.Context, connectionID string) ( ) { conn, ok := k.connectionKeeper.GetConnection(ctx, connectionID) if !ok { - return "", nil, sdkerrors.Wrapf(conntypes.ErrConnectionNotFound, + return "", nil, errorsmod.Wrapf(conntypes.ErrConnectionNotFound, "connection not found for connection ID: %s", connectionID) } clientID = conn.ClientId clientState, ok := k.clientKeeper.GetClientState(ctx, clientID) if !ok { - return "", nil, sdkerrors.Wrapf(clienttypes.ErrClientNotFound, + return "", nil, errorsmod.Wrapf(clienttypes.ErrClientNotFound, "client not found for client ID: %s", conn.ClientId) } tmClient, ok = clientState.(*ibctmtypes.ClientState) if !ok { - return "", nil, sdkerrors.Wrapf(clienttypes.ErrInvalidClientType, + return "", nil, errorsmod.Wrapf(clienttypes.ErrInvalidClientType, "invalid client type. expected %s, got %s", ibcexported.Tendermint, clientState.ClientType()) } return clientID, tmClient, nil @@ -625,7 +625,7 @@ func (k Keeper) chanCloseInit(ctx sdk.Context, channelID string) error { capName := host.ChannelCapabilityPath(ccv.ProviderPortID, channelID) chanCap, ok := k.scopedKeeper.GetCapability(ctx, capName) if !ok { - return sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName) + return errorsmod.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName) } return k.channelKeeper.ChanCloseInit(ctx, ccv.ProviderPortID, channelID, chanCap) } diff --git a/x/ccv/provider/keeper/key_assignment.go b/x/ccv/provider/keeper/key_assignment.go index b74a722d87..31dcade941 100644 --- a/x/ccv/provider/keeper/key_assignment.go +++ b/x/ccv/provider/keeper/key_assignment.go @@ -3,8 +3,8 @@ package keeper import ( "fmt" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" "github.com/cosmos/interchain-security/x/ccv/provider/types" @@ -409,13 +409,13 @@ func (k Keeper) AssignConsumerKey( // This ensures that a validator joining the active set who has not explicitly assigned // a consumer key, will be able to use their provider key as consumer key (as per default). if existingVal.OperatorAddress != validator.OperatorAddress { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrConsumerKeyInUse, "a different validator already uses the consumer key", ) } _, found := k.GetValidatorConsumerPubKey(ctx, chainID, providerAddr) if !found { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrCannotAssignDefaultKeyAssignment, "a validator cannot assign the default key assignment unless its key on that consumer has already been assigned", ) @@ -425,7 +425,7 @@ func (k Keeper) AssignConsumerKey( if _, found := k.GetValidatorByConsumerAddr(ctx, chainID, consumerAddr); found { // consumer key is already in use // prevent multiple validators from assigning the same key - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrConsumerKeyInUse, "a validator has assigned the consumer key already", ) } diff --git a/x/ccv/provider/keeper/msg_server.go b/x/ccv/provider/keeper/msg_server.go index f4e3a9038e..184984494f 100644 --- a/x/ccv/provider/keeper/msg_server.go +++ b/x/ccv/provider/keeper/msg_server.go @@ -4,8 +4,8 @@ import ( "context" "encoding/base64" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" "github.com/cosmos/interchain-security/x/ccv/provider/types" ccvtypes "github.com/cosmos/interchain-security/x/ccv/types" @@ -59,7 +59,7 @@ func (k msgServer) AssignConsumerKey(goCtx context.Context, msg *types.MsgAssign // cp := ctx.ConsensusParams() // if cp != nil && cp.Validator != nil { // if !tmstrings.StringInSlice(pkType, cp.Validator.PubKeyTypes) { - // return nil, sdkerrors.Wrapf( + // return nil, errorsmod.Wrapf( // stakingtypes.ErrValidatorPubKeyTypeNotSupported, // "got: %s, expected one of: %s", pkType, cp.Validator.PubKeyTypes, // ) @@ -69,7 +69,7 @@ func (k msgServer) AssignConsumerKey(goCtx context.Context, msg *types.MsgAssign // For now, only accept ed25519. // TODO: decide what types should be supported. if pkType != "/cosmos.crypto.ed25519.PubKey" { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( stakingtypes.ErrValidatorPubKeyTypeNotSupported, "got: %s, expected: %s", pkType, "/cosmos.crypto.ed25519.PubKey", ) diff --git a/x/ccv/provider/keeper/proposal.go b/x/ccv/provider/keeper/proposal.go index 158b4af3ce..aa3147b74b 100644 --- a/x/ccv/provider/keeper/proposal.go +++ b/x/ccv/provider/keeper/proposal.go @@ -7,6 +7,7 @@ import ( channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -54,7 +55,7 @@ func (k Keeper) CreateConsumerClient(ctx sdk.Context, prop *types.ConsumerAdditi chainID := prop.ChainId // check that a client for this chain does not exist if _, found := k.GetConsumerClientId(ctx, chainID); found { - return sdkerrors.Wrap(ccv.ErrDuplicateConsumerChain, + return errorsmod.Wrap(ccv.ErrDuplicateConsumerChain, fmt.Sprintf("cannot create client for existent consumer chain: %s", chainID)) } @@ -153,7 +154,7 @@ func (k Keeper) HandleConsumerRemovalProposal(ctx sdk.Context, p *types.Consumer func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, closeChan bool) (err error) { // check that a client for chainID exists if _, found := k.GetConsumerClientId(ctx, chainID); !found { - return sdkerrors.Wrap(ccv.ErrConsumerChainNotFound, + return errorsmod.Wrap(ccv.ErrConsumerChainNotFound, fmt.Sprintf("cannot stop non-existent consumer chain: %s", chainID)) } @@ -249,14 +250,14 @@ func (k Keeper) MakeConsumerGenesis( clientState.LatestHeight = height trustPeriod, err := ccv.CalculateTrustPeriod(providerUnbondingPeriod, k.GetTrustingPeriodFraction(ctx)) if err != nil { - return gen, nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidHeight, "error %s calculating trusting_period for: %s", err, height) + return gen, nil, errorsmod.Wrapf(sdkerrors.ErrInvalidHeight, "error %s calculating trusting_period for: %s", err, height) } clientState.TrustingPeriod = trustPeriod clientState.UnbondingPeriod = providerUnbondingPeriod consState, err := k.clientKeeper.GetSelfConsensusState(ctx, height) if err != nil { - return gen, nil, sdkerrors.Wrapf(clienttypes.ErrConsensusStateNotFound, "error %s getting self consensus state for: %s", err, height) + return gen, nil, errorsmod.Wrapf(clienttypes.ErrConsensusStateNotFound, "error %s getting self consensus state for: %s", err, height) } var lastPowers []stakingtypes.LastValidatorPower @@ -275,7 +276,7 @@ func (k Keeper) MakeConsumerGenesis( val, found := k.stakingKeeper.GetValidator(ctx, addr) if !found { - return gen, nil, sdkerrors.Wrapf(stakingtypes.ErrNoValidatorFound, "error getting validator from LastValidatorPowers: %s", err) + return gen, nil, errorsmod.Wrapf(stakingtypes.ErrNoValidatorFound, "error getting validator from LastValidatorPowers: %s", err) } tmProtoPk, err := val.TmConsPublicKey() diff --git a/x/ccv/provider/keeper/relay.go b/x/ccv/provider/keeper/relay.go index eeaa0edfb3..a669d47697 100644 --- a/x/ccv/provider/keeper/relay.go +++ b/x/ccv/provider/keeper/relay.go @@ -4,8 +4,8 @@ import ( "fmt" "strconv" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" clienttypes "github.com/cosmos/ibc-go/v4/modules/core/02-client/types" channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types" @@ -125,7 +125,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac // stop consumer chain and release unbonding return k.StopConsumerChain(ctx, chainID, false) } - return sdkerrors.Wrapf(providertypes.ErrUnknownConsumerChannelId, "recv ErrorAcknowledgement on unknown channel %s", packet.SourceChannel) + return errorsmod.Wrapf(providertypes.ErrUnknownConsumerChannelId, "recv ErrorAcknowledgement on unknown channel %s", packet.SourceChannel) } return nil } @@ -137,7 +137,7 @@ func (k Keeper) OnTimeoutPacket(ctx sdk.Context, packet channeltypes.Packet) err if !found { k.Logger(ctx).Error("packet timeout, unknown channel:", "channelID", packet.SourceChannel) // abort transaction - return sdkerrors.Wrap( + return errorsmod.Wrap( channeltypes.ErrInvalidChannelState, packet.SourceChannel, ) diff --git a/x/ccv/provider/proposal_handler.go b/x/ccv/provider/proposal_handler.go index 01ffd88dac..f3d51c3947 100644 --- a/x/ccv/provider/proposal_handler.go +++ b/x/ccv/provider/proposal_handler.go @@ -1,6 +1,7 @@ package provider import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" @@ -21,7 +22,7 @@ func NewProviderProposalHandler(k keeper.Keeper) govtypes.Handler { case *types.EquivocationProposal: return k.HandleEquivocationProposal(ctx, c) default: - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized ccv proposal content type: %T", c) + return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized ccv proposal content type: %T", c) } } } diff --git a/x/ccv/provider/types/errors.go b/x/ccv/provider/types/errors.go index 89505e3fd4..bc5af3cacf 100644 --- a/x/ccv/provider/types/errors.go +++ b/x/ccv/provider/types/errors.go @@ -1,22 +1,22 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" ) // Provider sentinel errors var ( - ErrInvalidConsumerAdditionProposal = sdkerrors.Register(ModuleName, 1, "invalid consumer addition proposal") - ErrInvalidConsumerRemovalProp = sdkerrors.Register(ModuleName, 2, "invalid consumer removal proposal") - ErrUnknownConsumerChainId = sdkerrors.Register(ModuleName, 3, "no consumer chain with this chain id") - ErrUnknownConsumerChannelId = sdkerrors.Register(ModuleName, 4, "no consumer chain with this channel id") - ErrInvalidConsumerConsensusPubKey = sdkerrors.Register(ModuleName, 5, "empty consumer consensus public key") - ErrBlankConsumerChainID = sdkerrors.Register(ModuleName, 6, "consumer chain id must not be blank") - ErrConsumerKeyNotFound = sdkerrors.Register(ModuleName, 7, "consumer key not found") - ErrNoValidatorConsumerAddress = sdkerrors.Register(ModuleName, 8, "error getting validator consumer address") - ErrNoValidatorProviderAddress = sdkerrors.Register(ModuleName, 9, "error getting validator provider address") - ErrConsumerKeyInUse = sdkerrors.Register(ModuleName, 10, "consumer key is already in use by a validator") - ErrCannotAssignDefaultKeyAssignment = sdkerrors.Register(ModuleName, 11, "cannot re-assign default key assignment") - ErrInvalidConsumerParams = sdkerrors.Register(ModuleName, 12, "invalid consumer params") - ErrInvalidProviderAddress = sdkerrors.Register(ModuleName, 13, "invalid provider address") + ErrInvalidConsumerAdditionProposal = errorsmod.Register(ModuleName, 1, "invalid consumer addition proposal") + ErrInvalidConsumerRemovalProp = errorsmod.Register(ModuleName, 2, "invalid consumer removal proposal") + ErrUnknownConsumerChainId = errorsmod.Register(ModuleName, 3, "no consumer chain with this chain id") + ErrUnknownConsumerChannelId = errorsmod.Register(ModuleName, 4, "no consumer chain with this channel id") + ErrInvalidConsumerConsensusPubKey = errorsmod.Register(ModuleName, 5, "empty consumer consensus public key") + ErrBlankConsumerChainID = errorsmod.Register(ModuleName, 6, "consumer chain id must not be blank") + ErrConsumerKeyNotFound = errorsmod.Register(ModuleName, 7, "consumer key not found") + ErrNoValidatorConsumerAddress = errorsmod.Register(ModuleName, 8, "error getting validator consumer address") + ErrNoValidatorProviderAddress = errorsmod.Register(ModuleName, 9, "error getting validator provider address") + ErrConsumerKeyInUse = errorsmod.Register(ModuleName, 10, "consumer key is already in use by a validator") + ErrCannotAssignDefaultKeyAssignment = errorsmod.Register(ModuleName, 11, "cannot re-assign default key assignment") + ErrInvalidConsumerParams = errorsmod.Register(ModuleName, 12, "invalid consumer params") + ErrInvalidProviderAddress = errorsmod.Register(ModuleName, 13, "invalid provider address") ) diff --git a/x/ccv/provider/types/genesis.go b/x/ccv/provider/types/genesis.go index 0098076818..f9f804b24c 100644 --- a/x/ccv/provider/types/genesis.go +++ b/x/ccv/provider/types/genesis.go @@ -3,8 +3,8 @@ package types import ( "fmt" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" host "github.com/cosmos/ibc-go/v4/modules/core/24-host" ccv "github.com/cosmos/interchain-security/x/ccv/types" ) @@ -47,7 +47,7 @@ func DefaultGenesisState() *GenesisState { func (gs GenesisState) Validate() error { if gs.ValsetUpdateId == 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "valset update ID cannot be equal to zero") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "valset update ID cannot be equal to zero") } for _, ubdOp := range gs.UnbondingOps { @@ -58,26 +58,26 @@ func (gs GenesisState) Validate() error { for _, prop := range gs.ConsumerAdditionProposals { if err := prop.ValidateBasic(); err != nil { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, err.Error()) + return errorsmod.Wrap(ccv.ErrInvalidGenesis, err.Error()) } } for _, prop := range gs.ConsumerRemovalProposals { if err := prop.ValidateBasic(); err != nil { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, err.Error()) + return errorsmod.Wrap(ccv.ErrInvalidGenesis, err.Error()) } } if len(gs.ValsetUpdateIdToHeight) > 0 { // check only the first tuple of the list since it is ordered by VSC ID if gs.ValsetUpdateIdToHeight[0].ValsetUpdateId == 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "valset update ID cannot be equal to zero") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "valset update ID cannot be equal to zero") } } for _, cs := range gs.ConsumerStates { if err := cs.Validate(); err != nil { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, fmt.Sprintf("%s: for consumer chain id: %s", err, cs.ChainId)) + return errorsmod.Wrap(ccv.ErrInvalidGenesis, fmt.Sprintf("%s: for consumer chain id: %s", err, cs.ChainId)) } } @@ -97,7 +97,7 @@ func (gs GenesisState) Validate() error { func (gs GenesisState) ValidateUnbondingOp(ubdOp UnbondingOp) error { if len(ubdOp.UnbondingConsumerChains) == 0 { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, "unbonding operations cannot have an empty consumer chain list") + return errorsmod.Wrap(ccv.ErrInvalidGenesis, "unbonding operations cannot have an empty consumer chain list") } // Check that the ID is set correctly in the UnbondingOpsIndex @@ -119,7 +119,7 @@ func (gs GenesisState) ValidateUnbondingOp(ubdOp UnbondingOp) error { } } if !found { - return sdkerrors.Wrap(ccv.ErrInvalidGenesis, + return errorsmod.Wrap(ccv.ErrInvalidGenesis, fmt.Sprintf("unbonding operation without UnbondingOpsIndex, opID=%d, chainID=%s", ubdOp.Id, chainID)) } } diff --git a/x/ccv/provider/types/key_assignment.go b/x/ccv/provider/types/key_assignment.go index 380b70c847..450f32c918 100644 --- a/x/ccv/provider/types/key_assignment.go +++ b/x/ccv/provider/types/key_assignment.go @@ -4,8 +4,8 @@ import ( "fmt" "strings" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ccvtypes "github.com/cosmos/interchain-security/x/ccv/types" ) @@ -57,34 +57,34 @@ func KeyAssignmentValidateBasic( ) error { for _, e := range assignedKeys { if strings.TrimSpace(e.ChainId) == "" { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, "consumer chain id must not be blank") + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, "consumer chain id must not be blank") } if err := sdk.VerifyAddressFormat(e.ProviderAddr.ToSdkConsAddr()); err != nil { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid provider address: %s", e.ProviderAddr)) + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid provider address: %s", e.ProviderAddr)) } if e.ConsumerKey == nil { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid consumer key: %s", e.ConsumerKey)) + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid consumer key: %s", e.ConsumerKey)) } } for _, e := range byConsumerAddrs { if strings.TrimSpace(e.ChainId) == "" { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, "consumer chain id must not be blank") + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, "consumer chain id must not be blank") } if err := sdk.VerifyAddressFormat(e.ProviderAddr.ToSdkConsAddr()); err != nil { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid provider address: %s", e.ProviderAddr)) + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid provider address: %s", e.ProviderAddr)) } if err := sdk.VerifyAddressFormat(e.ConsumerAddr.ToSdkConsAddr()); err != nil { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid consumer address: %s", e.ConsumerAddr)) + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid consumer address: %s", e.ConsumerAddr)) } } for _, e := range consumerAddrsToPrune { if strings.TrimSpace(e.ChainId) == "" { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, "consumer chain id must not be blank") + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, "consumer chain id must not be blank") } // Don't check e.vscid, it's an unsigned integer for _, a := range e.ConsumerAddrs.Addresses { if err := sdk.VerifyAddressFormat(a.ToSdkConsAddr()); err != nil { - return sdkerrors.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid consumer address: %s", a)) + return errorsmod.Wrap(ccvtypes.ErrInvalidGenesis, fmt.Sprintf("invalid consumer address: %s", a)) } } } diff --git a/x/ccv/provider/types/proposal.go b/x/ccv/provider/types/proposal.go index f5c702a322..bf7ed68ce2 100644 --- a/x/ccv/provider/types/proposal.go +++ b/x/ccv/provider/types/proposal.go @@ -6,7 +6,7 @@ import ( "strings" time "time" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" evidencetypes "github.com/cosmos/cosmos-sdk/x/evidence/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" clienttypes "github.com/cosmos/ibc-go/v4/modules/core/02-client/types" @@ -80,46 +80,46 @@ func (cccp *ConsumerAdditionProposal) ValidateBasic() error { } if strings.TrimSpace(cccp.ChainId) == "" { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "consumer chain id must not be blank") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "consumer chain id must not be blank") } if cccp.InitialHeight.IsZero() { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "initial height cannot be zero") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "initial height cannot be zero") } if len(cccp.GenesisHash) == 0 { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "genesis hash cannot be empty") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "genesis hash cannot be empty") } if len(cccp.BinaryHash) == 0 { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "binary hash cannot be empty") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "binary hash cannot be empty") } if cccp.SpawnTime.IsZero() { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "spawn time cannot be zero") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "spawn time cannot be zero") } if err := ccvtypes.ValidateStringFraction(cccp.ConsumerRedistributionFraction); err != nil { - return sdkerrors.Wrapf(ErrInvalidConsumerAdditionProposal, "consumer redistribution fraction is invalid: %s", err) + return errorsmod.Wrapf(ErrInvalidConsumerAdditionProposal, "consumer redistribution fraction is invalid: %s", err) } if err := ccvtypes.ValidatePositiveInt64(cccp.BlocksPerDistributionTransmission); err != nil { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "blocks per distribution transmission cannot be < 1") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "blocks per distribution transmission cannot be < 1") } if err := ccvtypes.ValidatePositiveInt64(cccp.HistoricalEntries); err != nil { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "historical entries cannot be < 1") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "historical entries cannot be < 1") } if err := ccvtypes.ValidateDuration(cccp.CcvTimeoutPeriod); err != nil { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "ccv timeout period cannot be zero") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "ccv timeout period cannot be zero") } if err := ccvtypes.ValidateDuration(cccp.TransferTimeoutPeriod); err != nil { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "transfer timeout period cannot be zero") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "transfer timeout period cannot be zero") } if err := ccvtypes.ValidateDuration(cccp.UnbondingPeriod); err != nil { - return sdkerrors.Wrap(ErrInvalidConsumerAdditionProposal, "unbonding period cannot be zero") + return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "unbonding period cannot be zero") } return nil @@ -179,11 +179,11 @@ func (sccp *ConsumerRemovalProposal) ValidateBasic() error { } if strings.TrimSpace(sccp.ChainId) == "" { - return sdkerrors.Wrap(ErrInvalidConsumerRemovalProp, "consumer chain id must not be blank") + return errorsmod.Wrap(ErrInvalidConsumerRemovalProp, "consumer chain id must not be blank") } if sccp.StopTime.IsZero() { - return sdkerrors.Wrap(ErrInvalidConsumerRemovalProp, "spawn time cannot be zero") + return errorsmod.Wrap(ErrInvalidConsumerRemovalProp, "spawn time cannot be zero") } return nil } diff --git a/x/ccv/types/ccv.go b/x/ccv/types/ccv.go index a94a4dc549..6ec3a6c7c3 100644 --- a/x/ccv/types/ccv.go +++ b/x/ccv/types/ccv.go @@ -3,7 +3,7 @@ package types import ( "fmt" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" abci "github.com/tendermint/tendermint/abci/types" ) @@ -19,10 +19,10 @@ func NewValidatorSetChangePacketData(valUpdates []abci.ValidatorUpdate, valUpdat // ValidateBasic is used for validating the CCV packet data. func (vsc ValidatorSetChangePacketData) ValidateBasic() error { if len(vsc.ValidatorUpdates) == 0 { - return sdkerrors.Wrap(ErrInvalidPacketData, "validator updates cannot be empty") + return errorsmod.Wrap(ErrInvalidPacketData, "validator updates cannot be empty") } if vsc.ValsetUpdateId == 0 { - return sdkerrors.Wrap(ErrInvalidPacketData, "valset update id cannot be equal to zero") + return errorsmod.Wrap(ErrInvalidPacketData, "valset update id cannot be equal to zero") } return nil } @@ -41,7 +41,7 @@ func NewVSCMaturedPacketData(valUpdateID uint64) *VSCMaturedPacketData { // ValidateBasic is used for validating the VSCMatured packet data. func (mat VSCMaturedPacketData) ValidateBasic() error { if mat.ValsetUpdateId == 0 { - return sdkerrors.Wrap(ErrInvalidPacketData, "vscId cannot be equal to zero") + return errorsmod.Wrap(ErrInvalidPacketData, "vscId cannot be equal to zero") } return nil } @@ -61,11 +61,11 @@ func NewSlashPacketData(validator abci.Validator, valUpdateId uint64, infraction func (vdt SlashPacketData) ValidateBasic() error { if len(vdt.Validator.Address) == 0 || vdt.Validator.Power == 0 { - return sdkerrors.Wrap(ErrInvalidPacketData, "validator fields cannot be empty") + return errorsmod.Wrap(ErrInvalidPacketData, "validator fields cannot be empty") } if vdt.Infraction == stakingtypes.InfractionEmpty { - return sdkerrors.Wrap(ErrInvalidPacketData, "invalid infraction type") + return errorsmod.Wrap(ErrInvalidPacketData, "invalid infraction type") } return nil diff --git a/x/ccv/types/errors.go b/x/ccv/types/errors.go index 7b67a02d60..79c0e1e31c 100644 --- a/x/ccv/types/errors.go +++ b/x/ccv/types/errors.go @@ -1,28 +1,28 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" ) // CCV sentinel errors var ( - ErrInvalidPacketData = sdkerrors.Register(ModuleName, 2, "invalid CCV packet data") - ErrInvalidPacketTimeout = sdkerrors.Register(ModuleName, 3, "invalid packet timeout") - ErrInvalidVersion = sdkerrors.Register(ModuleName, 4, "invalid CCV version") - ErrInvalidChannelFlow = sdkerrors.Register(ModuleName, 5, "invalid message sent to channel end") - ErrInvalidConsumerChain = sdkerrors.Register(ModuleName, 6, "invalid consumer chain") - ErrInvalidProviderChain = sdkerrors.Register(ModuleName, 7, "invalid provider chain") - ErrInvalidStatus = sdkerrors.Register(ModuleName, 8, "invalid channel status") - ErrInvalidGenesis = sdkerrors.Register(ModuleName, 9, "invalid genesis state") - ErrDuplicateChannel = sdkerrors.Register(ModuleName, 10, "CCV channel already exists") - ErrInvalidVSCMaturedId = sdkerrors.Register(ModuleName, 11, "invalid vscId for VSC packet") - ErrInvalidVSCMaturedTime = sdkerrors.Register(ModuleName, 12, "invalid maturity time for VSC packet") - ErrInvalidConsumerState = sdkerrors.Register(ModuleName, 13, "provider chain has invalid state for consumer chain") - ErrInvalidConsumerClient = sdkerrors.Register(ModuleName, 14, "ccv channel is not built on correct client") - ErrInvalidProposal = sdkerrors.Register(ModuleName, 15, "invalid proposal") - ErrInvalidHandshakeMetadata = sdkerrors.Register(ModuleName, 16, "invalid provider handshake metadata") - ErrChannelNotFound = sdkerrors.Register(ModuleName, 17, "channel not found") - ErrClientNotFound = sdkerrors.Register(ModuleName, 18, "client not found") - ErrDuplicateConsumerChain = sdkerrors.Register(ModuleName, 19, "consumer chain already exists") - ErrConsumerChainNotFound = sdkerrors.Register(ModuleName, 20, "consumer chain not found") + ErrInvalidPacketData = errorsmod.Register(ModuleName, 2, "invalid CCV packet data") + ErrInvalidPacketTimeout = errorsmod.Register(ModuleName, 3, "invalid packet timeout") + ErrInvalidVersion = errorsmod.Register(ModuleName, 4, "invalid CCV version") + ErrInvalidChannelFlow = errorsmod.Register(ModuleName, 5, "invalid message sent to channel end") + ErrInvalidConsumerChain = errorsmod.Register(ModuleName, 6, "invalid consumer chain") + ErrInvalidProviderChain = errorsmod.Register(ModuleName, 7, "invalid provider chain") + ErrInvalidStatus = errorsmod.Register(ModuleName, 8, "invalid channel status") + ErrInvalidGenesis = errorsmod.Register(ModuleName, 9, "invalid genesis state") + ErrDuplicateChannel = errorsmod.Register(ModuleName, 10, "CCV channel already exists") + ErrInvalidVSCMaturedId = errorsmod.Register(ModuleName, 11, "invalid vscId for VSC packet") + ErrInvalidVSCMaturedTime = errorsmod.Register(ModuleName, 12, "invalid maturity time for VSC packet") + ErrInvalidConsumerState = errorsmod.Register(ModuleName, 13, "provider chain has invalid state for consumer chain") + ErrInvalidConsumerClient = errorsmod.Register(ModuleName, 14, "ccv channel is not built on correct client") + ErrInvalidProposal = errorsmod.Register(ModuleName, 15, "invalid proposal") + ErrInvalidHandshakeMetadata = errorsmod.Register(ModuleName, 16, "invalid provider handshake metadata") + ErrChannelNotFound = errorsmod.Register(ModuleName, 17, "channel not found") + ErrClientNotFound = errorsmod.Register(ModuleName, 18, "client not found") + ErrDuplicateConsumerChain = errorsmod.Register(ModuleName, 19, "consumer chain already exists") + ErrConsumerChainNotFound = errorsmod.Register(ModuleName, 20, "consumer chain not found") ) diff --git a/x/ccv/types/utils.go b/x/ccv/types/utils.go index 7cb8e64d98..1d75152186 100644 --- a/x/ccv/types/utils.go +++ b/x/ccv/types/utils.go @@ -5,9 +5,9 @@ import ( "sort" "time" + errorsmod "cosmossdk.io/errors" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" clienttypes "github.com/cosmos/ibc-go/v4/modules/core/02-client/types" channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types" host "github.com/cosmos/ibc-go/v4/modules/core/24-host" @@ -67,17 +67,17 @@ func SendIBCPacket( ) error { channel, ok := channelKeeper.GetChannel(ctx, portID, channelID) if !ok { - return sdkerrors.Wrapf(channeltypes.ErrChannelNotFound, "channel not found for channel ID: %s", channelID) + return errorsmod.Wrapf(channeltypes.ErrChannelNotFound, "channel not found for channel ID: %s", channelID) } channelCap, ok := scopedKeeper.GetCapability(ctx, host.ChannelCapabilityPath(portID, channelID)) if !ok { - return sdkerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, "module does not own channel capability") + return errorsmod.Wrap(channeltypes.ErrChannelCapabilityNotFound, "module does not own channel capability") } // get the next sequence sequence, found := channelKeeper.GetNextSequenceSend(ctx, portID, channelID) if !found { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( channeltypes.ErrSequenceSendNotFound, "source port: %s, source channel: %s", portID, channelID, )