Merge branch 'main' into jonas/aggregation

jonas089 · web-flow · commit d7363a418c0a · 2026-02-04T16:43:40.000+01:00
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
@@ -0,0 +1,3 @@
+# https://help.github.com/articles/about-codeowners
+
+* @mbreithecker @yjamin @troykessler
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,21 @@
 
 An '!' indicates a state machine breaking change.
 
+## Unreleased
+
+### Features
+
+- ! [#135](https://github.com/bcp-innovations/hyperlane-cosmos/pull/135) Allow authority to create native synthetic tokens.
+
+### Bug Fixes
+
+- ! [#148](https://github.com/bcp-innovations/hyperlane-cosmos/pull/148) Fix Amino name typos in warp.
+- ! [#153](https://github.com/bcp-innovations/hyperlane-cosmos/pull/153) Fix SetDomain for RoutingISM.
+- ! [#123](https://github.com/bcp-innovations/hyperlane-cosmos/pull/123) Fix Amino name typos in core.
+- ! [#143](https://github.com/bcp-innovations/hyperlane-cosmos/pull/143) Allow IGP to charge zero fees.
+- ! [#151](https://github.com/bcp-innovations/hyperlane-cosmos/pull/151) Support 32 byte addresses in remote recv collateral.
+- ! [#141](https://github.com/bcp-innovations/hyperlane-cosmos/pull/141) Corrected coin comparison.
+
 ## [v1.0.1](https://github.com/bcp-innovations/hyperlane-cosmos/releases/tag/v1.0.1) - 2025-06-05
 
 ### Improvements
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -13,7 +13,7 @@ Cosmos-SDK principles and design architectures.
 
 ## Creating a Pull Request
 
-- Check out the latest state from main and always keep the PR in sync with main.
+- Check out the latest state from `main` and always keep the PR in sync with `main`.
 - Use [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/#specification).
 - Only one feature per pull request.
 - Write an entry for the Changelog.
@@ -23,7 +23,7 @@ Cosmos-SDK principles and design architectures.
 ## Coding Guidelines
 
 - Write readable and maintainable code. `Premature Optimization Is the Root of All Evil`.
-  Concentrate on clean interfaces first and only optimize for performance if it is needed.
+  Concentrate on clean interfaces first and only optimize for performance if it is necessary.
 - The keeper directory is structured the following:
   - `msg_server_*`-files are the entry point for message handling. This file
       should be very clean to read and outsource most of the part to the logic files.
@@ -32,6 +32,10 @@ Cosmos-SDK principles and design architectures.
   - `query_server_*`-files are the entry point for query handling. This file
       should be very clean to read. Most queries can make use of the pagination
       provided in `./util`.
+  - AI Usage: AI can significantly speed up development, but you are responsible 
+    for the code you submit. Before opening a PR, thoroughly review all changes. 
+    Do not submit PRs containing code you haven’t personally reviewed, 
+    as this creates an unnecessary burden for reviewers.
 
 ## Code Structure
 
diff --git a/proto/hyperlane/core/interchain_security/v1/tx.proto b/proto/hyperlane/core/interchain_security/v1/tx.proto
@@ -88,7 +88,7 @@ message MsgCreateMessageIdMultisigIsmResponse {
   ];
 }
 
-// MsgCreateMultisigIsm ...
+// MsgCreateMerkleRootMultisigIsm ...
 message MsgCreateMerkleRootMultisigIsm {
   option (cosmos.msg.v1.signer) = "creator";
   option (amino.name) = "hyperlane/v1/MsgCreateMerkleRootMultisigIsm";
@@ -104,7 +104,7 @@ message MsgCreateMerkleRootMultisigIsm {
   uint32 threshold = 3;
 }
 
-// MsgCreateMultisigIsmResponse ...
+// MsgCreateMerkleRootMultisigIsmResponse ...
 message MsgCreateMerkleRootMultisigIsmResponse {
   string id = 1 [
     (gogoproto.customtype) =
@@ -183,8 +183,7 @@ message MsgCreateRoutingIsmResponse {
 // MsgSetRoutingIsmDomain ...
 message MsgSetRoutingIsmDomain {
   option (cosmos.msg.v1.signer) = "owner";
-  option (amino.name) =
-      "hyperlane/v1/MsgCreateRoMsgSetRoutingIsmDomainutingIsm";
+  option (amino.name) = "hyperlane/v1/MsgSetRoutingIsmDomain";
 
   // ism_id ...
   string ism_id = 1 [
diff --git a/proto/hyperlane/core/post_dispatch/v1/tx.proto b/proto/hyperlane/core/post_dispatch/v1/tx.proto
@@ -41,7 +41,7 @@ service Msg {
 // MsgCreateIgp ...
 message MsgCreateIgp {
   option (cosmos.msg.v1.signer) = "owner";
-  option (amino.name) = "hyperlane/v1/MsgCreateInterchainGasPaymaster";
+  option (amino.name) = "hyperlane/v1/MsgCreateIgp";
 
   // owner is the message sender.
   string owner = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
@@ -81,7 +81,7 @@ message MsgSetIgpOwner {
   bool renounce_ownership = 4;
 }
 
-// MsgCreateIgpResponse ...
+// MsgSetIgpOwnerResponse ...
 message MsgSetIgpOwnerResponse {}
 
 // MsgSetDestinationGasConfig ...
@@ -164,7 +164,7 @@ message MsgClaim {
 // MsgClaimResponse ...
 message MsgClaimResponse {}
 
-// MsgMerkleTreeHook ...
+// MsgCreateMerkleTreeHook ...
 message MsgCreateMerkleTreeHook {
   option (cosmos.msg.v1.signer) = "owner";
   option (amino.name) = "hyperlane/v1/MsgCreateMerkleTreeHook";
@@ -188,16 +188,16 @@ message MsgCreateMerkleTreeHookResponse {
   ];
 }
 
-// MsgMerkleTreeHook ...
+// MsgCreateNoopHook ...
 message MsgCreateNoopHook {
   option (cosmos.msg.v1.signer) = "owner";
-  option (amino.name) = "hyperlane/v1/MsgCreateMerkleTreeHook";
+  option (amino.name) = "hyperlane/v1/MsgCreateNoopHook";
 
   // sender ...
   string owner = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
 }
 
-// MsgCreateMerkleTreeHookResponse ...
+// MsgCreateNoopHookResponse ...
 message MsgCreateNoopHookResponse {
   string id = 1 [
     (gogoproto.customtype) =
diff --git a/x/core/01_interchain_security/keeper/msg_server_test.go b/x/core/01_interchain_security/keeper/msg_server_test.go
@@ -929,7 +929,7 @@ var _ = Describe("msg_server.go", Ordered, func() {
 		Expect(ism.Id.String()).To(Equal(routingIsm.Id.String()))
 		Expect(ism.Routes).To(HaveLen(1))
 		Expect(ism.Routes[0].Domain).To(Equal(uint32(1337)))
-		Expect(ism.Routes[0].Ism.String()).To(Equal(noopIsmId.String()))
+		Expect(ism.Routes[0].Ism.String()).To(Equal(routingIsm.Id.String()))
 	})
 
 	It("RemoveRoutingIsmDomain (invalid) on non routing ism", func() {
diff --git a/x/core/01_interchain_security/module.go b/x/core/01_interchain_security/module.go
@@ -35,7 +35,7 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&types.MsgCreateMerkleRootMultisigIsm{}, "hyperlane/v1/MsgCreateMerkleRootMultisigIsm", nil)
 	cdc.RegisterConcrete(&types.MsgCreateNoopIsm{}, "hyperlane/v1/MsgCreateNoopIsm", nil)
 	cdc.RegisterConcrete(&types.MsgCreateRoutingIsm{}, "hyperlane/v1/MsgCreateRoutingIsm", nil)
-	cdc.RegisterConcrete(&types.MsgSetRoutingIsmDomain{}, "hyperlane/v1/MsgCreateRoMsgSetRoutingIsmDomainutingIsm", nil)
+	cdc.RegisterConcrete(&types.MsgSetRoutingIsmDomain{}, "hyperlane/v1/MsgSetRoutingIsmDomain", nil)
 	cdc.RegisterConcrete(&types.MsgRemoveRoutingIsmDomain{}, "hyperlane/v1/MsgRemoveRoutingIsmDomain", nil)
 	cdc.RegisterConcrete(&types.MsgUpdateRoutingIsmOwner{}, "hyperlane/v1/MsgUpdateRoutingIsmOwner", nil)
 }
diff --git a/x/core/01_interchain_security/types/routing_ism.go b/x/core/01_interchain_security/types/routing_ism.go
@@ -50,7 +50,8 @@ func (m *RoutingISM) RemoveDomain(domainId uint32) bool {
 
 // SetDomain adds/sets a domain to the routing ISM.
 func (m *RoutingISM) SetDomain(newRoute Route) {
-	for _, route := range m.Routes {
+	for i := range m.Routes {
+		route := &m.Routes[i]
 		if newRoute.Domain == route.Domain {
 			route.Ism = newRoute.Ism
 			return
diff --git a/x/core/01_interchain_security/types/tx.pb.go b/x/core/01_interchain_security/types/tx.pb.go
diff --git a/x/core/02_post_dispatch/keeper/hook_igp.go b/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)
 	}
 
@@ -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)
diff --git a/x/core/02_post_dispatch/keeper/hook_igp_test.go b/x/core/02_post_dispatch/keeper/hook_igp_test.go
@@ -0,0 +1,152 @@
+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())
+	})
+
+	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) {
+	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
+}
diff --git a/x/core/02_post_dispatch/keeper/msg_igp.go b/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))
diff --git a/x/core/02_post_dispatch/module.go b/x/core/02_post_dispatch/module.go
@@ -31,13 +31,10 @@ func RegisterQueryService(server grpc.Server, queryServer types.QueryServer) {
 // RegisterLegacyAminoCodec registers the mailbox module's types on the LegacyAmino codec.
 func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&types.MsgClaim{}, "hyperlane/v1/MsgClaim", nil)
-	cdc.RegisterConcrete(&types.MsgCreateIgp{}, "hyperlane/v1/MsgCreateInterchainGasPaymaster", nil)
+	cdc.RegisterConcrete(&types.MsgCreateIgp{}, "hyperlane/v1/MsgCreateIgp", nil)
 	cdc.RegisterConcrete(&types.MsgCreateMerkleTreeHook{}, "hyperlane/v1/MsgCreateMerkleTreeHook", nil)
+	cdc.RegisterConcrete(&types.MsgCreateNoopHook{}, "hyperlane/v1/MsgCreateNoopHook", nil)
 	cdc.RegisterConcrete(&types.MsgPayForGas{}, "hyperlane/v1/MsgPayForGas", nil)
 	cdc.RegisterConcrete(&types.MsgSetDestinationGasConfig{}, "hyperlane/v1/MsgSetDestinationGasConfig", nil)
 	cdc.RegisterConcrete(&types.MsgSetIgpOwner{}, "hyperlane/v1/MsgSetIgpOwner", nil)
-
-	// TODO
-	// Duplicates are not allowed. This will be fixed with https://github.com/bcp-innovations/hyperlane-cosmos/pull/123
-	// cdc.RegisterConcrete(&pdtypes.MsgCreateNoopHook{}, "hyperlane/v1/MsgCreateMerkleTreeHook", nil)
 }
diff --git a/x/core/02_post_dispatch/types/tx.pb.go b/x/core/02_post_dispatch/types/tx.pb.go
diff --git a/x/warp/keeper/logic_collateral.go b/x/warp/keeper/logic_collateral.go
diff --git a/x/warp/keeper/logic_collateral_test.go b/x/warp/keeper/logic_collateral_test.go
diff --git a/x/warp/module.go b/x/warp/module.go

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# https://help.github.com/articles/about-codeowners`
	`2`	`+`
	`3`	`+* @mbreithecker @yjamin @troykessler`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {`
`35`	`35`	`cdc.RegisterConcrete(&types.MsgCreateMerkleRootMultisigIsm{}, "hyperlane/v1/MsgCreateMerkleRootMultisigIsm", nil)`
`36`	`36`	`cdc.RegisterConcrete(&types.MsgCreateNoopIsm{}, "hyperlane/v1/MsgCreateNoopIsm", nil)`
`37`	`37`	`cdc.RegisterConcrete(&types.MsgCreateRoutingIsm{}, "hyperlane/v1/MsgCreateRoutingIsm", nil)`
`38`		`- cdc.RegisterConcrete(&types.MsgSetRoutingIsmDomain{}, "hyperlane/v1/MsgCreateRoMsgSetRoutingIsmDomainutingIsm", nil)`
	`38`	`+ cdc.RegisterConcrete(&types.MsgSetRoutingIsmDomain{}, "hyperlane/v1/MsgSetRoutingIsmDomain", nil)`
`39`	`39`	`cdc.RegisterConcrete(&types.MsgRemoveRoutingIsmDomain{}, "hyperlane/v1/MsgRemoveRoutingIsmDomain", nil)`
`40`	`40`	`cdc.RegisterConcrete(&types.MsgUpdateRoutingIsmOwner{}, "hyperlane/v1/MsgUpdateRoutingIsmOwner", nil)`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ func (i InterchainGasPaymasterHookHandler) PayForGas(ctx context.Context, hookId`
`52`	`52`	`return sdk.NewCoins(), err`
`53`	`53`	`}`
`54`	`54`
`55`		`- if requiredPayment.IsAllGT(maxFee) {`
	`55`	`+ if !maxFee.IsAllGTE(requiredPayment) {`
`56`	`56`	`return sdk.NewCoins(), fmt.Errorf("required payment exceeds max hyperlane fee: %v", requiredPayment)`
`57`	`57`	`}`
`58`	`58`
`@@ -69,7 +69,8 @@ func (i InterchainGasPaymasterHookHandler) PayForGasWithoutQuote(ctx context.Con`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`if amount.IsZero() {`
`72`		`- return fmt.Errorf("amount must be greater than zero")`
	`72`	`+ // Nothing to charge`
	`73`	`+ return nil`
`73`	`74`	`}`
`74`	`75`
`75`	`76`	`senderAcc, err := sdk.AccAddressFromBech32(sender)`