feat: bridging fee middleware (#899)

app/app.go

@@ -9,6 +9,7 @@ import (
  "os"
  "path/filepath"
 
+ "github.com/dymensionxyz/dymension/v3/x/bridging_fee"
  vfchooks "github.com/dymensionxyz/dymension/v3/x/vfc/hooks"
 
  "github.com/gorilla/mux"
@@ -739,9 +740,11 @@ func New(
  )
 
  transferModule := ibctransfer.NewAppModule(app.TransferKeeper)
+ transferMiddleware := ibctransfer.NewIBCModule(app.TransferKeeper)
 
  var transferStack ibcporttypes.IBCModule
- transferStack = ibctransfer.NewIBCModule(app.TransferKeeper)
+ transferStack = bridging_fee.NewIBCMiddleware(transferMiddleware, app.IBCKeeper.ChannelKeeper, app.DelayedAckKeeper, app.TransferKeeper, app.AccountKeeper.GetModuleAddress(txfeestypes.ModuleName))
+
  transferStack = packetforwardmiddleware.NewIBCMiddleware(
  transferStack,
  app.PacketForwardMiddlewareKeeper,
@@ -1025,6 +1028,7 @@ func (app *App) ModuleAccountAddrs() map[string]bool {
 
  // exclude the streamer as we want him to be able to get external incentives
  modAccAddrs[authtypes.NewModuleAddress(streamermoduletypes.ModuleName).String()] = false
+ modAccAddrs[authtypes.NewModuleAddress(txfeestypes.ModuleName).String()] = false
  return modAccAddrs
 }
 

app/apptesting/events.go

@@ -51,6 +51,6 @@ func (s *KeeperTestHelper) ExtractAttributes(event sdk.Event) map[string]string
 func (s *KeeperTestHelper) AssertAttributes(event sdk.Event, eventAttributes []sdk.Attribute) {
  attrs := s.ExtractAttributes(event)
  for _, attr := range eventAttributes {
- s.Require().Equal(attr.Value, attrs[attr.Key])
+ s.Assert().Equal(attr.Value, attrs[attr.Key])
  }
 }

ibctesting/bridging_fee_test.go

@@ -0,0 +1,105 @@
+package ibctesting_test
+
+import (
+ "testing"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
+ clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+ ibctesting "github.com/cosmos/ibc-go/v6/testing"
+ "github.com/osmosis-labs/osmosis/v15/x/txfees"
+ "github.com/stretchr/testify/suite"
+)
+
+type BridgingFeeTestSuite struct {
+ IBCTestUtilSuite
+}
+
+func TestBridgingFeeTestSuite(t *testing.T) {
+ suite.Run(t, new(BridgingFeeTestSuite))
+}
+
+func (suite *BridgingFeeTestSuite) SetupTest() {
+ suite.IBCTestUtilSuite.SetupTest()
+}
+
+func (suite *BridgingFeeTestSuite) TestNotRollappNoBridgingFee() {
+ // setup between cosmosChain and hubChain
+ path := suite.NewTransferPath(suite.hubChain, suite.cosmosChain)
+ suite.coordinator.Setup(path)
+ hubEndpoint := path.EndpointA
+ cosmosEndpoint := path.EndpointB
+
+ timeoutHeight := clienttypes.NewHeight(100, 110)
+ amount, ok := sdk.NewIntFromString("10000000000000000000") // 10DYM
+ suite.Require().True(ok)
+ coinToSendToB := sdk.NewCoin(sdk.DefaultBondDenom, amount)
+
+ // send from cosmosChain to hubChain
+ msg := types.NewMsgTransfer(cosmosEndpoint.ChannelConfig.PortID, cosmosEndpoint.ChannelID, coinToSendToB, cosmosEndpoint.Chain.SenderAccount.GetAddress().String(), hubEndpoint.Chain.SenderAccount.GetAddress().String(), timeoutHeight, 0, "")
+ res, err := cosmosEndpoint.Chain.SendMsgs(msg)
+ suite.Require().NoError(err) // message committed
+ packet, err := ibctesting.ParsePacketFromEvents(res.GetEvents())
+ suite.Require().NoError(err)
+ err = path.RelayPacket(packet)
+ suite.Require().NoError(err) // relay committed
+
+ denom := suite.GetRollappToHubIBCDenomFromPacket(packet)
+ finalBalance := ConvertToApp(suite.hubChain).BankKeeper.GetBalance(suite.hubChain.GetContext(), suite.hubChain.SenderAccount.GetAddress(), denom)
+ suite.Assert().Equal(sdk.NewCoin(denom, coinToSendToB.Amount), finalBalance)
+}
+
+func (suite *BridgingFeeTestSuite) TestBridgingFee() {
+ path := suite.NewTransferPath(suite.hubChain, suite.rollappChain)
+ suite.coordinator.Setup(path)
+
+ rollappEndpoint := path.EndpointB
+ rollappIBCKeeper := suite.rollappChain.App.GetIBCKeeper()
+
+ suite.CreateRollapp()
+ suite.RegisterSequencer()
+ suite.GenesisEvent(path.EndpointA.ChannelID)
+
+ // Update rollapp state
+ currentRollappBlockHeight := uint64(suite.rollappChain.GetContext().BlockHeight())
+ suite.UpdateRollappState(currentRollappBlockHeight)
+
+ timeoutHeight := clienttypes.NewHeight(100, 110)
+ amount, ok := sdk.NewIntFromString("10000000000000000000") // 10DYM
+ suite.Require().True(ok)
+ coinToSendToB := sdk.NewCoin(sdk.DefaultBondDenom, amount)
+
+ /* --------------------- initiating transfer on rollapp --------------------- */
+ msg := types.NewMsgTransfer(rollappEndpoint.ChannelConfig.PortID, rollappEndpoint.ChannelID, coinToSendToB, suite.rollappChain.SenderAccount.GetAddress().String(), suite.hubChain.SenderAccount.GetAddress().String(), timeoutHeight, 0, "")
+ res, err := suite.rollappChain.SendMsgs(msg)
+ suite.Require().NoError(err) // message committed
+ packet, err := ibctesting.ParsePacketFromEvents(res.GetEvents())
+ suite.Require().NoError(err)
+ found := rollappIBCKeeper.ChannelKeeper.HasPacketCommitment(rollappEndpoint.Chain.GetContext(), packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
+ suite.Require().True(found)
+ err = path.RelayPacket(packet)
+ suite.Require().Error(err) // expecting error as no AcknowledgePacket expected to return
+
+ // check balance before finalization
+ denom := suite.GetRollappToHubIBCDenomFromPacket(packet)
+ transferredCoins := sdk.NewCoin(denom, coinToSendToB.Amount)
+ recipient := suite.hubChain.SenderAccount.GetAddress()
+ initialBalance := ConvertToApp(suite.hubChain).BankKeeper.SpendableCoins(suite.hubChain.GetContext(), recipient)
+ suite.Require().Equal(initialBalance.AmountOf(denom), sdk.ZeroInt())
+
+ // Finalize the rollapp state
+ currentRollappBlockHeight = uint64(suite.rollappChain.GetContext().BlockHeight())
+ _, err = suite.FinalizeRollappState(1, currentRollappBlockHeight)
+ suite.Require().NoError(err)
+
+ // check balance after finalization
+ expectedFee := ConvertToApp(suite.hubChain).DelayedAckKeeper.BridgingFeeFromAmt(suite.hubChain.GetContext(), transferredCoins.Amount)
+ expectedBalance := initialBalance.Add(transferredCoins).Sub(sdk.NewCoin(denom, expectedFee))
+ finalBalance := ConvertToApp(suite.hubChain).BankKeeper.SpendableCoins(suite.hubChain.GetContext(), recipient)
+ suite.Assert().Equal(expectedBalance, finalBalance)
+
+ // check fees
+ addr := ConvertToApp(suite.hubChain).AccountKeeper.GetModuleAccount(suite.hubChain.GetContext(), txfees.ModuleName)
+ txFeesBalance := ConvertToApp(suite.hubChain).BankKeeper.GetBalance(suite.hubChain.GetContext(), addr.GetAddress(), denom)
+ suite.Assert().Equal(expectedFee, txFeesBalance.Amount)
+}

ibctesting/eibc_test.go

@@ -40,6 +40,7 @@ func (suite *EIBCTestSuite) SetupTest() {
  delayedAckKeeper := ConvertToApp(suite.hubChain).DelayedAckKeeper
  params := delayedAckKeeper.GetParams(suite.hubChain.GetContext())
  params.EpochIdentifier = "month"
+ params.BridgingFee = sdk.ZeroDec()
  delayedAckKeeper.SetParams(suite.hubChain.GetContext(), params)
 }
 

proto/dymension/delayedack/params.proto

@@ -10,4 +10,10 @@ message Params {
  option (gogoproto.goproto_stringer) = false;
  string epoch_identifier = 1
  [ (gogoproto.moretags) = "yaml:\"epoch_identifier\"" ];
+
+ string bridging_fee = 2 [
+ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
+ (gogoproto.moretags) = "yaml:\"bridging_fee\"",
+ (gogoproto.nullable) = false
+ ];
 }

x/bridging_fee/events.go

@@ -0,0 +1,6 @@
+package bridging_fee
+
+const (
+ EventTypeBridgingFee = "bridging_fee"
+ AttributeKeyFee = "fee"
+)

x/bridging_fee/ibc_middleware.go

@@ -0,0 +1,109 @@
+package bridging_fee
+
+import (
+ errorsmod "cosmossdk.io/errors"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ transfer "github.com/cosmos/ibc-go/v6/modules/apps/transfer"
+ transferkeeper "github.com/cosmos/ibc-go/v6/modules/apps/transfer/keeper"
+ channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+ porttypes "github.com/cosmos/ibc-go/v6/modules/core/05-port/types"
+ "github.com/cosmos/ibc-go/v6/modules/core/exported"
+
+ delayedaackkeeper "github.com/dymensionxyz/dymension/v3/x/delayedack/keeper"
+)
+
+const (
+ ModuleName = "bridging_fee"
+)
+
+var _ porttypes.Middleware = &BridgingFeeMiddleware{}
+
+// BridgingFeeMiddleware implements the ICS26 callbacks
+// The middleware is responsible for charging a bridging fee on transfers coming from rollapps
+// The actual charge happens on the packet finalization
+// based on ADR: https://www.notion.so/dymension/ADR-x-Bridging-Fee-Middleware-7ba8c191373f43ce81782fc759913299?pvs=4
+type BridgingFeeMiddleware struct {
+ transfer.IBCModule
+ porttypes.ICS4Wrapper
+
+ delayedAckKeeper delayedaackkeeper.Keeper
+ transferKeeper transferkeeper.Keeper
+ feeModuleAddr sdk.AccAddress
+}
+
+// NewIBCMiddleware creates a new IBCMiddleware given the keeper and underlying application
+func NewIBCMiddleware(transfer transfer.IBCModule, channelKeeper porttypes.ICS4Wrapper, keeper delayedaackkeeper.Keeper, transferKeeper transferkeeper.Keeper, feeModuleAddr sdk.AccAddress) *BridgingFeeMiddleware {
+ return &BridgingFeeMiddleware{
+ IBCModule: transfer,
+ ICS4Wrapper: channelKeeper,
+ delayedAckKeeper: keeper,
+ transferKeeper: transferKeeper,
+ feeModuleAddr: feeModuleAddr,
+ }
+}
+
+// GetFeeRecipient returns the address that will receive the bridging fee
+func (im BridgingFeeMiddleware) GetFeeRecipient() sdk.AccAddress {
+ return im.feeModuleAddr
+}
+
+func (im *BridgingFeeMiddleware) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet, relayer sdk.AccAddress) exported.Acknowledgement {
+ if !im.delayedAckKeeper.IsRollappsEnabled(ctx) {
+ return im.IBCModule.OnRecvPacket(ctx, packet, relayer)
+ }
+ logger := ctx.Logger().With(
+ "module", ModuleName,
+ "packet_source", packet.SourcePort,
+ "packet_destination", packet.DestinationPort,
+ "packet_sequence", packet.Sequence)
+
+ rollappPortOnHub, rollappChannelOnHub := packet.DestinationPort, packet.DestinationChannel
+ rollappID, transferPacketData, err := im.delayedAckKeeper.ExtractRollappIDAndTransferPacket(ctx, packet, rollappPortOnHub, rollappChannelOnHub)
+ if err != nil {
+ logger.Error("Failed to extract rollapp id from packet", "err", err)
+ return channeltypes.NewErrorAcknowledgement(err)
+ }
+
+ if rollappID == "" {
+ logger.Debug("Skipping IBC transfer OnRecvPacket for non-rollapp chain")
+ return im.IBCModule.OnRecvPacket(ctx, packet, relayer)
+ }
+
+ // parse the transfer amount
+ transferAmount, ok := sdk.NewIntFromString(transferPacketData.Amount)
+ if !ok {
+ err = errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "parse transfer amount into math.Int")
+ return channeltypes.NewErrorAcknowledgement(err)
+ }
+
+ // get fee
+ fee := im.delayedAckKeeper.BridgingFeeFromAmt(ctx, transferAmount)
+
+ // update packet data for the fee charge
+ feePacket := *transferPacketData
+ feePacket.Amount = fee.String()
+ feePacket.Receiver = im.GetFeeRecipient().String()
+
+ // No event emitted, as we called the transfer keeper directly (vs the transfer middleware)
+ err = im.transferKeeper.OnRecvPacket(ctx, packet, feePacket)
+ if err != nil {
+ logger.Error("Failed to charge bridging fee", "err", err)
+ // we continue as we don't want the fee charge to fail the transfer in any case
+ fee = sdk.ZeroInt()
+ } else {
+ logger.Debug("Charged bridging fee", "fee", fee)
+ ctx.EventManager().EmitEvent(
+ sdk.NewEvent(
+ EventTypeBridgingFee,
+ sdk.NewAttribute(AttributeKeyFee, fee.String()),
+ sdk.NewAttribute(sdk.AttributeKeySender, transferPacketData.Sender),
+ ),
+ )
+ }
+
+ // transfer the remaining amount
+ transferPacketData.Amount = transferAmount.Sub(fee).String()
+ packet.Data = transferPacketData.GetBytes()
+ return im.IBCModule.OnRecvPacket(ctx, packet, relayer)
+}

x/delayedack/eibc.go

@@ -59,7 +59,7 @@ func (im IBCMiddleware) eIBCDemandOrderHandler(ctx sdk.Context, rollappPacket co
  }
  }
 
- eibcDemandOrder, err := im.createDemandOrderFromIBCPacket(data, &rollappPacket, *packetMetaData.EIBC)
+ eibcDemandOrder, err := im.createDemandOrderFromIBCPacket(ctx, data, &rollappPacket, *packetMetaData.EIBC)
  if err != nil {
  return fmt.Errorf("create eibc demand order: %w", err)
  }
@@ -75,7 +75,7 @@ func (im IBCMiddleware) eIBCDemandOrderHandler(ctx sdk.Context, rollappPacket co
 // It validates the fungible token packet data, extracts the fee from the memo,
 // calculates the demand order price, and creates a new demand order.
 // It returns the created demand order or an error if there is any.
-func (im IBCMiddleware) createDemandOrderFromIBCPacket(fungibleTokenPacketData transfertypes.FungibleTokenPacketData,
+func (im IBCMiddleware) createDemandOrderFromIBCPacket(ctx sdk.Context, fungibleTokenPacketData transfertypes.FungibleTokenPacketData,
  rollappPacket *commontypes.RollappPacket, eibcMetaData types.EIBCMetadata,
 ) (*eibctypes.DemandOrder, error) {
  // Validate the fungible token packet data as we're going to use it to create the demand order
@@ -98,6 +98,7 @@ func (im IBCMiddleware) createDemandOrderFromIBCPacket(fungibleTokenPacketData t
  if amt.LT(fee) {
  return nil, fmt.Errorf("fee cannot be larger than amount: fee: %s: amt :%s", fee, fungibleTokenPacketData.Amount)
  }
+
  /*
  In case of timeout/errack:
  fee = fee_multiplier*transfer_amount
@@ -125,6 +126,12 @@ func (im IBCMiddleware) createDemandOrderFromIBCPacket(fungibleTokenPacketData t
  demandOrderDenom = trace.IBCDenom()
  demandOrderRecipient = fungibleTokenPacketData.Sender // and who tried to send it (refund because it failed)
  case commontypes.RollappPacket_ON_RECV:
+ bridgingFee := im.keeper.BridgingFeeFromAmt(ctx, amt)
+ if bridgingFee.GT(fee) {
+ // We check that the fee the fulfiller makes is at least as big as the bridging fee they will have to pay later
+ // this is to improve UX and help fulfillers not lose money.
+ return nil, fmt.Errorf("eibc fee cannot be smaller than bridging fee: eibc fee: %s: bridging fee: %s", fee, bridgingFee)
+ }
  demandOrderDenom = im.getEIBCTransferDenom(*rollappPacket.Packet, fungibleTokenPacketData)
  demandOrderRecipient = fungibleTokenPacketData.Receiver // who we tried to send to
  }

x/delayedack/genesis_test.go

@@ -11,6 +11,8 @@ import (
  "github.com/stretchr/testify/require"
 )
 
+var defBridgingFee = types.DefaultParams().BridgingFee
+
 func TestInitGenesis(t *testing.T) {
  tests := []struct {
  name string
@@ -22,14 +24,24 @@ func TestInitGenesis(t *testing.T) {
  name: "only params - success",
  params: types.Params{
  EpochIdentifier: "week",
+ BridgingFee: defBridgingFee,
  },
  rollappPackets: []commontypes.RollappPacket{},
  expPanic: false,
  },
+ {
+ name: "only params - missing bridging fee - fail",
+ params: types.Params{
+ EpochIdentifier: "week",
+ },
+ rollappPackets: []commontypes.RollappPacket{},
+ expPanic: true,
+ },
  {
  name: "params and rollapp packets - panic",
  params: types.Params{
  EpochIdentifier: "week",
+ BridgingFee: defBridgingFee,
  },
  rollappPackets: []commontypes.RollappPacket{{RollappId: "0"}},
  expPanic: true,
@@ -58,6 +70,7 @@ func TestExportGenesis(t *testing.T) {
  // Set params
  params := types.Params{
  EpochIdentifier: "week",
+ BridgingFee: defBridgingFee,
  }
  k.SetParams(ctx, params)
  // Set some demand orders