Merge branch 'main' into fork/keruch/keruch/igp-zero-fee

# Conflicts:
#	x/core/02_post_dispatch/keeper/hook_igp_test.go

Author: mbreithecker

proto/buf.yaml

@@ -17,3 +17,5 @@ lint:
     - SERVICE_SUFFIX
     - PACKAGE_VERSION_SUFFIX
     - RPC_REQUEST_STANDARD_NAME
+    - RPC_REQUEST_RESPONSE_UNIQUE
+    - RPC_RESPONSE_STANDARD_NAME

proto/hyperlane/warp/v1/tx.proto

@@ -21,6 +21,9 @@ service Msg {
   // CreateSyntheticToken ...
   rpc CreateSyntheticToken(MsgCreateSyntheticToken)
       returns (MsgCreateSyntheticTokenResponse);
+  // CreateNativeSyntheticToken ...
+  rpc CreateNativeSyntheticToken(MsgCreateNativeSyntheticToken)
+      returns (MsgCreateSyntheticTokenResponse);
 
   // SetToken ...
   rpc SetToken(MsgSetToken) returns (MsgSetTokenResponse);
@@ -77,6 +80,22 @@ message MsgCreateSyntheticToken {
   ];
 }
 
+// MsgCreateNativeSyntheticToken ...
+message MsgCreateNativeSyntheticToken {
+  option (cosmos.msg.v1.signer) = "owner";
+  option (amino.name) = "hyperlane/warp/v1/MsgCreateNativeSyntheticToken";
+
+  string owner = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
+
+  string origin_mailbox = 2 [
+    (gogoproto.customtype) =
+        "github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress",
+    (gogoproto.nullable) = false
+  ];
+
+  string origin_denom = 3;
+}
+
 // MsgCreateSyntheticTokenResponse ...
 message MsgCreateSyntheticTokenResponse {
   string id = 1 [

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

@@ -52,7 +52,7 @@ func (i InterchainGasPaymasterHookHandler) PayForGas(ctx context.Context, hookId
 		return sdk.NewCoins(), err
 	}
 
-	if requiredPayment.IsAllGT(maxFee) {
+	if !maxFee.IsAllGTE(requiredPayment) {
 		return sdk.NewCoins(), fmt.Errorf("required payment exceeds max hyperlane fee: %v", requiredPayment)
 	}
 

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

@@ -100,6 +100,37 @@ var _ = Describe("hook_igp_test.go", Ordered, func() {
 		_, err = s.App().HyperlaneKeeper.PostDispatch(s.Ctx(), mailboxId, hookId, metadata, message, maxFee)
 		Expect(err).To(BeNil())
 	})
+
+	It("IGP PayForGas should fail when any required payment exceeds maxFee", func() {
+		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,
+		}
+
+		// 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(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("required payment exceeds max hyperlane fee"))
+	})
 })
 
 func createDummyIgp(s *i.KeeperTestSuite, creator string, denom string) (util.HexAddress, error) {

x/warp/keeper/logic_collateral.go

@@ -88,7 +88,7 @@ func (k *Keeper) RemoteTransferCollateral(ctx sdk.Context, token types.HypToken,
 // RemoteReceiveCollateral handles the receipt of collateral from a remote chain.
 // It updates the token balance, verifies there is enough collateral, and transfers the funds to the recipient's account.
 func (k *Keeper) RemoteReceiveCollateral(ctx context.Context, token types.HypToken, payload types.WarpPayload) error {
-	account := sdk.AccAddress(payload.Recipient()[12:32])
+	account := payload.GetCosmosAccount()
 
 	amount := math.NewIntFromBigInt(payload.Amount())
 

x/warp/keeper/logic_collateral_test.go

@@ -11,6 +11,7 @@ import (
 	coreTypes "github.com/bcp-innovations/hyperlane-cosmos/x/core/types"
 	"github.com/bcp-innovations/hyperlane-cosmos/x/warp/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@@ -29,6 +30,7 @@ TEST CASES - logic_collateral.go
 * MsgRemoteTransfer (invalid) insufficient funds (Collateral)
 * MsgRemoteTransfer & MsgRemoteReceiveCollateral (invalid) not enough collateral (Collateral)
 * MsgRemoteTransfer && MsgRemoteReceiveCollateral (valid) (Collateral)
+* MsgRemoteTransfer && MsgRemoteReceiveCollateral (valid) 32-byte address (Collateral)
 
 */
 
@@ -366,4 +368,67 @@ var _ = Describe("logic_collateral.go", Ordered, func() {
 		Expect(err).To(BeNil())
 		Expect(s.App().BankKeeper.GetBalance(s.Ctx(), sender.AccAddress, denom).Amount).To(Equal(senderBalance.Amount.Add(amount)))
 	})
+
+	It("MsgRemoteTransfer && MsgRemoteReceiveCollateral (valid) 32-byte address (Collateral)", func() {
+		// Arrange
+		receiverAddress, _ := util.DecodeHexAddress("0xd7194459d45619d04a5a0f9e78dc9594a0f37fd6da8382fe12ddda6f2f46d647")
+		remoteRouter := types.RemoteRouter{
+			ReceiverDomain:   1,
+			ReceiverContract: "0x934b867052ca9c65e33362112f35fb548f8732c2fe45f07b9c591958e865def0",
+			Gas:              math.NewInt(50000),
+		}
+
+		amount := math.NewInt(100)
+		maxFee := sdk.NewCoin(denom, math.NewInt(250000))
+
+		tokenId, mailboxId, igpId, _ := createToken(s, &remoteRouter, owner.Address, sender.Address, types.HYP_TOKEN_TYPE_COLLATERAL)
+		err := s.MintBaseCoins(sender.Address, 1_000_000)
+		Expect(err).To(BeNil())
+
+		// Act
+		_, err = s.RunTx(&types.MsgRemoteTransfer{
+			Sender:            sender.Address,
+			TokenId:           tokenId,
+			DestinationDomain: remoteRouter.ReceiverDomain,
+			Recipient:         receiverAddress,
+			Amount:            amount,
+			CustomHookId:      &igpId,
+			GasLimit:          math.ZeroInt(),
+			MaxFee:            maxFee,
+		})
+		Expect(err).To(BeNil())
+
+		receiverContract, err := util.DecodeHexAddress(remoteRouter.ReceiverContract)
+		Expect(err).To(BeNil())
+
+		warpRecipient := address.Module(types.ModuleName, []byte("collateral-receiver"))
+		Expect(len(warpRecipient)).To(Equal(address.Len))
+
+		warpPayload, err := types.NewWarpPayload(warpRecipient, *big.NewInt(amount.Int64()))
+		Expect(err).To(BeNil())
+
+		message := util.HyperlaneMessage{
+			Version:     3,
+			Nonce:       1,
+			Origin:      remoteRouter.ReceiverDomain,
+			Sender:      receiverContract,
+			Destination: 0,
+			Recipient:   tokenId,
+			Body:        warpPayload.Bytes(),
+		}
+
+		receiverAcc := sdk.AccAddress(warpRecipient)
+		receiverBalance := s.App().BankKeeper.GetBalance(s.Ctx(), receiverAcc, denom)
+
+		_, err = s.RunTx(&coreTypes.MsgProcessMessage{
+			MailboxId: mailboxId,
+			Relayer:   sender.Address,
+			Metadata:  "",
+			Message:   message.String(),
+		})
+
+		// Assert
+		Expect(err).To(BeNil())
+		Expect(s.App().BankKeeper.GetBalance(s.Ctx(), receiverAcc, denom).Amount).To(Equal(receiverBalance.Amount.Add(amount)))
+	})
 })

x/warp/keeper/msg_server.go

@@ -19,29 +19,54 @@ type msgServer struct {
 
 // CreateSyntheticToken ...
 func (ms msgServer) CreateSyntheticToken(ctx context.Context, msg *types.MsgCreateSyntheticToken) (*types.MsgCreateSyntheticTokenResponse, error) {
+	return ms.internalCreateSyntheticToken(ctx, msg.Owner, msg.OriginMailbox, "")
+}
+
+// CreateNativeSyntheticToken is an authority gated version of
+// CreateSyntheticToken that allows the module authority to specify a native
+// (custom) origin denom for the synthetic token.
+func (ms msgServer) CreateNativeSyntheticToken(ctx context.Context, msg *types.MsgCreateNativeSyntheticToken) (*types.MsgCreateSyntheticTokenResponse, error) {
+	if msg.Owner != ms.k.authority {
+		return nil, fmt.Errorf("invalid authority: expected %s, got %s", ms.k.authority, msg.Owner)
+	}
+
+	if ms.k.bankKeeper.HasSupply(ctx, msg.OriginDenom) {
+		return nil, fmt.Errorf("denom %s already exists", msg.OriginDenom)
+	}
+
+	return ms.internalCreateSyntheticToken(ctx, msg.Owner, msg.OriginMailbox, msg.OriginDenom)
+}
+
+// internalCreateSyntheticToken handles the internal logic for creating a synthetic token.
+func (ms msgServer) internalCreateSyntheticToken(ctx context.Context, owner string, originMailbox util.HexAddress, originDenom string) (*types.MsgCreateSyntheticTokenResponse, error) {
 	if !slices.Contains(ms.k.enabledTokens, int32(types.HYP_TOKEN_TYPE_SYNTHETIC)) {
 		return nil, fmt.Errorf("module disabled synthetic tokens")
 	}
 
-	has, err := ms.k.coreKeeper.MailboxIdExists(ctx, msg.OriginMailbox)
+	has, err := ms.k.coreKeeper.MailboxIdExists(ctx, originMailbox)
 	if err != nil {
 		return nil, err
 	}
 	if !has {
-		return nil, fmt.Errorf("failed to find mailbox with id: %s", msg.OriginMailbox.String())
+		return nil, fmt.Errorf("failed to find mailbox with id: %s", originMailbox.String())
 	}
 
 	tokenId, err := ms.k.coreKeeper.AppRouter().GetNextSequence(ctx, uint8(types.HYP_TOKEN_TYPE_SYNTHETIC))
 	if err != nil {
 		return nil, err
 	}
 
+	// If the originDenom is left empty, we populate it as a non-native denom.
+	if originDenom == "" {
+		originDenom = fmt.Sprintf("hyperlane/%s", tokenId.String())
+	}
+
 	newToken := types.HypToken{
 		Id:            tokenId,
-		Owner:         msg.Owner,
+		Owner:         owner,
 		TokenType:     types.HYP_TOKEN_TYPE_SYNTHETIC,
-		OriginMailbox: msg.OriginMailbox,
-		OriginDenom:   fmt.Sprintf("hyperlane/%s", tokenId.String()),
+		OriginMailbox: originMailbox,
+		OriginDenom:   originDenom,
 	}
 
 	if err = ms.k.HypTokens.Set(ctx, tokenId.GetInternalId(), newToken); err != nil {

x/warp/types/expected_keepers.go

@@ -14,6 +14,7 @@ type BankKeeper interface {
 	BurnCoins(ctx context.Context, moduleName string, amt sdk.Coins) error
 	MintCoins(ctx context.Context, moduleName string, amt sdk.Coins) error
 	GetSupply(ctx context.Context, denom string) sdk.Coin
+	HasSupply(ctx context.Context, denom string) bool
 }
 
 type CoreKeeper interface {