auto deploy to devnet (#1241)

* auto deploy to devnet

* fixing taker fees and weight balance reward queries

* join pool fees

* fix

* add comment

---------

Co-authored-by: Amit Yadav <ay@Mac.lan>

Author: avkr003

.github/workflows/devnet-deploy.yml

@@ -1,6 +1,9 @@
 name: DevNet deploy
 on:
-  workflow_dispatch:
+  push:
+    branches:
+      - devnet
+      - main
 
 jobs:
   deploy:

api/elys/amm/query.pulsar.go

@@ -274,6 +274,11 @@ message QuerySwapEstimationResponse {
     (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false
   ];
+  string taker_fee = 8 [
+    (cosmos_proto.scalar) = "cosmos.Dec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable) = false
+  ];
 }
 
 message QuerySwapEstimationExactAmountOutResponse {
@@ -389,6 +394,11 @@ message QuerySwapEstimationByDenomResponse {
   ];
   cosmos.base.v1beta1.Coin weight_balance_reward_amount = 11
       [ (gogoproto.nullable) = false ];
+  string taker_fee = 12 [
+    (cosmos_proto.scalar) = "cosmos.Dec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable) = false
+  ];
 }
 
 message QueryAMMPriceRequest {

api/elys/leveragelp/query.pulsar.go

@@ -250,6 +250,8 @@ message QueryOpenEstResponse {
     (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false
   ];
+  cosmos.base.v1beta1.Coin weight_balance_reward_amount = 7
+      [ (gogoproto.nullable) = false ];
 }
 
 message QueryCloseEstRequest {

proto/elys/amm/query.proto

@@ -71,7 +71,8 @@ func (k Keeper) JoinPoolEst(
 	// on oracle pool, full tokenInMaxs are used regardless shareOutAmount
 	snapshot := k.GetAccountedPoolSnapshotOrSet(ctx, pool)
 	cacheCtx, _ := ctx.CacheContext()
-	tokensJoined, sharesOut, slippage, weightBalanceBonus, swapFee, _, err := pool.JoinPool(cacheCtx, &snapshot, k.oracleKeeper, k.accountedPoolKeeper, tokenInMaxs, params, takerFees)
+	tokensJoined := sdk.Coins{}
+	tokensJoined, sharesOut, slippage, weightBalanceBonus, swapFee, takerFeesFinal, err = pool.JoinPool(cacheCtx, &snapshot, k.oracleKeeper, k.accountedPoolKeeper, tokenInMaxs, params, takerFees)
 	if err != nil {
 		return nil, math.ZeroInt(), math.LegacyZeroDec(), math.LegacyZeroDec(), math.LegacyZeroDec(), math.LegacyZeroDec(), sdk.Coin{}, err
 	}

proto/elys/leveragelp/query.proto

@@ -17,6 +17,9 @@ func (k Keeper) SwapEstimation(goCtx context.Context, req *types.QuerySwapEstima
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
+	// Even when multiple routes, taker Fee per route is params.TakerFee/TotalRoutes, so net taker fee will be params.TakerFee
+	takerFees := k.parameterKeeper.GetParams(ctx).TakerFees
+
 	spotPrice, _, tokenOut, swapFee, discount, availableLiquidity, slippage, weightBonus, err := k.CalcInRouteSpotPrice(ctx, req.TokenIn, req.Routes, req.Discount, sdkmath.LegacyZeroDec())
 	if err != nil {
 		return nil, err
@@ -26,6 +29,7 @@ func (k Keeper) SwapEstimation(goCtx context.Context, req *types.QuerySwapEstima
 		SpotPrice:          spotPrice,
 		TokenOut:           tokenOut,
 		SwapFee:            swapFee,
+		TakerFee:           takerFees,
 		Discount:           discount,
 		AvailableLiquidity: availableLiquidity,
 		Slippage:           slippage,

x/amm/keeper/query_join_pool_estimation.go

@@ -44,6 +44,9 @@ func (k Keeper) SwapEstimationByDenom(goCtx context.Context, req *types.QuerySwa
 	// Add weight balance amount here, not added in execution as out amount will be changed and that will impact the transfers
 	amount.Amount = amount.Amount.Add(recoveryReward)
 
+	// Even when multiple routes, taker Fee per route is params.TakerFee/TotalRoutes, so net taker fee will be params.TakerFee
+	takerFees := k.parameterKeeper.GetParams(ctx).TakerFees
+
 	return &types.QuerySwapEstimationByDenomResponse{
 		InRoute:            inRoute,
 		OutRoute:           outRoute,
@@ -55,6 +58,7 @@ func (k Keeper) SwapEstimationByDenom(goCtx context.Context, req *types.QuerySwa
 		Slippage:           slippage,
 		WeightBalanceRatio: weightBonus,
 		PriceImpact:        priceImpact,
+		TakerFee:           takerFees,
 		// sdk.NewCoin() will panic in case of negative weightBonus
 		WeightBalanceRewardAmount: sdk.Coin{Denom: amount.Denom, Amount: recoveryReward},
 	}, nil

x/amm/keeper/query_swap_estimation.go

@@ -34,7 +34,7 @@ func (p *Pool) calcSingleAssetJoin(tokenIn sdk.Coin, spreadFactor sdkmath.Legacy
 //
 // It returns the number of shares created, the amount of coins actually joined into the pool
 // (in case of not being able to fully join), or an error.
-func (p *Pool) CalcSingleAssetJoinPoolShares(tokensIn sdk.Coins) (numShares sdkmath.Int, tokensJoined sdk.Coins, err error) {
+func (p *Pool) CalcSingleAssetJoinPoolShares(tokensIn sdk.Coins, takerFees sdkmath.LegacyDec) (numShares sdkmath.Int, tokensJoined sdk.Coins, err error) {
 	// get all 'pool assets' (aka current pool liquidity + balancer weight)
 	poolAssetsByDenom, err := GetPoolAssetsByDenom(p.GetAllPoolAssets())
 	if err != nil {
@@ -53,7 +53,7 @@ func (p *Pool) CalcSingleAssetJoinPoolShares(tokensIn sdk.Coins) (numShares sdkm
 
 	// 2) Single token provided, so do single asset join and exit.
 	totalShares := p.GetTotalShares()
-	numShares, err = p.calcSingleAssetJoin(tokensIn[0], p.PoolParams.SwapFee, poolAssetsByDenom[tokensIn[0].Denom], totalShares.Amount)
+	numShares, err = p.calcSingleAssetJoin(tokensIn[0], p.PoolParams.SwapFee.Add(takerFees), poolAssetsByDenom[tokensIn[0].Denom], totalShares.Amount)
 	if err != nil {
 		return sdkmath.ZeroInt(), sdk.NewCoins(), err
 	}

x/amm/keeper/query_swap_estimation_by_denom.go

@@ -92,7 +92,7 @@ func (p *Pool) JoinPool(
 	oracleKeeper OracleKeeper,
 	accountedPoolKeeper AccountedPoolKeeper, tokensIn sdk.Coins,
 	params Params,
-	takerfees sdkmath.LegacyDec,
+	takerFees sdkmath.LegacyDec,
 ) (tokensJoined sdk.Coins, numShares sdkmath.Int, slippage sdkmath.LegacyDec, weightBalanceBonus sdkmath.LegacyDec, swapFee sdkmath.LegacyDec, takerFeesFinal sdkmath.LegacyDec, err error) {
 	// if it's not single sided liquidity, add at pool ratio
 	if len(tokensIn) != 1 {
@@ -122,17 +122,26 @@ func (p *Pool) JoinPool(
 			}
 		}
 
-		numShares, tokensJoined, err := p.CalcSingleAssetJoinPoolShares(tokensIn)
+		numShares, tokensJoined, err := p.CalcSingleAssetJoinPoolShares(tokensIn, takerFees)
 		if err != nil {
 			return sdk.NewCoins(), sdkmath.Int{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), err
 		}
+		poolAssetsByDenom, err := GetPoolAssetsByDenom(p.GetAllPoolAssets())
+		if err != nil {
+			return sdk.NewCoins(), sdkmath.Int{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), err
+		}
+		totalWeight := p.TotalWeight
+		normalizedWeight := poolAssetsByDenom[tokenIn.Denom].Weight.ToLegacyDec().Quo(totalWeight.ToLegacyDec())
+		// We multiply the swap fee and taker fees by the normalized weight because it is calculated like this later in CalcSingleAssetJoinPoolShares function
+		swapFee := feeRatio(normalizedWeight, p.PoolParams.SwapFee)
+		takerFee := feeRatio(normalizedWeight, takerFees)
 
 		// update pool with the calculated share and liquidity needed to join pool
 		err = p.IncreaseLiquidity(numShares, tokensJoined)
 		if err != nil {
 			return sdk.NewCoins(), sdkmath.Int{}, sdkmath.LegacyDec{}, sdkmath.LegacyDec{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), err
 		}
-		return tokensJoined, numShares, totalSlippage, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), nil
+		return tokensJoined, numShares, totalSlippage, sdkmath.LegacyZeroDec(), swapFee, takerFee, nil
 	}
 
 	accountedAssets := p.GetAccountedBalance(ctx, accountedPoolKeeper, p.PoolAssets)
@@ -171,7 +180,7 @@ func (p *Pool) JoinPool(
 		swapFee = p.GetPoolParams().SwapFee.Mul(initialWeightOut)
 	}
 
-	takerFeesFinal = takerfees.Mul(initialWeightOut)
+	takerFeesFinal = takerFees.Mul(initialWeightOut)
 
 	totalShares := p.GetTotalShares()
 	numSharesDec := sdkmath.LegacyNewDecFromInt(totalShares.Amount).