Remove double import (#984)

remove dependency

x/accountedpool/keeper/accounted_pool_update_test.go

@@ -1,7 +1,6 @@
 package keeper_test
 
 import (
-	"cosmossdk.io/math"
 	"testing"
 
 	sdkmath "cosmossdk.io/math"
@@ -50,9 +49,8 @@ func TestAccountedPoolUpdate(t *testing.T) {
 		NonAmmPoolTokens: []sdk.Coin{},
 	}
 
-	for _, asset := range ammPool.PoolAssets {
-		accountedPool.PoolAssets = append(accountedPool.PoolAssets, asset)
-	}
+	accountedPool.PoolAssets = append(accountedPool.PoolAssets, ammPool.PoolAssets...)
+
 	// Set accounted pool
 	apk.SetAccountedPool(ctx, accountedPool)
 
@@ -62,33 +60,33 @@ func TestAccountedPoolUpdate(t *testing.T) {
 		BorrowInterestRate: sdkmath.LegacyNewDec(1),
 		PoolAssetsLong: []perpetualtypes.PoolAsset{
 			{
-				Liabilities:           math.NewInt(400),
-				Custody:               math.NewInt(50),
-				TakeProfitCustody:     math.NewInt(10),
-				TakeProfitLiabilities: math.NewInt(20),
+				Liabilities:           sdkmath.NewInt(400),
+				Custody:               sdkmath.NewInt(50),
+				TakeProfitCustody:     sdkmath.NewInt(10),
+				TakeProfitLiabilities: sdkmath.NewInt(20),
 				AssetDenom:            ptypes.BaseCurrency,
 			},
 			{
-				Liabilities:           math.NewInt(0),
-				Custody:               math.NewInt(50),
-				TakeProfitCustody:     math.ZeroInt(),
-				TakeProfitLiabilities: math.ZeroInt(),
+				Liabilities:           sdkmath.NewInt(0),
+				Custody:               sdkmath.NewInt(50),
+				TakeProfitCustody:     sdkmath.ZeroInt(),
+				TakeProfitLiabilities: sdkmath.ZeroInt(),
 				AssetDenom:            ptypes.ATOM,
 			},
 		},
 		PoolAssetsShort: []perpetualtypes.PoolAsset{
 			{
-				Liabilities:           math.NewInt(400),
-				Custody:               math.NewInt(70),
-				TakeProfitCustody:     math.ZeroInt(),
-				TakeProfitLiabilities: math.ZeroInt(),
+				Liabilities:           sdkmath.NewInt(400),
+				Custody:               sdkmath.NewInt(70),
+				TakeProfitCustody:     sdkmath.ZeroInt(),
+				TakeProfitLiabilities: sdkmath.ZeroInt(),
 				AssetDenom:            ptypes.BaseCurrency,
 			},
 			{
-				Liabilities:           math.NewInt(0),
-				Custody:               math.NewInt(50),
-				TakeProfitCustody:     math.ZeroInt(),
-				TakeProfitLiabilities: math.ZeroInt(),
+				Liabilities:           sdkmath.NewInt(0),
+				Custody:               sdkmath.NewInt(50),
+				TakeProfitCustody:     sdkmath.ZeroInt(),
+				TakeProfitLiabilities: sdkmath.ZeroInt(),
 				AssetDenom:            ptypes.ATOM,
 			},
 		},

x/accountedpool/keeper/keeper.go

@@ -5,7 +5,6 @@ import (
 
 	storetypes "cosmossdk.io/core/store"
 	"cosmossdk.io/log"
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -37,7 +36,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 }
 
 // Get accounted pool balance
-func (k Keeper) GetAccountedBalance(ctx sdk.Context, poolId uint64, denom string) math.Int {
+func (k Keeper) GetAccountedBalance(ctx sdk.Context, poolId uint64, denom string) sdkmath.Int {
 	pool, found := k.GetAccountedPool(ctx, poolId)
 	if !found {
 		return sdkmath.ZeroInt()

x/amm/keeper/calc_in_route_spot_price.go

@@ -1,7 +1,6 @@
 package keeper
 
 import (
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/elys-network/elys/x/amm/types"
@@ -97,7 +96,7 @@ func (k Keeper) CalcInRouteSpotPrice(ctx sdk.Context,
 		// Estimate swap
 		snapshot := k.GetAccountedPoolSnapshotOrSet(ctx, pool)
 		cacheCtx, _ := ctx.CacheContext()
-		tokenOut, swapSlippage, _, weightBalanceBonus, err := k.SwapOutAmtGivenIn(cacheCtx, pool.PoolId, k.oracleKeeper, &snapshot, tokensIn, tokenOutDenom, swapFee, math.LegacyOneDec())
+		tokenOut, swapSlippage, _, weightBalanceBonus, err := k.SwapOutAmtGivenIn(cacheCtx, pool.PoolId, k.oracleKeeper, &snapshot, tokensIn, tokenOutDenom, swapFee, sdkmath.LegacyOneDec())
 		if err != nil {
 			return sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdk.Coin{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdk.Coin{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), err
 		}

x/amm/keeper/calc_out_route_spot_price.go

@@ -1,7 +1,6 @@
 package keeper
 
 import (
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/elys-network/elys/x/amm/types"
@@ -54,7 +53,7 @@ func (k Keeper) CalcOutRouteSpotPrice(ctx sdk.Context, tokenOut sdk.Coin, routes
 		// Estimate swap
 		snapshot := k.GetAccountedPoolSnapshotOrSet(ctx, pool)
 		cacheCtx, _ := ctx.CacheContext()
-		swapResult, swapSlippage, _, weightBalanceBonus, err := k.SwapInAmtGivenOut(cacheCtx, pool.PoolId, k.oracleKeeper, &snapshot, tokensOut, tokenInDenom, swapFee, math.LegacyOneDec())
+		swapResult, swapSlippage, _, weightBalanceBonus, err := k.SwapInAmtGivenOut(cacheCtx, pool.PoolId, k.oracleKeeper, &snapshot, tokensOut, tokenInDenom, swapFee, sdkmath.LegacyOneDec())
 		if err != nil {
 			return sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdk.Coin{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdk.Coin{}, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), err
 		}

x/amm/keeper/fee.go

@@ -2,7 +2,6 @@ package keeper
 
 import (
 	errorsmod "cosmossdk.io/errors"
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/elys-network/elys/x/amm/types"
@@ -54,7 +53,7 @@ func (k Keeper) SwapFeesToRevenueToken(ctx sdk.Context, pool types.Pool, fee sdk
 		// Executes the swap in the pool and stores the output. Updates pool assets but
 		// does not actually transfer any tokens to or from the pool.
 		snapshot := k.GetAccountedPoolSnapshotOrSet(ctx, pool)
-		tokenOutCoin, _, _, _, err := pool.SwapOutAmtGivenIn(ctx, k.oracleKeeper, &snapshot, sdk.Coins{tokenIn}, pool.PoolParams.FeeDenom, sdkmath.LegacyZeroDec(), k.accountedPoolKeeper, math.LegacyOneDec(), params)
+		tokenOutCoin, _, _, _, err := pool.SwapOutAmtGivenIn(ctx, k.oracleKeeper, &snapshot, sdk.Coins{tokenIn}, pool.PoolParams.FeeDenom, sdkmath.LegacyZeroDec(), k.accountedPoolKeeper, sdkmath.LegacyOneDec(), params)
 		if err != nil {
 			return err
 		}

x/amm/keeper/msg_server_feed_multiple_external_liquidity_test.go

@@ -2,9 +2,9 @@ package keeper_test
 
 import (
 	"fmt"
+
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/elys-network/elys/x/amm/keeper"
@@ -364,8 +364,8 @@ func (suite *AmmKeeperTestSuite) TestFeedMultipleExternalLiquidity() {
 
 				addr := suite.AddAccounts(1, nil)[0]
 
-				amount := math.NewInt(100000000000)
-				pool := suite.CreateNewAmmPool(addr, true, math.LegacyZeroDec(), math.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
+				amount := sdkmath.NewInt(100000000000)
+				pool := suite.CreateNewAmmPool(addr, true, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
 
 				suite.app.OracleKeeper.SetPriceFeeder(suite.ctx, oracletypes.PriceFeeder{
 					Feeder:   addr.String(),

x/amm/keeper/pool.go

@@ -1,7 +1,6 @@
 package keeper
 
 import (
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	"cosmossdk.io/store/prefix"
 	storetypes "cosmossdk.io/store/types"
@@ -210,7 +209,7 @@ func (k Keeper) GetAccountedPoolSnapshotOrSet(ctx sdk.Context, pool types.Pool)
 }
 
 // AddToPoolBalance Used in perpetual balance changes
-func (k Keeper) AddToPoolBalance(ctx sdk.Context, pool *types.Pool, addShares math.Int, coins sdk.Coins) error {
+func (k Keeper) AddToPoolBalance(ctx sdk.Context, pool *types.Pool, addShares sdkmath.Int, coins sdk.Coins) error {
 	err := pool.IncreaseLiquidity(addShares, coins)
 	if err != nil {
 		return err
@@ -220,7 +219,7 @@ func (k Keeper) AddToPoolBalance(ctx sdk.Context, pool *types.Pool, addShares ma
 }
 
 // RemoveFromPoolBalance Used in perpetual balance changes
-func (k Keeper) RemoveFromPoolBalance(ctx sdk.Context, pool *types.Pool, removeShares math.Int, coins sdk.Coins) error {
+func (k Keeper) RemoveFromPoolBalance(ctx sdk.Context, pool *types.Pool, removeShares sdkmath.Int, coins sdk.Coins) error {
 	err := pool.DecreaseLiquidity(removeShares, coins)
 	if err != nil {
 		return err

x/amm/keeper/pool_share_test.go

@@ -10,7 +10,6 @@ import (
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	simapp "github.com/elys-network/elys/app"
 	"github.com/elys-network/elys/x/amm/types"
-	atypes "github.com/elys-network/elys/x/amm/types"
 	ptypes "github.com/elys-network/elys/x/parameter/types"
 	"github.com/stretchr/testify/require"
 )
@@ -41,23 +40,23 @@ func TestCommitMintedLPTokenToCommitmentModule(t *testing.T) {
 	err = app.BankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, addr[0], usdcToken)
 	require.NoError(t, err)
 
-	var poolAssets []atypes.PoolAsset
+	var poolAssets []types.PoolAsset
 	// Elys
-	poolAssets = append(poolAssets, atypes.PoolAsset{
+	poolAssets = append(poolAssets, types.PoolAsset{
 		Weight: sdkmath.NewInt(50),
 		Token:  sdk.NewCoin(ptypes.Elys, sdkmath.NewInt(100000)),
 	})
 
 	// USDC
-	poolAssets = append(poolAssets, atypes.PoolAsset{
+	poolAssets = append(poolAssets, types.PoolAsset{
 		Weight: sdkmath.NewInt(50),
 		Token:  sdk.NewCoin(ptypes.BaseCurrency, sdkmath.NewInt(10000)),
 	})
 
 	argSwapFee, err := sdkmath.LegacyNewDecFromStr("0.01")
 	require.NoError(t, err)
 
-	poolParams := atypes.PoolParams{
+	poolParams := types.PoolParams{
 		SwapFee: argSwapFee,
 	}
 

x/amm/keeper/pool_test.go

@@ -4,7 +4,6 @@ import (
 	"strconv"
 	"testing"
 
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -161,10 +160,10 @@ func (suite *AmmKeeperTestSuite) TestPool() {
 			func() {
 				addr := suite.AddAccounts(1, nil)[0]
 
-				amount := math.NewInt(100000000000)
-				pool := suite.CreateNewAmmPool(addr, true, math.LegacyZeroDec(), math.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
+				amount := sdkmath.NewInt(100000000000)
+				pool := suite.CreateNewAmmPool(addr, true, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
 
-				err := suite.app.AmmKeeper.AddToPoolBalance(suite.ctx, &pool, math.ZeroInt(), sdk.NewCoins(sdk.NewCoin("non-existant-denom", amount)))
+				err := suite.app.AmmKeeper.AddToPoolBalance(suite.ctx, &pool, sdkmath.ZeroInt(), sdk.NewCoins(sdk.NewCoin("non-existant-denom", amount)))
 				suite.Require().Error(err)
 			},
 		},
@@ -177,10 +176,10 @@ func (suite *AmmKeeperTestSuite) TestPool() {
 			func() {
 				addr := suite.AddAccounts(1, nil)[0]
 
-				amount := math.NewInt(100000000000)
-				pool := suite.CreateNewAmmPool(addr, true, math.LegacyZeroDec(), math.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
+				amount := sdkmath.NewInt(100000000000)
+				pool := suite.CreateNewAmmPool(addr, true, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
 
-				err := suite.app.AmmKeeper.AddToPoolBalance(suite.ctx, &pool, math.ZeroInt(), sdk.NewCoins(sdk.NewCoin(ptypes.ATOM, amount)))
+				err := suite.app.AmmKeeper.AddToPoolBalance(suite.ctx, &pool, sdkmath.ZeroInt(), sdk.NewCoins(sdk.NewCoin(ptypes.ATOM, amount)))
 				suite.Require().NoError(err)
 			},
 		},
@@ -193,10 +192,10 @@ func (suite *AmmKeeperTestSuite) TestPool() {
 			func() {
 				addr := suite.AddAccounts(1, nil)[0]
 
-				amount := math.NewInt(100000000000)
-				pool := suite.CreateNewAmmPool(addr, true, math.LegacyZeroDec(), math.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
+				amount := sdkmath.NewInt(100000000000)
+				pool := suite.CreateNewAmmPool(addr, true, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
 
-				err := suite.app.AmmKeeper.RemoveFromPoolBalance(suite.ctx, &pool, math.ZeroInt(), sdk.NewCoins(sdk.NewCoin("non-existant-denom", amount)))
+				err := suite.app.AmmKeeper.RemoveFromPoolBalance(suite.ctx, &pool, sdkmath.ZeroInt(), sdk.NewCoins(sdk.NewCoin("non-existant-denom", amount)))
 				suite.Require().Error(err)
 			},
 		},
@@ -209,10 +208,10 @@ func (suite *AmmKeeperTestSuite) TestPool() {
 			func() {
 				addr := suite.AddAccounts(1, nil)[0]
 
-				amount := math.NewInt(100000000000)
-				pool := suite.CreateNewAmmPool(addr, true, math.LegacyZeroDec(), math.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
+				amount := sdkmath.NewInt(100000000000)
+				pool := suite.CreateNewAmmPool(addr, true, sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), ptypes.ATOM, amount.MulRaw(10), amount.MulRaw(10))
 
-				err := suite.app.AmmKeeper.RemoveFromPoolBalance(suite.ctx, &pool, math.ZeroInt(), sdk.NewCoins(sdk.NewCoin(ptypes.ATOM, amount)))
+				err := suite.app.AmmKeeper.RemoveFromPoolBalance(suite.ctx, &pool, sdkmath.ZeroInt(), sdk.NewCoins(sdk.NewCoin(ptypes.ATOM, amount)))
 				suite.Require().NoError(err)
 			},
 		},

x/amm/keeper/swap_out_amt_given_in.go

@@ -1,9 +1,9 @@
 package keeper
 
 import (
-	"cosmossdk.io/math"
-	sdkmath "cosmossdk.io/math"
 	"fmt"
+
+	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/elys-network/elys/x/amm/types"
 )
@@ -16,7 +16,7 @@ func (k Keeper) SwapOutAmtGivenIn(
 	tokensIn sdk.Coins,
 	tokenOutDenom string,
 	swapFee sdkmath.LegacyDec,
-	weightBreakingFeePerpetualFactor math.LegacyDec,
+	weightBreakingFeePerpetualFactor sdkmath.LegacyDec,
 ) (tokenOut sdk.Coin, slippage sdkmath.LegacyDec, slippageAmount sdkmath.LegacyDec, weightBalanceBonus sdkmath.LegacyDec, err error) {
 	ammPool, found := k.GetPool(ctx, poolId)
 	if !found {

x/amm/types/swap_in_amt_given_out.go

@@ -3,7 +3,6 @@ package types
 import (
 	"fmt"
 
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -50,7 +49,7 @@ func (p Pool) CalcGivenOutSlippage(
 // weightBreakingFeePerpetualFactor should be 1 if perpetual is not the one calling this function
 func (p *Pool) SwapInAmtGivenOut(
 	ctx sdk.Context, oracleKeeper OracleKeeper, snapshot *Pool,
-	tokensOut sdk.Coins, tokenInDenom string, swapFee sdkmath.LegacyDec, accPoolKeeper AccountedPoolKeeper, weightBreakingFeePerpetualFactor math.LegacyDec, params Params) (
+	tokensOut sdk.Coins, tokenInDenom string, swapFee sdkmath.LegacyDec, accPoolKeeper AccountedPoolKeeper, weightBreakingFeePerpetualFactor sdkmath.LegacyDec, params Params) (
 	tokenIn sdk.Coin, slippage, slippageAmount sdkmath.LegacyDec, weightBalanceBonus sdkmath.LegacyDec, err error,
 ) {
 	// early return with balancer swap if normal amm pool

x/amm/types/swap_in_amt_given_out_test.go

@@ -1,7 +1,6 @@
 package types_test
 
 import (
-	"cosmossdk.io/math"
 	"time"
 
 	sdkmath "cosmossdk.io/math"
@@ -185,10 +184,10 @@ func (suite *TestSuite) TestSwapInAmtGivenOut() {
 			},
 			useOracle:              false,
 			externalLiquidityRatio: sdkmath.LegacyNewDec(10),
-			thresholdWeightDiff:    math.LegacyNewDecWithPrec(20, 2),
+			thresholdWeightDiff:    sdkmath.LegacyNewDecWithPrec(20, 2),
 			tokenOut:               sdk.NewInt64Coin("uusdt", 0),
 			inTokenDenom:           ptypes.BaseCurrency,
-			swapFee:                math.LegacyNewDecWithPrec(1, 2),
+			swapFee:                sdkmath.LegacyNewDecWithPrec(1, 2),
 			expRecoveryBonus:       sdkmath.LegacyZeroDec(),
 			expTokenIn:             sdk.NewInt64Coin(ptypes.BaseCurrency, 0),
 			expErr:                 true,
@@ -226,7 +225,7 @@ func (suite *TestSuite) TestSwapInAmtGivenOut() {
 			params.WeightBreakingFeeMultiplier = sdkmath.LegacyNewDecWithPrec(2, 4)
 			params.WeightBreakingFeeExponent = sdkmath.LegacyNewDecWithPrec(25, 1) // 2.5
 			params.WeightRecoveryFeePortion = sdkmath.LegacyNewDecWithPrec(50, 2)  // 50%
-			tokenOut, _, _, weightBonus, err := pool.SwapInAmtGivenOut(suite.ctx, suite.app.OracleKeeper, &pool, sdk.Coins{tc.tokenOut}, tc.inTokenDenom, tc.swapFee, suite.app.AccountedPoolKeeper, math.LegacyOneDec(), params)
+			tokenOut, _, _, weightBonus, err := pool.SwapInAmtGivenOut(suite.ctx, suite.app.OracleKeeper, &pool, sdk.Coins{tc.tokenOut}, tc.inTokenDenom, tc.swapFee, suite.app.AccountedPoolKeeper, sdkmath.LegacyOneDec(), params)
 			if tc.expErr {
 				suite.Require().Error(err)
 				suite.Require().EqualError(err, "amount too low")

x/amm/types/swap_out_amt_given_in.go

@@ -3,7 +3,6 @@ package types
 import (
 	"fmt"
 
-	"cosmossdk.io/math"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -178,7 +177,7 @@ func (p *Pool) SwapOutAmtGivenIn(
 	tokenOutDenom string,
 	swapFee sdkmath.LegacyDec,
 	accPoolKeeper AccountedPoolKeeper,
-	weightBreakingFeePerpetualFactor math.LegacyDec,
+	weightBreakingFeePerpetualFactor sdkmath.LegacyDec,
 	params Params,
 ) (tokenOut sdk.Coin, slippage, slippageAmount sdkmath.LegacyDec, weightBalanceBonus sdkmath.LegacyDec, err error) {
 	balancerOutCoin, slippage, err := p.CalcOutAmtGivenIn(ctx, oracleKeeper, snapshot, tokensIn, tokenOutDenom, swapFee, accPoolKeeper)