Cleanup v15

proto/stride/stakeibc/callbacks.proto

@@ -43,14 +43,6 @@ message UndelegateCallback {
  repeated uint64 epoch_unbonding_record_ids = 3;
 }
 
-message UndelegateHostCallback {
- string amt = 1 [
- (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
- (gogoproto.nullable) = false
- ];
- repeated SplitDelegation split_delegations = 2;
-}
-
 message RedemptionCallback {
  string host_zone_id = 1;
  repeated uint64 epoch_unbonding_record_ids = 2;

proto/stride/stakeibc/tx.proto

@@ -31,7 +31,6 @@ service Msg {
  rpc CalibrateDelegation(MsgCalibrateDelegation)
  returns (MsgCalibrateDelegationResponse);
  rpc ClearBalance(MsgClearBalance) returns (MsgClearBalanceResponse);
- rpc UndelegateHost(MsgUndelegateHost) returns (MsgUndelegateHostResponse);
  rpc UpdateInnerRedemptionRateBounds(MsgUpdateInnerRedemptionRateBounds)
  returns (MsgUpdateInnerRedemptionRateBoundsResponse);
  rpc ResumeHostZone(MsgResumeHostZone) returns (MsgResumeHostZoneResponse);
@@ -180,14 +179,6 @@ message MsgUpdateValidatorSharesExchRate {
  string valoper = 3;
 }
 message MsgUpdateValidatorSharesExchRateResponse {}
-message MsgUndelegateHost {
- string creator = 1;
- string amount = 2 [
- (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
- (gogoproto.nullable) = false
- ];
-}
-message MsgUndelegateHostResponse {}
 
 message MsgCalibrateDelegation {
  string creator = 1;

x/stakeibc/client/cli/tx.go

@@ -37,7 +37,6 @@ func GetTxCmd() *cobra.Command {
  cmd.AddCommand(CmdUpdateValidatorSharesExchRate())
  cmd.AddCommand(CmdCalibrateDelegation())
  cmd.AddCommand(CmdClearBalance())
- cmd.AddCommand(CmdUndelegateHost())
  cmd.AddCommand(CmdUpdateInnerRedemptionRateBounds())
  cmd.AddCommand(CmdResumeHostZone())
 

x/stakeibc/handler.go

@@ -58,9 +58,6 @@ func NewMessageHandler(k keeper.Keeper) sdk.Handler {
  case *types.MsgUpdateValidatorSharesExchRate:
  res, err := msgServer.UpdateValidatorSharesExchRate(sdk.WrapSDKContext(ctx), msg)
  return sdk.WrapServiceResult(ctx, res, err)
- case *types.MsgUndelegateHost:
- res, err := msgServer.UndelegateHost(sdk.WrapSDKContext(ctx), msg)
- return sdk.WrapServiceResult(ctx, res, err)
  case *types.MsgCalibrateDelegation:
  res, err := msgServer.CalibrateDelegation(sdk.WrapSDKContext(ctx), msg)
  return sdk.WrapServiceResult(ctx, res, err)

x/stakeibc/keeper/grpc_query_host_zone_test.go

@@ -20,9 +20,6 @@ func TestHostZoneQuerySingle(t *testing.T) {
  keeper, ctx := keepertest.StakeibcKeeper(t)
  wctx := sdk.WrapSDKContext(ctx)
  msgs := createNHostZone(keeper, ctx, 2)
- for _, msg := range msgs {
- t.Log(msg.ChainId)
- }
  for _, tc := range []struct {
  desc string
  request *types.QueryGetHostZoneRequest

x/stakeibc/keeper/icacallbacks.go

@@ -5,22 +5,20 @@ import (
 )
 
 const (
- ICACallbackID_Delegate = "delegate"
- ICACallbackID_Claim = "claim"
- ICACallbackID_Undelegate = "undelegate"
- ICACallbackID_UndelegateHost = "undelegatehost"
- ICACallbackID_Reinvest = "reinvest"
- ICACallbackID_Redemption = "redemption"
- ICACallbackID_Rebalance = "rebalance"
- ICACallbackID_Detokenize = "detokenize"
+ ICACallbackID_Delegate = "delegate"
+ ICACallbackID_Claim = "claim"
+ ICACallbackID_Undelegate = "undelegate"
+ ICACallbackID_Reinvest = "reinvest"
+ ICACallbackID_Redemption = "redemption"
+ ICACallbackID_Rebalance = "rebalance"
+ ICACallbackID_Detokenize = "detokenize"
 )
 
 func (k Keeper) Callbacks() icacallbackstypes.ModuleCallbacks {
  return []icacallbackstypes.ICACallback{
  {CallbackId: ICACallbackID_Delegate, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.DelegateCallback)},
  {CallbackId: ICACallbackID_Claim, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.ClaimCallback)},
  {CallbackId: ICACallbackID_Undelegate, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.UndelegateCallback)},
- {CallbackId: ICACallbackID_UndelegateHost, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.UndelegateHostCallback)},
  {CallbackId: ICACallbackID_Reinvest, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.ReinvestCallback)},
  {CallbackId: ICACallbackID_Redemption, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.RedemptionCallback)},
  {CallbackId: ICACallbackID_Rebalance, CallbackFunc: icacallbackstypes.ICACallbackFunction(k.RebalanceCallback)},

x/stakeibc/keeper/icacallbacks_undelegate.go

@@ -233,86 +233,3 @@ func (k Keeper) BurnTokens(ctx sdk.Context, hostZone types.HostZone, stTokenBurn
  k.Logger(ctx).Info(fmt.Sprintf("Total supply %s", k.bankKeeper.GetSupply(ctx, stCoinDenom)))
  return nil
 }
-
-// ICA Callback after undelegating host
-//
-// If successful:
-// * sets SetUndelegateHostPrevented
-// If timeout:
-// * Does nothing
-// If failure:
-// * Does nothing
-func (k Keeper) UndelegateHostCallback(ctx sdk.Context, packet channeltypes.Packet, ackResponse *icacallbackstypes.AcknowledgementResponse, args []byte) error {
- // Fetch callback args
- var undelegateHostCallback types.UndelegateHostCallback
- if err := proto.Unmarshal(args, &undelegateHostCallback); err != nil {
- return errorsmod.Wrapf(types.ErrUnmarshalFailure, fmt.Sprintf("Unable to unmarshal undelegate host callback args: %s", err.Error()))
- }
- k.Logger(ctx).Info("Starting undelegate host callback for amount %v%s", undelegateHostCallback.Amt)
-
- // Regardless of failure/success/timeout, indicate that this ICA has completed
- hostZone, found := k.GetHostZone(ctx, EvmosHostZoneChainId)
- if !found {
- return errorsmod.Wrapf(sdkerrors.ErrKeyNotFound, "Host zone not found: %s", EvmosHostZoneChainId)
- }
- for _, splitDelegation := range undelegateHostCallback.SplitDelegations {
- if err := k.DecrementValidatorDelegationChangesInProgress(&hostZone, splitDelegation.Validator); err != nil {
- // TODO: Revert after v14 upgrade
- if errors.Is(err, types.ErrInvalidValidatorDelegationUpdates) {
- k.Logger(ctx).Error(utils.LogICACallbackWithHostZone(EvmosHostZoneChainId, ICACallbackID_Undelegate,
- "Invariant failed - delegation changes in progress fell below 0 for %s", splitDelegation.Validator))
- continue
- }
- return err
- }
- }
- k.SetHostZone(ctx, hostZone)
-
- // Check for timeout (ack nil)
- if ackResponse.Status == icacallbackstypes.AckResponseStatus_TIMEOUT {
- k.Logger(ctx).Error("UndelegateHostCallback Timeout:", icacallbackstypes.AckResponseStatus_TIMEOUT, packet)
- return nil
- }
-
- // Check for a failed transaction (ack error)
- if ackResponse.Status == icacallbackstypes.AckResponseStatus_FAILURE {
- k.Logger(ctx).Error("UndelegateHostCallback failure (ack error):", icacallbackstypes.AckResponseStatus_FAILURE, packet)
- return nil
- }
-
- // Get the host zone
- evmosHost, found := k.GetHostZone(ctx, EvmosHostZoneChainId)
- if !found {
- return errorsmod.Wrapf(types.ErrHostZoneNotFound, "host zone %s not found", EvmosHostZoneChainId)
- }
-
- k.Logger(ctx).Info("UndelegateHostCallback success:", icacallbackstypes.AckResponseStatus_SUCCESS, packet)
-
- // Update delegation balances
- err := k.UpdateDelegationBalancesHost(ctx, evmosHost, undelegateHostCallback)
- if err != nil {
- k.Logger(ctx).Error(fmt.Sprintf("UndelegateCallback | %s", err.Error()))
- return err
- }
-
- k.Logger(ctx).Info("UndelegateHostCallback: SetUndelegateHostPrevented")
- if err := k.SetUndelegateHostPrevented(ctx); err != nil {
- k.Logger(ctx).Error(fmt.Sprintf("UndelegateHostCallback failed due to SetUndelegateHostPrevented | %s", err.Error()))
- return err
- }
-
- return nil
-}
-
-// Decrement the delegation field on host and each validator's delegations after a successful unbonding ICA
-func (k Keeper) UpdateDelegationBalancesHost(ctx sdk.Context, hostZone types.HostZone, undelegateHostCallback types.UndelegateHostCallback) error {
- // Undelegate from each validator and update Evmos staked balance, if successful
- for _, undelegation := range undelegateHostCallback.SplitDelegations {
- err := k.AddDelegationToValidator(ctx, &hostZone, undelegation.Validator, undelegation.Amount.Neg(), ICACallbackID_UndelegateHost)
- if err != nil {
- return err
- }
- }
- k.SetHostZone(ctx, hostZone)
- return nil
-}