Merge pull request #545 from bandprotocol/tunnel-fail-produce-packet

[Tunnel] Fix Produce packet logic

proto/band/tunnel/v1beta1/tunnel.proto

@@ -74,14 +74,8 @@ message Packet {
   repeated band.feeds.v1beta1.Price prices = 3 [(gogoproto.nullable) = false];
   // receipt represents the confirmation of the packet delivery to the destination via the specified route.
   google.protobuf.Any receipt = 4 [(cosmos_proto.accepts_interface) = "PacketReceiptI"];
-  // base_fee is the base fee of the packet
-  repeated cosmos.base.v1beta1.Coin base_fee = 5
-      [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
-  // route_fee is the route fee of the packet
-  repeated cosmos.base.v1beta1.Coin route_fee = 6
-      [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
   // created_at is the timestamp when the packet is created
-  int64 created_at = 7;
+  int64 created_at = 5;
 }
 
 // Deposit defines an amount deposited by an account address to the tunnel.

x/tunnel/keeper/keeper_packet.go

@@ -53,41 +53,24 @@ func (k Keeper) ProduceActiveTunnelPackets(ctx sdk.Context) error {
 
 	// create new packet. If failed to produce packet, emit an event.
 	for _, id := range ids {
-		if err := k.ProduceActiveTunnelPacket(ctx, id, pricesMap); err != nil {
+		cacheCtx, writeFn := ctx.CacheContext()
+
+		// Produce a packet. If produce packet successfully, update the context state.
+		// if not, emit an event and deactivate the tunnel.
+		if err := k.ProducePacket(cacheCtx, id, pricesMap); err != nil {
 			ctx.EventManager().EmitEvent(sdk.NewEvent(
 				types.EventTypeProducePacketFail,
 				sdk.NewAttribute(types.AttributeKeyTunnelID, fmt.Sprintf("%d", id)),
 				sdk.NewAttribute(types.AttributeKeyReason, err.Error()),
 			))
-		}
-	}
-
-	return nil
-}
-
-// ProduceActiveTunnelPacket generates a packet and sends it to the destination route for the given tunnel ID.
-// If not enough fund, deactivate the tunnel.
-func (k Keeper) ProduceActiveTunnelPacket(
-	ctx sdk.Context,
-	tunnelID uint64,
-	pricesMap map[string]feedstypes.Price,
-) (err error) {
-	// Check if the tunnel has enough fund to create a packet and deactivate the tunnel if not
-	// enough fund. Error should not happen here since the tunnel is already validated.
-	ok, err := k.HasEnoughFundToCreatePacket(ctx, tunnelID)
-	if err != nil {
-		return err
-	}
-	if !ok {
-		return k.DeactivateTunnel(ctx, tunnelID)
-	}
 
-	// Produce a packet. If produce packet successfully, update the context state.
-	cacheCtx, writeFn := ctx.CacheContext()
-	if err := k.ProducePacket(cacheCtx, tunnelID, pricesMap); err != nil {
-		return err
+			if err := k.DeactivateTunnel(ctx, id); err != nil {
+				return err
+			}
+		} else {
+			writeFn()
+		}
 	}
-	writeFn()
 
 	return nil
 }
@@ -162,9 +145,6 @@ func (k Keeper) CreatePacket(
 	tunnelID uint64,
 	prices []feedstypes.Price,
 ) (types.Packet, error) {
-	// get tunnel and prices info
-	params := k.GetParams(ctx)
-
 	tunnel, err := k.GetTunnel(ctx, tunnelID)
 	if err != nil {
 		return types.Packet{}, err
@@ -176,25 +156,11 @@ func (k Keeper) CreatePacket(
 		return types.Packet{}, sdkerrors.Wrapf(err, "failed to deduct base packet fee for tunnel %d", tunnel.ID)
 	}
 
-	// get the route
-	route, err := tunnel.GetRouteValue()
-	if err != nil {
-		return types.Packet{}, err
-	}
-
-	// get the route fee
-	routeFee, err := k.GetRouteFee(ctx, route)
-	if err != nil {
-		return types.Packet{}, err
-	}
-
 	tunnel.Sequence++
 	packet := types.NewPacket(
 		tunnelID,
 		tunnel.Sequence,
 		prices,
-		params.BasePacketFee,
-		routeFee,
 		ctx.BlockTime().Unix(),
 	)
 

x/tunnel/keeper/keeper_packet_test.go

@@ -6,6 +6,7 @@ import (
 	sdkmath "cosmossdk.io/math"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	bandtsstypes "github.com/bandprotocol/chain/v3/x/bandtss/types"
 	feedstypes "github.com/bandprotocol/chain/v3/x/feeds/types"
@@ -54,8 +55,6 @@ func (s *KeeperTestSuite) TestGetSetPacket() {
 func (s *KeeperTestSuite) TestCreatePacket() {
 	ctx, k := s.ctx, s.keeper
 
-	params := k.GetParams(ctx)
-
 	feePayer := sdk.AccAddress([]byte("fee_payer_address"))
 	tunnel := types.Tunnel{
 		ID:       1,
@@ -74,10 +73,6 @@ func (s *KeeperTestSuite) TestCreatePacket() {
 		{Status: feedstypes.PRICE_STATUS_AVAILABLE, SignalID: "CS:BAND-USD", Price: 5000000, Timestamp: 1733000000},
 	}
 
-	s.bandtssKeeper.EXPECT().GetSigningFee(gomock.Any()).Return(
-		sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))), nil,
-	)
-
 	s.bankKeeper.EXPECT().
 		SendCoinsFromAccountToModule(ctx, feePayer, types.ModuleName, k.GetParams(ctx).BasePacketFee).
 		Return(nil)
@@ -92,8 +87,6 @@ func (s *KeeperTestSuite) TestCreatePacket() {
 		TunnelID:  1,
 		Sequence:  1,
 		Prices:    prices,
-		BaseFee:   params.BasePacketFee,
-		RouteFee:  sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))),
 		CreatedAt: ctx.BlockTime().Unix(),
 	}
 
@@ -191,14 +184,12 @@ func (s *KeeperTestSuite) TestProduceActiveTunnelPackets() {
 
 	s.bandtssKeeper.EXPECT().GetSigningFee(gomock.Any()).Return(
 		sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))), nil,
-	).Times(2)
+	)
 
 	s.feedsKeeper.EXPECT().GetAllPrices(gomock.Any()).Return([]feedstypes.Price{
 		{Status: feedstypes.PRICE_STATUS_AVAILABLE, SignalID: "CS:BAND-USD", Price: 50000, Timestamp: 1733000000},
 	})
 
