feat(hyperlane): support HL-to-HL forwarding in x/forward module (#1944)

* feat: add support for HL-to-HL forwarding in x/forward module

- Added hook_forward_to_hl field to HLMetadata proto
- Implemented UnpackForwardToHL and MakeHLForwardToHLMetadata functions
- Updated OnHyperlaneMessage to handle HL-to-HL forwarding
- Added comprehensive unit tests for HL-to-HL forwarding
- Maintains backward compatibility with existing HL-to-IBC forwarding

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* feat: enforce at most one forward type in HLMetadata

Add ValidateBasic() to HLMetadata to ensure only one forward type
(IBC or HL) can be populated at a time. The kaspa field is excluded
from this check as it's orthogonal to forwarding logic.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* feat: add CLI command for HL-to-HL forwarding memo creation

- Add CmdMemoHLtoHLRaw command to create Hyperlane-to-Hyperlane forwarding memos
- Update CmdDecodeHyperlaneMessage to handle both IBC and HL forwarding types
- Follows existing pattern for other memo creation commands

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* fmt

* remove busted test

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: danwt

proto/dymensionxyz/dymension/forward/dt.proto

@@ -25,4 +25,7 @@ message HLMetadata {
   // see
   // https://www.notion.so/dymension/ADR-Kaspa-Bridge-Implementation-206a4a51f86a803980aec7099c826fb4?source=copy_link#208a4a51f86a8093a843cf4b5e903588
   bytes kaspa = 2;
+
+  // optional, can be empty
+  bytes hook_forward_to_hl = 3;
 }

x/forward/cli/util.go

@@ -37,6 +37,7 @@ func GetQueryCmd() *cobra.Command {
 	cmd.AddCommand(CmdMemoEIBCtoHL())
 	cmd.AddCommand(CmdMemoEIBCtoIBC())
 	cmd.AddCommand(CmdMemoHLtoIBCRaw())
+	cmd.AddCommand(CmdMemoHLtoHLRaw())
 	cmd.AddCommand(CmdHLEthTransferRecipientHubAccount())
 	cmd.AddCommand(CmdTestHLtoIBCMessage())
 	cmd.AddCommand(CmdTestHLMessageKaspa())
@@ -265,6 +266,53 @@ func CmdMemoHLtoIBCRaw() *cobra.Command {
 	return cmd
 }
 
+// Get a memo for the direction HL -> HL
+func CmdMemoHLtoHLRaw() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                        "memo-hl-to-hl [token-id] [destination-domain] [hl-recipient] [hl-amount] [max-hl-fee]",
+		Args:                       cobra.ExactArgs(5),
+		Short:                      "Get the memo for the direction HL -> HL",
+		Example:                    `dymd q forward memo-hl-to-hl 0x934b867052ca9c65e33362112f35fb548f8732c2fe45f07b9c591958e865def0 1 0x934b867052ca9c65e33362112f35fb548f8732c2fe45f07b9c591958e865def0 10000 20foo`,
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			hook, err := hookForwardToHL(args)
+			if err != nil {
+				return fmt.Errorf("hook forward to hl: %w", err)
+			}
+
+			readable, err := cmd.Flags().GetBool(MessageReadableFlag)
+			if err != nil {
+				return fmt.Errorf("readable flag: %w", err)
+			}
+
+			if readable {
+				fmt.Printf("hyperlane message: %+v\n", hook)
+			} else {
+				bz, err := proto.Marshal(hook)
+				if err != nil {
+					return fmt.Errorf("marshal: %w", err)
+				}
+				hlMetadata := &types.HLMetadata{
+					HookForwardToHl: bz,
+				}
+				bz, err = proto.Marshal(hlMetadata)
+				if err != nil {
+					return fmt.Errorf("marshal: %w", err)
+				}
+				fmt.Printf("%s\n", util.EncodeEthHex(bz))
+			}
+
+			return nil
+		},
+	}
+
+	cmd.Flags().Bool(MessageReadableFlag, false, "Show the message in a human readable format (for debug)")
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
 func hookForwardToIBC(args []string) (*types.HookForwardToIBC, error) {
 	ibcSourceChan := args[0]
 
@@ -558,11 +606,23 @@ func CmdDecodeHyperlaneMessage() *cobra.Command {
 				}
 				fmt.Printf("hl metadata: %+v\n", hlMetadata)
 
-				m, err := types.UnpackForwardToIBC(hlMetadata.HookForwardToIbc)
-				if err != nil {
-					return fmt.Errorf("unpack memo from warp message: %w", err)
+				// Check for IBC forward
+				if len(hlMetadata.HookForwardToIbc) > 0 {
+					m, err := types.UnpackForwardToIBC(hlMetadata.HookForwardToIbc)
+					if err != nil {
+						return fmt.Errorf("unpack ibc forward from warp message: %w", err)
+					}
+					fmt.Printf("ibc forward: %+v\n", m)
+				}
+
+				// Check for HL forward
+				if len(hlMetadata.HookForwardToHl) > 0 {
+					m, err := types.UnpackForwardToHL(hlMetadata.HookForwardToHl)
+					if err != nil {
+						return fmt.Errorf("unpack hl forward from warp message: %w", err)
+					}
+					fmt.Printf("hl forward: %+v\n", m)
 				}
-				fmt.Printf("ibc memo: %+v\n", m)
 			}
 			fmt.Printf("warp payload message: %+v\n", warpPL)
 			fmt.Printf("cosmos account: %s\n", warpPL.GetCosmosAccount().String())

x/forward/hyperlane.go

@@ -23,19 +23,36 @@ func (k Forward) OnHyperlaneMessage(goCtx context.Context, args warpkeeper.OnHyp
 		if err != nil {
 			return false, errorsmod.Wrap(err, "unpack hl metadata")
 		}
-		if hlMetadata == nil || len(hlMetadata.HookForwardToIbc) == 0 {
+		if hlMetadata == nil {
 			// Equivalent to the vanilla token standard.
 			return false, nil
 		}
 
-		d, err := types.UnpackForwardToIBC(hlMetadata.HookForwardToIbc)
-		if err != nil {
-			return true, errorsmod.Wrap(err, "unpack memo from hyperlane")
+		// Check for HL-to-HL forwarding first
+		if len(hlMetadata.HookForwardToHl) > 0 {
+			d, err := types.UnpackForwardToHL(hlMetadata.HookForwardToHl)
+			if err != nil {
+				return true, errorsmod.Wrap(err, "unpack hl to hl forward from hyperlane")
+			}
+
+			// funds src is the hyperlane transfer recipient
+			return true, k.forwardToHyperlane(ctx, args.Account, args.Coin(), *d)
+		}
+
+		// Check for HL-to-IBC forwarding
+		if len(hlMetadata.HookForwardToIbc) > 0 {
+			d, err := types.UnpackForwardToIBC(hlMetadata.HookForwardToIbc)
+			if err != nil {
+				return true, errorsmod.Wrap(err, "unpack memo from hyperlane")
+			}
+
+			// funds src is the hyperlane transfer recipient, which should have same priv key as rollapp recipient
+			// so in case of async failure, the funds will get refunded back there.
+			return true, k.forwardToIBC(ctx, d.Transfer, args.Account, args.Coin())
 		}
 
-		// funds src is the hyperlane transfer recipient, which should have same priv key as rollapp recipient
-		// so in case of async failure, the funds will get refunded back there.
-		return true, k.forwardToIBC(ctx, d.Transfer, args.Account, args.Coin())
+		// No forwarding configured
+		return false, nil
 	})
 
 	return nil

x/forward/types/dt.go

@@ -1,9 +1,32 @@
 package types
 
 import (
+	errorsmod "cosmossdk.io/errors"
 	proto "github.com/cosmos/gogoproto/proto"
+	"github.com/dymensionxyz/gerr-cosmos/gerrc"
 )
 
+// ValidateBasic validates that at most one forward type is populated (excluding kaspa which is orthogonal)
+func (m *HLMetadata) ValidateBasic() error {
+	populatedCount := 0
+
+	if len(m.HookForwardToIbc) > 0 {
+		populatedCount++
+	}
+
+	if len(m.HookForwardToHl) > 0 {
+		populatedCount++
+	}
+
+	// Note: kaspa field is orthogonal and not counted
+
+	if populatedCount > 1 {
+		return gerrc.ErrInvalidArgument.Wrap("at most one forward type can be populated in HLMetadata")
+	}
+
+	return nil
+}
+
 func UnpackHLMetadata(metadata []byte) (*HLMetadata, error) {
 	if len(metadata) == 0 {
 		return nil, nil
@@ -14,5 +37,11 @@ func UnpackHLMetadata(metadata []byte) (*HLMetadata, error) {
 	if err != nil {
 		return nil, err
 	}
+
+	// Validate the metadata
+	if err := x.ValidateBasic(); err != nil {
+		return nil, errorsmod.Wrap(err, "validate HLMetadata")
+	}
+
 	return &x, nil
 }