feat(08-wasm): implement 'RemoveCodeHash' RPC endpoint

modules/light-clients/08-wasm/keeper/msg_server.go

@@ -7,6 +7,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"github.com/cosmos/ibc-go/modules/light-clients/08-wasm/internal/ibcwasm"
 	"github.com/cosmos/ibc-go/modules/light-clients/08-wasm/types"
 	ibcerrors "github.com/cosmos/ibc-go/v8/modules/core/errors"
 )
@@ -32,6 +33,22 @@ func (k Keeper) StoreCode(goCtx context.Context, msg *types.MsgStoreCode) (*type
 	}, nil
 }
 
+// RemoveCodeHash defines a rpc handler method for MsgRemoveCodeHash
+func (k Keeper) RemoveCodeHash(goCtx context.Context, msg *types.MsgRemoveCodeHash) (*types.MsgRemoveCodeHashResponse, error) {
+	if k.GetAuthority() != msg.Signer {
+		return nil, errorsmod.Wrapf(ibcerrors.ErrUnauthorized, "expected %s, got %s", k.GetAuthority(), msg.Signer)
+	}
+
+	found := types.HasCodeHash(goCtx, msg.CodeHash)
+
+	err := ibcwasm.CodeHashes.Remove(goCtx, msg.CodeHash)
+	if err != nil {
+		return nil, errorsmod.Wrap(err, "failed to remove code hash")
+	}
+
+	return &types.MsgRemoveCodeHashResponse{Found: found}, nil
+}
+
 // MigrateContract defines a rpc handler method for MsgMigrateContract
 func (k Keeper) MigrateContract(goCtx context.Context, msg *types.MsgMigrateContract) (*types.MsgMigrateContractResponse, error) {
 	if k.GetAuthority() != msg.Signer {

modules/light-clients/08-wasm/keeper/msg_server_test.go

@@ -13,6 +13,7 @@ import (
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 
+	"github.com/cosmos/ibc-go/modules/light-clients/08-wasm/internal/ibcwasm"
 	wasmtesting "github.com/cosmos/ibc-go/modules/light-clients/08-wasm/testing"
 	"github.com/cosmos/ibc-go/modules/light-clients/08-wasm/types"
 	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
@@ -278,3 +279,102 @@ func (suite *KeeperTestSuite) TestMsgMigrateContract() {
 		})
 	}
 }
+
+func (suite *KeeperTestSuite) TestMsgRemoveCodeHash() {
+	codeHash := sha256.Sum256(wasmtesting.Code)
+
+	govAcc := authtypes.NewModuleAddress(govtypes.ModuleName).String()
+
+	var (
+		msg           *types.MsgRemoveCodeHash
+		expCodeHashes []types.CodeHash
+		expFound      bool
+	)
+
+	testCases := []struct {
+		name     string
+		malleate func()
+		expError error
+	}{
+		{
+			"success",
+			func() {
+				msg = types.NewMsgRemoveCodeHash(govAcc, codeHash[:])
+
+				expCodeHashes = []types.CodeHash{}
+				expFound = true
+			},
+			nil,
+		},
+		{
+			"success: many code hashes",
+			func() {
+				msg = types.NewMsgRemoveCodeHash(govAcc, codeHash[:])
+
+				expFound = true
+				expCodeHashes = []types.CodeHash{}
+
+				for i := 0; i < 20; i++ {
+					codeHash := sha256.Sum256([]byte{byte(i)})
+					err := ibcwasm.CodeHashes.Set(suite.chainA.GetContext(), codeHash[:])
+					suite.Require().NoError(err)
+
+					expCodeHashes = append(expCodeHashes, codeHash[:])
+				}
+			},
+			nil,
+		},
+		{
+			"success: code hash is missing",
+			func() {
+				msg = types.NewMsgRemoveCodeHash(govAcc, []byte{1})
+
+				expCodeHashes = []types.CodeHash{codeHash[:]}
+				expFound = false
+			},
+			nil,
+		},
+		{
+			"failure: unauthorized signer",
+			func() {
+				msg = types.NewMsgRemoveCodeHash(suite.chainA.SenderAccount.GetAddress().String(), codeHash[:])
+			},
+			ibcerrors.ErrUnauthorized,
+		},
+	}
+
+	for _, tc := range testCases {
+		suite.Run(tc.name, func() {
+			suite.SetupWasmWithMockVM()
+
+			endpoint := wasmtesting.NewWasmEndpoint(suite.chainA)
+			err := endpoint.CreateClient()
+			suite.Require().NoError(err)
+
+			tc.malleate()
+
+			ctx := suite.chainA.GetContext()
+			res, err := GetSimApp(suite.chainA).WasmClientKeeper.RemoveCodeHash(ctx, msg)
+			events := ctx.EventManager().Events().ToABCIEvents()
+
+			if tc.expError == nil {
+				suite.Require().NoError(err)
+				suite.Require().NotNil(res)
+				suite.Require().Equal(expFound, res.Found)
+
+				codeHashes, err := types.GetAllCodeHashes(suite.chainA.GetContext())
+				suite.Require().NoError(err)
+
+				// Check equality of code hashes up to order
+				suite.Require().Subset(expCodeHashes, codeHashes)
+				suite.Require().Subset(codeHashes, expCodeHashes)
+
+				// Verify events
+				suite.Require().Len(events, 0)
+			} else {
+				suite.Require().ErrorIs(err, tc.expError)
+				suite.Require().Nil(res)
+			}
+		})
+	}
+}

