Sdk v0.46.* and ibc-go v5.1.0

x/icacallbacks/module_ibc.go

@@ -12,6 +12,8 @@ import (
 	"github.com/gogo/protobuf/proto"
 	"github.com/tendermint/tendermint/libs/log"
 
+	"github.com/Stride-Labs/stride/v4/x/icacallbacks/types"
+
 	"github.com/Stride-Labs/stride/v4/x/icacallbacks/keeper"
 )
 
@@ -92,7 +94,11 @@ func (im IBCModule) NegotiateAppVersion(
 }
 
 // GetTxMsgData returns the msgs from an ICA transaction and can be reused across authentication modules
-func GetTxMsgData(ctx sdk.Context, ack channeltypes.Acknowledgement, logger log.Logger) (*sdk.TxMsgData, error) {
+func GetTxMsgData(ctx sdk.Context, ack channeltypes.Acknowledgement, logger log.Logger) (*types.ICATxResponse, error) {
+	// if ack is nil, a timeout occurred
+	if &ack == nil {
+		return &types.ICATxResponse{Status: types.TIMEOUT}, nil
+	}
 	txMsgData := &sdk.TxMsgData{}
 	switch response := ack.Response.(type) {
 	case *channeltypes.Acknowledgement_Result:
@@ -104,11 +110,13 @@ func GetTxMsgData(ctx sdk.Context, ack channeltypes.Acknowledgement, logger log.
 			logger.Error(fmt.Sprintf("cannot unmarshal ICS-27 tx message data: %s", err.Error()))
 			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal ICS-27 tx message data: %s", err.Error())
 		}
-		return txMsgData, nil
+		// NOTE: Is this safe to assume? According to the ics-27 spec, errors on host chains should be reflected in the acknowledgement type
+		// so Acknowledgement_Result should only be returned if the transaction was successful
+		// However, I recall seeing a case where the acknowledgement type was Acknowledgement_Result but the transaction failed
+		return &types.ICATxResponse{Status: types.SUCCESS, Data: *txMsgData}, nil
 	case *channeltypes.Acknowledgement_Error:
 		logger.Error(fmt.Sprintf("acknowledgement error: %s", response.Error))
-		return txMsgData, nil
-
+		return &types.ICATxResponse{Status: types.FAILURE}, nil
 	default:
 		return nil, sdkerrors.Wrapf(channeltypes.ErrInvalidAcknowledgement, "unsupported acknowledgement response field type %T", response)
 	}

x/icacallbacks/types/ICATxResponseStatus.go

@@ -0,0 +1,15 @@
+package types
+
+import sdk "github.com/cosmos/cosmos-sdk/types"
+
+
+type ICATxResponseStatus int
+const (
+    SUCCESS ICATxResponseStatus = iota
+    TIMEOUT
+    FAILURE
+)
+type ICATxResponse struct {
+	Status ICATxResponseStatus // enum of SUCCESS, TIMEOUT, FAILURE
+	Data sdk.TxMsgData // TxMsgData
+}

x/stakeibc/keeper/icacallbacks_claim.go

@@ -44,24 +44,24 @@ func ClaimCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, ack *c
 		return sdkerrors.Wrapf(types.ErrRecordNotFound, "user redemption record not found %s", claimCallback.GetUserRedemptionRecordId())
 	}
 
+	icaTxResponse, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
+	if err != nil {
+		k.Logger(ctx).Error(fmt.Sprintf("failed to unmarshal txMsgData, packet %v", packet))
+		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
+	}
+
 	// handle timeout
-	if ack == nil {
+	if icaTxResponse.Status == icacallbackstypes.TIMEOUT {
 		k.Logger(ctx).Error(fmt.Sprintf("ClaimCallback timeout, ack is nil, packet %v", packet))
 		// after a timeout, a user should be able to retry the claim
 		userRedemptionRecord.ClaimIsPending = false
 		k.RecordsKeeper.SetUserRedemptionRecord(ctx, userRedemptionRecord)
 		return nil
 	}
 
-	txMsgData, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
-	if err != nil {
-		k.Logger(ctx).Error(fmt.Sprintf("failed to unmarshal txMsgData, packet %v", packet))
-		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
-	}
-
-	k.Logger(ctx).Info("ClaimCallback executing", "packet", packet, "txMsgData", txMsgData, "args", args)
+	k.Logger(ctx).Info("ClaimCallback executing", "packet", packet, "txMsgData", &icaTxResponse.Data, "args", args)
 	// handle failed tx on host chain
-	if len(txMsgData.MsgResponses) == 0 {
+	if icaTxResponse.Status == icacallbackstypes.FAILURE {
 		k.Logger(ctx).Error(fmt.Sprintf("ClaimCallback failed, packet %v", packet))
 		// after an error, a user should be able to retry the claim
 		userRedemptionRecord.ClaimIsPending = false

x/stakeibc/keeper/icacallbacks_delegate.go

@@ -66,22 +66,20 @@ func DelegateCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, ack
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "deposit record not found %d", recordId)
 	}
 
-	// Check for timeout (ack nil)
-	// No need to reset the deposit record status since it will get revertted when the channel is restored
-	if ack == nil {
-		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Delegate,
-			"TIMEOUT (ack is nil), Packet: %+v", packet))
-		return nil
-	}
-
-	// Check for a failed transaction (ack error)
 	// Reset the deposit record status upon failure
