feat: add asset related messages in oracle module

proto/sentinel/oracle/v1/msg.proto

@@ -8,13 +8,43 @@ option go_package = "github.com/sentinel-official/hub/v12/x/oracle/types/v1";
 option (gogoproto.equal_all) = false;
 option (gogoproto.goproto_getters_all) = false;
 
+message MsgAddAssetRequest {
+  string from = 1;
+  string denom = 2;
+  int64 decimals = 3;
+  string base_asset_denom = 4;
+  string quote_asset_denom = 5;
+}
+
+message MsgDeleteAssetRequest {
+  string from = 1;
+  string denom = 2;
+}
+
+message MsgUpdateAssetRequest {
+  string from = 1;
+  string denom = 2;
+  int64 decimals = 3;
+  string base_asset_denom = 4;
+  string quote_asset_denom = 5;
+}
+
 message MsgUpdateParamsRequest {
   string from = 1;
   Params params = 2 [(gogoproto.nullable) = false];
 }
 
+message MsgAddAssetResponse {}
+
+message MsgDeleteAssetResponse {}
+
+message MsgUpdateAssetResponse {}
+
 message MsgUpdateParamsResponse {}
 
 service MsgService {
+  rpc MsgAddAsset(MsgAddAssetRequest) returns (MsgAddAssetResponse);
+  rpc MsgDeleteAsset(MsgDeleteAssetRequest) returns (MsgDeleteAssetResponse);
+  rpc MsgUpdateAsset(MsgUpdateAssetRequest) returns (MsgUpdateAssetResponse);
   rpc MsgUpdateParams(MsgUpdateParamsRequest) returns (MsgUpdateParamsResponse);
 }

x/oracle/keeper/asset.go

@@ -33,6 +33,14 @@ func (k *Keeper) GetAsset(ctx sdk.Context, denom string) (v v1.Asset, found bool
 	return v, true
 }
 