modules/light-clients/08-wasm/types/msgs.go

@@ -11,8 +11,10 @@ import (
 var (
 	_ sdk.Msg              = (*MsgStoreCode)(nil)
 	_ sdk.Msg              = (*MsgMigrateContract)(nil)
+	_ sdk.Msg              = (*MsgRemoveCodeHash)(nil)
 	_ sdk.HasValidateBasic = (*MsgStoreCode)(nil)
 	_ sdk.HasValidateBasic = (*MsgMigrateContract)(nil)
+	_ sdk.HasValidateBasic = (*MsgRemoveCodeHash)(nil)
 )
 
 // MsgStoreCode creates a new MsgStoreCode instance
@@ -37,6 +39,30 @@ func (m MsgStoreCode) ValidateBasic() error {
 	return nil
 }
 
+// NewMsgRemoveCodeHash creates a new MsgRemoveCodeHash instance
+//
+//nolint:interfacer
+func NewMsgRemoveCodeHash(signer string, codeHash []byte) *MsgRemoveCodeHash {
+	return &MsgRemoveCodeHash{
+		Signer:   signer,
+		CodeHash: codeHash,
+	}
+}
+
+// ValidateBasic implements sdk.Msg
+func (m MsgRemoveCodeHash) ValidateBasic() error {
+	_, err := sdk.AccAddressFromBech32(m.Signer)
+	if err != nil {
+		return errorsmod.Wrapf(ibcerrors.ErrInvalidAddress, "string could not be parsed as address: %v", err)
+	}
+
+	if err := ValidateWasmCodeHash(m.CodeHash); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // MsgMigrateContract creates a new MsgMigrateContract instance
 func NewMsgMigrateContract(signer, clientID string, codeHash, migrateMsg []byte) *MsgMigrateContract {
 	return &MsgMigrateContract{

modules/light-clients/08-wasm/types/msgs_test.go

@@ -52,7 +52,7 @@ func TestMsgStoreCodeValidateBasic(t *testing.T) {
 		err := tc.msg.ValidateBasic()
 		expPass := tc.expErr == nil
 		if expPass {
-			require.NoError(t, err)
+			require.NoError(t, err, tc.name)
 		} else {
 			require.ErrorIs(t, err, tc.expErr)
 		}
@@ -153,7 +153,52 @@ func TestMsgMigrateContractValidateBasic(t *testing.T) {
 		if expPass {
 			require.NoError(t, err)
 		} else {
-			require.ErrorIs(t, err, tc.expErr)
+			require.ErrorIs(t, err, tc.expErr, tc.name)
+		}
+	}
+}
+
+func TestMsgRemoveCodeHashValidateBasic(t *testing.T) {
+	signer := sdk.AccAddress(ibctesting.TestAccAddress).String()
+
+	codeHash := sha256.Sum256(wasmtesting.Code)
+
+	testCases := []struct {
+		name   string
+		msg    *types.MsgRemoveCodeHash
+		expErr error
+	}{
+		{
+			"success: valid signer address, valid length code hash",
+			types.NewMsgRemoveCodeHash(signer, codeHash[:]),
+			nil,
+		},
+		{
+			"failure: code hash is empty",
+			types.NewMsgRemoveCodeHash(signer, []byte("")),
+			types.ErrInvalidCodeHash,
+		},
+		{
+			"failure: code hash is nil",
+			types.NewMsgRemoveCodeHash(signer, nil),
+			types.ErrInvalidCodeHash,
+		},
+		{
+			"failure: signer is invalid",
+			types.NewMsgRemoveCodeHash(ibctesting.InvalidID, codeHash[:]),
+			ibcerrors.ErrInvalidAddress,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		err := tc.msg.ValidateBasic()
+		expPass := tc.expErr == nil
+		if expPass {
+			require.NoError(t, err, tc.name)
+		} else {
+			require.ErrorIs(t, err, tc.expErr, tc.name)
 		}
 	}
 }