fix(igp): allow IGP zero fee

Author: keruch

x/core/02_post_dispatch/keeper/hook_igp.go

@@ -69,7 +69,8 @@ func (i InterchainGasPaymasterHookHandler) PayForGasWithoutQuote(ctx context.Con
 	}
 
 	if amount.IsZero() {
-		return fmt.Errorf("amount must be greater than zero")
+		// Nothing to charge
+		return nil
 	}
 
 	senderAcc, err := sdk.AccAddressFromBech32(sender)

x/core/02_post_dispatch/keeper/hook_igp_test.go

@@ -0,0 +1,121 @@
+package keeper_test
+
+import (
+	"cosmossdk.io/math"
+
+	i "github.com/bcp-innovations/hyperlane-cosmos/tests/integration"
+	"github.com/bcp-innovations/hyperlane-cosmos/util"
+	"github.com/bcp-innovations/hyperlane-cosmos/x/core/02_post_dispatch/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/gogoproto/proto"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("hook_igp_test.go", Ordered, func() {
+	var s *i.KeeperTestSuite
+	var creator i.TestValidatorAddress
+
+	var mailboxId util.HexAddress
+	var hookId util.HexAddress
+
+	const igpDenom = "uatom"
+	const actualDenom = "uosmo"
+
+	BeforeEach(func() {
+		s = i.NewCleanChain()
+		creator = i.GenerateTestValidatorAddress("Creator")
+
+		err := s.MintBaseCoins(creator.Address, 1_000_000)
+		Expect(err).To(BeNil())
+
+		mailboxId, err = createDummyMailbox(s, creator.Address)
+		Expect(err).To(BeNil())
+
+		hookId, err = createDummyIgp(s, creator.Address, igpDenom)
+		Expect(err).To(BeNil())
+
+		_, err = s.RunTx(&types.MsgSetDestinationGasConfig{
+			Owner: creator.Address,
+			IgpId: hookId,
+			DestinationGasConfig: &types.DestinationGasConfig{
+				RemoteDomain: 2,
+				GasOracle: &types.GasOracle{
+					TokenExchangeRate: math.NewInt(1e10),
+					GasPrice:          math.NewInt(1e9),
+				},
+				GasOverhead: math.NewInt(100000),
+			},
+		})
+		Expect(err).To(BeNil())
+	})
+
+	It("IGP PayForGas should not fail on free IGP", func() {
+		// Set gas config to be gas-free
+		_, err := s.RunTx(&types.MsgSetDestinationGasConfig{
+			Owner: creator.Address,
+			IgpId: hookId,
+			DestinationGasConfig: &types.DestinationGasConfig{
+				RemoteDomain: 2,
+				GasOracle: &types.GasOracle{
+					TokenExchangeRate: math.NewInt(1e10),
+					GasPrice:          math.ZeroInt(), // NO GAS PAYMENT NEEDED
+				},
+				GasOverhead: math.NewInt(100000),
+			},
+		})
+		Expect(err).To(BeNil())
+
+		recipient, err := util.DecodeHexAddress("0x00000000000000000000000000000000000000000000000000000000deadbeef")
+		Expect(err).To(BeNil())
+
+		sender, err := util.DecodeHexAddress("0x0000000000000000000000007fa9385be102ac3eac297483dd6233d62b3e1496")
+		Expect(err).To(BeNil())
+
+		message := util.HyperlaneMessage{
+			Version:     1,
+			Nonce:       0,
+			Origin:      1,
+			Sender:      sender,
+			Destination: 2,
+			Recipient:   recipient,
+			Body:        []byte("test"),
+		}
+
+		metadata := util.StandardHookMetadata{
+			Address:            creator.AccAddress,
+			GasLimit:           math.NewInt(100000),
+			CustomHookMetadata: nil,
+		}
+
+		// Try PostDispatch with different maxFee denom
+
+		// igpDenom != actualDenom
+		maxFee := sdk.NewCoins(sdk.NewCoin(igpDenom, math.NewInt(50)))
+		_, err = s.App().HyperlaneKeeper.PostDispatch(s.Ctx(), mailboxId, hookId, metadata, message, maxFee)
+		Expect(err).To(BeNil())
+
+		// igpDenom == actualDenom
+		maxFee = sdk.NewCoins(sdk.NewCoin(actualDenom, math.NewInt(50)))
+		_, err = s.App().HyperlaneKeeper.PostDispatch(s.Ctx(), mailboxId, hookId, metadata, message, maxFee)
+		Expect(err).To(BeNil())
+	})
+})
+
+func createDummyIgp(s *i.KeeperTestSuite, creator string, denom string) (util.HexAddress, error) {
+	res, err := s.RunTx(&types.MsgCreateIgp{
+		Owner: creator,
+		Denom: denom,
+	})
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	var response types.MsgCreateIgpResponse
+	err = proto.Unmarshal(res.MsgResponses[0].Value, &response)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	return response.Id, nil
+}

x/core/02_post_dispatch/keeper/msg_igp.go

@@ -89,6 +89,10 @@ func (ms msgServer) SetIgpOwner(ctx context.Context, req *types.MsgSetIgpOwner)
 
 // PayForGas executes an InterchainGasPayment without for the specified payment amount.
 func (ms msgServer) PayForGas(ctx context.Context, req *types.MsgPayForGas) (*types.MsgPayForGasResponse, error) {
+	if req.Amount.IsZero() {
+		return nil, fmt.Errorf("amount must be greater than zero")
+	}
+
 	handler := InterchainGasPaymasterHookHandler{*ms.k}
 
 	return &types.MsgPayForGasResponse{}, handler.PayForGasWithoutQuote(ctx, req.IgpId, req.Sender, req.MessageId, req.DestinationDomain, req.GasLimit, sdk.NewCoins(req.Amount))