only stored pending packet if rate limit exists

x/ratelimit/README.md

@@ -225,7 +225,7 @@ GetAllWhitelistedAddresses() []string
 // Checks whether a packet will exceed a rate limit quota
 // If it does not exceed the quota, it updates the `Inflow` or `Outflow`
 // If it exceeds the quota, it returns an error
-CheckRateLimitAndUpdateFlow(direction types.PacketDirection, packetInfo RateLimitedPacketInfo)
+CheckRateLimitAndUpdateFlow(direction types.PacketDirection, packetInfo RateLimitedPacketInfo) (updated bool)
 
 // Reverts the change in outflow from a SendPacket if it fails or times out
 UndoSendPacket(channelId string, sequence uint64, denom string, amount sdkmath.Int) 

x/ratelimit/keeper/packet.go

@@ -165,14 +165,16 @@ func (k Keeper) SendRateLimitedPacket(ctx sdk.Context, packet channeltypes.Packe
 	}
 
 	// Check if the packet would exceed the outflow rate limit
-	err = k.CheckRateLimitAndUpdateFlow(ctx, types.PACKET_SEND, packetInfo)
+	updatedFlow, err := k.CheckRateLimitAndUpdateFlow(ctx, types.PACKET_SEND, packetInfo)
 	if err != nil {
 		return err
 	}
 
 	// Store the sequence number of the packet so that if the transfer fails,
 	// we can identify if it was sent during this quota and can revert the outflow
-	k.SetPendingSendPacket(ctx, packetInfo.ChannelID, packet.Sequence)
+	if updatedFlow {
+		k.SetPendingSendPacket(ctx, packetInfo.ChannelID, packet.Sequence)
+	}
 
 	return nil
 }
@@ -185,7 +187,8 @@ func (k Keeper) ReceiveRateLimitedPacket(ctx sdk.Context, packet channeltypes.Pa
 		return err
 	}
 
-	return k.CheckRateLimitAndUpdateFlow(ctx, types.PACKET_RECV, packetInfo)
+	_, err = k.CheckRateLimitAndUpdateFlow(ctx, types.PACKET_RECV, packetInfo)
+	return err
 }
 
 // Middleware implementation for OnAckPacket with rate limiting

x/ratelimit/keeper/rate_limit.go

@@ -54,7 +54,11 @@ func (k Keeper) UpdateFlow(rateLimit types.RateLimit, direction types.PacketDire
 
 // Checks whether the given packet will exceed the rate limit
 // Called by OnRecvPacket and OnSendPacket
-func (k Keeper) CheckRateLimitAndUpdateFlow(ctx sdk.Context, direction types.PacketDirection, packetInfo RateLimitedPacketInfo) error {
+func (k Keeper) CheckRateLimitAndUpdateFlow(
+	ctx sdk.Context,
+	direction types.PacketDirection,
+	packetInfo RateLimitedPacketInfo,
+) (updatedFlow bool, err error) {
 	denom := packetInfo.Denom
 	channelId := packetInfo.ChannelID
 	amount := packetInfo.Amount
@@ -63,33 +67,32 @@ func (k Keeper) CheckRateLimitAndUpdateFlow(ctx sdk.Context, direction types.Pac
 	if k.IsDenomBlacklisted(ctx, denom) {
 		err := errorsmod.Wrapf(types.ErrDenomIsBlacklisted, "denom %s is blacklisted", denom)
 		EmitTransferDeniedEvent(ctx, types.EventBlacklistedDenom, denom, channelId, direction, amount, err)
-		return err
+		return false, err
 	}
 
 	// If there's no rate limit yet for this denom, no action is necessary
 	rateLimit, found := k.GetRateLimit(ctx, denom, channelId)
 	if !found {
-		return nil
+		return false, nil
 	}
 
 	// Check if the sender or receiver are white listed
 	// If so, return a success without modifying the quota
 	if k.IsAddressWhitelisted(ctx, packetInfo.Sender) || k.IsAddressWhitelisted(ctx, packetInfo.Receiver) {
-		return nil
+		return false, nil
 	}
 
 	// Update the flow object with the change in amount
-	err := k.UpdateFlow(rateLimit, direction, amount)
-	if err != nil {
+	if err := k.UpdateFlow(rateLimit, direction, amount); err != nil {
 		// If the rate limit was exceeded, emit an event
 		EmitTransferDeniedEvent(ctx, types.EventRateLimitExceeded, denom, channelId, direction, amount, err)
-		return err
+		return false, err
 	}
 
 	// If there's no quota error, update the rate limit object in the store with the new flow
 	k.SetRateLimit(ctx, rateLimit)
 
-	return nil
+	return true, nil
 }
 
 // If a SendPacket fails or times out, undo the outflow increment that happened during the send

x/ratelimit/keeper/rate_limit_test.go

@@ -297,15 +297,18 @@ func (s *KeeperTestSuite) processCheckRateLimitAndUpdateFlowTestCase(tc checkRat
 			Sender:    sender,
 			Receiver:  receiver,
 		}
-		err := s.App.RatelimitKeeper.CheckRateLimitAndUpdateFlow(s.Ctx, action.direction, packetInfo)
+		updatedFlow, err := s.App.RatelimitKeeper.CheckRateLimitAndUpdateFlow(s.Ctx, action.direction, packetInfo)
 
 		// Each action optionally errors or skips a flow update
 		if action.expectedError != "" {
 			s.Require().ErrorContains(err, action.expectedError, tc.name+" - action: #%d - error", i)
 		} else {
 			s.Require().NoError(err, tc.name+" - action: #%d - no error", i)
 
-			if !action.skipFlowUpdate {
+			expectedUpdateFlow := !action.skipFlowUpdate
+			s.Require().Equal(expectedUpdateFlow, updatedFlow, tc.name+" - action: #%d - updated flow", i)
+
+			if expectedUpdateFlow {
 				if action.direction == types.PACKET_RECV {
 					expectedInflow = expectedInflow.Add(amount)
 				} else {