feat(eibc): auto create eibc demand order for rollapp packets (#944)

ibctesting/eibc_test.go

@@ -18,6 +18,7 @@ import (
 	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
 	ibctesting "github.com/cosmos/ibc-go/v6/testing"
 
+	"github.com/dymensionxyz/dymension/v3/app/apptesting"
 	commontypes "github.com/dymensionxyz/dymension/v3/x/common/types"
 	eibckeeper "github.com/dymensionxyz/dymension/v3/x/eibc/keeper"
 	eibctypes "github.com/dymensionxyz/dymension/v3/x/eibc/types"
@@ -68,68 +69,77 @@ func (suite *EIBCTestSuite) TestEIBCDemandOrderCreation() {
 		name                string
 		amount              string
 		fee                 string
-		recipient           string
 		demandOrdersCreated int
 		expectAck           bool
 		extraMemoData       map[string]map[string]string
+		skipEIBCmemo        bool
 	}{
 		{
 			"valid demand order",
 			"1000000000",
 			"150",
-			suite.hubChain.SenderAccount.GetAddress().String(),
 			1,
 			false,
 			map[string]map[string]string{},
+			false,
+		},
+		{
+			"valid demand order - fee is 0",
+			"1000000000",
+			"0",
+			1,
+			false,
+			map[string]map[string]string{},
+			false,
+		},
+		{
+			"valid demand order - auto created",
+			"1000000000",
+			"0",
+			1,
+			false,
+			map[string]map[string]string{},
+			true,
 		},
 		{
 			"invalid demand order - negative fee",
 			"1000000000",
 			"-150",
-			suite.hubChain.SenderAccount.GetAddress().String(),
 			0,
 			true,
 			map[string]map[string]string{},
+			false,
 		},
 		{
 			"invalid demand order - fee > amount",
 			"1000",
 			"1001",
-			suite.hubChain.SenderAccount.GetAddress().String(),
-			0,
-			true,
-			map[string]map[string]string{},
-		},
-		{
-			"invalid demand order - fee is 0",
-			"1",
-			"0",
-			suite.hubChain.SenderAccount.GetAddress().String(),
 			0,
 			true,
 			map[string]map[string]string{},
+			false,
 		},
 		{
 			"invalid demand order - fee > max uint64",
 			"10000",
 			"100000000000000000000000000000",
-			suite.hubChain.SenderAccount.GetAddress().String(),
 			0,
 			true,
 			map[string]map[string]string{},
+			false,
 		},
 		{
 			"invalid demand order - PFM and EIBC are not supported together",
 			"1000000000",
 			"150",
-			suite.hubChain.SenderAccount.GetAddress().String(),
 			0,
 			true,
 			map[string]map[string]string{"forward": {
 				"receiver": suite.hubChain.SenderAccount.GetAddress().String(),
 				"port":     "transfer",
 				"channel":  "channel-0",
 			}},
+			false,
 		},
 	}
 	totalDemandOrdersCreated := 0
@@ -148,23 +158,36 @@ func (suite *EIBCTestSuite) TestEIBCDemandOrderCreation() {
 			}
 			eibcJson, _ := json.Marshal(memoObj)
 			memo := string(eibcJson)
-			_ = suite.TransferRollappToHub(path, IBCSenderAccount, tc.recipient, tc.amount, memo, tc.expectAck)
+
+			if tc.skipEIBCmemo {
+				memo = ""
+			}
+
+			recipient := apptesting.CreateRandomAccounts(1)[0]
+			_ = suite.TransferRollappToHub(path, IBCSenderAccount, recipient.String(), tc.amount, memo, tc.expectAck)
 			// Validate demand orders results
 			eibcKeeper := ConvertToApp(suite.hubChain).EIBCKeeper
 			demandOrders, err := eibcKeeper.ListAllDemandOrders(suite.hubChain.GetContext())
 			suite.Require().NoError(err)
 			suite.Require().Equal(tc.demandOrdersCreated, len(demandOrders)-totalDemandOrdersCreated)
 			totalDemandOrdersCreated = len(demandOrders)
+
 			amountInt, ok := sdk.NewIntFromString(tc.amount)
 			suite.Require().True(ok)
 			feeInt, ok := sdk.NewIntFromString(tc.fee)
 			suite.Require().True(ok)
 			if tc.demandOrdersCreated > 0 {
-				lastDemandOrder := demandOrders[len(demandOrders)-1]
-				suite.Require().True(ok)
-				suite.Require().Equal(tc.recipient, lastDemandOrder.Recipient)
-				suite.Require().Equal(amountInt.Sub(feeInt), lastDemandOrder.Price[0].Amount)
-				suite.Require().Equal(feeInt, lastDemandOrder.Fee[0].Amount)
+				var demandOrder *eibctypes.DemandOrder
+				for _, order := range demandOrders {
+					if order.Recipient == recipient.String() {
+						demandOrder = order
+						break
+					}
+				}
+				suite.Require().NotNil(demandOrder)
+				suite.Require().Equal(recipient.String(), demandOrder.Recipient)
+				suite.Require().Equal(amountInt.Sub(feeInt), demandOrder.Price[0].Amount)
+				suite.Require().Equal(feeInt, demandOrder.Fee.AmountOf(demandOrder.Price[0].Denom))
 			}
 		})
 	}

