Adding lend module changes

app/app.go

@@ -566,6 +566,7 @@ func New(
 		app.AccountKeeper,
 		&app.AssetKeeper,
 		&app.MarketKeeper,
+		&app.EsmKeeper,
 	)
 
 	app.EsmKeeper = esmkeeper.NewKeeper(

proto/comdex/lend/v1beta1/query.proto

@@ -382,5 +382,6 @@ service Query {
   rpc QueryAuctionParams(QueryAuctionParamRequest) returns (QueryAuctionParamResponse) {
     option (google.api.http).get = "/comdex/lend/v1beta1/auctionparams/{app_id}";
   }
+
 }
 

scripts/comdex_local_setup/main.py

@@ -379,12 +379,12 @@ def CreateState():
             exit("Invalid liquidity pair configs")
         CreateLiquidityPair(liquidityPair[0], liquidityPair[1], liquidityPair[2])
         Vote("yes")
-    
+
     for liquidityPool in LIQUIDITY_POOLS:
         if len(liquidityPool) != 3:
             exit("Invalid liquidity pool configs")
         CreateLiquidityPool(liquidityPool[0], liquidityPool[1], liquidityPool[2])
-    
+
     for assetRate in ADD_ASSET_RATES:
         if len(assetRate) != 2:
             exit("Invalid add asset rate configs")

x/asset/keeper/asset.go

@@ -229,7 +229,7 @@ func (k Keeper) UpdateAssetRecords(ctx sdk.Context, msg types.Asset) error {
 	if msg.Name != "" {
 		var IsLetter = regexp.MustCompile(`^[A-Z]+$`).MatchString
 
-		if (!IsLetter(msg.Name) || len(msg.Name) > 10){
+		if !IsLetter(msg.Name) || len(msg.Name) > 10 {
 			return types.ErrorNameDidNotMeetCriterion
 		}
 	}

x/auction/abci.go

@@ -33,19 +33,19 @@ func BeginBlocker(ctx sdk.Context, k keeper.Keeper) {
 			}
 		}
 
-		lockedVaults := k.GetLockedVaults(ctx)
+		//lockedVaults := k.GetLockedVaults(ctx)
 
-		if len(lockedVaults) > 0 {
-			// err3 := k.DutchActivator(ctx, lockedVaults)
-			// if err3 != nil {
-			// 	ctx.Logger().Error("error in dutch activator")
-			// }
-
-			err5 := k.LendDutchActivator(ctx, lockedVaults)
-			if err5 != nil {
-				ctx.Logger().Error("error in lend dutch activator")
-			}
-		}
+		//if len(lockedVaults) > 0 {
+		//	err3 := k.DutchActivator(ctx, lockedVaults)
+		//	if err3 != nil {
+		//		ctx.Logger().Error("error in dutch activator")
+		//	}
+		//
+		//	err5 := k.LendDutchActivator(ctx, lockedVaults)
+		//	if err5 != nil {
+		//		ctx.Logger().Error("error in lend dutch activator")
+		//	}
+		//}
 
 		apps, appsFound := k.GetApps(ctx)
 

x/auction/client/cli/query.go

@@ -699,4 +699,4 @@ func queryFilterDutchAuctions() *cobra.Command {
 	flags.AddQueryFlagsToCmd(cmd)
 	flags.AddPaginationFlagsToCmd(cmd, "filter-dutch-auctions")
 	return cmd
-}
+}

x/auction/expected/keeper.go

@@ -2,6 +2,7 @@ package expected
 
 import (
 	assettypes "github.com/comdex-official/comdex/x/asset/types"
+	auctiontypes "github.com/comdex-official/comdex/x/auction/types"
 	"github.com/comdex-official/comdex/x/collector/types"
 	esmtypes "github.com/comdex-official/comdex/x/esm/types"
 	lendtypes "github.com/comdex-official/comdex/x/lend/types"
@@ -37,7 +38,7 @@ type LiquidationKeeper interface {
 	SetLockedVault(ctx sdk.Context, lockedVault liquidationtypes.LockedVault)
 	DeleteLockedVault(ctx sdk.Context, appID, id uint64)
 	CreateLockedVaultHistory(ctx sdk.Context, lockedVault liquidationtypes.LockedVault) error
-	UnLiquidateLockedBorrows(ctx sdk.Context, appID, id uint64) error
+	UnLiquidateLockedBorrows(ctx sdk.Context, appID, id uint64, dutchAuction auctiontypes.DutchAuction) error
 }
 
 type AssetKeeper interface {

x/auction/keeper/alias.go

@@ -271,8 +271,8 @@ func (k Keeper) ModuleBalance(ctx sdk.Context, moduleName string, denom string)
 func (k Keeper) UpdateReserveBalances(ctx sdk.Context, assetID uint64, moduleName string, payment sdk.Coin, inc bool) error {
 	return k.lend.UpdateReserveBalances(ctx, assetID, moduleName, payment, inc)
 }
-func (k Keeper) UnLiquidateLockedBorrows(ctx sdk.Context, appID, id uint64) error {
-	return k.liquidation.UnLiquidateLockedBorrows(ctx, appID, id)
+func (k Keeper) UnLiquidateLockedBorrows(ctx sdk.Context, appID, id uint64, dutchAuction auctiontypes.DutchAuction) error {
+	return k.liquidation.UnLiquidateLockedBorrows(ctx, appID, id, dutchAuction)
 }
 
 func (k Keeper) SetLend(ctx sdk.Context, lend lendtypes.LendAsset) {

x/auction/keeper/dutch_lend.go

@@ -10,58 +10,58 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func (k Keeper) LendDutchActivator(ctx sdk.Context, lockedVaults []liquidationtypes.LockedVault) error {
-	for _, lockedVault := range lockedVaults {
-		if lockedVault.Kind != nil {
-			if !lockedVault.IsAuctionInProgress {
-				extendedPair, found := k.GetLendPair(ctx, lockedVault.ExtendedPairId)
-				if !found {
-					return auctiontypes.ErrorInvalidPair
-				}
-				assetIn, _ := k.GetAsset(ctx, extendedPair.AssetIn)
-
-				assetOut, _ := k.GetAsset(ctx, extendedPair.AssetOut)
-
-				assetInPrice, found := k.GetPriceForAsset(ctx, assetIn.Id)
-				if !found {
-					ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
-					continue
-				}
-				assetOutPrice, found := k.GetPriceForAsset(ctx, assetOut.Id)
-				if !found {
-					ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
-					continue
-				}
-				//assetInPrice is the collateral price
-				////Here collateral to be auctioned is received in ucollateral*uusd so inorder to get back amount we divide with uusd of assetIn
-				AssetInPrice := sdk.NewDecFromInt(sdk.NewIntFromUint64(assetInPrice))
-				if AssetInPrice.Equal(sdk.ZeroDec()) {
-					ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
-					continue
-				}
-				AssetOutPrice := sdk.NewDecFromInt(sdk.NewIntFromUint64(assetOutPrice))
-				if AssetOutPrice.Equal(sdk.ZeroDec()) {
-					ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
-					continue
-				}
-				outflowToken := sdk.NewCoin(assetIn.Denom, lockedVault.CollateralToBeAuctioned.Quo(AssetInPrice).TruncateInt())
-				inflowToken := sdk.NewCoin(assetOut.Denom, lockedVault.CollateralToBeAuctioned.Quo(AssetOutPrice).TruncateInt())
-
-				AssetRatesStats, found := k.GetAssetRatesStats(ctx, extendedPair.AssetIn)
-				if !found {
-					ctx.Logger().Error(auctiontypes.ErrorAssetRates.Error(), lockedVault.LockedVaultId)
-					continue
-				}
-				liquidationPenalty := AssetRatesStats.LiquidationPenalty
-
-				err1 := k.StartLendDutchAuction(ctx, outflowToken, inflowToken, lockedVault.AppId, assetOut.Id, assetIn.Id, lockedVault.LockedVaultId, lockedVault.Owner, liquidationPenalty)
-				if err1 != nil {
-					ctx.Logger().Error(auctiontypes.ErrorInStartDutchAuction.Error(), lockedVault.LockedVaultId)
-					continue
-				}
+func (k Keeper) LendDutchActivator(ctx sdk.Context, lockedVault liquidationtypes.LockedVault) error {
+
+	if lockedVault.Kind != nil {
+		if !lockedVault.IsAuctionInProgress {
+			extendedPair, found := k.GetLendPair(ctx, lockedVault.ExtendedPairId)
+			if !found {
+				return auctiontypes.ErrorInvalidPair
+			}
+			assetIn, _ := k.GetAsset(ctx, extendedPair.AssetIn)
+
+			assetOut, _ := k.GetAsset(ctx, extendedPair.AssetOut)
+
+			assetInPrice, found := k.GetPriceForAsset(ctx, assetIn.Id)
+			if !found {
+				ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
+				return nil
+			}
+			assetOutPrice, found := k.GetPriceForAsset(ctx, assetOut.Id)
+			if !found {
+				ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
+				return nil
+			}
+			//assetInPrice is the collateral price
+			////Here collateral to be auctioned is received in ucollateral*uusd so inorder to get back amount we divide with uusd of assetIn
+			AssetInPrice := sdk.NewDecFromInt(sdk.NewIntFromUint64(assetInPrice))
+			if AssetInPrice.Equal(sdk.ZeroDec()) {
+				ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
+				return nil
+			}
+			AssetOutPrice := sdk.NewDecFromInt(sdk.NewIntFromUint64(assetOutPrice))
+			if AssetOutPrice.Equal(sdk.ZeroDec()) {
+				ctx.Logger().Error(auctiontypes.ErrorPrices.Error(), lockedVault.LockedVaultId)
+				return nil
+			}
+			outflowToken := sdk.NewCoin(assetIn.Denom, lockedVault.CollateralToBeAuctioned.Quo(AssetInPrice).TruncateInt())
+			inflowToken := sdk.NewCoin(assetOut.Denom, lockedVault.CollateralToBeAuctioned.Quo(AssetOutPrice).TruncateInt())
+
+			AssetRatesStats, found := k.GetAssetRatesStats(ctx, extendedPair.AssetIn)
+			if !found {
+				ctx.Logger().Error(auctiontypes.ErrorAssetRates.Error(), lockedVault.LockedVaultId)
+				return nil
+			}
+			liquidationPenalty := AssetRatesStats.LiquidationPenalty
+
+			err1 := k.StartLendDutchAuction(ctx, outflowToken, inflowToken, lockedVault.AppId, assetOut.Id, assetIn.Id, lockedVault.LockedVaultId, lockedVault.Owner, liquidationPenalty)
+			if err1 != nil {
+				ctx.Logger().Error(auctiontypes.ErrorInStartDutchAuction.Error(), lockedVault.LockedVaultId)
+				return nil
 			}
 		}
 	}
+
 	return nil
 }
 
@@ -96,15 +96,21 @@ func (k Keeper) StartLendDutchAuction(
 	if !found {
 		return auctiontypes.ErrorInvalidAuctionParams
 	}
-
 	BorrowMetaData := lockedVault.GetBorrowMetaData()
 	LendPos, _ := k.GetLend(ctx, BorrowMetaData.LendingId)
 	pool, _ := k.GetPool(ctx, LendPos.PoolID)
-	err := k.SendCoinsFromModuleToModule(ctx, pool.ModuleName, auctiontypes.ModuleName, sdk.NewCoins(outFlowToken))
-	if err != nil {
-		return err
+	assetStat, _ := k.GetAssetRatesStats(ctx, LendPos.AssetID)
+	cAsset, _ := k.GetAsset(ctx, assetStat.CAssetID)
+	if outFlowToken.Amount.GT(sdk.ZeroInt()) {
+		err := k.SendCoinsFromModuleToModule(ctx, pool.ModuleName, auctiontypes.ModuleName, sdk.NewCoins(outFlowToken))
+		if err != nil {
+			return err
+		}
+		err = k.BurnCoins(ctx, pool.ModuleName, sdk.NewCoin(cAsset.Denom, outFlowToken.Amount))
+		if err != nil {
+			return err
+		}
 	}
-
 	outFlowTokenPrice, found = k.GetPriceForAsset(ctx, assetOutID)
 	if !found {
 		return auctiontypes.ErrorPrices
@@ -212,7 +218,8 @@ func (k Keeper) PlaceLendDutchAuctionBid(ctx sdk.Context, appID, auctionMappingI
 	if !found {
 		return auctiontypes.ErrorInvalidExtendedPairVault
 	}
-
+	assetStats, _ := k.GetAssetRatesStats(ctx, ExtendedPairVault.AssetIn)
+	assetOutPool, _ := k.GetPool(ctx, ExtendedPairVault.AssetOutPoolID)
 	//dust is in usd * 10*-6 (uusd)
 	dust := sdk.NewIntFromUint64(ExtendedPairVault.MinUsdValueLeft)
 	//here subtracting current amount and slice to get amount left in auction and also converting it to usd * 10**-12
@@ -239,11 +246,17 @@ func (k Keeper) PlaceLendDutchAuctionBid(ctx sdk.Context, appID, auctionMappingI
 	if err != nil {
 		return err
 	}
-	err = k.SendCoinsFromModuleToAccount(ctx, auctiontypes.ModuleName, bidder, sdk.NewCoins(outFlowTokenCoin))
+	// sending inflow token back to the pool
+	err = k.SendCoinsFromModuleToModule(ctx, auctiontypes.ModuleName, assetOutPool.ModuleName, sdk.NewCoins(inFlowTokenCoin))
 	if err != nil {
 		return err
 	}
 
+	// calculating additional auction bonus to the bidder
+
+	auctionBonus := slice.ToDec().Mul(assetStats.LiquidationBonus)
+	totalAmountToBidder := sdk.NewCoin(auction.OutflowTokenInitAmount.Denom, slice.Add(auctionBonus.TruncateInt()))
+
 	biddingID, err := k.CreateNewDutchLendBid(ctx, appID, auctionMappingID, auctionID, bidder.String(), inFlowTokenCoin, outFlowTokenCoin)
 	if err != nil {
 		return err
@@ -261,27 +274,22 @@ func (k Keeper) PlaceLendDutchAuctionBid(ctx sdk.Context, appID, auctionMappingI
 	//collateral not over but target cmst reached then send remaining collateral to owner
 	//if inflow token current amount >= InflowTokenTargetAmount
 	if auction.InflowTokenCurrentAmount.IsGTE(auction.InflowTokenTargetAmount) {
-		//send left overcollateral to vault owner as target cmst reached and also
-
 		total := auction.OutflowTokenCurrentAmount
 		err = k.SendCoinsFromModuleToAccount(ctx, auctiontypes.ModuleName, sdk.AccAddress(lockedVault.Owner), sdk.NewCoins(total))
+		err = k.SendCoinsFromModuleToAccount(ctx, auctiontypes.ModuleName, bidder, sdk.NewCoins(totalAmountToBidder))
 		if err != nil {
 			return err
 		}
-
 		err = k.SetDutchLendAuction(ctx, auction)
 		if err != nil {
 			return err
 		}
 
-		//remove dutch auction
-
 		err = k.CloseDutchLendAuction(ctx, auction)
 		if err != nil {
 			return err
 		}
 	} else if auction.OutflowTokenCurrentAmount.Amount.IsZero() && auction.InflowTokenCurrentAmount.IsLT(auction.InflowTokenTargetAmount) { //entire collateral sold out
-
 		// take requiredAmount from reserve-pool
 		requiredAmount := auction.InflowTokenTargetAmount.Sub(auction.InflowTokenCurrentAmount)
 		//get reserve balance if the requiredAmount is available in the reserves or not
@@ -299,6 +307,11 @@ func (k Keeper) PlaceLendDutchAuctionBid(ctx sdk.Context, appID, auctionMappingI
 		if err != nil {
 			return err
 		}
+		err = k.SendCoinsFromModuleToAccount(ctx, auctiontypes.ModuleName, bidder, sdk.NewCoins(totalAmountToBidder))
+		if err != nil {
+			return err
+		}
+
 		err = k.SetDutchLendAuction(ctx, auction)
 		if err != nil {
 			return err
@@ -311,6 +324,11 @@ func (k Keeper) PlaceLendDutchAuctionBid(ctx sdk.Context, appID, auctionMappingI
 		}
 	} else if auction.OutflowTokenCurrentAmount.Amount.IsZero() { //entire collateral sold out
 
+		err = k.SendCoinsFromModuleToAccount(ctx, auctiontypes.ModuleName, bidder, sdk.NewCoins(totalAmountToBidder))
+		if err != nil {
+			return err
+		}
+
 		err = k.SetDutchLendAuction(ctx, auction)
 		if err != nil {
 			return err
@@ -383,24 +401,9 @@ func (k Keeper) CloseDutchLendAuction(
 		return auctiontypes.ErrorVaultNotFound
 	}
 
-	//logic to send the coins back to pool
-	//calculate penalty
-	penaltyCoin := sdk.NewCoin(dutchAuction.InflowTokenCurrentAmount.Denom, sdk.ZeroInt())
-
-	// send penalty
-
-	pairID := lockedVault.ExtendedPairId
-	lendPair, _ := k.GetLendPair(ctx, pairID)
-	inFlowTokenAssetID := lendPair.AssetOut
-
-	err := k.UpdateReserveBalances(ctx, inFlowTokenAssetID, auctiontypes.ModuleName, penaltyCoin, true)
-	if err != nil {
-		return err
-	}
-
 	lockedVault.AmountIn = lockedVault.AmountIn.Sub(dutchAuction.OutflowTokenInitAmount.Amount)
 	//set sell of history in locked vault
-	err = k.CreateLockedVaultHistory(ctx, lockedVault)
+	err := k.CreateLockedVaultHistory(ctx, lockedVault)
 	if err != nil {
 		return err
 	}
@@ -411,6 +414,7 @@ func (k Keeper) CloseDutchLendAuction(
 	k.SetLend(ctx, lendPos)
 
 	lockedVault.AmountOut = lockedVault.AmountOut.Sub(dutchAuction.InflowTokenTargetAmount.Amount)
+	lockedVault.UpdatedAmountOut = lockedVault.UpdatedAmountOut.Sub(dutchAuction.InflowTokenTargetAmount.Amount)
 	if lockedVault.AmountOut.LTE(sdk.ZeroInt()) {
 		lockedVault.AmountOut = sdk.ZeroInt()
 	}
@@ -432,15 +436,15 @@ func (k Keeper) CloseDutchLendAuction(
 	if err != nil {
 		return err
 	}
-	err = k.DeleteDutchLendAuction(ctx, dutchAuction)
+	err = k.SetHistoryDutchLendAuction(ctx, dutchAuction)
 	if err != nil {
 		return err
 	}
-	err = k.SetHistoryDutchLendAuction(ctx, dutchAuction)
+	err = k.UnLiquidateLockedBorrows(ctx, lockedVault.AppId, lockedVault.LockedVaultId, dutchAuction)
 	if err != nil {
 		return err
 	}
-	err = k.UnLiquidateLockedBorrows(ctx, lockedVault.AppId, lockedVault.LockedVaultId)
+	err = k.DeleteDutchLendAuction(ctx, dutchAuction)
 	if err != nil {
 		return err
 	}

x/auction/keeper/query_server.go

@@ -479,7 +479,7 @@ func (q QueryServer) QueryFilterDutchAuctions(c context.Context, req *types.Quer
 				check = true
 			}
 
-			if accumulate && check{
+			if accumulate && check {
 				items = append(items, item)
 			}
 
@@ -495,4 +495,4 @@ func (q QueryServer) QueryFilterDutchAuctions(c context.Context, req *types.Quer
 		Auctions:   items,
 		Pagination: pagination,
 	}, nil
-}
+}