-	txMsgData, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
+	icaTxResponse, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
 	if err != nil {
 		k.Logger(ctx).Error(fmt.Sprintf("failed to fetch txMsgData, packet %v", packet))
 		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
 	}
-	if len(txMsgData.MsgResponses) == 0 {
+
+	// No need to reset the deposit record status since it will get revertted when the channel is restored
+	if icaTxResponse.Status == icacallbackstypes.TIMEOUT {
+		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Delegate,
+			"TIMEOUT (ack is nil), Packet: %+v", packet))
+		return nil
+	}
+	if icaTxResponse.Status == icacallbackstypes.FAILURE {
 		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Delegate,
 			"ICA TX FAILED (ack is empty / ack error), Packet: %+v", packet))
 

x/stakeibc/keeper/icacallbacks_rebalance.go

@@ -33,19 +33,20 @@ func (k Keeper) UnmarshalRebalanceCallbackArgs(ctx sdk.Context, rebalanceCallbac
 
 func RebalanceCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, ack *channeltypes.Acknowledgement, args []byte) error {
 	k.Logger(ctx).Info("RebalanceCallback executing", "packet", packet)
-	if ack == nil {
-		// timeout
-		k.Logger(ctx).Error(fmt.Sprintf("RebalanceCallback timeout, ack is nil, packet %v", packet))
-		return nil
-	}
 
-	txMsgData, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
+	icaTxResponse, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
 	if err != nil {
 		k.Logger(ctx).Error(fmt.Sprintf("failed to fetch txMsgData, packet %v", packet))
 		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
 	}
 
-	if len(txMsgData.MsgResponses) == 0 {
+	if icaTxResponse.Status == icacallbackstypes.TIMEOUT {
+		// timeout
+		k.Logger(ctx).Error(fmt.Sprintf("RebalanceCallback timeout, ack is nil, packet %v", packet))
+		return nil
+	}
+
+	if icaTxResponse.Status == icacallbackstypes.FAILURE {
 		// failed transaction
 		k.Logger(ctx).Error(fmt.Sprintf("RebalanceCallback tx failed, ack is empty (ack error), packet %v", packet))
 		return nil

x/stakeibc/keeper/icacallbacks_redemption.go

@@ -54,22 +54,21 @@ func RedemptionCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, a
 	k.Logger(ctx).Info(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Redemption,
 		"Starting callback for Epoch Unbonding Records: %+v", redemptionCallback.EpochUnbondingRecordIds))
 
-	// Check for timeout (ack nil)
+	// Reset the unbonding record status upon failure
+	icaTxResponse, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
+	if err != nil {
+		k.Logger(ctx).Error(fmt.Sprintf("RedemptionCallback txMsgData could not be parsed, packet %v", packet))
+		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
+	}
+
 	// No need to reset the unbonding record status since it will get revertted when the channel is restored
-	if ack == nil {
+	if icaTxResponse.Status == icacallbackstypes.TIMEOUT {
 		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Redemption,
 			"TIMEOUT (ack is nil), Packet: %+v", packet))
 		return nil
 	}
 
-	// Check for a failed transaction (ack error)
-	// Reset the unbonding record status upon failure
-	txMsgData, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
-	if err != nil {
-		k.Logger(ctx).Error(fmt.Sprintf("RedemptionCallback txMsgData could not be parsed, packet %v", packet))
-		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
-	}
-	if len(txMsgData.MsgResponses) == 0 {
+	if icaTxResponse.Status == icacallbackstypes.FAILURE {
 		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Redemption,
 			"ICA TX FAILED (ack is empty / ack error), Packet: %+v", packet))
 

x/stakeibc/keeper/icacallbacks_reinvest.go

@@ -35,19 +35,19 @@ func (k Keeper) UnmarshalReinvestCallbackArgs(ctx sdk.Context, reinvestCallback
 
 func ReinvestCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, ack *channeltypes.Acknowledgement, args []byte) error {
 	k.Logger(ctx).Info("ReinvestCallback executing", "packet", packet)
-	if ack == nil {
-		// handle timeout
-		k.Logger(ctx).Error(fmt.Sprintf("ReinvestCallback timeout, ack is nil, packet %v", packet))
-		return nil
-	}
-
-	txMsgData, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
+	icaTxResponse, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
 	if err != nil {
 		k.Logger(ctx).Error(fmt.Sprintf("failed to fetch txMsgData, packet %v", packet))
 		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
 	}
+
+	if icaTxResponse.Status == icacallbackstypes.TIMEOUT {
+		// handle timeout
+		k.Logger(ctx).Error(fmt.Sprintf("ReinvestCallback timeout, ack is nil, packet %v", packet))
+		return nil
+	}
 
-	if len(txMsgData.MsgResponses) == 0 {
+	if icaTxResponse.Status == icacallbackstypes.FAILURE {
 		// handle tx failure
 		k.Logger(ctx).Error(fmt.Sprintf("ReinvestCallback tx failed, txMsgData is empty, ack error, packet %v", packet))
 		return nil

x/stakeibc/keeper/icacallbacks_undelegate.go

@@ -61,22 +61,21 @@ func UndelegateCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, a
 	k.Logger(ctx).Info(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Undelegate,
 		"Starting callback for Epoch Unbonding Records: %+v", undelegateCallback.EpochUnbondingRecordIds))
 
-	// Check for timeout (ack nil)
+	// Reset the unbonding record status upon failure
+	icaTxResponse, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
+	if err != nil {
+		k.Logger(ctx).Error(fmt.Sprintf("UndelegateCallback failed to fetch txMsgData, packet %v", packet))
+		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
+	}
+
 	// No need to reset the unbonding record status since it will get revertted when the channel is restored
-	if ack == nil {
+	if icaTxResponse.Status == icacallbackstypes.TIMEOUT {
 		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Undelegate,
 			"TIMEOUT (ack is nil), Packet: %+v", packet))
 		return nil
 	}
 
-	// Check for a failed transaction (ack error)
-	// Reset the unbonding record status upon failure
-	txMsgData, err := icacallbacks.GetTxMsgData(ctx, *ack, k.Logger(ctx))
-	if err != nil {
-		k.Logger(ctx).Error(fmt.Sprintf("UndelegateCallback failed to fetch txMsgData, packet %v", packet))
-		return sdkerrors.Wrap(icacallbackstypes.ErrTxMsgData, err.Error())
-	}
-	if len(txMsgData.MsgResponses) == 0 {
+	if icaTxResponse.Status == icacallbackstypes.FAILURE {
 		k.Logger(ctx).Error(utils.LogCallbackWithHostZone(chainId, ICACallbackID_Undelegate,
 			"ICA TX FAILED (ack is empty / ack error), Packet: %+v", packet))
 
@@ -102,7 +101,7 @@ func UndelegateCallback(k Keeper, ctx sdk.Context, packet channeltypes.Packet, a
 	}
 
 	// Get the latest transaction completion time (to determine the unbonding time)
-	latestCompletionTime, err := k.GetLatestCompletionTime(ctx, txMsgData)
+	latestCompletionTime, err := k.GetLatestCompletionTime(ctx, &icaTxResponse.Data)
 	if err != nil {
 		k.Logger(ctx).Error(fmt.Sprintf("UndelegateCallback | %s", err.Error()))
 		return err
@@ -155,22 +154,44 @@ func (k Keeper) UpdateDelegationBalances(ctx sdk.Context, zone types.HostZone, u
 func (k Keeper) GetLatestCompletionTime(ctx sdk.Context, txMsgData *sdk.TxMsgData) (*time.Time, error) {
 	// Update the completion time using the latest completion time across each message within the transaction
 	latestCompletionTime := time.Time{}
-	for _, msgResponse := range txMsgData.MsgResponses {
-		var undelegateResponse stakingtypes.MsgUndelegateResponse
-		if msgResponse == nil {
-			return nil, sdkerrors.Wrap(types.ErrTxMsgDataInvalid, "msgResponseBytes or msgResponseBytes.Data is nil")
+	switch len(txMsgData.Data) {
+	case 0: // for SDK 0.46 and above
+		for _, msgResponse := range txMsgData.MsgResponses {
+			// unmarshall msgResponse and execute logic based on the response 
+			var undelegateResponse stakingtypes.MsgUndelegateResponse
+			if msgResponse == nil {
+				return nil, sdkerrors.Wrap(types.ErrTxMsgDataInvalid, "msgResponse is nil")
+			}
+			undelegateResponsebz := msgResponse.GetValue()
+			err := proto.Unmarshal(undelegateResponsebz, &undelegateResponse)
+			if err != nil {
+				errMsg := fmt.Sprintf("Unable to unmarshal undelegation tx response | %s", err)
+				k.Logger(ctx).Error(errMsg)
+				return nil, sdkerrors.Wrapf(types.ErrUnmarshalFailure, errMsg)
+			}
+			if undelegateResponse.CompletionTime.After(latestCompletionTime) {
+				latestCompletionTime = undelegateResponse.CompletionTime
+			}
 		}
-		undelegateResponsebz := msgResponse.GetValue()
-		err := proto.Unmarshal(undelegateResponsebz, &undelegateResponse)
-		if err != nil {
-			errMsg := fmt.Sprintf("Unable to unmarshal undelegation tx response | %s", err)
-			k.Logger(ctx).Error(errMsg)
-			return nil, sdkerrors.Wrapf(types.ErrUnmarshalFailure, errMsg)
-		}
-		if undelegateResponse.CompletionTime.After(latestCompletionTime) {
-			latestCompletionTime = undelegateResponse.CompletionTime
+	default: // for SDK 0.45 and below
+		for _, msgResponseBytes := range txMsgData.Data {
+			// unmarshall msgData and execute logic based on the response 
+			var undelegateResponse stakingtypes.MsgUndelegateResponse
+			if msgResponseBytes == nil || msgResponseBytes.Data == nil {
+				return nil, sdkerrors.Wrap(types.ErrTxMsgDataInvalid, "msgResponseBytes or msgResponseBytes.Data is nil")
+			}
+			err := proto.Unmarshal(msgResponseBytes.Data, &undelegateResponse)
+			if err != nil {
+				errMsg := fmt.Sprintf("Unable to unmarshal undelegation tx response | %s", err)
+				k.Logger(ctx).Error(errMsg)
+				return nil, sdkerrors.Wrapf(types.ErrUnmarshalFailure, errMsg)
+			}
+			if undelegateResponse.CompletionTime.After(latestCompletionTime) {
+				latestCompletionTime = undelegateResponse.CompletionTime
+			}
 		}
 	}
+
 	if latestCompletionTime.IsZero() {
 		errMsg := fmt.Sprintf("Invalid completion time (%s) from txMsg", latestCompletionTime.String())
 		k.Logger(ctx).Error(errMsg)