isolate packet fee distribution for on acknowledgement and on timeout…

… into separate functions (#1253)

## Description

Reduces the complexity contained in `DistributePacketFees` and `DistributePacketFeesOnAcknowledgement` in anticipation of #1251 

closes: #XXXX

---

Before we can merge this PR, please make sure that all the following items have been
checked off. If any of the checklist items are not applicable, please leave them but
write a little note why.

- [ ] Targeted PR against correct branch (see [CONTRIBUTING.md](https://github.com/cosmos/ibc-go/blob/master/CONTRIBUTING.md#pr-targeting))
- [ ] Linked to Github issue with discussion and accepted design OR link to spec that describes this work.
- [ ] Code follows the [module structure standards](https://github.com/cosmos/cosmos-sdk/blob/master/docs/building-modules/structure.md).
- [ ] Wrote unit and integration [tests](https://github.com/cosmos/ibc-go/blob/master/CONTRIBUTING.md#testing)
- [ ] Updated relevant documentation (`docs/`) or specification (`x/<module>/spec/`)
- [ ] Added relevant `godoc` [comments](https://blog.golang.org/godoc-documenting-go-code).
- [ ] Added a relevant changelog entry to the `Unreleased` section in `CHANGELOG.md`
- [ ] Re-reviewed `Files changed` in the Github PR explorer
- [ ] Review `Codecov Report` in the comment section below once CI passes

modules/apps/29-fee/keeper/escrow.go

@@ -49,7 +49,7 @@ func (k Keeper) EscrowPacketFee(ctx sdk.Context, packetID channeltypes.PacketId,
 	return nil
 }
 
-// DistributePacketFees pays the acknowledgement fee & receive fee for a given packetID while refunding the timeout fee to the refund account associated with the Fee.
+// DistributePacketFees pays all the acknowledgement & receive fees for a given packetID while refunding the timeout fees to the refund account.
 func (k Keeper) DistributePacketFees(ctx sdk.Context, forwardRelayer string, reverseRelayer sdk.AccAddress, feesInEscrow []types.PacketFee) {
 	forwardAddr, _ := sdk.AccAddressFromBech32(forwardRelayer)
 
@@ -59,24 +59,31 @@ func (k Keeper) DistributePacketFees(ctx sdk.Context, forwardRelayer string, rev
 			panic(fmt.Sprintf("could not parse refundAcc %s to sdk.AccAddress", packetFee.RefundAddress))
 		}
 
-		// distribute fee to valid forward relayer address otherwise refund the fee
-		if !forwardAddr.Empty() && !k.bankKeeper.BlockedAddr(forwardAddr) {
-			// distribute fee for forward relaying
-			k.distributeFee(ctx, forwardAddr, refundAddr, packetFee.Fee.RecvFee)
-		} else {
-			// refund onRecv fee as forward relayer is not valid address
-			k.distributeFee(ctx, refundAddr, refundAddr, packetFee.Fee.RecvFee)
-		}
-
-		// distribute fee for reverse relaying
-		k.distributeFee(ctx, reverseRelayer, refundAddr, packetFee.Fee.AckFee)
+		k.distributePacketFeeOnAcknowledgement(ctx, refundAddr, forwardAddr, reverseRelayer, packetFee)
+	}
+}
 
-		// refund timeout fee for unused timeout
-		k.distributeFee(ctx, refundAddr, refundAddr, packetFee.Fee.TimeoutFee)
+// distributePacketFeeOnAcknowledgement pays the receive fee for a given packetID while refunding the timeout fee to the refund account associated with the Fee.
+// If there was no forward relayer or the associated forward relayer address is blocked, the receive fee is refunded.
+func (k Keeper) distributePacketFeeOnAcknowledgement(ctx sdk.Context, refundAddr, forwardRelayer, reverseRelayer sdk.AccAddress, packetFee types.PacketFee) {
+	// distribute fee to valid forward relayer address otherwise refund the fee
+	if !forwardRelayer.Empty() && !k.bankKeeper.BlockedAddr(forwardRelayer) {
+		// distribute fee for forward relaying
+		k.distributeFee(ctx, forwardRelayer, refundAddr, packetFee.Fee.RecvFee)
+	} else {
+		// refund onRecv fee as forward relayer is not valid address
+		k.distributeFee(ctx, refundAddr, refundAddr, packetFee.Fee.RecvFee)
 	}
+
+	// distribute fee for reverse relaying
+	k.distributeFee(ctx, reverseRelayer, refundAddr, packetFee.Fee.AckFee)
+
+	// refund timeout fee for unused timeout
+	k.distributeFee(ctx, refundAddr, refundAddr, packetFee.Fee.TimeoutFee)
+
 }
 
-// DistributePacketsFeesTimeout pays the timeout fee for a given packetID while refunding the acknowledgement fee & receive fee to the refund account associated with the Fee
+// DistributePacketsFeesOnTimeout pays all the timeout fees for a given packetID while refunding the acknowledgement & receive fees to the refund account.
 func (k Keeper) DistributePacketFeesOnTimeout(ctx sdk.Context, timeoutRelayer sdk.AccAddress, feesInEscrow []types.PacketFee) {
 	for _, feeInEscrow := range feesInEscrow {
 		// check if refundAcc address works
@@ -85,15 +92,20 @@ func (k Keeper) DistributePacketFeesOnTimeout(ctx sdk.Context, timeoutRelayer sd
 			panic(fmt.Sprintf("could not parse refundAcc %s to sdk.AccAddress", feeInEscrow.RefundAddress))
 		}
 
-		// refund receive fee for unused forward relaying
-		k.distributeFee(ctx, refundAddr, refundAddr, feeInEscrow.Fee.RecvFee)
+		k.distributePacketFeeOnTimeout(ctx, refundAddr, timeoutRelayer, feeInEscrow)
+	}
+}
 
-		// refund ack fee for unused reverse relaying
-		k.distributeFee(ctx, refundAddr, refundAddr, feeInEscrow.Fee.AckFee)
+// distributePacketFeeOnTimeout pays the timeout fee to the timeout relayer and refunds the acknowledgement & receive fee.
+func (k Keeper) distributePacketFeeOnTimeout(ctx sdk.Context, refundAddr, timeoutRelayer sdk.AccAddress, packetFee types.PacketFee) {
+	// refund receive fee for unused forward relaying
+	k.distributeFee(ctx, refundAddr, refundAddr, packetFee.Fee.RecvFee)
 
-		// distribute fee for timeout relaying
-		k.distributeFee(ctx, timeoutRelayer, refundAddr, feeInEscrow.Fee.TimeoutFee)
-	}
+	// refund ack fee for unused reverse relaying
+	k.distributeFee(ctx, refundAddr, refundAddr, packetFee.Fee.AckFee)
+
+	// distribute fee for timeout relaying
+	k.distributeFee(ctx, timeoutRelayer, refundAddr, packetFee.Fee.TimeoutFee)
 }
 
 // distributeFee will attempt to distribute the escrowed fee to the receiver address.