diff --git a/proto/comdex/lend/v1beta1/lend.proto b/proto/comdex/lend/v1beta1/lend.proto
index e407dc709..5abf69e00 100644
--- a/proto/comdex/lend/v1beta1/lend.proto
+++ b/proto/comdex/lend/v1beta1/lend.proto
@@ -87,9 +87,10 @@ message BorrowAsset {
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.Coin"
   ];
 
-  uint64 bridged_asset_id = 7 [
-    (gogoproto.customname) = "BridgedAssetID",
-    (gogoproto.moretags) = "yaml:\"bridged_asset_id\""
+  cosmos.base.v1beta1.Coin bridged_asset_amount = 7 [
+    (gogoproto.nullable) = false,
+    (gogoproto.moretags) = "yaml:\"bridged_asset_amount\"",
+    (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.Coin"
   ];
 
   google.protobuf.Timestamp borrowing_time = 8 [
diff --git a/x/lend/keeper/grpc_query.go b/x/lend/keeper/grpc_query.go
index 51b15efcd..806b30ceb 100644
--- a/x/lend/keeper/grpc_query.go
+++ b/x/lend/keeper/grpc_query.go
@@ -72,7 +72,7 @@ func (q queryServer) QueryLend(c context.Context, req *types.QueryLendRequest) (
 
 	item, found := q.GetLend(ctx, req.Id)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "asset does not exist for id %d", req.Id)
+		return &types.QueryLendResponse{}, nil
 	}
 
 	return &types.QueryLendResponse{
@@ -94,7 +94,10 @@ func (q queryServer) QueryAllLendByOwner(c context.Context, req *types.QueryAllL
 		return nil, status.Errorf(codes.NotFound, "Address is not correct")
 	}
 
-	userVaultAssetData, _ := q.UserLends(ctx, req.Owner)
+	userVaultAssetData, found := q.UserLends(ctx, req.Owner)
+	if !found {
+		return &types.QueryAllLendByOwnerResponse{}, nil
+	}
 
 	for _, data := range userVaultAssetData {
 		lends = append(lends, data)
@@ -120,7 +123,10 @@ func (q queryServer) QueryAllLendByOwnerAndPool(c context.Context, req *types.Qu
 		return nil, status.Errorf(codes.NotFound, "Address is not correct")
 	}
 
-	userVaultAssetData, _ := q.LendIdByOwnerAndPool(ctx, req.Owner, req.PoolId)
+	userVaultAssetData, found := q.LendIdByOwnerAndPool(ctx, req.Owner, req.PoolId)
+	if !found {
+		return &types.QueryAllLendByOwnerAndPoolResponse{}, nil
+	}
 
 	for _, data := range userVaultAssetData {
 		lends = append(lends, data)
@@ -146,7 +152,10 @@ func (q queryServer) QueryAllBorrowByOwnerAndPool(c context.Context, req *types.
 		return nil, status.Errorf(codes.NotFound, "Address is not correct")
 	}
 
-	userVaultAssetData, _ := q.BorrowIdByOwnerAndPool(ctx, req.Owner, req.PoolId)
+	userVaultAssetData, found := q.BorrowIdByOwnerAndPool(ctx, req.Owner, req.PoolId)
+	if !found {
+		return &types.QueryAllBorrowByOwnerAndPoolResponse{}, nil
+	}
 
 	for _, data := range userVaultAssetData {
 		borrows = append(borrows, data)
@@ -206,7 +215,7 @@ func (q queryServer) QueryPair(c context.Context, req *types.QueryPairRequest) (
 
 	item, found := q.GetLendPair(ctx, req.Id)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "asset does not exist for id %d", req.Id)
+		return &types.QueryPairResponse{}, nil
 	}
 
 	return &types.QueryPairResponse{
@@ -262,7 +271,7 @@ func (q queryServer) QueryPool(c context.Context, req *types.QueryPoolRequest) (
 
 	item, found := q.GetPool(ctx, req.Id)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "asset does not exist for id %d", req.Id)
+		return &types.QueryPoolResponse{}, nil
 	}
 
 	return &types.QueryPoolResponse{
@@ -318,7 +327,7 @@ func (q queryServer) QueryAssetToPairMapping(c context.Context, req *types.Query
 
 	item, found := q.GetAssetToPair(ctx, req.AssetId, req.PoolId)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "pairs does not exist for assetId and poolId %d", req.AssetId, req.PoolId)
+		return &types.QueryAssetToPairMappingResponse{}, nil
 	}
 
 	return &types.QueryAssetToPairMappingResponse{
@@ -374,7 +383,7 @@ func (q queryServer) QueryBorrow(c context.Context, req *types.QueryBorrowReques
 
 	item, found := q.GetBorrow(ctx, req.Id)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "asset does not exist for id %d", req.Id)
+		return &types.QueryBorrowResponse{}, nil
 	}
 
 	return &types.QueryBorrowResponse{
@@ -396,7 +405,10 @@ func (q queryServer) QueryAllBorrowByOwner(c context.Context, req *types.QueryAl
 		return nil, status.Errorf(codes.NotFound, "Address is not correct")
 	}
 
-	userVaultAssetData, _ := q.UserBorrows(ctx, req.Owner)
+	userVaultAssetData, found := q.UserBorrows(ctx, req.Owner)
+	if !found {
+		return &types.QueryAllBorrowByOwnerResponse{}, nil
+	}
 
 	for _, data := range userVaultAssetData {
 		borrows = append(borrows, data)
@@ -456,7 +468,7 @@ func (q queryServer) QueryAssetRatesStat(c context.Context, req *types.QueryAsse
 
 	item, found := q.GetAssetRatesStats(ctx, req.Id)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "asset does not exist for id %d", req.Id)
+		return &types.QueryAssetRatesStatResponse{}, nil
 	}
 
 	return &types.QueryAssetRatesStatResponse{
@@ -472,7 +484,7 @@ func (q queryServer) QueryAssetStats(c context.Context, req *types.QueryAssetSta
 
 	assetStatsData, found := q.AssetStatsByPoolIdAndAssetId(ctx, req.AssetId, req.PoolId)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "assetStatsData does not exist for assetId %d and poolId %d ", req.AssetId, req.PoolId)
+		return &types.QueryAssetStatsResponse{}, nil
 	}
 
 	return &types.QueryAssetStatsResponse{
@@ -488,7 +500,7 @@ func (q queryServer) QueryModuleBalance(c context.Context, req *types.QueryModul
 
 	modBal, found := q.GetModuleBalanceByPoolId(ctx, req.PoolId)
 	if !found {
-		return nil, status.Errorf(codes.NotFound, "module Balance does not exist for poolId %d ", req.PoolId)
+		return &types.QueryModuleBalanceResponse{}, nil
 	}
 
 	return &types.QueryModuleBalanceResponse{
diff --git a/x/lend/keeper/iter.go b/x/lend/keeper/iter.go
index f25c23b10..69a87bfe9 100644
--- a/x/lend/keeper/iter.go
+++ b/x/lend/keeper/iter.go
@@ -78,6 +78,7 @@ func (k Keeper) IterateBorrows(ctx sdk.Context) error {
 			PairID:               borrow.PairID,
 			AmountIn:             borrow.AmountIn,
 			AmountOut:            borrow.AmountOut,
+			BridgedAssetAmount:   borrow.BridgedAssetAmount,
 			BorrowingTime:        borrow.BorrowingTime,
 			StableBorrowRate:     borrow.StableBorrowRate,
 			UpdatedAmountOut:     borrow.UpdatedAmountOut.Add(interestPerBlock),
@@ -116,7 +117,7 @@ func (k Keeper) RebalanceStableRates(ctx sdk.Context) error {
 	for _, v := range stableBorrows.StableBorrowIds {
 		borrowPos, _ := k.GetBorrow(ctx, v)
 		pair, _ := k.GetLendPair(ctx, borrowPos.PairID)
-		assetStats, _ := k.UpdateAPR(ctx, pair.AssetOut, pair.AssetOutPoolId)
+		assetStats, _ := k.UpdateAPR(ctx, pair.AssetOutPoolId, pair.AssetOut)
 		utilizationRatio, _ := k.GetUtilisationRatioByPoolIdAndAssetId(ctx, pair.AssetOutPoolId, pair.AssetOut)
 		perc1, _ := sdk.NewDecFromStr("0.2")
 		perc2, _ := sdk.NewDecFromStr("0.9")
diff --git a/x/lend/keeper/keeper.go b/x/lend/keeper/keeper.go
index 343568914..d3ff75bb1 100644
--- a/x/lend/keeper/keeper.go
+++ b/x/lend/keeper/keeper.go
@@ -413,6 +413,20 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 		return types.ErrLendAccessUnauthorised
 	}
 
+	pair, found := k.GetLendPair(ctx, pairId)
+	if !found {
+		return types.ErrorPairNotFound
+	}
+	//check cr ratio
+	assetIn, _ := k.GetAsset(ctx, lendPos.AssetId)
+	assetOut, _ := k.GetAsset(ctx, pair.AssetOut)
+	assetInRatesStats, _ := k.GetAssetRatesStats(ctx, pair.AssetIn)
+
+	cAsset, _ := k.GetAsset(ctx, assetInRatesStats.CAssetId)
+	if AmountIn.Denom != cAsset.Denom {
+		return types.ErrBadOfferCoinAmount
+	}
+
 	if k.HasBorrowForAddressByPair(ctx, lenderAddr, pairId) {
 		return types.ErrorDuplicateBorrow
 	}
@@ -426,18 +440,15 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 	//if !found {
 	//	return types.ErrorPairNotFound
 	//}
-	pair, found := k.GetLendPair(ctx, pairId)
-	if !found {
-		return types.ErrorPairNotFound
-	}
+
 	AssetInPool, _ := k.GetPool(ctx, lendPos.PoolId)
 	AssetOutPool, _ := k.GetPool(ctx, pair.AssetOutPoolId)
 
-	//check cr ratio
-	assetIn, _ := k.GetAsset(ctx, lendPos.AssetId)
-	assetOut, _ := k.GetAsset(ctx, pair.AssetOut)
-
 	assetRatesStats, _ := k.GetAssetRatesStats(ctx, pair.AssetOut)
+	if IsStableBorrow && !assetRatesStats.EnableStableBorrow {
+		return sdkerrors.Wrap(types.ErrStableBorrowDisabled, loan.String())
+	}
+
 	err := k.VerifyCollaterlizationRatio(ctx, AmountIn.Amount, assetIn, loan.Amount, assetOut, assetRatesStats.LiquidationThreshold)
 	if err != nil {
 		return err
@@ -455,16 +466,6 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 
 		AmountOut := loan
 		// take c/Tokens from the user
-
-		assetRatesStat, found := k.GetAssetRatesStats(ctx, lendPos.AssetId)
-		if !found {
-			return sdkerrors.Wrap(types.ErrorAssetRatesStatsNotFound, strconv.FormatUint(lendPos.AssetId, 10))
-		}
-		cAsset, _ := k.GetAsset(ctx, assetRatesStat.CAssetId)
-		if AmountIn.Denom != cAsset.Denom {
-			return sdkerrors.Wrap(types.ErrBadOfferCoinAmount, AmountIn.Denom)
-		}
-
 		if err := k.SendCoinFromAccountToModule(ctx, lenderAddr, AssetInPool.ModuleName, AmountIn); err != nil {
 			return err
 		}
@@ -494,7 +495,7 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 			PairID:               pairId,
 			AmountIn:             AmountIn,
 			AmountOut:            AmountOut,
-			BridgedAssetID:       0,
+			BridgedAssetAmount:   sdk.NewCoin("", sdk.NewInt(0)),
 			IsStableBorrow:       IsStableBorrow,
 			StableBorrowRate:     StableBorrowRate,
 			BorrowingTime:        ctx.BlockTime(),
@@ -506,7 +507,7 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 		if !found {
 			assetStats.TotalBorrowed = sdk.ZeroInt()
 		}
-		if borrowPos.StableBorrowRate != sdk.ZeroDec() {
+		if borrowPos.IsStableBorrow {
 			AssetStats := types.AssetStats{
 				PoolId:              pair.AssetOutPoolId,
 				AssetId:             pair.AssetOut,
@@ -562,14 +563,14 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 		priceAssetIn, _ := k.GetPriceForAsset(ctx, pair.AssetIn)
 		amtIn := assetIn.Mul(sdk.NewIntFromUint64(priceAssetIn))
 
-		priceFirstBridgedAsset, _ := k.GetPriceForAsset(ctx, AssetInPool.FirstBridgedAssetId)
+		//priceFirstBridgedAsset, _ := k.GetPriceForAsset(ctx, AssetInPool.FirstBridgedAssetId)
 		priceSecondBridgedAsset, _ := k.GetPriceForAsset(ctx, AssetInPool.SecondBridgedAssetId)
 		firstBridgedAsset, _ := k.GetAsset(ctx, AssetInPool.FirstBridgedAssetId)
 		secondBridgedAsset, _ := k.GetAsset(ctx, AssetInPool.SecondBridgedAssetId)
 
 		// qty of first and second bridged asset to be sent over different pool according to the borrow Pool
 
-		firstBridgedAssetQty := amtIn.Quo(sdk.NewIntFromUint64(priceFirstBridgedAsset))
+		firstBridgedAssetQty := amtIn.Quo(sdk.NewIntFromUint64(1000000))
 		firstBridgedAssetBal := k.ModuleBalance(ctx, AssetInPool.ModuleName, firstBridgedAsset.Denom)
 		secondBridgedAssetQty := amtIn.Quo(sdk.NewIntFromUint64(priceSecondBridgedAsset))
 		secondBridgedAssetBal := k.ModuleBalance(ctx, AssetInPool.ModuleName, secondBridgedAsset.Denom)
@@ -577,21 +578,11 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 		if firstBridgedAssetQty.LT(firstBridgedAssetBal) {
 
 			// take c/Tokens from the user
-
-			assetRatesStat, found := k.GetAssetRatesStats(ctx, lendPos.AssetId)
-			if !found {
-				return sdkerrors.Wrap(types.ErrorAssetRatesStatsNotFound, strconv.FormatUint(lendPos.AssetId, 10))
-			}
-			cAsset, _ := k.GetAsset(ctx, assetRatesStat.CAssetId)
-			if AmountIn.Denom != cAsset.Denom {
-				return sdkerrors.Wrap(types.ErrBadOfferCoinAmount, AmountIn.Denom)
-			}
-
 			if err := k.SendCoinFromAccountToModule(ctx, lenderAddr, AssetInPool.ModuleName, AmountIn); err != nil {
 				return err
 			}
-
-			if err := k.SendCoinFromModuleToModule(ctx, AssetInPool.ModuleName, AssetOutPool.ModuleName, sdk.NewCoins(sdk.NewCoin(firstBridgedAsset.Denom, firstBridgedAssetQty))); err != nil {
+			bridgedAssetAmount := sdk.NewCoin(firstBridgedAsset.Denom, firstBridgedAssetQty)
+			if err := k.SendCoinFromModuleToModule(ctx, AssetInPool.ModuleName, AssetOutPool.ModuleName, sdk.NewCoins(bridgedAssetAmount)); err != nil {
 				return err
 			}
 
@@ -599,7 +590,6 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 				return err
 			}
 
-			AmountIn := sdk.NewCoin(lendPos.AmountIn.Denom, lendPos.UpdatedAmountIn)
 			AmountOut := loan
 
 			var StableBorrowRate sdk.Dec
@@ -623,7 +613,7 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 				PairID:               pairId,
 				AmountIn:             AmountIn,
 				AmountOut:            AmountOut,
-				BridgedAssetID:       AssetInPool.FirstBridgedAssetId,
+				BridgedAssetAmount:   bridgedAssetAmount,
 				IsStableBorrow:       IsStableBorrow,
 				StableBorrowRate:     StableBorrowRate,
 				BorrowingTime:        ctx.BlockTime(),
@@ -681,20 +671,12 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 
 		} else if secondBridgedAssetQty.LT(secondBridgedAssetBal) {
 			// take c/Tokens from the user
-			assetRatesStat, found := k.GetAssetRatesStats(ctx, lendPos.AssetId)
-			if !found {
-				return sdkerrors.Wrap(types.ErrorAssetRatesStatsNotFound, strconv.FormatUint(lendPos.AssetId, 10))
-			}
-			cAsset, _ := k.GetAsset(ctx, assetRatesStat.CAssetId)
-			if AmountIn.Denom != cAsset.Denom {
-				return sdkerrors.Wrap(types.ErrBadOfferCoinAmount, AmountIn.Denom)
-			}
-
 			if err := k.SendCoinFromAccountToModule(ctx, lenderAddr, AssetInPool.ModuleName, AmountIn); err != nil {
 				return err
 			}
 
-			if err := k.SendCoinFromModuleToModule(ctx, AssetInPool.ModuleName, AssetOutPool.ModuleName, sdk.NewCoins(sdk.NewCoin(secondBridgedAsset.Denom, secondBridgedAssetQty))); err != nil {
+			bridgedAssetAmount := sdk.NewCoin(secondBridgedAsset.Denom, secondBridgedAssetQty)
+			if err := k.SendCoinFromModuleToModule(ctx, AssetInPool.ModuleName, AssetOutPool.ModuleName, sdk.NewCoins(bridgedAssetAmount)); err != nil {
 				return err
 			}
 
@@ -702,7 +684,6 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 				return err
 			}
 
-			AmountIn := sdk.NewCoin(lendPos.AmountIn.Denom, lendPos.UpdatedAmountIn)
 			AmountOut := loan
 
 			var StableBorrowRate sdk.Dec
@@ -726,7 +707,7 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 				PairID:               pairId,
 				AmountIn:             AmountIn,
 				AmountOut:            AmountOut,
-				BridgedAssetID:       AssetInPool.SecondBridgedAssetId,
+				BridgedAssetAmount:   bridgedAssetAmount,
 				IsStableBorrow:       IsStableBorrow,
 				StableBorrowRate:     StableBorrowRate,
 				BorrowingTime:        ctx.BlockTime(),
@@ -738,7 +719,7 @@ func (k Keeper) BorrowAsset(ctx sdk.Context, addr string, lendId, pairId uint64,
 			if !found {
 				assetStats.TotalBorrowed = sdk.ZeroInt()
 			}
-			if borrowPos.StableBorrowRate != sdk.ZeroDec() {
+			if borrowPos.IsStableBorrow {
 				AssetStats := types.AssetStats{
 					PoolId:              pair.AssetOutPoolId,
 					AssetId:             pair.AssetOut,
@@ -816,8 +797,7 @@ func (k Keeper) RepayAsset(ctx sdk.Context, borrowId uint64, borrowerAddr string
 				return err
 			}
 			borrowPos.UpdatedAmountOut = borrowPos.UpdatedAmountOut.Sub(payment.Amount)
-			borrowPos.Interest_Accumulated = borrowPos.AmountOut.Amount.Sub(payment.Amount)
-
+			borrowPos.Interest_Accumulated = borrowPos.Interest_Accumulated.Sub(payment.Amount)
 			k.SetBorrow(ctx, borrowPos)
 		} else {
 			// sending repayment to moduleAcc from borrower
@@ -825,7 +805,7 @@ func (k Keeper) RepayAsset(ctx sdk.Context, borrowId uint64, borrowerAddr string
 				return err
 			}
 			borrowPos.UpdatedAmountOut = borrowPos.UpdatedAmountOut.Sub(payment.Amount)
-			borrowPos.AmountOut.Amount = borrowPos.AmountOut.Amount.Sub(payment.Amount).Sub(borrowPos.Interest_Accumulated)
+			borrowPos.AmountOut.Amount = borrowPos.AmountOut.Amount.Sub(payment.Amount).Add(borrowPos.Interest_Accumulated)
 			borrowPos.Interest_Accumulated = sdk.ZeroInt()
 
 			reserveRates, _ := k.GetReserveRate(ctx, pair.AssetOutPoolId, pair.AssetOut)
@@ -1014,6 +994,8 @@ func (k Keeper) CloseBorrow(ctx sdk.Context, borrowerAddr string, borrowId uint6
 	pair, _ := k.GetLendPair(ctx, borrowPos.PairID)
 	pool, _ := k.GetPool(ctx, pair.AssetOutPoolId)
 	lendPos, _ := k.GetLend(ctx, borrowPos.LendingID)
+	assetInPool, _ := k.GetPool(ctx, lendPos.PoolId)
+
 	if lendPos.Owner != borrowerAddr {
 		return types.ErrLendAccessUnauthorised
 	}
@@ -1055,9 +1037,14 @@ func (k Keeper) CloseBorrow(ctx sdk.Context, borrowerAddr string, borrowId uint6
 	if err != nil {
 		return err
 	}
-	//TODO:
-	// send the bridged asset back to the assetIn pools
 
+	if pair.IsInterPool {
+		if err := k.bank.SendCoinsFromModuleToModule(ctx, pool.ModuleName, assetInPool.ModuleName, sdk.NewCoins(borrowPos.BridgedAssetAmount)); err != nil {
+			return err
+		}
+	}
+	lendPos.AvailableToBorrow = lendPos.AvailableToBorrow.Add(borrowPos.AmountIn.Amount)
+	k.SetLend(ctx, lendPos)
 	k.DeleteBorrow(ctx, borrowId)
 
 	return nil
diff --git a/x/lend/keeper/lend.go b/x/lend/keeper/lend.go
index 0c99cbebb..ae5ade72c 100644
--- a/x/lend/keeper/lend.go
+++ b/x/lend/keeper/lend.go
@@ -407,7 +407,7 @@ func (k *Keeper) GetAssetStatsByPoolIdAndAssetId(ctx sdk.Context, assetID, poolI
 }
 
 func (k *Keeper) AssetStatsByPoolIdAndAssetId(ctx sdk.Context, assetID, poolId uint64) (AssetStats types.AssetStats, found bool) {
-	AssetStats, found = k.UpdateAPR(ctx, assetID, poolId)
+	AssetStats, found = k.UpdateAPR(ctx, poolId, assetID)
 	if !found {
 		return AssetStats, false
 	}
diff --git a/x/lend/keeper/maths.go b/x/lend/keeper/maths.go
index b8234ca12..8542292c9 100644
--- a/x/lend/keeper/maths.go
+++ b/x/lend/keeper/maths.go
@@ -77,8 +77,7 @@ func (k Keeper) GetLendAPRByAssetIdAndPoolId(ctx sdk.Context, poolId, assetId ui
 }
 
 func (k Keeper) GetAverageBorrowRate(ctx sdk.Context, poolId, assetId uint64) (averageBorrowRate sdk.Dec, err error) {
-
-	assetStats, _ := k.UpdateAPR(ctx, assetId, poolId)
+	assetStats, _ := k.UpdateAPR(ctx, poolId, assetId)
 	factor1 := assetStats.BorrowApr.Mul(sdk.Dec(assetStats.TotalBorrowed))
 	factor2 := assetStats.StableBorrowApr.Mul(sdk.Dec(assetStats.TotalStableBorrowed))
 	numerator := factor1.Add(factor2)
@@ -116,15 +115,21 @@ func (k Keeper) GetReserveRate(ctx sdk.Context, poolId, assetId uint64) (reserve
 }
 
 func (k Keeper) UpdateAPR(ctx sdk.Context, poolId, assetId uint64) (AssetStats types.AssetStats, found bool) {
+	assetStats, _ := k.GetAssetStatsByPoolIdAndAssetId(ctx, assetId, poolId)
 	lendAPR, _ := k.GetLendAPRByAssetIdAndPoolId(ctx, poolId, assetId)
 	borrowAPR, _ := k.GetBorrowAPRByAssetId(ctx, poolId, assetId, false)
 	stableBorrowAPR, _ := k.GetBorrowAPRByAssetId(ctx, poolId, assetId, true)
 	currentUtilisationRatio, _ := k.GetUtilisationRatioByPoolIdAndAssetId(ctx, poolId, assetId)
 	AssetStats = types.AssetStats{
-		LendApr:          lendAPR,
-		BorrowApr:        borrowAPR,
-		StableBorrowApr:  stableBorrowAPR,
-		UtilisationRatio: currentUtilisationRatio,
+		PoolId:              assetStats.PoolId,
+		AssetId:             assetStats.AssetId,
+		TotalBorrowed:       assetStats.TotalBorrowed,
+		TotalStableBorrowed: assetStats.TotalStableBorrowed,
+		TotalLend:           assetStats.TotalLend,
+		LendApr:             lendAPR,
+		BorrowApr:           borrowAPR,
+		StableBorrowApr:     stableBorrowAPR,
+		UtilisationRatio:    currentUtilisationRatio,
 	}
 	return AssetStats, true
 }
diff --git a/x/lend/types/errors.go b/x/lend/types/errors.go
index b3fd25f18..8bcf28c4d 100644
--- a/x/lend/types/errors.go
+++ b/x/lend/types/errors.go
@@ -57,4 +57,5 @@ var (
 	ErrorAssetRatesStatsNotFound       = sdkerrors.Register(ModuleName, 1146, "Asset Rates Stats not found")
 	ErrPoolNotFound                    = sdkerrors.Register(ModuleName, 1147, "Pool Not Found")
 	ErrAvailableToBorrowInsufficient   = sdkerrors.Register(ModuleName, 1148, "Available To Borrow Insufficient")
+	ErrStableBorrowDisabled            = sdkerrors.Register(ModuleName, 1149, "Stable Borrow Rate Not Enabled for This Asset")
 )
diff --git a/x/lend/types/lend.pb.go b/x/lend/types/lend.pb.go
index fc2715317..e4ed7b840 100644
--- a/x/lend/types/lend.pb.go
+++ b/x/lend/types/lend.pb.go
@@ -123,7 +123,7 @@ type BorrowAsset struct {
 	PairID               uint64                                  `protobuf:"varint,4,opt,name=pair_id,json=pairId,proto3" json:"pair_id,omitempty" yaml:"pair_id"`
 	AmountIn             github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,5,opt,name=amount_in,json=amountIn,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"amount_in" yaml:"amount_in"`
 	AmountOut            github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,6,opt,name=amount_out,json=amountOut,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"amount_out" yaml:"amount_out"`
-	BridgedAssetID       uint64                                  `protobuf:"varint,7,opt,name=bridged_asset_id,json=bridgedAssetId,proto3" json:"bridged_asset_id,omitempty" yaml:"bridged_asset_id"`
+	BridgedAssetAmount   github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,7,opt,name=bridged_asset_amount,json=bridgedAssetAmount,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"bridged_asset_amount" yaml:"bridged_asset_amount"`
 	BorrowingTime        time.Time                               `protobuf:"bytes,8,opt,name=borrowing_time,json=borrowingTime,proto3,stdtime" json:"borrowing_time" yaml:"borrowing_time"`
 	StableBorrowRate     github_com_cosmos_cosmos_sdk_types.Dec  `protobuf:"bytes,9,opt,name=stable_borrow_rate,json=stableBorrowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"stable_borrow_rate" yaml:"stable_borrow_rate"`
 	UpdatedAmountOut     github_com_cosmos_cosmos_sdk_types.Int  `protobuf:"bytes,10,opt,name=updated_amount_out,json=updatedAmountOut,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"updated_amount_out" yaml:"updated_amount_out"`
@@ -205,11 +205,11 @@ func (m *BorrowAsset) GetAmountOut() github_com_cosmos_cosmos_sdk_types.Coin {
 	return github_com_cosmos_cosmos_sdk_types.Coin{}
 }
 
-func (m *BorrowAsset) GetBridgedAssetID() uint64 {
+func (m *BorrowAsset) GetBridgedAssetAmount() github_com_cosmos_cosmos_sdk_types.Coin {
 	if m != nil {
-		return m.BridgedAssetID
+		return m.BridgedAssetAmount
 	}
-	return 0
+	return github_com_cosmos_cosmos_sdk_types.Coin{}
 }
 
 func (m *BorrowAsset) GetBorrowingTime() time.Time {
@@ -1157,135 +1157,135 @@ func init() {
 func init() { proto.RegisterFile("comdex/lend/v1beta1/lend.proto", fileDescriptor_b87bb4bef8334ddd) }
 
 var fileDescriptor_b87bb4bef8334ddd = []byte{
-	// 2040 bytes of a gzipped FileDescriptorProto
+	// 2039 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xcd, 0x6f, 0x1b, 0xc7,
-	0x15, 0xf7, 0x4a, 0xb2, 0x44, 0x3e, 0x8a, 0x94, 0x38, 0xa4, 0x6a, 0x46, 0x8a, 0xb9, 0xca, 0xb4,
-	0xb0, 0xdd, 0x83, 0x49, 0x58, 0x6d, 0x81, 0xc4, 0x48, 0x91, 0x70, 0x2d, 0xbb, 0x51, 0x13, 0xdb,
-	0xc9, 0xd8, 0x45, 0xd0, 0x0f, 0x74, 0x31, 0xe4, 0x8e, 0xe4, 0x45, 0x96, 0xbb, 0xcc, 0xee, 0x50,
-	0x8e, 0xfa, 0x11, 0x04, 0xed, 0xa1, 0x40, 0x4f, 0xb9, 0xf7, 0x5c, 0xf4, 0xda, 0x53, 0x6f, 0x05,
-	0x7a, 0x69, 0x9b, 0x43, 0x0f, 0x39, 0x16, 0x3d, 0x6c, 0x0b, 0xfa, 0x3f, 0xd0, 0xb1, 0xa7, 0x62,
-	0x3e, 0xf6, 0x4b, 0x64, 0x1d, 0xaf, 0x14, 0x20, 0x27, 0x71, 0x67, 0xde, 0xfb, 0xfd, 0xde, 0xbc,
-	0x99, 0xf7, 0x31, 0x23, 0xe8, 0x8e, 0x82, 0xb1, 0xc3, 0x3e, 0xea, 0x7b, 0xcc, 0x77, 0xfa, 0xc7,
-	0xb7, 0x86, 0x8c, 0xd3, 0x5b, 0xf2, 0xa3, 0x37, 0x09, 0x03, 0x1e, 0xa0, 0x96, 0x9a, 0xef, 0xc9,
-	0x21, 0x3d, 0xbf, 0xdd, 0x3e, 0x0a, 0x8e, 0x02, 0x39, 0xdf, 0x17, 0xbf, 0x94, 0xe8, 0xb6, 0x79,
-	0x14, 0x04, 0x47, 0x1e, 0xeb, 0xcb, 0xaf, 0xe1, 0xf4, 0xb0, 0xcf, 0xdd, 0x31, 0x8b, 0x38, 0x1d,
-	0x4f, 0xb4, 0x40, 0x77, 0x14, 0x44, 0xe3, 0x20, 0xea, 0x0f, 0x69, 0xc4, 0x52, 0xae, 0x51, 0xe0,
-	0xfa, 0x6a, 0x1e, 0xff, 0x71, 0x15, 0xaa, 0xef, 0x30, 0xdf, 0x19, 0x44, 0x11, 0xe3, 0xe8, 0x36,
-	0x80, 0x20, 0x75, 0xfd, 0x23, 0xdb, 0x75, 0x3a, 0xc6, 0xae, 0x71, 0x63, 0xc5, 0xda, 0x99, 0xc5,
-	0xe6, 0xd2, 0xc1, 0xfe, 0x69, 0x6c, 0x36, 0x4f, 0xe8, 0xd8, 0xbb, 0x8d, 0x33, 0x09, 0x4c, 0xaa,
-	0xfa, 0xe3, 0xc0, 0x41, 0xaf, 0x41, 0x85, 0x0a, 0x10, 0xa1, 0xb9, 0x24, 0x35, 0xbb, 0xb3, 0xd8,
-	0x5c, 0x93, 0xc0, 0x07, 0xce, 0x69, 0x6c, 0x6e, 0x28, 0xf5, 0x44, 0x08, 0x93, 0x35, 0xaa, 0xe6,
-	0xd0, 0x77, 0x60, 0x6d, 0x12, 0x04, 0x9e, 0xd0, 0x5c, 0x96, 0x9a, 0x2f, 0xcf, 0x62, 0x73, 0xf5,
-	0xdd, 0x20, 0xf0, 0xa4, 0x62, 0x43, 0x29, 0x6a, 0x11, 0x4c, 0x56, 0x27, 0x72, 0x06, 0x5d, 0x83,
-	0xcb, 0xc1, 0x53, 0x9f, 0x85, 0x9d, 0x95, 0x5d, 0xe3, 0x46, 0xd5, 0xda, 0x3c, 0x8d, 0xcd, 0x75,
-	0x25, 0x2a, 0x87, 0x31, 0x51, 0xd3, 0xe8, 0xe7, 0x50, 0xa5, 0xe3, 0x60, 0xea, 0x73, 0xdb, 0xf5,
-	0x3b, 0x97, 0x77, 0x8d, 0x1b, 0xb5, 0xbd, 0x97, 0x7a, 0xca, 0x2f, 0x3d, 0xe1, 0x97, 0xc4, 0xc7,
-	0xbd, 0x3b, 0x81, 0xeb, 0x5b, 0x77, 0x3e, 0x8b, 0xcd, 0x4b, 0xa7, 0xb1, 0xb9, 0xa9, 0xcd, 0x4d,
-	0x34, 0xf1, 0x7f, 0x63, 0xf3, 0xfa, 0x91, 0xcb, 0x9f, 0x4c, 0x87, 0xbd, 0x51, 0x30, 0xee, 0x6b,
-	0xc7, 0xaa, 0x3f, 0x37, 0x23, 0xe7, 0x83, 0x3e, 0x3f, 0x99, 0xb0, 0x48, 0x82, 0x90, 0x8a, 0x52,
-	0x3b, 0xf0, 0xd1, 0x4f, 0x61, 0x3d, 0x71, 0x98, 0xd8, 0x9b, 0xce, 0xaa, 0xe4, 0xdf, 0xee, 0xa9,
-	0x8d, 0xeb, 0x25, 0x1b, 0xd7, 0x7b, 0x9c, 0x6c, 0x9c, 0x65, 0x6a, 0x03, 0x5a, 0x45, 0x77, 0x0b,
-	0x6d, 0xfc, 0xe9, 0xbf, 0x4d, 0x83, 0xd4, 0xf4, 0x90, 0x50, 0x41, 0xc7, 0xd0, 0x9c, 0x4e, 0x1c,
-	0xca, 0x99, 0x63, 0x67, 0x8b, 0x5c, 0x93, 0x0e, 0xf9, 0xbe, 0x00, 0xfa, 0x57, 0x6c, 0x5e, 0x7b,
-	0x01, 0xab, 0x0f, 0x7c, 0x7e, 0x1a, 0x9b, 0x1d, 0x45, 0x39, 0x07, 0x88, 0xc9, 0x86, 0x1e, 0x1b,
-	0x24, 0xeb, 0xfa, 0x05, 0xb4, 0xe8, 0x31, 0x75, 0x3d, 0x3a, 0xf4, 0x98, 0xcd, 0x03, 0x7b, 0x18,
-	0x84, 0x61, 0xf0, 0xb4, 0x53, 0x91, 0xcc, 0xef, 0x94, 0x66, 0xde, 0xd6, 0xde, 0x9e, 0x87, 0xc4,
-	0xa4, 0x99, 0x8e, 0x3e, 0x0e, 0x2c, 0x39, 0x86, 0x7e, 0x06, 0x28, 0x64, 0x4f, 0x69, 0xe8, 0xd8,
-	0x83, 0xd1, 0x68, 0x3a, 0x9e, 0x7a, 0xc2, 0xb6, 0x4e, 0x55, 0x92, 0xbf, 0x5d, 0x9a, 0xfc, 0x25,
-	0x45, 0xae, 0x11, 0x69, 0x86, 0x88, 0x49, 0x53, 0x0d, 0xe6, 0x58, 0xf0, 0x5f, 0x2b, 0x50, 0x53,
-	0x66, 0xa8, 0xa0, 0x79, 0x13, 0xd6, 0x95, 0xa5, 0x85, 0xb0, 0xb9, 0x9a, 0x86, 0x8d, 0xde, 0xc7,
-	0xbc, 0x0c, 0x26, 0xb5, 0xf4, 0xf3, 0xc0, 0x41, 0x83, 0x42, 0xd8, 0xa9, 0xe0, 0xc1, 0xb3, 0xd8,
-	0x94, 0x91, 0x29, 0x44, 0xbe, 0x38, 0xfa, 0xee, 0xc2, 0xa6, 0x1b, 0xd9, 0x11, 0x97, 0xbe, 0xd3,
-	0x7b, 0x21, 0x62, 0xa9, 0x62, 0xed, 0x9c, 0xc6, 0xe6, 0x15, 0xa5, 0x7b, 0x56, 0x02, 0x93, 0x86,
-	0x1b, 0x3d, 0x92, 0x23, 0xda, 0xaf, 0x22, 0x12, 0xa9, 0x1b, 0x0a, 0x33, 0x56, 0x72, 0x91, 0x48,
-	0xdd, 0x50, 0xda, 0x90, 0x44, 0xa2, 0x12, 0x11, 0x91, 0x28, 0x66, 0x9c, 0xaf, 0x36, 0xc2, 0x3e,
-	0x06, 0xd0, 0x10, 0xc1, 0x94, 0xeb, 0xf8, 0x7a, 0x0e, 0xfb, 0xbe, 0x66, 0x6f, 0x16, 0xd8, 0x83,
-	0x29, 0x2f, 0x45, 0xaf, 0xd7, 0xfb, 0x70, 0xca, 0xd1, 0xfb, 0xb0, 0x39, 0x0c, 0x5d, 0xe7, 0x48,
-	0x04, 0x4c, 0x92, 0x00, 0xd7, 0xa4, 0xf3, 0x6e, 0xce, 0x62, 0xb3, 0x61, 0xa9, 0x39, 0x95, 0x07,
-	0xf7, 0xb3, 0xcd, 0x38, 0xab, 0x83, 0x49, 0x63, 0x98, 0x17, 0x75, 0x90, 0x03, 0x8d, 0xec, 0xd0,
-	0xc8, 0xe4, 0x51, 0xf9, 0xc2, 0xe4, 0xf1, 0x8a, 0x5e, 0xdd, 0xd6, 0xd9, 0x43, 0x97, 0xa5, 0x8f,
-	0x7a, 0x3a, 0x28, 0x13, 0xc8, 0x09, 0xa0, 0xc2, 0xa1, 0xb0, 0x43, 0xca, 0xd9, 0x39, 0x42, 0x69,
-	0x9f, 0x8d, 0xb2, 0x50, 0x9a, 0x47, 0xc4, 0x64, 0x33, 0xca, 0x9d, 0x34, 0x42, 0xb9, 0xa4, 0x3e,
-	0x93, 0x6a, 0xc4, 0x0e, 0xc2, 0xc5, 0xa2, 0x78, 0x1e, 0x11, 0x93, 0xcd, 0x42, 0xf6, 0x12, 0x9b,
-	0xf6, 0x89, 0x01, 0x6d, 0xd7, 0xe7, 0x2c, 0x64, 0x11, 0x2f, 0xe4, 0x90, 0x9a, 0x64, 0xbf, 0x5f,
-	0x9a, 0x7d, 0x47, 0x87, 0x58, 0x82, 0x59, 0xc8, 0x22, 0xad, 0x64, 0x38, 0x9f, 0x47, 0x7e, 0xbf,
-	0x02, 0x2b, 0xa2, 0xc6, 0xe5, 0xcb, 0x9f, 0x51, 0xa2, 0xfc, 0xdd, 0x85, 0xda, 0x38, 0x70, 0xa6,
-	0x1e, 0xb3, 0x7d, 0x3a, 0x66, 0x32, 0x6d, 0x54, 0xad, 0x6f, 0xcc, 0x62, 0x13, 0xee, 0xcb, 0xe1,
-	0x07, 0x74, 0xcc, 0x4e, 0x63, 0x13, 0x29, 0xf5, 0x9c, 0x28, 0x26, 0x30, 0x4e, 0x25, 0xd0, 0xdb,
-	0x50, 0x1f, 0x53, 0xd7, 0xcf, 0xce, 0xae, 0x2a, 0xc1, 0xd7, 0x67, 0xb1, 0x59, 0xbb, 0x4f, 0x5d,
-	0x3f, 0x2b, 0xe0, 0x6d, 0x8d, 0x94, 0x97, 0xc6, 0xa4, 0x36, 0xce, 0x84, 0xd0, 0x18, 0xbe, 0x76,
-	0xe8, 0x86, 0x11, 0xb7, 0xe7, 0x22, 0x42, 0xa5, 0x93, 0x57, 0x67, 0xb1, 0xd9, 0xba, 0x27, 0x24,
-	0x0a, 0x61, 0x21, 0xd0, 0xaf, 0x2a, 0xf4, 0xc5, 0xea, 0x98, 0xb4, 0x0e, 0xe7, 0xb5, 0xd0, 0x87,
-	0x70, 0x25, 0x62, 0xa3, 0xc0, 0x77, 0xe6, 0xf9, 0x2e, 0x4b, 0xbe, 0xdb, 0xb3, 0xd8, 0x6c, 0x3f,
-	0x92, 0x22, 0x73, 0x84, 0x5d, 0x7d, 0x54, 0x17, 0x03, 0x60, 0xd2, 0x8e, 0x16, 0xe8, 0xa1, 0x09,
-	0x80, 0x12, 0x71, 0x28, 0xa7, 0x9d, 0xd5, 0xdd, 0xe5, 0x1b, 0xb5, 0xbd, 0x6f, 0xf6, 0x16, 0x74,
-	0x6c, 0x3d, 0xa9, 0xb1, 0x4f, 0x39, 0x15, 0x3b, 0x79, 0x9f, 0x4e, 0x26, 0xae, 0x7f, 0x64, 0x5d,
-	0x13, 0x07, 0x4b, 0xa4, 0xf6, 0x74, 0x36, 0x97, 0x8a, 0x52, 0x5c, 0x4c, 0xaa, 0x34, 0x99, 0xc7,
-	0xbf, 0x31, 0xa0, 0xbd, 0x08, 0xab, 0xd0, 0x71, 0x19, 0xe5, 0x3a, 0xae, 0x6f, 0x03, 0xb8, 0x51,
-	0xb2, 0x66, 0x79, 0x74, 0x2a, 0xd6, 0x56, 0x66, 0x49, 0x36, 0x87, 0x49, 0xd5, 0x8d, 0xb4, 0x0b,
-	0xf0, 0xef, 0x96, 0xa0, 0x7e, 0xf7, 0x23, 0xce, 0x7c, 0x87, 0x39, 0xb6, 0x28, 0x0a, 0xa8, 0x01,
-	0x4b, 0x09, 0x39, 0x59, 0x72, 0x1d, 0xd4, 0x4b, 0x4d, 0xf2, 0x75, 0x1d, 0x6b, 0xcd, 0xd9, 0xe1,
-	0xa7, 0x76, 0xf8, 0xe8, 0x16, 0xa8, 0x85, 0xca, 0xc0, 0x57, 0x07, 0xaf, 0x9d, 0xab, 0x0c, 0xc9,
-	0x14, 0x26, 0x0a, 0x56, 0x44, 0xee, 0xeb, 0x50, 0x77, 0x23, 0x5b, 0x06, 0x94, 0x2d, 0x22, 0x41,
-	0x9e, 0xac, 0x8a, 0xd5, 0xc9, 0x0e, 0x68, 0x61, 0x1a, 0x93, 0x9a, 0x1b, 0x1d, 0x88, 0x4f, 0x19,
-	0x6b, 0x3f, 0x84, 0x66, 0x8a, 0x6a, 0x27, 0x51, 0xa7, 0xce, 0x4a, 0x4f, 0x64, 0xeb, 0x81, 0xa6,
-	0x49, 0xa3, 0xaf, 0x73, 0xc6, 0x14, 0x3b, 0x8d, 0xc3, 0x06, 0x2d, 0xc8, 0xe2, 0x3f, 0x1b, 0x80,
-	0xa4, 0xfa, 0xe3, 0x40, 0xf8, 0xe6, 0x4b, 0xd8, 0xa5, 0x5c, 0x62, 0x58, 0x2a, 0x91, 0x18, 0x72,
-	0x45, 0x7c, 0x79, 0x77, 0xb9, 0x50, 0xc4, 0x9d, 0xff, 0x5f, 0xc4, 0xf1, 0x31, 0x34, 0x7f, 0x10,
-	0xb1, 0x50, 0xf4, 0x1c, 0x07, 0x4e, 0x62, 0x7d, 0xda, 0x63, 0x1b, 0xcf, 0xef, 0xb1, 0x5f, 0x83,
-	0x8a, 0x38, 0xfc, 0xb6, 0xeb, 0x44, 0x9d, 0x25, 0x49, 0x2a, 0x57, 0xa9, 0xc0, 0xa2, 0x6c, 0x95,
-	0x89, 0x10, 0x26, 0x6b, 0x9e, 0x9a, 0xc3, 0x7f, 0x32, 0x60, 0x47, 0xc9, 0x59, 0x27, 0x0f, 0x05,
-	0xd8, 0xc0, 0x77, 0xf2, 0xc7, 0xfc, 0x45, 0x4d, 0x38, 0xa7, 0xb7, 0x5e, 0x85, 0xc4, 0x12, 0xed,
-	0xad, 0x17, 0x36, 0xfc, 0x2f, 0x06, 0x5c, 0x55, 0xd5, 0xec, 0x2b, 0x32, 0xfd, 0x4d, 0xa8, 0x0e,
-	0x35, 0x7f, 0x62, 0xbc, 0x6c, 0x1b, 0x13, 0xa3, 0xa2, 0x2c, 0xa2, 0x75, 0x25, 0x96, 0x0b, 0xc8,
-	0x94, 0xf0, 0x27, 0x06, 0xb4, 0xc4, 0xa6, 0x27, 0x1a, 0x65, 0x0d, 0x1f, 0x00, 0x64, 0xc8, 0x7a,
-	0xe3, 0x4b, 0x9a, 0xf0, 0x07, 0x03, 0xae, 0x28, 0x6f, 0x27, 0xdd, 0x7d, 0x66, 0xc6, 0x60, 0xc1,
-	0x7d, 0xb4, 0x64, 0x63, 0x7c, 0x70, 0xa6, 0x3b, 0x57, 0x36, 0x5e, 0x13, 0xd5, 0xcd, 0x4a, 0x5b,
-	0xf0, 0x17, 0x6a, 0xd3, 0xf1, 0x6f, 0xd7, 0x00, 0x64, 0xd8, 0x3e, 0xe2, 0x94, 0x47, 0xe7, 0x2d,
-	0xdb, 0x17, 0xb8, 0x27, 0xfb, 0xd0, 0xe0, 0x01, 0xa7, 0x9e, 0xee, 0xab, 0x98, 0xaa, 0xd5, 0x55,
-	0xeb, 0x7b, 0xa5, 0xbb, 0x15, 0xdd, 0x1e, 0x16, 0xd1, 0x30, 0xa9, 0xcb, 0x01, 0x4b, 0x7f, 0xa3,
-	0x5f, 0x19, 0xb0, 0xa5, 0x44, 0x0a, 0xfd, 0x1c, 0x73, 0xf4, 0x8d, 0xfb, 0x41, 0x69, 0xde, 0x97,
-	0xf3, 0xbc, 0x67, 0x40, 0x31, 0x69, 0xc9, 0xf1, 0xfc, 0x85, 0x84, 0x39, 0x68, 0x08, 0xa0, 0xc4,
-	0xc5, 0x9e, 0xca, 0x54, 0x5d, 0x55, 0x37, 0x88, 0x52, 0xc4, 0xcd, 0x3c, 0xb1, 0x40, 0xc2, 0xa4,
-	0x2a, 0x3f, 0xc4, 0x49, 0x42, 0x3f, 0xd1, 0xd9, 0x8b, 0x4e, 0x42, 0x79, 0x81, 0xa8, 0x5a, 0x83,
-	0xd2, 0x9d, 0x6f, 0x3e, 0x4f, 0xd0, 0x49, 0xa8, 0xf3, 0xc4, 0x60, 0x12, 0x8a, 0x15, 0xe8, 0xb3,
-	0x2f, 0xf0, 0xd7, 0x4a, 0xaf, 0x40, 0xe1, 0x17, 0xa3, 0x48, 0x32, 0xe8, 0x28, 0x12, 0x1c, 0xc7,
-	0xd0, 0x2c, 0xf6, 0xdc, 0x82, 0xaa, 0x52, 0xfa, 0x19, 0x40, 0x51, 0x75, 0x16, 0x35, 0xf1, 0x92,
-	0x71, 0x23, 0xdf, 0xc3, 0x0b, 0xde, 0xa7, 0xd0, 0x9c, 0x72, 0xd7, 0x73, 0x23, 0xca, 0xdd, 0xc0,
-	0x17, 0x9d, 0xbe, 0x1b, 0xe8, 0xcb, 0xc3, 0xb9, 0x79, 0xe7, 0x00, 0x45, 0x03, 0x9f, 0x8d, 0x11,
-	0x39, 0xf4, 0x0f, 0x80, 0x0d, 0x19, 0x33, 0xe2, 0x26, 0x11, 0xa9, 0x88, 0xbc, 0x40, 0xa9, 0xb5,
-	0xa1, 0x3a, 0xb5, 0x83, 0x09, 0x77, 0xc7, 0xd4, 0xd3, 0xad, 0xb4, 0x55, 0xda, 0x7e, 0xdd, 0xb6,
-	0xa4, 0x40, 0x98, 0x54, 0xa6, 0x0f, 0xd5, 0x4f, 0xf4, 0x1e, 0xac, 0x88, 0xbb, 0xa8, 0x8e, 0xd8,
-	0xef, 0x96, 0xc6, 0xae, 0xe9, 0xed, 0xa7, 0x11, 0xc3, 0x44, 0x42, 0xa1, 0xf7, 0x61, 0x35, 0xf2,
-	0x82, 0x09, 0xbb, 0xa5, 0xc3, 0xf1, 0x8d, 0xd2, 0xa0, 0x75, 0xbd, 0xd1, 0x12, 0x05, 0x13, 0x0d,
-	0x97, 0x02, 0xef, 0xe9, 0x70, 0xbb, 0x18, 0xf0, 0x5e, 0x02, 0xbc, 0x87, 0xde, 0x83, 0x36, 0xf3,
-	0xe5, 0xa1, 0x2a, 0xbe, 0x54, 0xac, 0xca, 0x16, 0xce, 0xcc, 0xae, 0x51, 0x8b, 0xa4, 0x30, 0x41,
-	0x6a, 0xb8, 0xf0, 0x62, 0xc1, 0xa0, 0x96, 0x48, 0x09, 0xf7, 0xaa, 0xe8, 0xda, 0x2f, 0x6d, 0x30,
-	0x2a, 0x1e, 0x79, 0xe9, 0x65, 0xd0, 0x87, 0x5d, 0xf8, 0xfa, 0x03, 0xa8, 0xeb, 0x39, 0xed, 0x72,
-	0x15, 0x5b, 0xf7, 0x4a, 0x13, 0xb5, 0x0b, 0x44, 0x89, 0xe7, 0xd7, 0xd5, 0xf7, 0x23, 0xe5, 0xff,
-	0x33, 0x64, 0x7b, 0x3a, 0xa0, 0xbe, 0x14, 0xb2, 0xbd, 0x22, 0xd9, 0x1e, 0x7a, 0x00, 0xcb, 0x1e,
-	0x3f, 0xd6, 0xb7, 0xee, 0xd7, 0x4b, 0x53, 0x80, 0x4e, 0x7b, 0xfc, 0x18, 0x13, 0x01, 0x84, 0x7e,
-	0x6d, 0xc0, 0x96, 0xe7, 0x7e, 0x38, 0x75, 0x1d, 0x15, 0xc1, 0xfc, 0x49, 0xc8, 0xa2, 0x27, 0x81,
-	0x97, 0x5c, 0xad, 0x1f, 0x94, 0xa6, 0xd0, 0x45, 0x63, 0x21, 0x28, 0x26, 0xed, 0xdc, 0xf8, 0xe3,
-	0x64, 0x18, 0xfd, 0x12, 0x5a, 0x79, 0xf9, 0x09, 0xf3, 0xa9, 0xc7, 0x4f, 0x3a, 0xeb, 0xa5, 0x9f,
-	0x27, 0x95, 0x09, 0xdb, 0xf3, 0x26, 0x68, 0x48, 0x4c, 0x50, 0x6e, 0xf4, 0x5d, 0x35, 0x28, 0x2a,
-	0x75, 0xc8, 0x22, 0x16, 0x1e, 0x33, 0xfb, 0x90, 0x8e, 0x78, 0x10, 0x76, 0xea, 0xa5, 0x2b, 0xb5,
-	0x62, 0xde, 0x4a, 0xde, 0x26, 0xf3, 0x68, 0x98, 0xd4, 0xf5, 0xc0, 0x3d, 0xf9, 0x8d, 0xde, 0x00,
-	0x18, 0x65, 0x77, 0xdf, 0x86, 0xcc, 0x7d, 0xaf, 0xcc, 0x62, 0xb3, 0x72, 0x27, 0x4b, 0x7e, 0xba,
-	0x80, 0x8c, 0x72, 0x57, 0xdc, 0xca, 0x48, 0x4f, 0xe3, 0xb7, 0xa0, 0x26, 0x2a, 0x61, 0xee, 0xd2,
-	0x92, 0xb6, 0xf3, 0x46, 0xb9, 0xae, 0x98, 0x40, 0x5d, 0x85, 0x66, 0xae, 0x89, 0xcb, 0xf5, 0x88,
-	0xc6, 0x79, 0x7a, 0xc4, 0x10, 0x5a, 0xf9, 0xa0, 0x4f, 0x90, 0x7f, 0x7c, 0xb6, 0xe8, 0x65, 0x04,
-	0xfd, 0x59, 0x6c, 0x6e, 0xe4, 0x75, 0x14, 0xcd, 0xc2, 0xca, 0x26, 0xd9, 0x0a, 0x95, 0x4d, 0x70,
-	0xfe, 0xcd, 0x80, 0xba, 0x7a, 0x48, 0xb1, 0xa8, 0x47, 0xfd, 0x11, 0x3b, 0x6f, 0xc3, 0xf7, 0x31,
-	0xb4, 0xf5, 0xe3, 0xcb, 0x50, 0x01, 0x89, 0xb4, 0xc6, 0x55, 0xb7, 0x5c, 0xdb, 0xbb, 0xbe, 0xf0,
-	0xed, 0xa0, 0x40, 0x2c, 0x8b, 0x9b, 0xf5, 0x75, 0xfd, 0xb2, 0xb7, 0x53, 0x78, 0xcf, 0x29, 0x40,
-	0x62, 0x82, 0xc6, 0x73, 0x8a, 0xf8, 0xef, 0x06, 0xa0, 0x79, 0xbc, 0x8b, 0x14, 0xcb, 0x63, 0x58,
-	0xd3, 0xbc, 0xb2, 0x54, 0x3e, 0xf7, 0xb9, 0x75, 0xa0, 0xcd, 0x6e, 0x24, 0xf5, 0x4b, 0xea, 0x95,
-	0x7a, 0x6b, 0x4d, 0xc8, 0xac, 0xb7, 0x3e, 0x9b, 0x75, 0x8d, 0xcf, 0x67, 0x5d, 0xe3, 0x3f, 0xb3,
-	0xae, 0xf1, 0xe9, 0xb3, 0xee, 0xa5, 0xcf, 0x9f, 0x75, 0x2f, 0xfd, 0xf3, 0x59, 0xf7, 0xd2, 0x8f,
-	0x7a, 0x05, 0x2c, 0xe1, 0xcf, 0x9b, 0xc1, 0xe1, 0xa1, 0x3b, 0x72, 0xa9, 0xa7, 0xbf, 0xfb, 0xfa,
-	0xff, 0x6d, 0x12, 0x77, 0xb8, 0x2a, 0x9f, 0x4e, 0xbf, 0xf5, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x60, 0xb6, 0x41, 0xf2, 0x8b, 0x1b, 0x00, 0x00,
+	0x15, 0xf7, 0x4a, 0xb2, 0x44, 0x3e, 0x8a, 0x92, 0x38, 0xa4, 0x6a, 0x46, 0x8e, 0xb9, 0xca, 0xb4,
+	0xb0, 0xdd, 0x43, 0x48, 0x58, 0x6d, 0x81, 0xc4, 0x48, 0x91, 0x70, 0x2d, 0xbb, 0x51, 0x13, 0xcb,
+	0xc9, 0xd8, 0x45, 0xd1, 0x0f, 0x74, 0x31, 0xe4, 0x8e, 0xe4, 0x45, 0x96, 0xbb, 0xcc, 0xee, 0x90,
+	0x8e, 0xfa, 0x11, 0x04, 0xed, 0xa1, 0x40, 0x4e, 0xb9, 0xe7, 0x5c, 0xf4, 0xda, 0x53, 0x6f, 0x05,
+	0x7a, 0x6a, 0x73, 0xe8, 0x21, 0xc7, 0xa2, 0x87, 0x6d, 0x41, 0xff, 0x07, 0x3a, 0xf6, 0x54, 0xcc,
+	0xc7, 0x7e, 0x89, 0xac, 0xe3, 0x95, 0x02, 0xf8, 0x24, 0xee, 0xcc, 0x7b, 0xbf, 0xdf, 0xdb, 0x37,
+	0xef, 0x6b, 0x56, 0xd0, 0x19, 0x06, 0x23, 0x87, 0x7d, 0xd4, 0xf3, 0x98, 0xef, 0xf4, 0xa6, 0xb7,
+	0x06, 0x8c, 0xd3, 0x5b, 0xf2, 0xa1, 0x3b, 0x0e, 0x03, 0x1e, 0xa0, 0xa6, 0xda, 0xef, 0xca, 0x25,
+	0xbd, 0xbf, 0xd3, 0x3a, 0x0e, 0x8e, 0x03, 0xb9, 0xdf, 0x13, 0xbf, 0x94, 0xe8, 0x8e, 0x79, 0x1c,
+	0x04, 0xc7, 0x1e, 0xeb, 0xc9, 0xa7, 0xc1, 0xe4, 0xa8, 0xc7, 0xdd, 0x11, 0x8b, 0x38, 0x1d, 0x8d,
+	0xb5, 0x40, 0x67, 0x18, 0x44, 0xa3, 0x20, 0xea, 0x0d, 0x68, 0xc4, 0x52, 0xae, 0x61, 0xe0, 0xfa,
+	0x6a, 0x1f, 0xff, 0x69, 0x15, 0xaa, 0xef, 0x32, 0xdf, 0xe9, 0x47, 0x11, 0xe3, 0xe8, 0x36, 0x80,
+	0x20, 0x75, 0xfd, 0x63, 0xdb, 0x75, 0xda, 0xc6, 0xae, 0x71, 0x73, 0xc5, 0xba, 0x3a, 0x8b, 0xcd,
+	0xa5, 0x83, 0xfd, 0xd3, 0xd8, 0x6c, 0x9c, 0xd0, 0x91, 0x77, 0x1b, 0x67, 0x12, 0x98, 0x54, 0xf5,
+	0xc3, 0x81, 0x83, 0x5e, 0x87, 0x0a, 0x15, 0x20, 0x42, 0x73, 0x49, 0x6a, 0x76, 0x66, 0xb1, 0xb9,
+	0x26, 0x81, 0x0f, 0x9c, 0xd3, 0xd8, 0xdc, 0x54, 0xea, 0x89, 0x10, 0x26, 0x6b, 0x54, 0xed, 0xa1,
+	0xef, 0xc1, 0xda, 0x38, 0x08, 0x3c, 0xa1, 0xb9, 0x2c, 0x35, 0x5f, 0x9e, 0xc5, 0xe6, 0xea, 0x7b,
+	0x41, 0xe0, 0x49, 0xc5, 0x0d, 0xa5, 0xa8, 0x45, 0x30, 0x59, 0x1d, 0xcb, 0x1d, 0x74, 0x1d, 0x2e,
+	0x07, 0x4f, 0x7c, 0x16, 0xb6, 0x57, 0x76, 0x8d, 0x9b, 0x55, 0x6b, 0xeb, 0x34, 0x36, 0xd7, 0x95,
+	0xa8, 0x5c, 0xc6, 0x44, 0x6d, 0xa3, 0x5f, 0x41, 0x95, 0x8e, 0x82, 0x89, 0xcf, 0x6d, 0xd7, 0x6f,
+	0x5f, 0xde, 0x35, 0x6e, 0xd6, 0xf6, 0x5e, 0xea, 0x2a, 0xbf, 0x74, 0x85, 0x5f, 0x12, 0x1f, 0x77,
+	0xef, 0x04, 0xae, 0x6f, 0xdd, 0xf9, 0x22, 0x36, 0x2f, 0x9d, 0xc6, 0xe6, 0x96, 0x36, 0x37, 0xd1,
+	0xc4, 0xff, 0x8d, 0xcd, 0x1b, 0xc7, 0x2e, 0x7f, 0x3c, 0x19, 0x74, 0x87, 0xc1, 0xa8, 0xa7, 0x1d,
+	0xab, 0xfe, 0xbc, 0x1a, 0x39, 0x1f, 0xf4, 0xf8, 0xc9, 0x98, 0x45, 0x12, 0x84, 0x54, 0x94, 0xda,
+	0x81, 0x8f, 0x7e, 0x01, 0xeb, 0x89, 0xc3, 0xc4, 0xd9, 0xb4, 0x57, 0x25, 0xff, 0x4e, 0x57, 0x1d,
+	0x5c, 0x37, 0x39, 0xb8, 0xee, 0xa3, 0xe4, 0xe0, 0x2c, 0x53, 0x1b, 0xd0, 0x2c, 0xba, 0x5b, 0x68,
+	0xe3, 0xcf, 0xfe, 0x6d, 0x1a, 0xa4, 0xa6, 0x97, 0x84, 0x0a, 0x9a, 0x42, 0x63, 0x32, 0x76, 0x28,
+	0x67, 0x8e, 0x9d, 0xbd, 0xe4, 0x9a, 0x74, 0xc8, 0x0f, 0x05, 0xd0, 0xbf, 0x62, 0xf3, 0xfa, 0x73,
+	0x58, 0x7d, 0xe0, 0xf3, 0xd3, 0xd8, 0x6c, 0x2b, 0xca, 0x39, 0x40, 0x4c, 0x36, 0xf5, 0x5a, 0x3f,
+	0x79, 0xaf, 0x5f, 0x43, 0x93, 0x4e, 0xa9, 0xeb, 0xd1, 0x81, 0xc7, 0x6c, 0x1e, 0xd8, 0x83, 0x20,
+	0x0c, 0x83, 0x27, 0xed, 0x8a, 0x64, 0x7e, 0xb7, 0x34, 0xf3, 0x8e, 0xf6, 0xf6, 0x3c, 0x24, 0x26,
+	0x8d, 0x74, 0xf5, 0x51, 0x60, 0xc9, 0x35, 0xf4, 0x4b, 0x40, 0x21, 0x7b, 0x42, 0x43, 0xc7, 0xee,
+	0x0f, 0x87, 0x93, 0xd1, 0xc4, 0x13, 0xb6, 0xb5, 0xab, 0x92, 0xfc, 0x9d, 0xd2, 0xe4, 0x2f, 0x29,
+	0x72, 0x8d, 0x48, 0x33, 0x44, 0x4c, 0x1a, 0x6a, 0x31, 0xc7, 0x82, 0x3f, 0xad, 0x42, 0x4d, 0x99,
+	0xa1, 0x92, 0xe6, 0x2d, 0x58, 0x57, 0x96, 0x16, 0xd2, 0xe6, 0x5a, 0x9a, 0x36, 0xfa, 0x1c, 0xf3,
+	0x32, 0x98, 0xd4, 0xd2, 0xc7, 0x03, 0x07, 0xf5, 0x0b, 0x69, 0xa7, 0x92, 0x07, 0xcf, 0x62, 0x53,
+	0x66, 0xa6, 0x10, 0xf9, 0xea, 0xec, 0xbb, 0x0b, 0x5b, 0x6e, 0x64, 0x47, 0x5c, 0xfa, 0x4e, 0x9f,
+	0x85, 0xc8, 0xa5, 0x8a, 0x75, 0xf5, 0x34, 0x36, 0xaf, 0x28, 0xdd, 0xb3, 0x12, 0x98, 0x6c, 0xb8,
+	0xd1, 0x43, 0xb9, 0xa2, 0xfd, 0x2a, 0x32, 0x91, 0xba, 0xa1, 0x30, 0x63, 0x25, 0x97, 0x89, 0xd4,
+	0x0d, 0xa5, 0x0d, 0x49, 0x26, 0x2a, 0x11, 0x91, 0x89, 0x62, 0xc7, 0x79, 0xb1, 0x19, 0xf6, 0x31,
+	0x80, 0x86, 0x08, 0x26, 0x5c, 0xe7, 0xd7, 0x33, 0xd8, 0xf7, 0x35, 0x7b, 0xa3, 0xc0, 0x1e, 0x4c,
+	0x78, 0x29, 0x7a, 0xfd, 0xbe, 0x0f, 0x26, 0x1c, 0x7d, 0x6e, 0x40, 0x6b, 0x10, 0xba, 0xce, 0xb1,
+	0xc8, 0x18, 0x59, 0xdc, 0xd4, 0x9e, 0xcc, 0xc2, 0x67, 0x9a, 0x72, 0xa8, 0x4d, 0xb9, 0xaa, 0x23,
+	0x64, 0x01, 0x48, 0x29, 0xa3, 0x90, 0x46, 0x90, 0x71, 0xa9, 0x32, 0x15, 0x39, 0xb0, 0x91, 0x45,
+	0x9e, 0xac, 0x40, 0x95, 0xaf, 0xac, 0x40, 0xaf, 0x68, 0xbb, 0xb6, 0xcf, 0x46, 0x6e, 0x56, 0x83,
+	0xea, 0xe9, 0xa2, 0xac, 0x42, 0x27, 0x80, 0x0a, 0x91, 0x65, 0x87, 0x94, 0xb3, 0x73, 0xe4, 0xe3,
+	0x3e, 0x1b, 0x66, 0xf9, 0x38, 0x8f, 0x88, 0xc9, 0x56, 0x94, 0x0b, 0x57, 0x42, 0xb9, 0xa4, 0x3e,
+	0x53, 0xaf, 0x44, 0x18, 0xc0, 0xc5, 0x4a, 0xc1, 0x3c, 0x22, 0x26, 0x5b, 0x85, 0x12, 0x28, 0x4e,
+	0xfe, 0x13, 0x03, 0x5a, 0xae, 0xcf, 0x59, 0xc8, 0x22, 0x5e, 0x28, 0x44, 0x35, 0xc9, 0x7e, 0xbf,
+	0x34, 0xbb, 0x0e, 0x84, 0x14, 0xb3, 0x50, 0x8a, 0x9a, 0xc9, 0x72, 0xbe, 0x18, 0xfd, 0x61, 0x05,
+	0x56, 0x44, 0xa3, 0xcc, 0xf7, 0x50, 0xa3, 0x44, 0x0f, 0xbd, 0x0b, 0xb5, 0x51, 0xe0, 0x4c, 0x3c,
+	0x66, 0xfb, 0x74, 0xc4, 0x64, 0xed, 0xa9, 0x5a, 0xdf, 0x9a, 0xc5, 0x26, 0xdc, 0x97, 0xcb, 0x87,
+	0x74, 0xc4, 0x4e, 0x63, 0x13, 0x29, 0xf5, 0x9c, 0x28, 0x26, 0x30, 0x4a, 0x25, 0xd0, 0x3b, 0x50,
+	0x1f, 0x51, 0xd7, 0xb7, 0xd3, 0x09, 0x40, 0xf5, 0xf1, 0x1b, 0xb3, 0xd8, 0xac, 0xdd, 0xa7, 0xae,
+	0x9f, 0x4d, 0x01, 0x2d, 0x8d, 0x94, 0x97, 0xc6, 0xa4, 0x36, 0xca, 0x84, 0xd0, 0x08, 0xbe, 0x71,
+	0xe4, 0x86, 0x11, 0xb7, 0x8b, 0x09, 0x91, 0xd6, 0xa4, 0xd7, 0x66, 0xb1, 0xd9, 0xbc, 0x27, 0x24,
+	0xac, 0x5c, 0xbc, 0x4b, 0xf4, 0x6b, 0x0a, 0x7d, 0xb1, 0x3a, 0x26, 0xcd, 0xa3, 0x79, 0x2d, 0xf4,
+	0x21, 0x5c, 0x89, 0xd8, 0x30, 0xf0, 0x9d, 0x79, 0xbe, 0xcb, 0x92, 0xef, 0xf6, 0x2c, 0x36, 0x5b,
+	0x0f, 0xa5, 0xc8, 0x1c, 0x61, 0x47, 0x87, 0xea, 0x62, 0x00, 0x4c, 0x5a, 0xd1, 0x02, 0x3d, 0x34,
+	0x06, 0x50, 0x22, 0x0e, 0xe5, 0xb4, 0xbd, 0xba, 0xbb, 0x7c, 0xb3, 0xb6, 0xf7, 0xed, 0xee, 0x82,
+	0xb1, 0xaf, 0x2b, 0x35, 0xf6, 0x29, 0xa7, 0xe2, 0x24, 0xef, 0xd3, 0xf1, 0xd8, 0xf5, 0x8f, 0xad,
+	0xeb, 0x22, 0xb0, 0x44, 0x7f, 0x48, 0x77, 0x73, 0xf5, 0x2c, 0xc5, 0xc5, 0xa4, 0x4a, 0x93, 0x7d,
+	0xfc, 0x7b, 0x03, 0x5a, 0x8b, 0xb0, 0x0a, 0x63, 0x9b, 0x51, 0x6e, 0x6c, 0xfb, 0x2e, 0x80, 0x1b,
+	0x25, 0xef, 0x2c, 0x43, 0xa7, 0x62, 0x6d, 0x67, 0x96, 0x64, 0x7b, 0x98, 0x54, 0xdd, 0x48, 0xbb,
+	0x00, 0x7f, 0xbe, 0x04, 0xf5, 0xbb, 0x1f, 0x71, 0xe6, 0x3b, 0xcc, 0xb1, 0x45, 0x67, 0x41, 0x1b,
+	0xb0, 0x94, 0x90, 0x93, 0x25, 0xd7, 0x41, 0xdd, 0xd4, 0x24, 0x5f, 0x37, 0xc3, 0xe6, 0x9c, 0x1d,
+	0x7e, 0x6a, 0x87, 0x8f, 0x6e, 0x81, 0x7a, 0x51, 0x99, 0xf8, 0x2a, 0xf0, 0x5a, 0xb9, 0xf6, 0x92,
+	0x6c, 0x61, 0xa2, 0x60, 0x45, 0xe6, 0xbe, 0x01, 0x75, 0x37, 0xb2, 0x65, 0x42, 0xd9, 0x22, 0x13,
+	0x64, 0x64, 0x55, 0xac, 0x76, 0x16, 0xa0, 0x85, 0x6d, 0x4c, 0x6a, 0x6e, 0x74, 0x20, 0x1e, 0x65,
+	0xae, 0xfd, 0x04, 0x1a, 0x29, 0xaa, 0x9d, 0x64, 0x9d, 0x8a, 0x95, 0xee, 0x2c, 0x36, 0x37, 0xfa,
+	0x9a, 0x26, 0xcd, 0xbe, 0xf6, 0x19, 0x53, 0xec, 0x34, 0x0f, 0x37, 0x68, 0x41, 0x16, 0xff, 0xc5,
+	0x00, 0x24, 0xd5, 0x1f, 0x05, 0xc2, 0x37, 0x5f, 0xc3, 0x29, 0xe5, 0x0a, 0xc3, 0x52, 0x89, 0xc2,
+	0x90, 0x9b, 0x04, 0x96, 0x77, 0x97, 0x0b, 0x93, 0x80, 0xf3, 0xff, 0x27, 0x01, 0x3c, 0x85, 0xc6,
+	0x8f, 0x22, 0x16, 0x8a, 0xc1, 0xe5, 0xc0, 0x49, 0xac, 0x4f, 0x07, 0x75, 0xe3, 0xd9, 0x83, 0xfa,
+	0xeb, 0x50, 0x11, 0xc1, 0x6f, 0xbb, 0x4e, 0xd4, 0x5e, 0x92, 0xa4, 0xf2, 0x2d, 0x15, 0x58, 0x94,
+	0xbd, 0x65, 0x22, 0x84, 0xc9, 0x9a, 0xa7, 0xf6, 0xf0, 0x9f, 0x0d, 0xb8, 0xaa, 0xe4, 0xac, 0x93,
+	0x07, 0x02, 0xac, 0xef, 0x3b, 0xf9, 0x30, 0x7f, 0x5e, 0x13, 0xce, 0xe9, 0xad, 0xd7, 0x20, 0xb1,
+	0x44, 0x7b, 0xeb, 0xb9, 0x0d, 0xff, 0xab, 0x01, 0xd7, 0x54, 0x37, 0x7b, 0x41, 0xa6, 0xbf, 0x05,
+	0xd5, 0x81, 0xe6, 0x4f, 0x8c, 0x97, 0xb3, 0x67, 0x62, 0x54, 0x94, 0x65, 0xb4, 0xee, 0xc4, 0xf2,
+	0x05, 0x32, 0x25, 0xfc, 0x89, 0x01, 0x4d, 0x71, 0xe8, 0x89, 0x46, 0x59, 0xc3, 0xfb, 0x00, 0x19,
+	0xb2, 0x3e, 0xf8, 0x92, 0x26, 0xfc, 0xd1, 0x80, 0x2b, 0xca, 0xdb, 0xc9, 0x15, 0x21, 0x33, 0xa3,
+	0xbf, 0xe0, 0x52, 0x5b, 0x72, 0xba, 0x3e, 0x38, 0x33, 0xe2, 0x2b, 0x1b, 0xaf, 0x8b, 0xee, 0x66,
+	0xa5, 0x73, 0xfc, 0x73, 0xcd, 0xfa, 0xf8, 0xd3, 0x35, 0x00, 0x99, 0xb6, 0x0f, 0x39, 0xe5, 0xd1,
+	0x79, 0xdb, 0xf6, 0x05, 0x2e, 0xdb, 0x3e, 0x6c, 0xf0, 0x80, 0x53, 0x4f, 0xcf, 0x55, 0x4c, 0xf5,
+	0xea, 0xaa, 0xf5, 0x83, 0xd2, 0xd3, 0x8a, 0x1e, 0x0f, 0x8b, 0x68, 0x98, 0xd4, 0xe5, 0x82, 0xa5,
+	0x9f, 0xd1, 0x6f, 0x0d, 0xd8, 0x56, 0x22, 0x85, 0x79, 0x8e, 0x39, 0xfa, 0xda, 0x7e, 0x58, 0x9a,
+	0xf7, 0xe5, 0x3c, 0xef, 0x19, 0x50, 0x4c, 0x9a, 0x72, 0x3d, 0x7f, 0xab, 0x61, 0x0e, 0x1a, 0x00,
+	0x28, 0x71, 0x71, 0xa6, 0xb2, 0x54, 0x57, 0xd5, 0x35, 0xa4, 0x14, 0x71, 0x23, 0x4f, 0x2c, 0x90,
+	0x30, 0xa9, 0xca, 0x07, 0x11, 0x49, 0xe8, 0xe7, 0xba, 0x7a, 0xd1, 0x71, 0x28, 0x6f, 0x21, 0x55,
+	0xab, 0x5f, 0x7a, 0xf2, 0xcd, 0xd7, 0x09, 0x3a, 0x0e, 0x75, 0x9d, 0xe8, 0x8f, 0x43, 0xf1, 0x06,
+	0x3a, 0xf6, 0x05, 0xfe, 0x5a, 0xe9, 0x37, 0x50, 0xf8, 0xc5, 0x2c, 0x92, 0x0c, 0x3a, 0x8b, 0x04,
+	0xc7, 0x14, 0x1a, 0xc5, 0x99, 0x5b, 0x50, 0x55, 0x4a, 0x7f, 0x4b, 0x50, 0x54, 0xed, 0x45, 0x43,
+	0xbc, 0x64, 0xdc, 0xcc, 0xcf, 0xf0, 0x82, 0xf7, 0x09, 0x34, 0x26, 0xdc, 0xf5, 0xdc, 0x88, 0x72,
+	0x37, 0xf0, 0xc5, 0xa4, 0xef, 0x06, 0xfa, 0xf2, 0x70, 0x6e, 0xde, 0x39, 0x40, 0x31, 0xc0, 0x67,
+	0x6b, 0x44, 0x2e, 0xfd, 0x03, 0x60, 0x53, 0xe6, 0x8c, 0xb8, 0x49, 0x44, 0x2a, 0x23, 0x2f, 0xd0,
+	0x6a, 0x6d, 0xa8, 0x4e, 0xec, 0x60, 0xcc, 0xdd, 0x11, 0xf5, 0xf4, 0x28, 0x6d, 0x95, 0xb6, 0x5f,
+	0x8f, 0x2d, 0x29, 0x10, 0x26, 0x95, 0xc9, 0x03, 0xf5, 0x13, 0xbd, 0x0f, 0x2b, 0xe2, 0x16, 0xa9,
+	0x33, 0xf6, 0xfb, 0xa5, 0xb1, 0x6b, 0xfa, 0xf8, 0x69, 0xc4, 0x30, 0x91, 0x50, 0xe8, 0xc7, 0xb0,
+	0x1a, 0x79, 0xc1, 0x98, 0xdd, 0xd2, 0xe9, 0xf8, 0x66, 0x69, 0xd0, 0xba, 0x3e, 0x68, 0x89, 0x82,
+	0x89, 0x86, 0x4b, 0x81, 0xf7, 0x74, 0xba, 0x5d, 0x0c, 0x78, 0x2f, 0x01, 0xde, 0x43, 0xef, 0x43,
+	0x8b, 0xf9, 0x32, 0xa8, 0x8a, 0x9f, 0x3b, 0x56, 0xe5, 0x08, 0x67, 0x66, 0xd7, 0xa8, 0x45, 0x52,
+	0x98, 0x20, 0xb5, 0x5c, 0xf8, 0xec, 0xc1, 0xa0, 0x96, 0x48, 0x09, 0xf7, 0xaa, 0xec, 0xda, 0x2f,
+	0x6d, 0x30, 0x2a, 0x86, 0xbc, 0xf4, 0x32, 0xe8, 0x60, 0x17, 0xbe, 0xfe, 0x00, 0xea, 0x7a, 0x4f,
+	0xbb, 0x5c, 0xe5, 0xd6, 0xbd, 0xd2, 0x44, 0xad, 0x02, 0x51, 0xe2, 0xf9, 0x75, 0xf5, 0xfc, 0x50,
+	0xf9, 0xff, 0x0c, 0xd9, 0x9e, 0x4e, 0xa8, 0xaf, 0x85, 0x6c, 0xaf, 0x48, 0xb6, 0x87, 0x0e, 0x61,
+	0xd9, 0xe3, 0x53, 0x7d, 0xeb, 0x7e, 0xa3, 0x34, 0x05, 0xe8, 0xb2, 0xc7, 0xa7, 0x98, 0x08, 0x20,
+	0xf4, 0x3b, 0x03, 0xb6, 0x3d, 0xf7, 0xc3, 0x89, 0xeb, 0xa8, 0x0c, 0xe6, 0x8f, 0x43, 0x16, 0x3d,
+	0x0e, 0xbc, 0xe4, 0x6a, 0x7d, 0x58, 0x9a, 0x42, 0x37, 0x8d, 0x85, 0xa0, 0x98, 0xb4, 0x72, 0xeb,
+	0x8f, 0x92, 0x65, 0xf4, 0x1b, 0x68, 0xe6, 0xe5, 0xc7, 0xcc, 0xa7, 0x1e, 0x3f, 0x69, 0xaf, 0x97,
+	0xfe, 0xc6, 0xa9, 0x4c, 0xd8, 0x99, 0x37, 0x41, 0x43, 0x62, 0x82, 0x72, 0xab, 0xef, 0xa9, 0x45,
+	0xd1, 0xa9, 0x43, 0x16, 0xb1, 0x70, 0xca, 0xec, 0x23, 0x3a, 0xe4, 0x41, 0xd8, 0xae, 0x97, 0xee,
+	0xd4, 0x8a, 0x79, 0x3b, 0xf9, 0xc0, 0x99, 0x47, 0xc3, 0xa4, 0xae, 0x17, 0xee, 0xc9, 0x67, 0xf4,
+	0x26, 0xc0, 0x30, 0xbb, 0xfb, 0x6e, 0xc8, 0xda, 0xf7, 0xca, 0x2c, 0x36, 0x2b, 0x77, 0xb2, 0xe2,
+	0xa7, 0x1b, 0xc8, 0x30, 0x77, 0xc5, 0xad, 0x0c, 0xf5, 0x36, 0x7e, 0x1b, 0x6a, 0xa2, 0x13, 0xe6,
+	0x2e, 0x2d, 0xe9, 0x38, 0x6f, 0x94, 0x9b, 0x8a, 0x09, 0xd4, 0x55, 0x6a, 0xe6, 0x86, 0xb8, 0xdc,
+	0x8c, 0x68, 0x9c, 0x67, 0x46, 0x0c, 0xa1, 0x99, 0x4f, 0xfa, 0x04, 0xf9, 0x67, 0x67, 0x9b, 0x5e,
+	0x46, 0xd0, 0x9b, 0xc5, 0xe6, 0x66, 0x5e, 0x47, 0xd1, 0x2c, 0xec, 0x6c, 0x92, 0xad, 0xd0, 0xd9,
+	0x04, 0xe7, 0xdf, 0x0c, 0xa8, 0xab, 0x0f, 0x29, 0x16, 0xf5, 0xa8, 0x3f, 0x64, 0xe7, 0x1d, 0xf8,
+	0x3e, 0x86, 0x96, 0xfe, 0xf8, 0x32, 0x50, 0x40, 0xa2, 0xac, 0x71, 0x35, 0x2d, 0xd7, 0xf6, 0x6e,
+	0x2c, 0xfc, 0x76, 0x50, 0x20, 0x96, 0xcd, 0xcd, 0xfa, 0x66, 0xf1, 0x8b, 0xe3, 0x22, 0x48, 0x4c,
+	0xd0, 0x68, 0x4e, 0x11, 0xff, 0xdd, 0x00, 0x34, 0x8f, 0x77, 0x91, 0x66, 0x39, 0x85, 0x35, 0xcd,
+	0x2b, 0x5b, 0xe5, 0x33, 0x3f, 0x94, 0xf6, 0xb5, 0xd9, 0x1b, 0x49, 0xff, 0x92, 0x7a, 0xa5, 0xbe,
+	0x8d, 0x26, 0x64, 0xd6, 0xdb, 0x5f, 0xcc, 0x3a, 0xc6, 0x97, 0xb3, 0x8e, 0xf1, 0x9f, 0x59, 0xc7,
+	0xf8, 0xec, 0x69, 0xe7, 0xd2, 0x97, 0x4f, 0x3b, 0x97, 0xfe, 0xf9, 0xb4, 0x73, 0xe9, 0xa7, 0xdd,
+	0x02, 0x96, 0xf0, 0xe7, 0xab, 0xc1, 0xd1, 0x91, 0x3b, 0x74, 0xa9, 0xa7, 0x9f, 0x7b, 0xfa, 0x9f,
+	0x76, 0x12, 0x77, 0xb0, 0x2a, 0x3f, 0x9d, 0x7e, 0xe7, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x55,
+	0x9e, 0x68, 0x74, 0xd0, 0x1b, 0x00, 0x00,
 }
 
 func (m *LendAsset) Marshal() (dAtA []byte, err error) {
@@ -1439,11 +1439,16 @@ func (m *BorrowAsset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i = encodeVarintLend(dAtA, i, uint64(n3))
 	i--
 	dAtA[i] = 0x42
-	if m.BridgedAssetID != 0 {
-		i = encodeVarintLend(dAtA, i, uint64(m.BridgedAssetID))
-		i--
-		dAtA[i] = 0x38
+	{
+		size, err := m.BridgedAssetAmount.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintLend(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0x3a
 	{
 		size, err := m.AmountOut.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
@@ -1668,20 +1673,20 @@ func (m *AssetToPairMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.PairId) > 0 {
-		dAtA7 := make([]byte, len(m.PairId)*10)
-		var j6 int
+		dAtA8 := make([]byte, len(m.PairId)*10)
+		var j7 int
 		for _, num := range m.PairId {
 			for num >= 1<<7 {
-				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j6++
+				j7++
 			}
-			dAtA7[j6] = uint8(num)
-			j6++
+			dAtA8[j7] = uint8(num)
+			j7++
 		}
-		i -= j6
-		copy(dAtA[i:], dAtA7[:j6])
-		i = encodeVarintLend(dAtA, i, uint64(j6))
+		i -= j7
+		copy(dAtA[i:], dAtA8[:j7])
+		i = encodeVarintLend(dAtA, i, uint64(j7))
 		i--
 		dAtA[i] = 0x1a
 	}
@@ -1719,20 +1724,20 @@ func (m *UserLendIdMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.LendIds) > 0 {
-		dAtA9 := make([]byte, len(m.LendIds)*10)
-		var j8 int
+		dAtA10 := make([]byte, len(m.LendIds)*10)
+		var j9 int
 		for _, num := range m.LendIds {
 			for num >= 1<<7 {
-				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j8++
+				j9++
 			}
-			dAtA9[j8] = uint8(num)
-			j8++
+			dAtA10[j9] = uint8(num)
+			j9++
 		}
-		i -= j8
-		copy(dAtA[i:], dAtA9[:j8])
-		i = encodeVarintLend(dAtA, i, uint64(j8))
+		i -= j9
+		copy(dAtA[i:], dAtA10[:j9])
+		i = encodeVarintLend(dAtA, i, uint64(j9))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -1767,20 +1772,20 @@ func (m *LendIdByOwnerAndPoolMapping) MarshalToSizedBuffer(dAtA []byte) (int, er
 	var l int
 	_ = l
 	if len(m.LendIds) > 0 {
-		dAtA11 := make([]byte, len(m.LendIds)*10)
-		var j10 int
+		dAtA12 := make([]byte, len(m.LendIds)*10)
+		var j11 int
 		for _, num := range m.LendIds {
 			for num >= 1<<7 {
-				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j10++
+				j11++
 			}
-			dAtA11[j10] = uint8(num)
-			j10++
+			dAtA12[j11] = uint8(num)
+			j11++
 		}
-		i -= j10
-		copy(dAtA[i:], dAtA11[:j10])
-		i = encodeVarintLend(dAtA, i, uint64(j10))
+		i -= j11
+		copy(dAtA[i:], dAtA12[:j11])
+		i = encodeVarintLend(dAtA, i, uint64(j11))
 		i--
 		dAtA[i] = 0x1a
 	}
@@ -1820,20 +1825,20 @@ func (m *BorrowIdByOwnerAndPoolMapping) MarshalToSizedBuffer(dAtA []byte) (int,
 	var l int
 	_ = l
 	if len(m.BorrowIds) > 0 {
-		dAtA13 := make([]byte, len(m.BorrowIds)*10)
-		var j12 int
+		dAtA14 := make([]byte, len(m.BorrowIds)*10)
+		var j13 int
 		for _, num := range m.BorrowIds {
 			for num >= 1<<7 {
-				dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j12++
+				j13++
 			}
-			dAtA13[j12] = uint8(num)
-			j12++
+			dAtA14[j13] = uint8(num)
+			j13++
 		}
-		i -= j12
-		copy(dAtA[i:], dAtA13[:j12])
-		i = encodeVarintLend(dAtA, i, uint64(j12))
+		i -= j13
+		copy(dAtA[i:], dAtA14[:j13])
+		i = encodeVarintLend(dAtA, i, uint64(j13))
 		i--
 		dAtA[i] = 0x1a
 	}
@@ -1873,20 +1878,20 @@ func (m *UserBorrowIdMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.BorrowIds) > 0 {
-		dAtA15 := make([]byte, len(m.BorrowIds)*10)
-		var j14 int
+		dAtA16 := make([]byte, len(m.BorrowIds)*10)
+		var j15 int
 		for _, num := range m.BorrowIds {
 			for num >= 1<<7 {
-				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j14++
+				j15++
 			}
-			dAtA15[j14] = uint8(num)
-			j14++
+			dAtA16[j15] = uint8(num)
+			j15++
 		}
-		i -= j14
-		copy(dAtA[i:], dAtA15[:j14])
-		i = encodeVarintLend(dAtA, i, uint64(j14))
+		i -= j15
+		copy(dAtA[i:], dAtA16[:j15])
+		i = encodeVarintLend(dAtA, i, uint64(j15))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -1921,20 +1926,20 @@ func (m *LendIdToBorrowIdMapping) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	var l int
 	_ = l
 	if len(m.BorrowingID) > 0 {
-		dAtA17 := make([]byte, len(m.BorrowingID)*10)
-		var j16 int
+		dAtA18 := make([]byte, len(m.BorrowingID)*10)
+		var j17 int
 		for _, num := range m.BorrowingID {
 			for num >= 1<<7 {
-				dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j16++
+				j17++
 			}
-			dAtA17[j16] = uint8(num)
-			j16++
+			dAtA18[j17] = uint8(num)
+			j17++
 		}
-		i -= j16
-		copy(dAtA[i:], dAtA17[:j16])
-		i = encodeVarintLend(dAtA, i, uint64(j16))
+		i -= j17
+		copy(dAtA[i:], dAtA18[:j17])
+		i = encodeVarintLend(dAtA, i, uint64(j17))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -2223,20 +2228,20 @@ func (m *LendMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.LendIds) > 0 {
-		dAtA19 := make([]byte, len(m.LendIds)*10)
-		var j18 int
+		dAtA20 := make([]byte, len(m.LendIds)*10)
+		var j19 int
 		for _, num := range m.LendIds {
 			for num >= 1<<7 {
-				dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j18++
+				j19++
 			}
-			dAtA19[j18] = uint8(num)
-			j18++
+			dAtA20[j19] = uint8(num)
+			j19++
 		}
-		i -= j18
-		copy(dAtA[i:], dAtA19[:j18])
-		i = encodeVarintLend(dAtA, i, uint64(j18))
+		i -= j19
+		copy(dAtA[i:], dAtA20[:j19])
+		i = encodeVarintLend(dAtA, i, uint64(j19))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -2264,20 +2269,20 @@ func (m *BorrowMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.BorrowIds) > 0 {
-		dAtA21 := make([]byte, len(m.BorrowIds)*10)
-		var j20 int
+		dAtA22 := make([]byte, len(m.BorrowIds)*10)
+		var j21 int
 		for _, num := range m.BorrowIds {
 			for num >= 1<<7 {
-				dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j20++
+				j21++
 			}
-			dAtA21[j20] = uint8(num)
-			j20++
+			dAtA22[j21] = uint8(num)
+			j21++
 		}
-		i -= j20
-		copy(dAtA[i:], dAtA21[:j20])
-		i = encodeVarintLend(dAtA, i, uint64(j20))
+		i -= j21
+		copy(dAtA[i:], dAtA22[:j21])
+		i = encodeVarintLend(dAtA, i, uint64(j21))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -2305,20 +2310,20 @@ func (m *StableBorrowMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.StableBorrowIds) > 0 {
-		dAtA23 := make([]byte, len(m.StableBorrowIds)*10)
-		var j22 int
+		dAtA24 := make([]byte, len(m.StableBorrowIds)*10)
+		var j23 int
 		for _, num := range m.StableBorrowIds {
 			for num >= 1<<7 {
-				dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j22++
+				j23++
 			}
-			dAtA23[j22] = uint8(num)
-			j22++
+			dAtA24[j23] = uint8(num)
+			j23++
 		}
-		i -= j22
-		copy(dAtA[i:], dAtA23[:j22])
-		i = encodeVarintLend(dAtA, i, uint64(j22))
+		i -= j23
+		copy(dAtA[i:], dAtA24[:j23])
+		i = encodeVarintLend(dAtA, i, uint64(j23))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -2470,9 +2475,8 @@ func (m *BorrowAsset) Size() (n int) {
 	n += 1 + l + sovLend(uint64(l))
 	l = m.AmountOut.Size()
 	n += 1 + l + sovLend(uint64(l))
-	if m.BridgedAssetID != 0 {
-		n += 1 + sovLend(uint64(m.BridgedAssetID))
-	}
+	l = m.BridgedAssetAmount.Size()
+	n += 1 + l + sovLend(uint64(l))
 	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.BorrowingTime)
 	n += 1 + l + sovLend(uint64(l))
 	l = m.StableBorrowRate.Size()
@@ -3316,10 +3320,10 @@ func (m *BorrowAsset) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 7:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BridgedAssetID", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BridgedAssetAmount", wireType)
 			}
-			m.BridgedAssetID = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowLend
@@ -3329,11 +3333,25 @@ func (m *BorrowAsset) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BridgedAssetID |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthLend
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthLend
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.BridgedAssetAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field BorrowingTime", wireType)