+// HasAsset checks if an asset with the given denomination exists in the module's KVStore.
+func (k *Keeper) HasAsset(ctx sdk.Context, denom string) bool {
+	store := k.Store(ctx)
+	key := types.AssetKey(denom)
+
+	return store.Has(key)
+}
+
 // DeleteAsset removes an asset from the module's KVStore based on the asset denomination.
 func (k *Keeper) DeleteAsset(ctx sdk.Context, denom string) {
 	store := k.Store(ctx)

x/oracle/keeper/msg_handler.go

@@ -1,12 +1,68 @@
 package keeper
 
 import (
+	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/sentinel-official/hub/v12/x/oracle/types"
 	"github.com/sentinel-official/hub/v12/x/oracle/types/v1"
 )
 
+func (k *Keeper) HandleMsgAddAsset(ctx sdk.Context, msg *v1.MsgAddAssetRequest) (*v1.MsgAddAssetResponse, error) {
+	authority := k.GetAuthority()
+	if msg.From != authority {
+		return nil, types.NewErrorInvalidSigner(msg.From, authority)
+	}
+
+	if k.HasAsset(ctx, msg.Denom) {
+		return nil, types.NewErrorDuplicateAsset(msg.Denom)
+	}
+
+	asset := v1.Asset{
+		Denom:           msg.Denom,
+		Decimals:        msg.Decimals,
+		PoolID:          0,
+		BaseAssetDenom:  msg.BaseAssetDenom,
+		QuoteAssetDenom: msg.QuoteAssetDenom,
+		Price:           sdkmath.ZeroInt(),
+	}
+
+	k.SetAsset(ctx, asset)
+
+	return &v1.MsgAddAssetResponse{}, nil
+}
+
+func (k *Keeper) HandleMsgDeleteAsset(ctx sdk.Context, msg *v1.MsgDeleteAssetRequest) (*v1.MsgDeleteAssetResponse, error) {
+	authority := k.GetAuthority()
+	if msg.From != authority {
+		return nil, types.NewErrorInvalidSigner(msg.From, authority)
+	}
+
+	k.DeleteAsset(ctx, msg.Denom)
+
+	return &v1.MsgDeleteAssetResponse{}, nil
+}
+
+func (k *Keeper) HandleMsgUpdateAsset(ctx sdk.Context, msg *v1.MsgUpdateAssetRequest) (*v1.MsgUpdateAssetResponse, error) {
+	authority := k.GetAuthority()
+	if msg.From != authority {
+		return nil, types.NewErrorInvalidSigner(msg.From, authority)
+	}
+
+	asset, found := k.GetAsset(ctx, msg.Denom)
+	if !found {
+		return nil, types.NewErrorAssetNotFound(msg.Denom)
+	}
+
+	asset.Decimals = msg.Decimals
+	asset.BaseAssetDenom = msg.BaseAssetDenom
+	asset.QuoteAssetDenom = msg.QuoteAssetDenom
+
+	k.SetAsset(ctx, asset)
+
+	return &v1.MsgUpdateAssetResponse{}, nil
+}
+
 func (k *Keeper) HandleMsgUpdateParams(ctx sdk.Context, msg *v1.MsgUpdateParamsRequest) (*v1.MsgUpdateParamsResponse, error) {
 	authority := k.GetAuthority()
 	if msg.From != authority {

x/oracle/services/v1/msg_server.go

@@ -21,6 +21,21 @@ func NewMsgServiceServer(k keeper.Keeper) v1.MsgServiceServer {
 	return &msgServer{k}
 }
 
+func (m *msgServer) MsgAddAsset(c context.Context, req *v1.MsgAddAssetRequest) (*v1.MsgAddAssetResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	return m.HandleMsgAddAsset(ctx, req)
+}
+
+func (m *msgServer) MsgDeleteAsset(c context.Context, req *v1.MsgDeleteAssetRequest) (*v1.MsgDeleteAssetResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	return m.HandleMsgDeleteAsset(ctx, req)
+}
+
+func (m *msgServer) MsgUpdateAsset(c context.Context, req *v1.MsgUpdateAssetRequest) (*v1.MsgUpdateAssetResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	return m.HandleMsgUpdateAsset(ctx, req)
+}
+
 func (m *msgServer) MsgUpdateParams(c context.Context, req *v1.MsgUpdateParamsRequest) (*v1.MsgUpdateParamsResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 	return m.HandleMsgUpdateParams(ctx, req)

x/oracle/types/errors.go

@@ -11,8 +11,9 @@ import (
 var (
 	ErrorInvalidMessage = sdkerrors.Register(ModuleName, 101, "invalid message")
 
-	ErrorAssetNotFound = sdkerrors.Register(ModuleName, 201, "asset not found")
-	ErrorDenomNotFound = sdkerrors.Register(ModuleName, 202, "denom not found")
+	ErrorAssetNotFound  = sdkerrors.Register(ModuleName, 201, "asset not found")
+	ErrorDenomNotFound  = sdkerrors.Register(ModuleName, 202, "denom not found")
+	ErrorDuplicateAsset = sdkerrors.Register(ModuleName, 203, "duplicate asset")
 )
 
 func NewErrorInvalidVersion(version, expected string) error {
@@ -42,3 +43,7 @@ func NewErrorDenomtNotFound(portID, channelID string, sequence uint64) error {
 func NewErrorInvalidSigner(from, expected string) error {
 	return sdkerrors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority %s; expected %s", from, expected)
 }
+
+func NewErrorDuplicateAsset(denom string) error {
+	return sdkerrors.Wrapf(ErrorDuplicateAsset, "asset %s already exists", denom)
+}

x/oracle/types/v1/msg.go

@@ -8,9 +8,99 @@ import (
 )
 
 var (
+	_ sdk.Msg = (*MsgAddAssetRequest)(nil)
+	_ sdk.Msg = (*MsgDeleteAssetRequest)(nil)
+	_ sdk.Msg = (*MsgUpdateAssetRequest)(nil)
 	_ sdk.Msg = (*MsgUpdateParamsRequest)(nil)
 )
 
+func (m *MsgAddAssetRequest) ValidateBasic() error {
+	if m.From == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "from cannot be empty")
+	}
+	if _, err := sdk.AccAddressFromBech32(m.From); err != nil {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, err.Error())
+	}
+	if err := sdk.ValidateDenom(m.Denom); err != nil {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, err.Error())
+	}
+	if m.Decimals < 0 {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "decimals cannot be negative")
+	}
+	if m.BaseAssetDenom == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "base_asset_denom cannot be empty")
+	}
+	if m.QuoteAssetDenom == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "quote_asset_denom cannot be empty")
+	}
+
+	return nil
+}
+
+func (m *MsgAddAssetRequest) GetSigners() []sdk.AccAddress {
+	from, err := sdk.AccAddressFromBech32(m.From)
+	if err != nil {
+		panic(err)
+	}
+
+	return []sdk.AccAddress{from.Bytes()}
+}
+
+func (m *MsgDeleteAssetRequest) ValidateBasic() error {
+	if m.From == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "from cannot be empty")
+	}
+	if _, err := sdk.AccAddressFromBech32(m.From); err != nil {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, err.Error())
+	}
+	if err := sdk.ValidateDenom(m.Denom); err != nil {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, err.Error())
+	}
+
+	return nil
+}
+
+func (m *MsgDeleteAssetRequest) GetSigners() []sdk.AccAddress {
+	from, err := sdk.AccAddressFromBech32(m.From)
+	if err != nil {
+		panic(err)
+	}
+
+	return []sdk.AccAddress{from.Bytes()}
+}
+
+func (m *MsgUpdateAssetRequest) ValidateBasic() error {
+	if m.From == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "from cannot be empty")
+	}
+	if _, err := sdk.AccAddressFromBech32(m.From); err != nil {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, err.Error())
+	}
+	if err := sdk.ValidateDenom(m.Denom); err != nil {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, err.Error())
+	}
+	if m.Decimals < 0 {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "decimals cannot be negative")
+	}
+	if m.BaseAssetDenom == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "base_asset_denom cannot be empty")
+	}
+	if m.QuoteAssetDenom == "" {
+		return sdkerrors.Wrap(types.ErrorInvalidMessage, "quote_asset_denom cannot be empty")
+	}
+
+	return nil
+}
+
+func (m *MsgUpdateAssetRequest) GetSigners() []sdk.AccAddress {
+	from, err := sdk.AccAddressFromBech32(m.From)
+	if err != nil {
+		panic(err)
+	}
+
+	return []sdk.AccAddress{from.Bytes()}
+}
+
 func (m *MsgUpdateParamsRequest) ValidateBasic() error {
 	if m.From == "" {
 		return sdkerrors.Wrap(types.ErrorInvalidMessage, "from cannot be empty")