-	spendableCoins := types.DefaultBasePacketFee.Add(sdk.NewCoin("uband", sdkmath.NewInt(20)))
-	s.bankKeeper.EXPECT().SpendableCoins(gomock.Any(), feePayer).Return(spendableCoins)
 	s.bankKeeper.EXPECT().
 		SendCoinsFromAccountToModule(gomock.Any(), feePayer, types.ModuleName, types.DefaultBasePacketFee).
 		Return(nil)
@@ -259,15 +250,13 @@ func (s *KeeperTestSuite) TestProduceActiveTunnelPacketsNotEnoughMoney() {
 		DestinationContractAddress: "0x",
 	}
 
-	s.bandtssKeeper.EXPECT().GetSigningFee(gomock.Any()).Return(
-		sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))), nil,
-	)
-
 	s.feedsKeeper.EXPECT().GetAllPrices(gomock.Any()).Return([]feedstypes.Price{
 		{Status: feedstypes.PRICE_STATUS_AVAILABLE, SignalID: "CS:BAND-USD", Price: 50000, Timestamp: 1733000000},
 	})
-	s.bankKeeper.EXPECT().SpendableCoins(gomock.Any(), feePayer).
-		Return(sdk.Coins{sdk.NewInt64Coin("uband", 1)})
+
+	s.bankKeeper.EXPECT().
+		SendCoinsFromAccountToModule(gomock.Any(), feePayer, types.ModuleName, types.DefaultBasePacketFee).
+		Return(sdkerrors.ErrInsufficientFunds)
 
 	err := tunnel.SetRoute(route)
 	s.Require().NoError(err)

x/tunnel/keeper/keeper_packet_tss.go

@@ -20,6 +20,11 @@ func (k Keeper) SendTSSPacket(
 		route.Encoder,
 	)
 
+	tssFee, err := k.bandtssKeeper.GetSigningFee(ctx)
+	if err != nil {
+		return nil, err
+	}
+
 	// try signing TSS packet, if success, write the context.
 	signingID, err := k.bandtssKeeper.CreateTunnelSigningRequest(
 		ctx,
@@ -28,7 +33,7 @@ func (k Keeper) SendTSSPacket(
 		route.DestinationContractAddress,
 		content,
 		feePayer,
-		packet.RouteFee,
+		tssFee,
 	)
 	if err != nil {
 		return nil, err

x/tunnel/keeper/keeper_packet_tss_test.go

@@ -27,11 +27,11 @@ func (s *KeeperTestSuite) TestSendTSSPacket() {
 		1,                    // tunnelID
 		1,                    // sequence
 		[]feedstypes.Price{}, // priceInfos[]
-		sdk.NewCoins(),       // baseFee
-		sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))), // routeFee
 		time.Now().Unix(),
 	)
 