x/delayedack/types/errors.go

@@ -7,10 +7,9 @@ import (
 var (
 	ErrCanOnlyUpdatePendingPacket = errorsmod.Register(ModuleName, 1, "can only update pending packet")
 	ErrRollappPacketDoesNotExist  = errorsmod.Register(ModuleName, 2, "rollapp packet does not exist")
-	ErrEmptyEpochIdentifier       = errorsmod.Register(ModuleName, 4, "empty epoch identifier")
 	ErrMismatchedStateRoots       = errorsmod.Register(ModuleName, 5, "mismatched state roots")
 	ErrMismatchedSequencer        = errorsmod.Register(ModuleName, 6, "mismatched sequencer")
-	ErrMissingEIBCMetadata        = errorsmod.Register(ModuleName, 7, "missing eibc metadata")
 	ErrUnknownRequest             = errorsmod.Register(ModuleName, 8, "unknown request")
 	ErrInvalidType                = errorsmod.Register(ModuleName, 9, "invalid type")
+	ErrBadEIBCFee                 = errorsmod.Register(ModuleName, 10, "provided eibc fee is invalid")
 )

x/delayedack/types/packet_metadata.go

@@ -29,12 +29,10 @@ func (e EIBCMetadata) ValidateBasic() error {
 	return nil
 }
 
-var ErrEIBCFeeNotPositiveInt = fmt.Errorf("eibc fee is not a positive integer")
-
 func (e EIBCMetadata) FeeInt() (math.Int, error) {
 	i, ok := sdk.NewIntFromString(e.Fee)
-	if !ok || !i.IsPositive() {
-		return math.Int{}, ErrEIBCFeeNotPositiveInt
+	if !ok || i.IsNegative() {
+		return math.Int{}, ErrBadEIBCFee
 	}
 	return i, nil
 }
@@ -59,13 +57,13 @@ func ParsePacketMetadata(input string) (*PacketMetadata, error) {
 	if err != nil {
 		return nil, ErrMemoUnmarshal
 	}
-	if memo[memoObjectKeyEIBC] == nil {
-		return nil, ErrMemoEibcEmpty
-	}
 	if memo[memoObjectKeyPFM] != nil {
 		// Currently not supporting eibc with PFM: https://github.com/dymensionxyz/dymension/issues/599
 		return nil, ErrMemoHashPFMandEIBC
 	}
+	if memo[memoObjectKeyEIBC] == nil {
+		return nil, ErrMemoEibcEmpty
+	}
 	var metadata PacketMetadata
 	err = json.Unmarshal(bz, &metadata)
 	if err != nil {

x/eibc/keeper/handler.go

@@ -1,12 +1,12 @@
 package keeper
 
 import (
-	"errors"
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
 	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	"github.com/pkg/errors"
 
 	"github.com/dymensionxyz/dymension/v3/utils"
 	commontypes "github.com/dymensionxyz/dymension/v3/x/common/types"
@@ -61,16 +61,17 @@ func (k Keeper) EIBCDemandOrderHandler(ctx sdk.Context, rollappPacket commontype
 func (k *Keeper) CreateDemandOrderOnRecv(ctx sdk.Context, fungibleTokenPacketData transfertypes.FungibleTokenPacketData,
 	rollappPacket *commontypes.RollappPacket,
 ) (*types.DemandOrder, error) {
-	packetMetaData, err := dacktypes.ParsePacketMetadata(fungibleTokenPacketData.Memo)
-	if errors.Is(err, dacktypes.ErrMemoUnmarshal) || errors.Is(err, dacktypes.ErrMemoEibcEmpty) {
-		ctx.Logger().Debug("skipping demand order creation - no eibc memo provided")
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
+	// zero fee demand order by default
+	eibcMetaData := dacktypes.EIBCMetadata{Fee: "0"}
+
+	if fungibleTokenPacketData.Memo != "" {
+		packetMetaData, err := dacktypes.ParsePacketMetadata(fungibleTokenPacketData.Memo)
+		if err == nil {
+			eibcMetaData = *packetMetaData.EIBC
+		} else if !errors.Is(err, dacktypes.ErrMemoEibcEmpty) {
+			return nil, fmt.Errorf("parse packet metadata: %w", err)
+		}
 	}
-
-	eibcMetaData := packetMetaData.EIBC
 	if err := eibcMetaData.ValidateBasic(); err != nil {
 		return nil, fmt.Errorf("validate eibc metadata: %w", err)
 	}

x/eibc/keeper/handler_test.go

@@ -0,0 +1,82 @@
+package keeper_test
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	dacktypes "github.com/dymensionxyz/dymension/v3/x/delayedack/types"
+)
+
+func (suite *KeeperTestSuite) TestCreateDemandOrderOnRecv() {
+	tests := []struct {
+		name          string
+		memo          string
+		expectedErr   bool
+		expectedFee   string
+		expectedPrice string // considering bridging fee of 1%
+	}{
+		{
+			name:          "fee by memo - create demand order",
+			memo:          `{"eibc":{"fee":"100"}}`,
+			expectedErr:   false,
+			expectedFee:   "100",
+			expectedPrice: "890",
+		},
+		{
+			name:          "empty memo - create demand order",
+			memo:          "",
+			expectedErr:   false,
+			expectedPrice: "990",
+		},
+		{
+			name:          "memo w/o eibc - create demand order",
+			memo:          `{"notEIBC":{}}`,
+			expectedErr:   false,
+			expectedPrice: "990",
+		},
+		{
+			name:        "bad memo - fail",
+			memo:        "bad",
+			expectedErr: true,
+		},
+		{
+			name:        "PFM memo - fail",
+			memo:        `{"forward":{}}`,
+			expectedErr: true,
+		},
+	}
+
+	// set 1% bridging fee
+	dackParams := dacktypes.NewParams("hour", sdk.NewDecWithPrec(1, 2)) // 1%
+	suite.App.DelayedAckKeeper.SetParams(suite.Ctx, dackParams)
+
+	amt, _ := sdk.NewIntFromString(transferPacketData.Amount)
+	bridgeFee := suite.App.DelayedAckKeeper.BridgingFeeFromAmt(suite.Ctx, amt)
+	suite.Require().True(bridgeFee.IsPositive())
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			// modify the memo and set rollapp packet
+			transferPacketData.Memo = tt.memo
+			packet = channeltypes.NewPacket(transferPacketData.GetBytes(), 1, portid, chanid, cpportid, cpchanid, timeoutHeight, timeoutTimestamp)
+			rollappPacket.Packet = &packet
+			suite.App.DelayedAckKeeper.SetRollappPacket(suite.Ctx, *rollappPacket)
+
+			// Create new demand order
+			order, err := suite.App.EIBCKeeper.CreateDemandOrderOnRecv(suite.Ctx, transferPacketData, rollappPacket)
+			if tt.expectedErr {
+				suite.Require().Error(err)
+				return
+			}
+
+			suite.Require().NoError(err)
+			suite.Require().NotNil(order)
+			if tt.expectedFee != "" {
+				suite.Require().Equal(tt.expectedFee, order.Fee[0].Amount.String())
+				suite.Require().Equal(tt.expectedPrice, order.Price[0].Amount.String())
+			} else {
+				suite.Require().Len(order.Fee, 0)
+				suite.Require().Equal(tt.expectedPrice, order.Price[0].Amount.String())
+			}
+		})
+	}
+}