From 55ff98964cc707f4bfa4246b3cbb423134fdbf88 Mon Sep 17 00:00:00 2001 From: Arham Chordia <43543921+arhamchordia@users.noreply.github.com> Date: Mon, 13 Feb 2023 13:36:57 +0530 Subject: [PATCH] Fixing lint errors. --- wasmbinding/callback.go | 8 +- wasmbinding/message_plugin.go | 58 +++++++-------- wasmbinding/query_plugin.go | 13 ++-- x/epochs/handler.go | 3 +- x/epochs/types/errors.go | 4 +- x/intergamm/handler.go | 3 +- x/intergamm/ibc_module.go | 13 ++-- ..._query_ica_address_on_denom_native_zone.go | 9 ++- .../keeper/grpc_query_ica_address_on_zone.go | 7 +- x/intergamm/keeper/ibc_callbacks.go | 73 +++++++++---------- x/intergamm/keeper/ibc_transfer.go | 17 +++-- x/intergamm/keeper/keeper.go | 31 ++++---- x/intergamm/types/errors.go | 20 ++--- ...ssage_register_ica_on_denom_native_zone.go | 5 +- .../types/message_register_ica_on_zone.go | 5 +- .../message_register_interchain_account.go | 7 +- x/intergamm/types/message_send_token.go | 11 +-- .../types/message_send_token_to_ica.go | 9 ++- x/intergamm/types/message_test_scenario.go | 5 +- .../message_transmit_ibc_begin_unlocking.go | 9 ++- .../types/message_transmit_ibc_exit_pool.go | 11 +-- ...ransmit_ibc_exit_swap_extern_amount_out.go | 11 +-- .../types/message_transmit_ibc_join_pool.go | 11 +-- ...transmit_ibc_join_swap_extern_amount_in.go | 11 +-- .../types/message_transmit_ibc_lock_tokens.go | 16 ++-- .../types/message_transmit_ica_transfer.go | 9 ++- x/qoracle/bandchain/ibc_module.go | 13 ++-- x/qoracle/bandchain/keeper/relay.go | 17 +++-- x/qoracle/bandchain/types/errors.go | 4 +- x/qoracle/osmosis/ibc_module.go | 15 ++-- x/qoracle/osmosis/keeper/relay.go | 17 +++-- x/qoracle/osmosis/types/errors.go | 12 +-- x/qoracle/osmosis/types/msgs.go | 3 +- x/qoracle/types/denom_symbol_mapping.go | 8 +- x/qoracle/types/errors.go | 8 +- x/qoracle/types/msgs.go | 7 +- x/qoracle/utils/send_packet.go | 9 ++- 37 files changed, 259 insertions(+), 233 deletions(-) diff --git a/wasmbinding/callback.go b/wasmbinding/callback.go index 1ed934b00..d2d7da147 100644 --- a/wasmbinding/callback.go +++ b/wasmbinding/callback.go @@ -10,10 +10,10 @@ import ( "github.com/gogo/protobuf/proto" "github.com/tendermint/tendermint/libs/log" + "cosmossdk.io/errors" "github.com/CosmWasm/wasmd/x/wasm" wasmk "github.com/CosmWasm/wasmd/x/wasm/keeper" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ibctransfertypes "github.com/cosmos/ibc-go/v5/modules/apps/transfer/types" gammbalancer "github.com/quasarlabs/quasarnode/osmosis/gamm/pool-models/balancer" gammtypes "github.com/quasarlabs/quasarnode/osmosis/gamm/types" @@ -127,7 +127,7 @@ func (c *CallbackPlugin) doHandle(ctx sdk.Context, seq uint64, channel string, p resp := new(bytes.Buffer) err := m.Marshal(resp, response) if err != nil { - return sdkerrors.Wrap(err, "ibc ack callback marshalling") + return errors.Wrap(err, "ibc ack callback marshalling") } data, err := json.Marshal(ContractAck{ @@ -144,13 +144,13 @@ func (c *CallbackPlugin) doHandle(ctx sdk.Context, seq uint64, channel string, p }) if err != nil { - return sdkerrors.Wrap(err, "ibc ack callback") + return errors.Wrap(err, "ibc ack callback") } c.Logger(ctx).Info(fmt.Sprintf("Preparing callback message: %v", string(data))) _, err = c.contractKeeper.Execute(ctx, addr, c.callBackAddress, data, nil) if err != nil { - return sdkerrors.Wrap(err, "ack callback execute") + return errors.Wrap(err, "ack callback execute") } return nil diff --git a/wasmbinding/message_plugin.go b/wasmbinding/message_plugin.go index efb6a2549..2c0e4d8ab 100644 --- a/wasmbinding/message_plugin.go +++ b/wasmbinding/message_plugin.go @@ -4,10 +4,10 @@ import ( "encoding/json" "time" + "cosmossdk.io/errors" wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper" wasmvmtypes "github.com/CosmWasm/wasmvm/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" "github.com/quasarlabs/quasarnode/wasmbinding/bindings" @@ -41,7 +41,7 @@ func (m *CustomMessenger) DispatchMsg(ctx sdk.Context, contractAddr sdk.AccAddre // leave everything else for the wrapped version var contractMsg bindings.QuasarMsg if err := json.Unmarshal(msg.Custom, &contractMsg); err != nil { - return nil, nil, sdkerrors.Wrap(err, "osmosis msg") + return nil, nil, errors.Wrap(err, "osmosis msg") } if contractMsg.TestScenario != nil { return m.testScenario(ctx, contractAddr, contractMsg.TestScenario) @@ -78,7 +78,7 @@ func (m *CustomMessenger) testScenario(ctx sdk.Context, contractAddr sdk.AccAddr err := PerformTestScenario(m.intergammKeeper, ctx, contractAddr, testScenario) // err := PerformCreateDenom(m.tokenFactory, m.bank, ctx, contractAddr, createDenom) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "perform test scenario") + return nil, nil, errors.Wrap(err, "perform test scenario") } return nil, nil, nil } @@ -95,7 +95,7 @@ func PerformTestScenario(k *intergammkeeper.Keeper, ctx sdk.Context, contractAdd // msgCreateDenom := tokenfactorytypes.NewMsgCreateDenom(contractAddr.String(), createDenom.Subdenom) if err := msgTestScenario.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "failed validating MsgTestScenario") + return errors.Wrap(err, "failed validating MsgTestScenario") } // Run the test scenario @@ -104,7 +104,7 @@ func PerformTestScenario(k *intergammkeeper.Keeper, ctx sdk.Context, contractAdd msgTestScenario, ) if err != nil { - return sdkerrors.Wrap(err, "running test scenario") + return errors.Wrap(err, "running test scenario") } return nil } @@ -112,7 +112,7 @@ func PerformTestScenario(k *intergammkeeper.Keeper, ctx sdk.Context, contractAdd func (m *CustomMessenger) sendToken(ctx sdk.Context, contractAddr sdk.AccAddress, send *bindings.SendToken) ([]sdk.Event, [][]byte, error) { err := PerformSendToken(m.intergammKeeper, m.bank, ctx, contractAddr, send, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "send token") + return nil, nil, errors.Wrap(err, "send token") } return nil, nil, nil } @@ -123,13 +123,13 @@ func PerformSendToken(k *intergammkeeper.Keeper, b *bankkeeper.BaseKeeper, ctx s } sdkMsg := intergammtypes.NewMsgSendToken(contractAddr.String(), send.DestinationLocalZoneId, send.Receiver, send.Coin) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.SendToken(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "sending tokens") + return errors.Wrap(err, "sending tokens") } // register the packet as sent with the callback plugin @@ -140,7 +140,7 @@ func PerformSendToken(k *intergammkeeper.Keeper, b *bankkeeper.BaseKeeper, ctx s func (m *CustomMessenger) RegisterICAOnZone(ctx sdk.Context, contractAddr sdk.Address, register *bindings.RegisterICAOnZone) ([]sdk.Event, [][]byte, error) { err := PerformRegisterICAOnZone(m.intergammKeeper, ctx, contractAddr, register) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "register ica account") + return nil, nil, errors.Wrap(err, "register ica account") } return nil, nil, nil } @@ -152,13 +152,13 @@ func PerformRegisterICAOnZone(k *intergammkeeper.Keeper, ctx sdk.Context, contra sdkMsg := intergammtypes.NewMsgRegisterICAOnZone(contractAddr.String(), register.ZoneId) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) _, err := msgServer.RegisterICAOnZone(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "register interchain account") + return errors.Wrap(err, "register interchain account") } return nil } @@ -166,7 +166,7 @@ func PerformRegisterICAOnZone(k *intergammkeeper.Keeper, ctx sdk.Context, contra func (m *CustomMessenger) OsmosisJoinPool(ctx sdk.Context, contractAddr sdk.AccAddress, join *bindings.OsmosisJoinPool) ([]sdk.Event, [][]byte, error) { err := PerformOsmosisJoinPool(m.intergammKeeper, ctx, contractAddr, join, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "join pool") + return nil, nil, errors.Wrap(err, "join pool") } return nil, nil, nil } @@ -179,13 +179,13 @@ func PerformOsmosisJoinPool(k *intergammkeeper.Keeper, ctx sdk.Context, contract // TODO see if hardcoding creator like this works sdkMsg := intergammtypes.NewMsgTransmitIbcJoinPool(contractAddr.String(), join.ConnectionId, join.TimeoutTimestamp, join.PoolId, join.ShareOutAmount, join.TokenInMaxs) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.TransmitIbcJoinPool(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "join pool") + return errors.Wrap(err, "join pool") } cb.OnSendPacket(ctx, res.Seq, res.Channel, res.PortId, contractAddr) @@ -195,7 +195,7 @@ func PerformOsmosisJoinPool(k *intergammkeeper.Keeper, ctx sdk.Context, contract func (m *CustomMessenger) OsmosisExitPool(ctx sdk.Context, contractAddr sdk.AccAddress, exit *bindings.OsmosisExitPool) ([]sdk.Event, [][]byte, error) { err := PerformOsmosisExitPool(m.intergammKeeper, ctx, contractAddr, exit, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "exit pool") + return nil, nil, errors.Wrap(err, "exit pool") } return nil, nil, nil } @@ -207,13 +207,13 @@ func PerformOsmosisExitPool(k *intergammkeeper.Keeper, ctx sdk.Context, contract sdkMsg := intergammtypes.NewMsgTransmitIbcExitPool(contractAddr.String(), exit.ConnectionId, exit.TimeoutTimestamp, exit.PoolId, exit.ShareInAmount, exit.TokenOutMins) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.TransmitIbcExitPool(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "exit pool") + return errors.Wrap(err, "exit pool") } cb.OnSendPacket(ctx, res.GetSeq(), res.Channel, res.PortId, contractAddr) @@ -223,7 +223,7 @@ func PerformOsmosisExitPool(k *intergammkeeper.Keeper, ctx sdk.Context, contract func (m *CustomMessenger) OsmosisLockTokens(ctx sdk.Context, contractAddr sdk.AccAddress, withdraw *bindings.OsmosisLockTokens) ([]sdk.Event, [][]byte, error) { err := PerformOsmosisLockTokens(m.intergammKeeper, ctx, contractAddr, withdraw, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "withdraw") + return nil, nil, errors.Wrap(err, "withdraw") } return nil, nil, nil } @@ -236,13 +236,13 @@ func PerformOsmosisLockTokens(k *intergammkeeper.Keeper, ctx sdk.Context, contra // TODO: lets make sure the way we do durations is correct sdkMsg := intergammtypes.NewMsgTransmitIbcLockTokens(contractAddr.String(), lock.ConnectionId, lock.TimeoutTimestamp, time.Duration(lock.Duration), lock.Coins) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.TransmitIbcLockTokens(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "lock tokens") + return errors.Wrap(err, "lock tokens") } cb.OnSendPacket(ctx, res.GetSeq(), res.Channel, res.PortId, contractAddr) @@ -252,7 +252,7 @@ func PerformOsmosisLockTokens(k *intergammkeeper.Keeper, ctx sdk.Context, contra func (m *CustomMessenger) OsmosisBeginUnlocking(ctx sdk.Context, contractAddr sdk.AccAddress, begin *bindings.OsmosisBeginUnlocking) ([]sdk.Event, [][]byte, error) { err := PerformOsmosisBeginUnlocking(m.intergammKeeper, ctx, contractAddr, begin, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "begin unlocking") + return nil, nil, errors.Wrap(err, "begin unlocking") } return nil, nil, nil } @@ -264,13 +264,13 @@ func PerformOsmosisBeginUnlocking(k *intergammkeeper.Keeper, ctx sdk.Context, co sdkMsg := intergammtypes.NewMsgTransmitIbcBeginUnlocking(contractAddr.String(), begin.ConnectionId, begin.TimeoutTimestamp, begin.Id, begin.Coins) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.TransmitIbcBeginUnlocking(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "begin unlocking") + return errors.Wrap(err, "begin unlocking") } cb.OnSendPacket(ctx, res.GetSeq(), res.Channel, res.PortId, contractAddr) @@ -280,7 +280,7 @@ func PerformOsmosisBeginUnlocking(k *intergammkeeper.Keeper, ctx sdk.Context, co func (m *CustomMessenger) OsmosisJoinSwapExternAmountIn(ctx sdk.Context, contractAddr sdk.AccAddress, join *bindings.OsmosisJoinSwapExternAmountIn) ([]sdk.Event, [][]byte, error) { err := PerformOsmosisJoinSwapExternAmountIn(m.intergammKeeper, ctx, contractAddr, join, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "join swap extern amount in") + return nil, nil, errors.Wrap(err, "join swap extern amount in") } return nil, nil, nil } @@ -292,13 +292,13 @@ func PerformOsmosisJoinSwapExternAmountIn(k *intergammkeeper.Keeper, ctx sdk.Con sdkMsg := intergammtypes.NewMsgTransmitIbcJoinSwapExternAmountIn(contractAddr.String(), join.ConnectionId, join.TimeoutTimestamp, join.PoolId, join.ShareOutMinAmount, join.TokenIn) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.TransmitIbcJoinSwapExternAmountIn(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "join swap extern amount in") + return errors.Wrap(err, "join swap extern amount in") } cb.OnSendPacket(ctx, res.GetSeq(), res.Channel, res.PortId, contractAddr) @@ -309,7 +309,7 @@ func PerformOsmosisJoinSwapExternAmountIn(k *intergammkeeper.Keeper, ctx sdk.Con func (m *CustomMessenger) OsmosisExitSwapExternAmountOut(ctx sdk.Context, contractAddr sdk.AccAddress, exit *bindings.OsmosisExitSwapExternAmountOut) ([]sdk.Event, [][]byte, error) { err := PerformOsmosisExitSwapExternAmountOut(m.intergammKeeper, ctx, contractAddr, exit, m.callback) if err != nil { - return nil, nil, sdkerrors.Wrap(err, "exit swap extern amount out") + return nil, nil, errors.Wrap(err, "exit swap extern amount out") } return nil, nil, nil } @@ -321,13 +321,13 @@ func PerformOsmosisExitSwapExternAmountOut(k *intergammkeeper.Keeper, ctx sdk.Co sdkMsg := intergammtypes.NewMsgTransmitIbcExitSwapExternAmountOut(contractAddr.String(), exit.ConnectionId, exit.TimeoutTimestamp, exit.PoolId, exit.ShareInAmount, exit.TokenOutMins) if err := sdkMsg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "basic validate msg") + return errors.Wrap(err, "basic validate msg") } msgServer := intergammkeeper.NewMsgServerImpl(k) res, err := msgServer.TransmitIbcExitSwapExternAmountOut(sdk.WrapSDKContext(ctx), sdkMsg) if err != nil { - return sdkerrors.Wrap(err, "join swap extern amount out") + return errors.Wrap(err, "join swap extern amount out") } cb.OnSendPacket(ctx, res.GetSeq(), res.Channel, res.PortId, contractAddr) diff --git a/wasmbinding/query_plugin.go b/wasmbinding/query_plugin.go index b69f12e13..c31ebe2ae 100644 --- a/wasmbinding/query_plugin.go +++ b/wasmbinding/query_plugin.go @@ -3,6 +3,7 @@ package wasmbinding import ( "encoding/json" + "cosmossdk.io/errors" wasmvmtypes "github.com/CosmWasm/wasmvm/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -14,7 +15,7 @@ func CustomQuerier(qk qoraclekeeper.Keeper) func(ctx sdk.Context, request json.R return func(ctx sdk.Context, request json.RawMessage) ([]byte, error) { var contractQuery bindings.QuasarQuery if err := json.Unmarshal(request, &contractQuery); err != nil { - return nil, sdkerrors.Wrap(err, "osmosis query") + return nil, errors.Wrap(err, "osmosis query") } switch { @@ -23,29 +24,29 @@ func CustomQuerier(qk qoraclekeeper.Keeper) func(ctx sdk.Context, request json.R bz, err := json.Marshal(pools) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to marshal quasar qoracle pools") + return nil, errors.Wrap(err, "failed to marshal quasar qoracle pools") } return bz, nil case contractQuery.Pool != nil: pool, found := qk.GetPool(ctx, contractQuery.Pool.Id) if !found { - return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "pool not found") + return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "pool not found") } bz, err := json.Marshal(pool) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to marshal quasar pool") + return nil, errors.Wrap(err, "failed to marshal quasar pool") } return bz, nil case contractQuery.TokenPrice != nil: price, err := qk.GetDenomPrice(ctx, contractQuery.TokenPrice.Denom) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to get token price") + return nil, errors.Wrap(err, "failed to get token price") } bz, err := price.MarshalJSON() if err != nil { - return nil, sdkerrors.Wrap(err, "failed to marshal quasar token price") + return nil, errors.Wrap(err, "failed to marshal quasar token price") } return bz, nil default: diff --git a/x/epochs/handler.go b/x/epochs/handler.go index 8c7c5467f..1c7f1c517 100644 --- a/x/epochs/handler.go +++ b/x/epochs/handler.go @@ -1,6 +1,7 @@ package epochs import ( + "cosmossdk.io/errors" "fmt" sdk "github.com/cosmos/cosmos-sdk/types" @@ -15,7 +16,7 @@ func NewHandler(k *keeper.Keeper) sdk.Handler { switch msg := msg.(type) { default: errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg) - return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) + return nil, errors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) } } } diff --git a/x/epochs/types/errors.go b/x/epochs/types/errors.go index 0c13f2f4e..862294b1d 100644 --- a/x/epochs/types/errors.go +++ b/x/epochs/types/errors.go @@ -3,10 +3,10 @@ package types // DONTCOVER import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // x/epochs module sentinel errors. var ( - ErrSample = sdkerrors.Register(ModuleName, 1100, "sample error") + ErrSample = errors.Register(ModuleName, 1100, "sample error") ) diff --git a/x/intergamm/handler.go b/x/intergamm/handler.go index da579a0f9..5179fc986 100644 --- a/x/intergamm/handler.go +++ b/x/intergamm/handler.go @@ -3,6 +3,7 @@ package intergamm import ( "fmt" + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/quasarlabs/quasarnode/x/intergamm/keeper" @@ -56,7 +57,7 @@ func NewHandler(k *keeper.Keeper) sdk.Handler { // this line is used by starport scaffolding # 1 default: errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg) - return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) + return nil, errors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) } } } diff --git a/x/intergamm/ibc_module.go b/x/intergamm/ibc_module.go index c135d5ab1..9af3064c8 100644 --- a/x/intergamm/ibc_module.go +++ b/x/intergamm/ibc_module.go @@ -3,6 +3,7 @@ package intergamm import ( "fmt" + "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" @@ -127,7 +128,7 @@ func (im IBCModule) OnRecvPacket( packet channeltypes.Packet, relayer sdk.AccAddress, ) ibcexported.Acknowledgement { - err := sdkerrors.Wrapf(icatypes.ErrInvalidChannelFlow, "cannot receive packet via interchain accounts authentication module") + err := errors.Wrapf(icatypes.ErrInvalidChannelFlow, "cannot receive packet via interchain accounts authentication module") return channeltypes.NewErrorAcknowledgement(err) } @@ -144,13 +145,13 @@ func (im IBCModule) OnAcknowledgementPacket( icaPacket, err := parseIcaPacket(packet) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal ICS-27 ica packet data: %s", err.Error()) + return errors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal ICS-27 ica packet data: %s", err.Error()) } ack := channeltypes.Acknowledgement{} err = icatypes.ModuleCdc.UnmarshalJSON(acknowledgement, &ack) if err != nil { - return sdkerrors.Wrapf(icatypes.ErrUnknownDataType, "cannot unmarshal IBC acknowledgement") + return errors.Wrapf(icatypes.ErrUnknownDataType, "cannot unmarshal IBC acknowledgement") } return im.keeper.HandleIcaAcknowledgement(ctx, packet.GetSequence(), packet.SourceChannel, packet.SourcePort, icaPacket, ack) @@ -166,7 +167,7 @@ func (im IBCModule) OnTimeoutPacket( icaPacket, err := parseIcaPacket(packet) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal ICS-27 ica packet data: %s", err.Error()) + return errors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal ICS-27 ica packet data: %s", err.Error()) } return im.keeper.HandleIcaTimeout(ctx, packet.GetSequence(), icaPacket) @@ -192,11 +193,11 @@ func parseIcaPacket(packet channeltypes.Packet) (icatypes.InterchainAccountPacke var icaPacket icatypes.InterchainAccountPacketData err := icatypes.ModuleCdc.UnmarshalJSON(packet.GetData(), &icaPacket) if err != nil { - return icaPacket, sdkerrors.Wrapf(icatypes.ErrUnknownDataType, "cannot unmarshal ICS-27 interchain account packet data") + return icaPacket, errors.Wrapf(icatypes.ErrUnknownDataType, "cannot unmarshal ICS-27 interchain account packet data") } if icaPacket.Type != icatypes.EXECUTE_TX { - return icaPacket, sdkerrors.Wrapf(icatypes.ErrUnsupported, "only EXECUTE_TX ICA callbacks are supported") + return icaPacket, errors.Wrapf(icatypes.ErrUnsupported, "only EXECUTE_TX ICA callbacks are supported") } return icaPacket, nil diff --git a/x/intergamm/keeper/grpc_query_ica_address_on_denom_native_zone.go b/x/intergamm/keeper/grpc_query_ica_address_on_denom_native_zone.go index e1c7f03b2..58acb8a11 100644 --- a/x/intergamm/keeper/grpc_query_ica_address_on_denom_native_zone.go +++ b/x/intergamm/keeper/grpc_query_ica_address_on_denom_native_zone.go @@ -2,9 +2,10 @@ package keeper import ( "context" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/quasarlabs/quasarnode/x/intergamm/types" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -18,16 +19,16 @@ func (k Keeper) ICAAddressOnDenomNativeZone(goCtx context.Context, req *types.Qu ctx := sdk.UnwrapSDKContext(goCtx) if _, err := sdk.AccAddressFromBech32(req.Owner); err != nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid owner address (%s)", err) + return nil, errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid owner address (%s)", err) } if err := sdk.ValidateDenom(req.Denom); err != nil { - return nil, sdkerrors.Wrap(types.ErrInvalidDenom, err.Error()) + return nil, errors.Wrap(types.ErrInvalidDenom, err.Error()) } address, found := k.IsICACreatedOnDenomNativeZone(ctx, req.Denom, req.Owner) if !found { - return nil, sdkerrors.Wrapf(types.ErrICANotFound, "no ICA owned by %s is found on native zone od denom %s", req.Owner, req.Denom) + return nil, errors.Wrapf(types.ErrICANotFound, "no ICA owned by %s is found on native zone od denom %s", req.Owner, req.Denom) } return &types.QueryICAAddressOnDenomNativeZoneResponse{IcaAddress: address}, nil diff --git a/x/intergamm/keeper/grpc_query_ica_address_on_zone.go b/x/intergamm/keeper/grpc_query_ica_address_on_zone.go index 562e66740..5d215d6d8 100644 --- a/x/intergamm/keeper/grpc_query_ica_address_on_zone.go +++ b/x/intergamm/keeper/grpc_query_ica_address_on_zone.go @@ -2,9 +2,10 @@ package keeper import ( "context" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/quasarlabs/quasarnode/x/intergamm/types" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -18,12 +19,12 @@ func (k Keeper) ICAAddressOnZone(goCtx context.Context, req *types.QueryICAAddre ctx := sdk.UnwrapSDKContext(goCtx) if _, err := sdk.AccAddressFromBech32(req.Owner); err != nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid owner address (%s)", err) + return nil, errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid owner address (%s)", err) } address, found := k.IsICACreatedOnZoneId(ctx, req.ZoneId, req.Owner) if !found { - return nil, sdkerrors.Wrapf(types.ErrICANotFound, "no ICA owned by %s is found on zone %s", req.Owner, req.ZoneId) + return nil, errors.Wrapf(types.ErrICANotFound, "no ICA owned by %s is found on zone %s", req.Owner, req.ZoneId) } return &types.QueryICAAddressOnZoneResponse{IcaAddress: address}, nil diff --git a/x/intergamm/keeper/ibc_callbacks.go b/x/intergamm/keeper/ibc_callbacks.go index 0de2a6197..ae8143af8 100644 --- a/x/intergamm/keeper/ibc_callbacks.go +++ b/x/intergamm/keeper/ibc_callbacks.go @@ -2,7 +2,6 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" icatypes "github.com/cosmos/ibc-go/v5/modules/apps/27-interchain-accounts/types" ibctransfertypes "github.com/cosmos/ibc-go/v5/modules/apps/transfer/types" channeltypes "github.com/cosmos/ibc-go/v5/modules/core/04-channel/types" @@ -24,11 +23,11 @@ func (k *Keeper) HandleIcaAcknowledgement( ) error { msgs, err := icatypes.DeserializeCosmosTx(k.cdc, icaPacket.GetData()) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidPacket, "cannot deserialize packet data") + return errors.Wrap(channeltypes.ErrInvalidPacket, "cannot deserialize packet data") } if len(msgs) != 1 { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "expected single message in packet") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "expected single message in packet") } msg := msgs[0] @@ -37,12 +36,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &ibctransfertypes.MsgTransferResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*ibctransfertypes.MsgTransfer, *ibctransfertypes.MsgTransferResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -57,12 +56,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammbalancer.MsgCreateBalancerPoolResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammbalancer.MsgCreateBalancerPool, *gammbalancer.MsgCreateBalancerPoolResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -77,12 +76,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammtypes.MsgJoinPoolResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammtypes.MsgJoinPool, *gammtypes.MsgJoinPoolResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -97,12 +96,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammtypes.MsgExitPoolResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammtypes.MsgExitPool, *gammtypes.MsgExitPoolResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -117,12 +116,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammtypes.MsgJoinSwapExternAmountInResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammtypes.MsgJoinSwapExternAmountIn, *gammtypes.MsgJoinSwapExternAmountInResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -137,12 +136,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammtypes.MsgExitSwapExternAmountOutResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammtypes.MsgExitSwapExternAmountOut, *gammtypes.MsgExitSwapExternAmountOutResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -157,12 +156,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammtypes.MsgJoinSwapShareAmountOutResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammtypes.MsgJoinSwapShareAmountOut, *gammtypes.MsgJoinSwapShareAmountOutResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -177,12 +176,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &gammtypes.MsgExitSwapShareAmountInResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*gammtypes.MsgExitSwapShareAmountIn, *gammtypes.MsgExitSwapShareAmountInResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -197,12 +196,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &lockuptypes.MsgLockTokensResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*lockuptypes.MsgLockTokens, *lockuptypes.MsgLockTokensResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -217,12 +216,12 @@ func (k *Keeper) HandleIcaAcknowledgement( resp := &lockuptypes.MsgBeginUnlockingResponse{} err := ParseIcaAck(ack, req, resp) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "cannot parse acknowledgement") } ex := types.AckExchange[*lockuptypes.MsgBeginUnlocking, *lockuptypes.MsgBeginUnlockingResponse]{ Sequence: sequence, - Channel: channel, - PortId: portId, + Channel: channel, + PortId: portId, Error: ack.GetError(), Request: req, Response: resp, @@ -234,7 +233,7 @@ func (k *Keeper) HandleIcaAcknowledgement( } default: - return sdkerrors.Wrap(channeltypes.ErrInvalidPacket, "unsupported packet type") + return errors.Wrap(channeltypes.ErrInvalidPacket, "unsupported packet type") } return nil @@ -247,11 +246,11 @@ func (k *Keeper) HandleIcaTimeout( ) error { msgs, err := icatypes.DeserializeCosmosTx(k.cdc, icaPacket.GetData()) if err != nil { - return sdkerrors.Wrap(channeltypes.ErrInvalidPacket, "cannot deserialize packet data") + return errors.Wrap(channeltypes.ErrInvalidPacket, "cannot deserialize packet data") } if len(msgs) != 1 { - return sdkerrors.Wrap(channeltypes.ErrInvalidAcknowledgement, "expected single message in packet") + return errors.Wrap(channeltypes.ErrInvalidAcknowledgement, "expected single message in packet") } msg := msgs[0] @@ -367,7 +366,7 @@ func (k *Keeper) HandleIcaTimeout( } default: - return sdkerrors.Wrap(channeltypes.ErrInvalidPacket, "unsupported packet type") + return errors.Wrap(channeltypes.ErrInvalidPacket, "unsupported packet type") } return nil diff --git a/x/intergamm/keeper/ibc_transfer.go b/x/intergamm/keeper/ibc_transfer.go index b95d159ff..565bb22a6 100644 --- a/x/intergamm/keeper/ibc_transfer.go +++ b/x/intergamm/keeper/ibc_transfer.go @@ -3,6 +3,7 @@ package keeper import ( "fmt" + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ibctransfertypes "github.com/cosmos/ibc-go/v5/modules/apps/transfer/types" @@ -22,7 +23,7 @@ func (k Keeper) TransferIbcTokens( ) (uint64, error) { seq, found := k.channelKeeper.GetNextSequenceSend(ctx, srcPort, srcChannel) if !found { - return 0, sdkerrors.Wrapf( + return 0, errors.Wrapf( channeltypes.ErrSequenceSendNotFound, "source port: %s, source channel: %s", srcPort, srcChannel, ) @@ -87,14 +88,14 @@ func (k Keeper) TransmitICATransfer( logger := k.Logger(ctx) if _, err := sdk.AccAddressFromBech32(finalReceiver); err != nil { - err := sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid final receiver address (%s) for quasar zone", err) + err := errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid final receiver address (%s) for quasar zone", err) logger.Error("TransmitICATransfer", err) return 0, "", "", err } icaZoneInfo, found := k.GetZoneInfo(ctx, types.OsmosisZoneId) if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "zone info for osmosis not found in CompleteZoneInfoMap for direct transfer of %s", + err := errors.Wrapf(types.ErrZoneInfoNotFound, "zone info for osmosis not found in CompleteZoneInfoMap for direct transfer of %s", token.String()) logger.Error("TransmitICATransfer", err) return 0, "", "", err @@ -112,13 +113,13 @@ func (k Keeper) TransmitICATransfer( osmosisDenom := token.Denom quasarDenom, found := k.OsmosisDenomToQuasarDenomMap(ctx)[osmosisDenom] if !found { - err := sdkerrors.Wrapf(types.ErrInvalidDenom, "corresponding quasar denom for osmosis denom %s not found", osmosisDenom) + err := errors.Wrapf(types.ErrInvalidDenom, "corresponding quasar denom for osmosis denom %s not found", osmosisDenom) logger.Error("TransmitICATransfer", err) return 0, "", "", err } nativeZoneId, found := k.QuasarDenomToNativeZoneIdMap(ctx)[quasarDenom] if !found { - err := sdkerrors.Wrapf(types.ErrDenomNativeZoneIdNotFound, "native zone ID of quasar denom '%s' not specified", quasarDenom) + err := errors.Wrapf(types.ErrDenomNativeZoneIdNotFound, "native zone ID of quasar denom '%s' not specified", quasarDenom) logger.Error("TransmitICATransfer", err) return 0, "", "", err } @@ -146,7 +147,7 @@ func (k Keeper) TransmitICATransfer( nativeZoneInfo, found := k.GetZoneInfo(ctx, nativeZoneId) if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "zone info for zone ID '%s' not specified", nativeZoneId) + err := errors.Wrapf(types.ErrZoneInfoNotFound, "zone info for zone ID '%s' not specified", nativeZoneId) logger.Error("TransmitICATransfer", err) return 0, "", "", err } @@ -154,7 +155,7 @@ func (k Keeper) TransmitICATransfer( // icaFromNativeInfo contains IBC info about the channel between ICA zone and the native zone. icaFromNativeInfo, found := nativeZoneInfo.NextZoneRouteMap[types.OsmosisZoneId] if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "zone info for osmosis not specified in NextZoneRouteMap of zone '%s' (native zone of %s)", + err := errors.Wrapf(types.ErrZoneInfoNotFound, "zone info for osmosis not specified in NextZoneRouteMap of zone '%s' (native zone of %s)", nativeZoneInfo.ZoneRouteInfo.CounterpartyZoneId, token.String()) logger.Error("TransmitICATransfer", err) return 0, "", "", err @@ -162,7 +163,7 @@ func (k Keeper) TransmitICATransfer( nativeIcaAddr, found := k.IsICARegistered(ctx, nativeZoneInfo.ZoneRouteInfo.ConnectionId, owner) if !found { - err := sdkerrors.Wrapf(types.ErrICANotFound, "no inter-chain account owned by %s found on zone '%s' (native zone of %s)", + err := errors.Wrapf(types.ErrICANotFound, "no inter-chain account owned by %s found on zone '%s' (native zone of %s)", owner, nativeZoneId, token.String()) logger.Error("TransmitICATransfer", err) return 0, "", "", err diff --git a/x/intergamm/keeper/keeper.go b/x/intergamm/keeper/keeper.go index 3c1e308f5..1953facb2 100644 --- a/x/intergamm/keeper/keeper.go +++ b/x/intergamm/keeper/keeper.go @@ -1,16 +1,14 @@ package keeper import ( - "errors" + goerrors "errors" "fmt" - "github.com/tendermint/tendermint/libs/log" - + "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/store/prefix" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper" capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" @@ -22,6 +20,7 @@ import ( host "github.com/cosmos/ibc-go/v5/modules/core/24-host" ibctmtypes "github.com/cosmos/ibc-go/v5/modules/light-clients/07-tendermint/types" "github.com/quasarlabs/quasarnode/x/intergamm/types" + "github.com/tendermint/tendermint/libs/log" ) var ( @@ -175,7 +174,7 @@ func (k Keeper) RegisterInterchainAccount(ctx sdk.Context, connectionID, owner s func (k Keeper) RegisterICAOnZoneId(ctx sdk.Context, zoneId, owner string) error { nativeZoneInfo, found := k.CompleteZoneInfoMap(ctx)[zoneId] if !found { - return sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "zone info for zone ID '%s' not specified", zoneId) + return errors.Wrapf(types.ErrZoneInfoNotFound, "zone info for zone ID '%s' not specified", zoneId) } return k.RegisterInterchainAccount(ctx, nativeZoneInfo.ZoneRouteInfo.ConnectionId, owner) } @@ -183,7 +182,7 @@ func (k Keeper) RegisterICAOnZoneId(ctx sdk.Context, zoneId, owner string) error func (k Keeper) RegisterICAOnDenomNativeZone(ctx sdk.Context, denom, owner string) error { nativeZoneId, found := k.QuasarDenomToNativeZoneIdMap(ctx)[denom] if !found { - return sdkerrors.Wrapf(types.ErrDenomNativeZoneIdNotFound, "native zone ID of denom '%s' not specified", denom) + return errors.Wrapf(types.ErrDenomNativeZoneIdNotFound, "native zone ID of denom '%s' not specified", denom) } return k.RegisterICAOnZoneId(ctx, nativeZoneId, owner) } @@ -229,7 +228,7 @@ func (k Keeper) RegisterOrReturnICA(ctx sdk.Context, connectionId, owner string) if addr, found := k.IsICARegistered(ctx, connectionId, owner); found { return addr, nil } else { - return "", errors.New("unexpected error: RegisterInterchainAccount returned no error, but ICA still can't be found") + return "", goerrors.New("unexpected error: RegisterInterchainAccount returned no error, but ICA still can't be found") } } } @@ -243,11 +242,11 @@ func (k Keeper) sendTxOverIca(ctx sdk.Context, owner, connectionId string, msgs } channelID, found := k.icaControllerKeeper.GetActiveChannelID(ctx, connectionId, portID) if !found { - return 0, "", "", sdkerrors.Wrapf(icatypes.ErrActiveChannelNotFound, "failed to retrieve active channel for port %s", portID) + return 0, "", "", errors.Wrapf(icatypes.ErrActiveChannelNotFound, "failed to retrieve active channel for port %s", portID) } chanCap, found := k.scopedKeeper.GetCapability(ctx, host.ChannelCapabilityPath(portID, channelID)) if !found { - return 0, "", "", sdkerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, "module does not own channel capability") + return 0, "", "", errors.Wrap(channeltypes.ErrChannelCapabilityNotFound, "module does not own channel capability") } data, err := icatypes.SerializeCosmosTx(k.cdc, msgs) @@ -308,7 +307,7 @@ func (k Keeper) SendToken(ctx sdk.Context, transferTimeoutHeight := clienttypes.Height{RevisionNumber: 0, RevisionHeight: 0} nativeZoneId, found := k.QuasarDenomToNativeZoneIdMap(ctx)[coin.Denom] if !found { - err := sdkerrors.Wrapf(types.ErrDenomNativeZoneIdNotFound, "native zone ID of denom '%s' not specified", coin.Denom) + err := errors.Wrapf(types.ErrDenomNativeZoneIdNotFound, "native zone ID of denom '%s' not specified", coin.Denom) logger.Error("SendToken", err) return 0, "", "", err } @@ -317,7 +316,7 @@ func (k Keeper) SendToken(ctx sdk.Context, // direct transfer destZoneInfo, found := k.GetZoneInfo(ctx, destZoneId) if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "destination zone info for zone ID '%s' not specified in CompleteZoneInfoMap", + err := errors.Wrapf(types.ErrZoneInfoNotFound, "destination zone info for zone ID '%s' not specified in CompleteZoneInfoMap", destZoneId) logger.Error("SendToken", err) return 0, "", "", err @@ -334,14 +333,14 @@ func (k Keeper) SendToken(ctx sdk.Context, logger.Info("SendToken", fmt.Sprintf("forwarding transfer of %s via zone %s", coin.String(), nativeZoneId)) nativeZoneInfo, found := k.GetZoneInfo(ctx, nativeZoneId) if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "no zone info specified for zone ID '%s'", nativeZoneId) + err := errors.Wrapf(types.ErrZoneInfoNotFound, "no zone info specified for zone ID '%s'", nativeZoneId) logger.Error("SendToken", err) return 0, "", "", err } // destFromNativeInfo contains IBC info needed to reach destination zone from the native zone. destFromNativeInfo, found := nativeZoneInfo.NextZoneRouteMap[destZoneId] if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "destination zone info for zone ID '%s' not specified in NextZoneRouteMap of zone '%s' (native zone of %s)", + err := errors.Wrapf(types.ErrZoneInfoNotFound, "destination zone info for zone ID '%s' not specified in NextZoneRouteMap of zone '%s' (native zone of %s)", destZoneId, nativeZoneInfo.ZoneRouteInfo.CounterpartyZoneId, coin.String()) logger.Error("SendToken", err) return 0, "", "", err @@ -350,7 +349,7 @@ func (k Keeper) SendToken(ctx sdk.Context, nativeIcaAddr, found := k.IsICARegistered(ctx, nativeZoneInfo.ZoneRouteInfo.ConnectionId, sender.String()) if !found { - err := sdkerrors.Wrapf(types.ErrICANotFound, "no inter-chain account owned by %s found on zone '%s' (native zone of %s)", + err := errors.Wrapf(types.ErrICANotFound, "no inter-chain account owned by %s found on zone '%s' (native zone of %s)", sender.String(), nativeZoneId, coin.String()) logger.Error("SendToken", err) return 0, "", "", err @@ -376,14 +375,14 @@ func (k Keeper) SendTokenToICA(ctx sdk.Context, destZoneId string, sender sdk.Ac logger := ctx.Logger() destZoneInfo, found := k.GetZoneInfo(ctx, destZoneId) if !found { - err := sdkerrors.Wrapf(types.ErrZoneInfoNotFound, "error: destination zone info for zone ID '%s' not specified in CompleteZoneInfoMap", + err := errors.Wrapf(types.ErrZoneInfoNotFound, "error: destination zone info for zone ID '%s' not specified in CompleteZoneInfoMap", destZoneId) logger.Error("SendTokenToICA", err) return 0, "", "", err } icaAddr, found := k.IsICARegistered(ctx, destZoneInfo.ZoneRouteInfo.ConnectionId, sender.String()) if !found { - err := sdkerrors.Wrapf(types.ErrICANotFound, "inter-chain account on destination zone (zone ID '%s') not found", + err := errors.Wrapf(types.ErrICANotFound, "inter-chain account on destination zone (zone ID '%s') not found", destZoneId) logger.Error("SendTokenToICA", err) return 0, "", "", err diff --git a/x/intergamm/types/errors.go b/x/intergamm/types/errors.go index fc3f072e5..6cb154fdd 100644 --- a/x/intergamm/types/errors.go +++ b/x/intergamm/types/errors.go @@ -3,24 +3,24 @@ package types import ( "fmt" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // IBC channel sentinel errors var ( - ErrAcknowledgementHookFailed = sdkerrors.Register(ModuleName, 2, "acknowledgement hook failed") - ErrTimeoutHookFailed = sdkerrors.Register(ModuleName, 3, "timeout hook failed") - ErrInvalidZoneId = sdkerrors.Register(ModuleName, 4, "invalid zone id") - ErrInvalidDenom = sdkerrors.Register(ModuleName, 5, "invalid zone id") - ErrZoneInfoNotFound = sdkerrors.Register(ModuleName, 6, "zone info not found") - ErrICANotFound = sdkerrors.Register(ModuleName, 7, "inter-chain account not found") - ErrDenomNativeZoneIdNotFound = sdkerrors.Register(ModuleName, 8, "native zone id of the given denom not found") + ErrAcknowledgementHookFailed = errors.Register(ModuleName, 2, "acknowledgement hook failed") + ErrTimeoutHookFailed = errors.Register(ModuleName, 3, "timeout hook failed") + ErrInvalidZoneId = errors.Register(ModuleName, 4, "invalid zone id") + ErrInvalidDenom = errors.Register(ModuleName, 5, "invalid zone id") + ErrZoneInfoNotFound = errors.Register(ModuleName, 6, "zone info not found") + ErrICANotFound = errors.Register(ModuleName, 7, "inter-chain account not found") + ErrDenomNativeZoneIdNotFound = errors.Register(ModuleName, 8, "native zone id of the given denom not found") ) func NewErrAcknowledgementHookFailed(msg string) error { - return sdkerrors.Wrap(ErrAcknowledgementHookFailed, fmt.Sprintf("handling msg %s", msg)) + return errors.Wrap(ErrAcknowledgementHookFailed, fmt.Sprintf("handling msg %s", msg)) } func NewErrTimeoutHookFailed(msg string) error { - return sdkerrors.Wrap(ErrTimeoutHookFailed, fmt.Sprintf("handling msg %s", msg)) + return errors.Wrap(ErrTimeoutHookFailed, fmt.Sprintf("handling msg %s", msg)) } diff --git a/x/intergamm/types/message_register_ica_on_denom_native_zone.go b/x/intergamm/types/message_register_ica_on_denom_native_zone.go index fc8b7ae3c..69ed18caa 100644 --- a/x/intergamm/types/message_register_ica_on_denom_native_zone.go +++ b/x/intergamm/types/message_register_ica_on_denom_native_zone.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -40,10 +41,10 @@ func (msg *MsgRegisterICAOnDenomNativeZone) GetSignBytes() []byte { func (msg *MsgRegisterICAOnDenomNativeZone) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.OwnerAddress) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid ownerAddress address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid ownerAddress address (%s)", err) } if sdk.ValidateDenom(msg.Denom) != nil { - return sdkerrors.Wrapf(ErrInvalidDenom, "invalid denom (%s)", msg.Denom) + return errors.Wrapf(ErrInvalidDenom, "invalid denom (%s)", msg.Denom) } return nil } diff --git a/x/intergamm/types/message_register_ica_on_zone.go b/x/intergamm/types/message_register_ica_on_zone.go index 7695b8375..ea3e45973 100644 --- a/x/intergamm/types/message_register_ica_on_zone.go +++ b/x/intergamm/types/message_register_ica_on_zone.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -40,10 +41,10 @@ func (msg *MsgRegisterICAOnZone) GetSignBytes() []byte { func (msg *MsgRegisterICAOnZone) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.OwnerAddress) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid ownerAddress address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid ownerAddress address (%s)", err) } if msg.ZoneId == "" { - return sdkerrors.Wrap(ErrInvalidZoneId, "zoneId cannot be empty") + return errors.Wrap(ErrInvalidZoneId, "zoneId cannot be empty") } return nil } diff --git a/x/intergamm/types/message_register_interchain_account.go b/x/intergamm/types/message_register_interchain_account.go index 8f8893fbe..a2712df82 100644 --- a/x/intergamm/types/message_register_interchain_account.go +++ b/x/intergamm/types/message_register_interchain_account.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -11,7 +12,7 @@ var _ sdk.Msg = &MsgRegisterInterchainAccount{} func NewMsgRegisterInterchainAccount(creator string, connectionId string) *MsgRegisterInterchainAccount { return &MsgRegisterInterchainAccount{ - Creator: creator, + Creator: creator, ConnectionId: connectionId, } } @@ -40,10 +41,10 @@ func (msg *MsgRegisterInterchainAccount) GetSignBytes() []byte { func (msg *MsgRegisterInterchainAccount) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "ConnectionId cannot be nil") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "ConnectionId cannot be nil") } return nil } diff --git a/x/intergamm/types/message_send_token.go b/x/intergamm/types/message_send_token.go index f8480d811..c0761656a 100644 --- a/x/intergamm/types/message_send_token.go +++ b/x/intergamm/types/message_send_token.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -42,19 +43,19 @@ func (msg *MsgSendToken) GetSignBytes() []byte { func (msg *MsgSendToken) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.FromAddress) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid fromAddress address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid fromAddress address (%s)", err) } if msg.ToZoneId == "" { - return sdkerrors.Wrap(ErrInvalidZoneId, "toZoneId cannot be empty") + return errors.Wrap(ErrInvalidZoneId, "toZoneId cannot be empty") } if msg.ToAddress == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "toAddress cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "toAddress cannot be empty") } if !msg.Coin.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be valid", msg.Coin.String()) + return errors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be valid", msg.Coin.String()) } if !msg.Coin.IsPositive() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be positive", msg.Coin.String()) + return errors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be positive", msg.Coin.String()) } return nil } diff --git a/x/intergamm/types/message_send_token_to_ica.go b/x/intergamm/types/message_send_token_to_ica.go index 08074a5c8..2a46a5fc3 100644 --- a/x/intergamm/types/message_send_token_to_ica.go +++ b/x/intergamm/types/message_send_token_to_ica.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -41,16 +42,16 @@ func (msg *MsgSendTokenToICA) GetSignBytes() []byte { func (msg *MsgSendTokenToICA) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.FromAddress) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid fromAddress address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid fromAddress address (%s)", err) } if msg.ToZoneId == "" { - return sdkerrors.Wrap(ErrInvalidZoneId, "toZoneId cannot be empty") + return errors.Wrap(ErrInvalidZoneId, "toZoneId cannot be empty") } if !msg.Coin.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be valid", msg.Coin.String()) + return errors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be valid", msg.Coin.String()) } if !msg.Coin.IsPositive() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be positive", msg.Coin.String()) + return errors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be positive", msg.Coin.String()) } return nil } diff --git a/x/intergamm/types/message_test_scenario.go b/x/intergamm/types/message_test_scenario.go index 7fbbe22c2..0babda9ef 100644 --- a/x/intergamm/types/message_test_scenario.go +++ b/x/intergamm/types/message_test_scenario.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -40,10 +41,10 @@ func (msg *MsgTestScenario) GetSignBytes() []byte { func (msg *MsgTestScenario) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.Scenario == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "scenario cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "scenario cannot be empty") } return nil } diff --git a/x/intergamm/types/message_transmit_ibc_begin_unlocking.go b/x/intergamm/types/message_transmit_ibc_begin_unlocking.go index 400117495..4f2d9627c 100644 --- a/x/intergamm/types/message_transmit_ibc_begin_unlocking.go +++ b/x/intergamm/types/message_transmit_ibc_begin_unlocking.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -43,16 +44,16 @@ func (msg *MsgTransmitIbcBeginUnlocking) GetSignBytes() []byte { func (msg *MsgTransmitIbcBeginUnlocking) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "connectionID cannot be empty") } if len(msg.Coins) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "coins cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidCoins, "coins cannot be empty") } if msg.TimeoutTimestamp == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") } return nil } diff --git a/x/intergamm/types/message_transmit_ibc_exit_pool.go b/x/intergamm/types/message_transmit_ibc_exit_pool.go index dd468ba6c..c85e67960 100644 --- a/x/intergamm/types/message_transmit_ibc_exit_pool.go +++ b/x/intergamm/types/message_transmit_ibc_exit_pool.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -44,19 +45,19 @@ func (msg *MsgTransmitIbcExitPool) GetSignBytes() []byte { func (msg *MsgTransmitIbcExitPool) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") } if msg.ShareInAmount == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") } if len(msg.TokenOutMins) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "TokenOutMins cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidCoins, "TokenOutMins cannot be empty") } if msg.TimeoutTimestamp == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") } return nil } diff --git a/x/intergamm/types/message_transmit_ibc_exit_swap_extern_amount_out.go b/x/intergamm/types/message_transmit_ibc_exit_swap_extern_amount_out.go index e9dfcbd5a..1c007257f 100644 --- a/x/intergamm/types/message_transmit_ibc_exit_swap_extern_amount_out.go +++ b/x/intergamm/types/message_transmit_ibc_exit_swap_extern_amount_out.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -44,19 +45,19 @@ func (msg *MsgTransmitIbcExitSwapExternAmountOut) GetSignBytes() []byte { func (msg *MsgTransmitIbcExitSwapExternAmountOut) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") } if msg.ShareInAmount == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") } if msg.TokenOutMins.Amount == sdk.ZeroInt() || msg.TokenOutMins.Denom == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "tokenIn cannot have nil field ()") + return errors.Wrap(sdkerrors.ErrInvalidCoins, "tokenIn cannot have nil field ()") } if msg.TimeoutTimestamp == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") } return nil } diff --git a/x/intergamm/types/message_transmit_ibc_join_pool.go b/x/intergamm/types/message_transmit_ibc_join_pool.go index 1fc4b8d1b..179be2d8f 100644 --- a/x/intergamm/types/message_transmit_ibc_join_pool.go +++ b/x/intergamm/types/message_transmit_ibc_join_pool.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -44,19 +45,19 @@ func (msg *MsgTransmitIbcJoinPool) GetSignBytes() []byte { func (msg *MsgTransmitIbcJoinPool) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") } if msg.ShareOutAmount == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") } if len(msg.TokenInMaxs) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "coins cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidCoins, "coins cannot be empty") } if msg.TimeoutTimestamp == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") } return nil } diff --git a/x/intergamm/types/message_transmit_ibc_join_swap_extern_amount_in.go b/x/intergamm/types/message_transmit_ibc_join_swap_extern_amount_in.go index 17c8e9600..eeb0c928a 100644 --- a/x/intergamm/types/message_transmit_ibc_join_swap_extern_amount_in.go +++ b/x/intergamm/types/message_transmit_ibc_join_swap_extern_amount_in.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -44,19 +45,19 @@ func (msg *MsgTransmitIbcJoinSwapExternAmountIn) GetSignBytes() []byte { func (msg *MsgTransmitIbcJoinSwapExternAmountIn) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") } if msg.ShareOutMinAmount == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "ShareInAmount cannot be 0") } if msg.TokenIn.Amount == sdk.ZeroInt() || msg.TokenIn.Denom == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "tokenIn cannot have nil field ()") + return errors.Wrap(sdkerrors.ErrInvalidCoins, "tokenIn cannot have nil field ()") } if msg.TimeoutTimestamp == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "TimeoutTimestamp cannot be 0") } return nil } diff --git a/x/intergamm/types/message_transmit_ibc_lock_tokens.go b/x/intergamm/types/message_transmit_ibc_lock_tokens.go index 8e9dc02d9..a023765b1 100644 --- a/x/intergamm/types/message_transmit_ibc_lock_tokens.go +++ b/x/intergamm/types/message_transmit_ibc_lock_tokens.go @@ -1,9 +1,11 @@ package types import ( + "time" + + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - "time" ) const TypeMsgTransmitIbcLockTokens = "transmit_ibc_lock_tokens" @@ -44,22 +46,22 @@ func (msg *MsgTransmitIbcLockTokens) GetSignBytes() []byte { func (msg *MsgTransmitIbcLockTokens) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") } if msg.ConnectionId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "connectionID cannot be empty") } if msg.Duration == time.Duration(0) { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "duration cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "duration cannot be 0") } if len(msg.Coins) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "coins cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidCoins, "coins cannot be empty") } if msg.TimeoutTimestamp == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid TimeoutTimestamp, cannot be 0") + return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid TimeoutTimestamp, cannot be 0") } return nil } diff --git a/x/intergamm/types/message_transmit_ica_transfer.go b/x/intergamm/types/message_transmit_ica_transfer.go index e47725846..8cf70e091 100644 --- a/x/intergamm/types/message_transmit_ica_transfer.go +++ b/x/intergamm/types/message_transmit_ica_transfer.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -41,16 +42,16 @@ func (msg *MsgTransmitICATransfer) GetSignBytes() []byte { func (msg *MsgTransmitICATransfer) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.IcaOwnerAddress) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid icaOwnerAddress address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid icaOwnerAddress address (%s)", err) } if msg.ToAddress == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "toAddress cannot be empty") + return errors.Wrap(sdkerrors.ErrInvalidAddress, "toAddress cannot be empty") } if !msg.Coin.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be valid", msg.Coin.String()) + return errors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be valid", msg.Coin.String()) } if !msg.Coin.IsPositive() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be positive", msg.Coin.String()) + return errors.Wrapf(sdkerrors.ErrInvalidCoins, "coin (%s) must be positive", msg.Coin.String()) } return nil } diff --git a/x/qoracle/bandchain/ibc_module.go b/x/qoracle/bandchain/ibc_module.go index c783f47d1..3f40b3435 100644 --- a/x/qoracle/bandchain/ibc_module.go +++ b/x/qoracle/bandchain/ibc_module.go @@ -3,6 +3,7 @@ package qoracle import ( "strings" + "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" @@ -52,7 +53,7 @@ func (im IBCModule) OnChanOpenInit( } if version != types.BandchainOracleVersion { - return "", sdkerrors.Wrapf(channeltypes.ErrInvalidChannelVersion, "got %s, expected %s", version, types.BandchainOracleVersion) + return "", errors.Wrapf(channeltypes.ErrInvalidChannelVersion, "got %s, expected %s", version, types.BandchainOracleVersion) } // Claim channel capability passed back by IBC module @@ -69,13 +70,13 @@ func (im IBCModule) validateChannelParams( portID string, ) error { if order != channeltypes.UNORDERED { - return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.UNORDERED, order) + return errors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.UNORDERED, order) } // Require port id to be the port id module is bound to boundPort := im.keeper.GetPort(ctx) if boundPort != portID { - return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) + return errors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) } return nil @@ -101,7 +102,7 @@ func (im IBCModule) OnChanOpenTry( } if counterpartyVersion != types.BandchainOracleVersion { - return "", sdkerrors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, types.BandchainOracleVersion) + return "", errors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, types.BandchainOracleVersion) } // OpenTry must claim the channelCapability that IBC passes into the callback @@ -121,7 +122,7 @@ func (im IBCModule) OnChanOpenAck( counterpartyVersion string, ) error { if counterpartyVersion != types.BandchainOracleVersion { - return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, types.BandchainOracleVersion) + return errors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, types.BandchainOracleVersion) } return nil } @@ -188,7 +189,7 @@ func (im IBCModule) OnAcknowledgementPacket( ) error { var ack channeltypes.Acknowledgement if err := types.ModuleCdc.UnmarshalJSON(acknowledgement, &ack); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal packet acknowledgement: %v", err) + return errors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal packet acknowledgement: %v", err) } return im.keeper.OnAcknowledgementPacket(ctx, packet, ack) diff --git a/x/qoracle/bandchain/keeper/relay.go b/x/qoracle/bandchain/keeper/relay.go index 21f1fc272..95ff7aacc 100644 --- a/x/qoracle/bandchain/keeper/relay.go +++ b/x/qoracle/bandchain/keeper/relay.go @@ -3,6 +3,7 @@ package keeper import ( "fmt" + "cosmossdk.io/errors" "github.com/bandprotocol/bandchain-packet/obi" bandpacket "github.com/bandprotocol/bandchain-packet/packet" sdk "github.com/cosmos/cosmos-sdk/types" @@ -73,7 +74,7 @@ func (k Keeper) sendCoinRatesRequest(ctx sdk.Context) (uint64, error) { func (k Keeper) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet) ([]byte, error) { var packetData bandpacket.OracleResponsePacketData if err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &packetData); err != nil { - return nil, sdkerrors.Wrapf(err, "could not unmarshal bandchain oracle packet data") + return nil, errors.Wrapf(err, "could not unmarshal bandchain oracle packet data") } switch packetData.GetClientID() { @@ -93,7 +94,7 @@ func (k Keeper) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet) ([]byt if packetData.ResolveStatus == bandpacket.RESOLVE_STATUS_SUCCESS { var coinRatesResult types.CoinRatesResult if err := obi.Decode(packetData.GetResult(), &coinRatesResult); err != nil { - return sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "cannot decode the CoinRates result") + return errors.Wrap(sdkerrors.ErrUnknownRequest, "cannot decode the CoinRates result") } state.SetResult(&coinRatesResult) @@ -111,7 +112,7 @@ func (k Keeper) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet) ([]byt k.updatePriceList(ctx) default: - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "oracle received packet with unknown client id: %s", packetData.GetClientID()) + return nil, errors.Wrapf(sdkerrors.ErrUnknownRequest, "oracle received packet with unknown client id: %s", packetData.GetClientID()) } return types.ModuleCdc.MustMarshalJSON( @@ -147,7 +148,7 @@ func (k Keeper) GetCoinRatesState(ctx sdk.Context) types.OracleScriptState { func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Packet, ack channeltypes.Acknowledgement) error { var packetData bandpacket.OracleRequestPacketData if err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &packetData); err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal bandchain oracle packet data") + return errors.Wrapf(err, "could not unmarshal bandchain oracle packet data") } switch packetData.GetClientID() { @@ -171,7 +172,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac } else { var ackData bandpacket.OracleRequestPacketAcknowledgement if err := types.ModuleCdc.UnmarshalJSON(ack.GetResult(), &ackData); err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal bandchain oracle packet acknowledgement data") + return errors.Wrapf(err, "could not unmarshal bandchain oracle packet acknowledgement data") } // Update request latest state with oracle request id state.OracleRequestId = ackData.GetRequestID() @@ -191,7 +192,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac } return nil default: - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "oracle acknowledgment handler for client id %s not found", packetData.GetClientID()) + return errors.Wrapf(sdkerrors.ErrInvalidRequest, "oracle acknowledgment handler for client id %s not found", packetData.GetClientID()) } } @@ -213,7 +214,7 @@ func (k Keeper) validatePacketAgainstState(ctx sdk.Context, packet channeltypes. func (k Keeper) OnTimeoutPacket(ctx sdk.Context, packet channeltypes.Packet) error { var packetData bandpacket.OracleRequestPacketData if err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &packetData); err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal bandchain oracle packet data") + return errors.Wrapf(err, "could not unmarshal bandchain oracle packet data") } switch packetData.GetClientID() { @@ -240,6 +241,6 @@ func (k Keeper) OnTimeoutPacket(ctx sdk.Context, packet channeltypes.Packet) err } return nil default: - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "oracle timeout handler for client id %s not found", packetData.GetClientID()) + return errors.Wrapf(sdkerrors.ErrInvalidRequest, "oracle timeout handler for client id %s not found", packetData.GetClientID()) } } diff --git a/x/qoracle/bandchain/types/errors.go b/x/qoracle/bandchain/types/errors.go index fa7b330ce..09fd9cac3 100644 --- a/x/qoracle/bandchain/types/errors.go +++ b/x/qoracle/bandchain/types/errors.go @@ -1,10 +1,10 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // IBC transfer sentinel errors var ( - ErrDisabled = sdkerrors.Register(SubModuleName, 2, "bandchain oracle module is disabled") + ErrDisabled = errors.Register(SubModuleName, 2, "bandchain oracle module is disabled") ) diff --git a/x/qoracle/osmosis/ibc_module.go b/x/qoracle/osmosis/ibc_module.go index 563cc0f50..7147dcd96 100644 --- a/x/qoracle/osmosis/ibc_module.go +++ b/x/qoracle/osmosis/ibc_module.go @@ -3,6 +3,7 @@ package qoracle import ( "strings" + "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" @@ -53,7 +54,7 @@ func (im IBCModule) OnChanOpenInit( } if version != icqtypes.Version { - return "", sdkerrors.Wrapf(channeltypes.ErrInvalidChannelVersion, "got %s, expected %s", version, icqtypes.Version) + return "", errors.Wrapf(channeltypes.ErrInvalidChannelVersion, "got %s, expected %s", version, icqtypes.Version) } // Claim channel capability passed back by IBC module @@ -70,13 +71,13 @@ func (im IBCModule) validateChannelParams( portID string, ) error { if order != channeltypes.UNORDERED { - return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.UNORDERED, order) + return errors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.UNORDERED, order) } // Require port id to be the port id module is bound to boundPort := im.keeper.GetPort(ctx) if boundPort != portID { - return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) + return errors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort) } return nil @@ -102,7 +103,7 @@ func (im IBCModule) OnChanOpenTry( } if counterpartyVersion != icqtypes.Version { - return "", sdkerrors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, icqtypes.Version) + return "", errors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, icqtypes.Version) } // OpenTry must claim the channelCapability that IBC passes into the callback @@ -122,7 +123,7 @@ func (im IBCModule) OnChanOpenAck( counterpartyVersion string, ) error { if counterpartyVersion != icqtypes.Version { - return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, icqtypes.Version) + return errors.Wrapf(channeltypes.ErrInvalidChannelVersion, "invalid counterparty version: %s, expected %s", counterpartyVersion, icqtypes.Version) } return nil } @@ -164,7 +165,7 @@ func (im IBCModule) OnRecvPacket( packet channeltypes.Packet, relayer sdk.AccAddress, ) ibcexported.Acknowledgement { - err := sdkerrors.Wrapf(types.ErrInvalidChannelFlow, "cannot receive packet on qoracle module") + err := errors.Wrapf(types.ErrInvalidChannelFlow, "cannot receive packet on qoracle module") ack := channeltypes.NewErrorAcknowledgement(err) keeper.EmitAcknowledgementEvent(ctx, packet, ack, err) return ack @@ -179,7 +180,7 @@ func (im IBCModule) OnAcknowledgementPacket( ) error { var ack channeltypes.Acknowledgement if err := types.ModuleCdc.UnmarshalJSON(acknowledgement, &ack); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal packet acknowledgement: %v", err) + return errors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal packet acknowledgement: %v", err) } return im.keeper.OnAcknowledgementPacket(ctx, packet, ack) diff --git a/x/qoracle/osmosis/keeper/relay.go b/x/qoracle/osmosis/keeper/relay.go index 372d4fbe6..5f0b1a5fa 100644 --- a/x/qoracle/osmosis/keeper/relay.go +++ b/x/qoracle/osmosis/keeper/relay.go @@ -1,6 +1,7 @@ package keeper import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" icqtypes "github.com/cosmos/ibc-go/v5/modules/apps/icq/types" @@ -215,27 +216,27 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac var ackData icqtypes.InterchainQueryPacketAck if err := types.ModuleCdc.UnmarshalJSON(ack.GetResult(), &ackData); err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal icq packet acknowledgement data") + return errors.Wrapf(err, "could not unmarshal icq packet acknowledgement data") } resps, err := icqtypes.DeserializeCosmosResponse(ackData.Data) if err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal icq acknowledgement data to cosmos response") + return errors.Wrapf(err, "could not unmarshal icq acknowledgement data to cosmos response") } var packetData icqtypes.InterchainQueryPacketData if err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &packetData); err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal icq packet data") + return errors.Wrapf(err, "could not unmarshal icq packet data") } reqs, err := icqtypes.DeserializeCosmosQuery(packetData.Data) if err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal icq packet data to cosmos query") + return errors.Wrapf(err, "could not unmarshal icq packet data to cosmos query") } cacheCtx, writeCache := ctx.CacheContext() for i, req := range reqs { if err := k.handleOsmosisICQResponse(cacheCtx, req, resps[i]); err != nil { - return sdkerrors.Wrapf(err, "could not handle icq response of request %d", i) + return errors.Wrapf(err, "could not handle icq response of request %d", i) } } @@ -283,7 +284,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac func (k Keeper) handleOsmosisICQResponse(ctx sdk.Context, req abcitypes.RequestQuery, resp abcitypes.ResponseQuery) error { if resp.IsErr() { - return sdkerrors.Wrapf(types.ErrFailedICQResponse, "icq response failed with code %d", resp.GetCode()) + return errors.Wrapf(types.ErrFailedICQResponse, "icq response failed with code %d", resp.GetCode()) } switch req.Path { @@ -302,7 +303,7 @@ func (k Keeper) handleOsmosisICQResponse(ctx sdk.Context, req abcitypes.RequestQ case types.OsmosisQueryDistrInfoPath: return k.handleOsmosisDistrInfoResponse(ctx, req, resp) default: - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "icq response handler for path %s not found", req.Path) + return errors.Wrapf(sdkerrors.ErrInvalidRequest, "icq response handler for path %s not found", req.Path) } } @@ -321,7 +322,7 @@ func (k Keeper) handleOsmosisPoolResponse(ctx sdk.Context, req abcitypes.Request var pool balancerpool.Pool err := pool.Unmarshal(qresp.GetPool().GetValue()) if err != nil { - return sdkerrors.Wrapf(err, "could not unmarshal pool") + return errors.Wrapf(err, "could not unmarshal pool") } k.SetPool(ctx, pool) diff --git a/x/qoracle/osmosis/types/errors.go b/x/qoracle/osmosis/types/errors.go index 901af6635..e43473e8e 100644 --- a/x/qoracle/osmosis/types/errors.go +++ b/x/qoracle/osmosis/types/errors.go @@ -1,14 +1,14 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // IBC transfer sentinel errors var ( - ErrDisabled = sdkerrors.Register(SubModuleName, 2, "osmosis oracle module is disabled") - ErrInvalidChannelFlow = sdkerrors.Register(SubModuleName, 3, "invalid message sent to channel end") - ErrFailedICQResponse = sdkerrors.Register(SubModuleName, 4, "failed ICQ response") - ErrEpochNotFound = sdkerrors.Register(SubModuleName, 5, "epoch not found") - ErrGaugeWeightNotFound = sdkerrors.Register(SubModuleName, 6, "gauge weight not found") + ErrDisabled = errors.Register(SubModuleName, 2, "osmosis oracle module is disabled") + ErrInvalidChannelFlow = errors.Register(SubModuleName, 3, "invalid message sent to channel end") + ErrFailedICQResponse = errors.Register(SubModuleName, 4, "failed ICQ response") + ErrEpochNotFound = errors.Register(SubModuleName, 5, "epoch not found") + ErrGaugeWeightNotFound = errors.Register(SubModuleName, 6, "gauge weight not found") ) diff --git a/x/qoracle/osmosis/types/msgs.go b/x/qoracle/osmosis/types/msgs.go index 616bbc906..e7d4bc4d0 100644 --- a/x/qoracle/osmosis/types/msgs.go +++ b/x/qoracle/osmosis/types/msgs.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -39,7 +40,7 @@ func (msg *MsgUpdateChainParams) GetSignBytes() []byte { func (msg *MsgUpdateChainParams) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } return nil } diff --git a/x/qoracle/types/denom_symbol_mapping.go b/x/qoracle/types/denom_symbol_mapping.go index e3d8b5607..86587ebdb 100644 --- a/x/qoracle/types/denom_symbol_mapping.go +++ b/x/qoracle/types/denom_symbol_mapping.go @@ -1,19 +1,19 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) func (mapping DenomSymbolMapping) Validate() error { if err := sdk.ValidateDenom(mapping.Denom); err != nil { - return sdkerrors.Wrap(err, "mapping denom") + return errors.Wrap(err, "mapping denom") } if err := sdk.ValidateDenom(mapping.OracleSymbol); err != nil { - return sdkerrors.Wrap(err, "mapping oracle symbol") + return errors.Wrap(err, "mapping oracle symbol") } if mapping.Multiplier.IsNegative() { - return sdkerrors.Wrapf(ErrNegativeDenomPriceMultiplier, "multiplier of mapping can't be negative") + return errors.Wrapf(ErrNegativeDenomPriceMultiplier, "multiplier of mapping can't be negative") } return nil } diff --git a/x/qoracle/types/errors.go b/x/qoracle/types/errors.go index dd17c9597..a1f6bde90 100644 --- a/x/qoracle/types/errors.go +++ b/x/qoracle/types/errors.go @@ -3,12 +3,12 @@ package types // DONTCOVER import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // x/qoracle module sentinel errors var ( - ErrNegativeDenomPriceMultiplier = sdkerrors.Register(ModuleName, 2, "negative denom price multiplier") - ErrPriceListOutdated = sdkerrors.Register(ModuleName, 3, "price list is outdated") - ErrDenomPriceNotFound = sdkerrors.Register(ModuleName, 4, "symbol price not found") + ErrNegativeDenomPriceMultiplier = errors.Register(ModuleName, 2, "negative denom price multiplier") + ErrPriceListOutdated = errors.Register(ModuleName, 3, "price list is outdated") + ErrDenomPriceNotFound = errors.Register(ModuleName, 4, "symbol price not found") ) diff --git a/x/qoracle/types/msgs.go b/x/qoracle/types/msgs.go index 9bd52ecd3..1ee38cce0 100644 --- a/x/qoracle/types/msgs.go +++ b/x/qoracle/types/msgs.go @@ -1,6 +1,7 @@ package types import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -40,12 +41,12 @@ func (msg *MsgAddDenomSymbolMappings) GetSignBytes() []byte { func (msg *MsgAddDenomSymbolMappings) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } for _, mapping := range msg.Mappings { if err := mapping.Validate(); err != nil { - return sdkerrors.Wrapf(err, "invalid mapping with denom %s", mapping.Denom) + return errors.Wrapf(err, "invalid mapping with denom %s", mapping.Denom) } } @@ -86,7 +87,7 @@ func (msg *MsgRemoveDenomSymbolMappings) GetSignBytes() []byte { func (msg *MsgRemoveDenomSymbolMappings) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Creator) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) } for _, denom := range msg.Denoms { diff --git a/x/qoracle/utils/send_packet.go b/x/qoracle/utils/send_packet.go index 5982b5775..4d6134523 100644 --- a/x/qoracle/utils/send_packet.go +++ b/x/qoracle/utils/send_packet.go @@ -1,6 +1,7 @@ package utils import ( + "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper" @@ -25,7 +26,7 @@ func SendPacket( ) (channeltypes.Packet, error) { sourceChannelEnd, found := channelKeeper.GetChannel(ctx, sourcePort, sourceChannel) if !found { - return channeltypes.Packet{}, sdkerrors.Wrapf( + return channeltypes.Packet{}, errors.Wrapf( sdkerrors.ErrUnknownRequest, "unknown port %s channel %s", sourcePort, @@ -38,12 +39,12 @@ func SendPacket( // get the next sequence sequence, found := channelKeeper.GetNextSequenceSend(ctx, sourcePort, sourceChannel) if !found { - return channeltypes.Packet{}, sdkerrors.Wrapf(channeltypes.ErrSequenceSendNotFound, "failed to retrieve next sequence send for channel %s on port %s", sourceChannel, sourcePort) + return channeltypes.Packet{}, errors.Wrapf(channeltypes.ErrSequenceSendNotFound, "failed to retrieve next sequence send for channel %s on port %s", sourceChannel, sourcePort) } chanCap, ok := scopedKeeper.GetCapability(ctx, host.ChannelCapabilityPath(sourcePort, sourceChannel)) if !ok { - return channeltypes.Packet{}, sdkerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, + return channeltypes.Packet{}, errors.Wrap(channeltypes.ErrChannelCapabilityNotFound, "module does not own channel capability") } @@ -94,7 +95,7 @@ func convertRelativeToAbsoluteTimeout( clientHeight, ok := clientState.GetLatestHeight().(clienttypes.Height) if !ok { - return clienttypes.ZeroHeight(), 0, sdkerrors.Wrapf(sdkerrors.ErrInvalidHeight, "invalid height type. expected type: %T, got: %T", + return clienttypes.ZeroHeight(), 0, errors.Wrapf(sdkerrors.ErrInvalidHeight, "invalid height type. expected type: %T, got: %T", clienttypes.Height{}, clientHeight) }