+	s.bandtssKeeper.EXPECT().GetSigningFee(ctx).Return(sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))), nil)
+
 	// Mock the TSS keeper and set the state for checking later
 	s.bandtssKeeper.EXPECT().CreateTunnelSigningRequest(
 		gomock.Any(),

x/tunnel/keeper/keeper_tunnel.go

@@ -255,36 +255,7 @@ func (k Keeper) GetTotalFees(ctx sdk.Context) types.TotalFees {
 	return totalFee
 }
 
-// HasEnoughFundToCreatePacket checks if the fee payer has enough balance to create a packet
-func (k Keeper) HasEnoughFundToCreatePacket(ctx sdk.Context, tunnelID uint64) (bool, error) {
-	tunnel, err := k.GetTunnel(ctx, tunnelID)
-	if err != nil {
-		return false, err
-	}
-
-	// get the route fee from the tunnel
-	route, err := tunnel.GetRouteValue()
-	if err != nil {
-		return false, err
-	}
-	routeFee, err := k.GetRouteFee(ctx, route)
-	if err != nil {
-		return false, err
-	}
-
-	// get the base packet fee and calculate total fee
-	basePacketFee := k.GetParams(ctx).BasePacketFee
-	totalFee := basePacketFee.Add(routeFee...)
-
-	// compare the fee payer's balance with the total fee
-	feePayer, err := sdk.AccAddressFromBech32(tunnel.FeePayer)
-	if err != nil {
-		return false, err
-	}
-	balances := k.bankKeeper.SpendableCoins(ctx, feePayer)
-	return balances.IsAllGTE(totalFee), nil
-}
-
+// GenerateTunnelAccount generates a new tunnel account for the given key
 func (k Keeper) GenerateTunnelAccount(ctx sdk.Context, key string) (sdk.AccAddress, error) {
 	header := ctx.BlockHeader()
 
@@ -317,15 +288,3 @@ func (k Keeper) GenerateTunnelAccount(ctx sdk.Context, key string) (sdk.AccAddre
 
 	return tunnelAccAddr, nil
 }
-
-// GetRouteFee returns the fee of the given route
-func (k Keeper) GetRouteFee(ctx sdk.Context, route types.RouteI) (sdk.Coins, error) {
-	switch route.(type) {
-	case *types.TSSRoute:
-		return k.bandtssKeeper.GetSigningFee(ctx)
-	case *types.IBCRoute:
-		return sdk.Coins{}, nil
-	default:
-		return sdk.Coins{}, types.ErrInvalidRoute
-	}
-}

x/tunnel/keeper/msg_server.go

@@ -289,15 +289,6 @@ func (k msgServer) TriggerTunnel(
 		return nil, types.ErrInactiveTunnel.Wrapf("tunnelID %d", msg.TunnelID)
 	}
 
-	ok, err := k.Keeper.HasEnoughFundToCreatePacket(ctx, tunnel.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if !ok {
-		return nil, types.ErrInsufficientFund.Wrapf("tunnelID %d", msg.TunnelID)
-	}
-
 	signalIDs := tunnel.GetSignalIDs()
 	prices := k.Keeper.feedsKeeper.GetPrices(ctx, signalIDs)
 

x/tunnel/keeper/msg_server_test.go

@@ -694,7 +694,7 @@ func (s *KeeperTestSuite) TestMsgTriggerTunnel() {
 
 				s.bandtssKeeper.EXPECT().GetSigningFee(gomock.Any()).Return(
 					sdk.NewCoins(sdk.NewCoin("uband", sdkmath.NewInt(20))), nil,
-				).Times(2)
+				)
 
 				s.bandtssKeeper.EXPECT().CreateTunnelSigningRequest(
 					gomock.Any(),
@@ -720,9 +720,6 @@ func (s *KeeperTestSuite) TestMsgTriggerTunnel() {
 					SendCoinsFromAccountToModule(gomock.Any(), feePayer, types.ModuleName, types.DefaultBasePacketFee).
 					Return(nil)
 
-				spendableCoins := types.DefaultBasePacketFee.Add(sdk.NewCoin("uband", sdkmath.NewInt(20)))
-				s.bankKeeper.EXPECT().SpendableCoins(gomock.Any(), feePayer).Return(spendableCoins)
-
 				return types.NewMsgTriggerTunnel(1, sdk.AccAddress([]byte("creator_address")).String())
 			},
 			expErr:    false,