diff --git a/app/ante/ante_test.go b/app/ante/ante_test.go
index fd4af13f..ebe2c4c6 100644
--- a/app/ante/ante_test.go
+++ b/app/ante/ante_test.go
@@ -6,12 +6,10 @@ import (
 	"testing"
 	"time"
 
-	sdkmath "cosmossdk.io/math"
 	tmdb "github.com/cometbft/cometbft-db"
 	abci "github.com/cometbft/cometbft/abci/types"
 	"github.com/cometbft/cometbft/libs/log"
 	"github.com/cosmos/cosmos-sdk/baseapp"
-	"github.com/cosmos/cosmos-sdk/codec"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	"github.com/cosmos/cosmos-sdk/testutil/sims"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -23,8 +21,8 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/kava-labs/kava/app"
-	bep3types "github.com/kava-labs/kava/x/bep3/types"
-	pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
+	// bep3types "github.com/kava-labs/kava/x/bep3/types"
+	// pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
 )
 
 func TestMain(m *testing.M) {
@@ -36,10 +34,10 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
 	testPrivKeys, testAddresses := app.GeneratePrivKeyAddressPairs(10)
 	unauthed := testAddresses[0:2]
 	unauthedKeys := testPrivKeys[0:2]
-	deputy := testAddresses[2]
-	deputyKey := testPrivKeys[2]
-	oracles := testAddresses[3:6]
-	oraclesKeys := testPrivKeys[3:6]
+	// deputy := testAddresses[2]
+	// deputyKey := testPrivKeys[2]
+	// oracles := testAddresses[3:6]
+	// oraclesKeys := testPrivKeys[3:6]
 	manual := testAddresses[6:]
 	manualKeys := testPrivKeys[6:]
 
@@ -70,8 +68,8 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
 			sdk.NewCoins(sdk.NewInt64Coin("ukava", 1e9)),
 			testAddresses,
 		),
-		newBep3GenStateMulti(tApp.AppCodec(), deputy),
-		newPricefeedGenStateMulti(tApp.AppCodec(), oracles),
+		// newBep3GenStateMulti(tApp.AppCodec(), deputy),
+		// newPricefeedGenStateMulti(tApp.AppCodec(), oracles),
 	)
 
 	testcases := []struct {
@@ -86,18 +84,18 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
 			privKey:    unauthedKeys[1],
 			expectPass: false,
 		},
-		{
-			name:       "oracle",
-			address:    oracles[1],
-			privKey:    oraclesKeys[1],
-			expectPass: true,
-		},
-		{
-			name:       "deputy",
-			address:    deputy,
-			privKey:    deputyKey,
-			expectPass: true,
-		},
+		// {
+		// 	name:       "oracle",
+		// 	address:    oracles[1],
+		// 	privKey:    oraclesKeys[1],
+		// 	expectPass: true,
+		// },
+		// {
+		// 	name:       "deputy",
+		// 	address:    deputy,
+		// 	privKey:    deputyKey,
+		// 	expectPass: true,
+		// },
 		{
 			name:       "manual",
 			address:    manual[1],
@@ -145,53 +143,53 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
 	}
 }
 
-func newPricefeedGenStateMulti(cdc codec.JSONCodec, oracles []sdk.AccAddress) app.GenesisState {
-	pfGenesis := pricefeedtypes.GenesisState{
-		Params: pricefeedtypes.Params{
-			Markets: []pricefeedtypes.Market{
-				{MarketID: "btc:usd", BaseAsset: "btc", QuoteAsset: "usd", Oracles: oracles, Active: true},
-			},
-		},
-	}
-	return app.GenesisState{pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pfGenesis)}
-}
+// func newPricefeedGenStateMulti(cdc codec.JSONCodec, oracles []sdk.AccAddress) app.GenesisState {
+// 	pfGenesis := pricefeedtypes.GenesisState{
+// 		Params: pricefeedtypes.Params{
+// 			Markets: []pricefeedtypes.Market{
+// 				{MarketID: "btc:usd", BaseAsset: "btc", QuoteAsset: "usd", Oracles: oracles, Active: true},
+// 			},
+// 		},
+// 	}
+// 	return app.GenesisState{pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pfGenesis)}
+// }
 
-func newBep3GenStateMulti(cdc codec.JSONCodec, deputyAddress sdk.AccAddress) app.GenesisState {
-	bep3Genesis := bep3types.GenesisState{
-		Params: bep3types.Params{
-			AssetParams: bep3types.AssetParams{
-				bep3types.AssetParam{
-					Denom:  "bnb",
-					CoinID: 714,
-					SupplyLimit: bep3types.SupplyLimit{
-						Limit:          sdkmath.NewInt(350000000000000),
-						TimeLimited:    false,
-						TimeBasedLimit: sdk.ZeroInt(),
-						TimePeriod:     time.Hour,
-					},
-					Active:        true,
-					DeputyAddress: deputyAddress,
-					FixedFee:      sdkmath.NewInt(1000),
-					MinSwapAmount: sdk.OneInt(),
-					MaxSwapAmount: sdkmath.NewInt(1000000000000),
-					MinBlockLock:  bep3types.DefaultMinBlockLock,
-					MaxBlockLock:  bep3types.DefaultMaxBlockLock,
-				},
-			},
-		},
-		Supplies: bep3types.AssetSupplies{
-			bep3types.NewAssetSupply(
-				sdk.NewCoin("bnb", sdk.ZeroInt()),
-				sdk.NewCoin("bnb", sdk.ZeroInt()),
-				sdk.NewCoin("bnb", sdk.ZeroInt()),
-				sdk.NewCoin("bnb", sdk.ZeroInt()),
-				time.Duration(0),
-			),
-		},
-		PreviousBlockTime: bep3types.DefaultPreviousBlockTime,
-	}
-	return app.GenesisState{bep3types.ModuleName: cdc.MustMarshalJSON(&bep3Genesis)}
-}
+// func newBep3GenStateMulti(cdc codec.JSONCodec, deputyAddress sdk.AccAddress) app.GenesisState {
+// 	bep3Genesis := bep3types.GenesisState{
+// 		Params: bep3types.Params{
+// 			AssetParams: bep3types.AssetParams{
+// 				bep3types.AssetParam{
+// 					Denom:  "bnb",
+// 					CoinID: 714,
+// 					SupplyLimit: bep3types.SupplyLimit{
+// 						Limit:          sdkmath.NewInt(350000000000000),
+// 						TimeLimited:    false,
+// 						TimeBasedLimit: sdk.ZeroInt(),
+// 						TimePeriod:     time.Hour,
+// 					},
+// 					Active:        true,
+// 					DeputyAddress: deputyAddress,
+// 					FixedFee:      sdkmath.NewInt(1000),
+// 					MinSwapAmount: sdk.OneInt(),
+// 					MaxSwapAmount: sdkmath.NewInt(1000000000000),
+// 					MinBlockLock:  bep3types.DefaultMinBlockLock,
+// 					MaxBlockLock:  bep3types.DefaultMaxBlockLock,
+// 				},
+// 			},
+// 		},
+// 		Supplies: bep3types.AssetSupplies{
+// 			bep3types.NewAssetSupply(
+// 				sdk.NewCoin("bnb", sdk.ZeroInt()),
+// 				sdk.NewCoin("bnb", sdk.ZeroInt()),
+// 				sdk.NewCoin("bnb", sdk.ZeroInt()),
+// 				sdk.NewCoin("bnb", sdk.ZeroInt()),
+// 				time.Duration(0),
+// 			),
+// 		},
+// 		PreviousBlockTime: bep3types.DefaultPreviousBlockTime,
+// 	}
+// 	return app.GenesisState{bep3types.ModuleName: cdc.MustMarshalJSON(&bep3Genesis)}
+// }
 
 func TestAppAnteHandler_RejectMsgsInAuthz(t *testing.T) {
 	testPrivKeys, testAddresses := app.GeneratePrivKeyAddressPairs(10)
diff --git a/app/ante/eip712_test.go b/app/ante/eip712_test.go
index 91504d69..9b2df617 100644
--- a/app/ante/eip712_test.go
+++ b/app/ante/eip712_test.go
@@ -34,12 +34,12 @@ import (
 	"github.com/stretchr/testify/suite"
 
 	"github.com/kava-labs/kava/app"
-	cdptypes "github.com/kava-labs/kava/x/cdp/types"
+	// cdptypes "github.com/kava-labs/kava/x/cdp/types"
 	evmutilkeeper "github.com/kava-labs/kava/x/evmutil/keeper"
 	evmutiltestutil "github.com/kava-labs/kava/x/evmutil/testutil"
 	evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
-	hardtypes "github.com/kava-labs/kava/x/hard/types"
-	pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
+	// hardtypes "github.com/kava-labs/kava/x/hard/types"
+	// pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
 )
 
 const (
@@ -173,98 +173,98 @@ func (suite *EIP712TestSuite) SetupTest() {
 	feemarketGenesis.Params.EnableHeight = 1
 	feemarketGenesis.Params.NoBaseFee = false
 
-	cdpGenState := cdptypes.DefaultGenesisState()
-	cdpGenState.Params.GlobalDebtLimit = sdk.NewInt64Coin("usdx", 53000000000000)
-	cdpGenState.Params.CollateralParams = cdptypes.CollateralParams{
-		{
-			Denom:                            USDCCoinDenom,
-			Type:                             USDCCDPType,
-			LiquidationRatio:                 sdk.MustNewDecFromStr("1.01"),
-			DebtLimit:                        sdk.NewInt64Coin("usdx", 500000000000),
-			StabilityFee:                     sdk.OneDec(),
-			AuctionSize:                      sdkmath.NewIntFromUint64(10000000000),
-			LiquidationPenalty:               sdk.MustNewDecFromStr("0.05"),
-			CheckCollateralizationIndexCount: sdkmath.NewInt(10),
-			KeeperRewardPercentage:           sdk.MustNewDecFromStr("0.01"),
-			SpotMarketID:                     "usdc:usd",
-			LiquidationMarketID:              "usdc:usd:30",
-			ConversionFactor:                 sdkmath.NewInt(18),
-		},
-	}
+	// cdpGenState := cdptypes.DefaultGenesisState()
+	// cdpGenState.Params.GlobalDebtLimit = sdk.NewInt64Coin("usdx", 53000000000000)
+	// cdpGenState.Params.CollateralParams = cdptypes.CollateralParams{
+	// 	{
+	// 		Denom:                            USDCCoinDenom,
+	// 		Type:                             USDCCDPType,
+	// 		LiquidationRatio:                 sdk.MustNewDecFromStr("1.01"),
+	// 		DebtLimit:                        sdk.NewInt64Coin("usdx", 500000000000),
+	// 		StabilityFee:                     sdk.OneDec(),
+	// 		AuctionSize:                      sdkmath.NewIntFromUint64(10000000000),
+	// 		LiquidationPenalty:               sdk.MustNewDecFromStr("0.05"),
+	// 		CheckCollateralizationIndexCount: sdkmath.NewInt(10),
+	// 		KeeperRewardPercentage:           sdk.MustNewDecFromStr("0.01"),
+	// 		SpotMarketID:                     "usdc:usd",
+	// 		LiquidationMarketID:              "usdc:usd:30",
+	// 		ConversionFactor:                 sdkmath.NewInt(18),
+	// 	},
+	// }
 
-	hardGenState := hardtypes.DefaultGenesisState()
-	hardGenState.Params.MoneyMarkets = []hardtypes.MoneyMarket{
-		{
-			Denom: "usdx",
-			BorrowLimit: hardtypes.BorrowLimit{
-				HasMaxLimit:  true,
-				MaximumLimit: sdk.MustNewDecFromStr("100000000000"),
-				LoanToValue:  sdk.MustNewDecFromStr("1"),
-			},
-			SpotMarketID:     "usdx:usd",
-			ConversionFactor: sdkmath.NewInt(1_000_000),
-			InterestRateModel: hardtypes.InterestRateModel{
-				BaseRateAPY:    sdk.MustNewDecFromStr("0.05"),
-				BaseMultiplier: sdk.MustNewDecFromStr("2"),
-				Kink:           sdk.MustNewDecFromStr("0.8"),
-				JumpMultiplier: sdk.MustNewDecFromStr("10"),
-			},
-			ReserveFactor:          sdk.MustNewDecFromStr("0.05"),
-			KeeperRewardPercentage: sdk.ZeroDec(),
-		},
-	}
+	// hardGenState := hardtypes.DefaultGenesisState()
+	// hardGenState.Params.MoneyMarkets = []hardtypes.MoneyMarket{
+	// 	{
+	// 		Denom: "usdx",
+	// 		BorrowLimit: hardtypes.BorrowLimit{
+	// 			HasMaxLimit:  true,
+	// 			MaximumLimit: sdk.MustNewDecFromStr("100000000000"),
+	// 			LoanToValue:  sdk.MustNewDecFromStr("1"),
+	// 		},
+	// 		SpotMarketID:     "usdx:usd",
+	// 		ConversionFactor: sdkmath.NewInt(1_000_000),
+	// 		InterestRateModel: hardtypes.InterestRateModel{
+	// 			BaseRateAPY:    sdk.MustNewDecFromStr("0.05"),
+	// 			BaseMultiplier: sdk.MustNewDecFromStr("2"),
+	// 			Kink:           sdk.MustNewDecFromStr("0.8"),
+	// 			JumpMultiplier: sdk.MustNewDecFromStr("10"),
+	// 		},
+	// 		ReserveFactor:          sdk.MustNewDecFromStr("0.05"),
+	// 		KeeperRewardPercentage: sdk.ZeroDec(),
+	// 	},
+	// }
 
-	pricefeedGenState := pricefeedtypes.DefaultGenesisState()
-	pricefeedGenState.Params.Markets = []pricefeedtypes.Market{
-		{
-			MarketID:   "usdx:usd",
-			BaseAsset:  "usdx",
-			QuoteAsset: "usd",
-			Oracles:    []sdk.AccAddress{},
-			Active:     true,
-		},
-		{
-			MarketID:   "usdc:usd",
-			BaseAsset:  "usdc",
-			QuoteAsset: "usd",
-			Oracles:    []sdk.AccAddress{},
-			Active:     true,
-		},
-		{
-			MarketID:   "usdc:usd:30",
-			BaseAsset:  "usdc",
-			QuoteAsset: "usd",
-			Oracles:    []sdk.AccAddress{},
-			Active:     true,
-		},
-	}
-	pricefeedGenState.PostedPrices = []pricefeedtypes.PostedPrice{
-		{
-			MarketID:      "usdx:usd",
-			OracleAddress: sdk.AccAddress{},
-			Price:         sdk.MustNewDecFromStr("1.00"),
-			Expiry:        time.Now().Add(1 * time.Hour),
-		},
-		{
-			MarketID:      "usdc:usd",
-			OracleAddress: sdk.AccAddress{},
-			Price:         sdk.MustNewDecFromStr("1.00"),
-			Expiry:        time.Now().Add(1 * time.Hour),
-		},
-		{
-			MarketID:      "usdc:usd:30",
-			OracleAddress: sdk.AccAddress{},
-			Price:         sdk.MustNewDecFromStr("1.00"),
-			Expiry:        time.Now().Add(1 * time.Hour),
-		},
-	}
+	// pricefeedGenState := pricefeedtypes.DefaultGenesisState()
+	// pricefeedGenState.Params.Markets = []pricefeedtypes.Market{
+	// 	{
+	// 		MarketID:   "usdx:usd",
+	// 		BaseAsset:  "usdx",
+	// 		QuoteAsset: "usd",
+	// 		Oracles:    []sdk.AccAddress{},
+	// 		Active:     true,
+	// 	},
+	// 	{
+	// 		MarketID:   "usdc:usd",
+	// 		BaseAsset:  "usdc",
+	// 		QuoteAsset: "usd",
+	// 		Oracles:    []sdk.AccAddress{},
+	// 		Active:     true,
+	// 	},
+	// 	{
+	// 		MarketID:   "usdc:usd:30",
+	// 		BaseAsset:  "usdc",
+	// 		QuoteAsset: "usd",
+	// 		Oracles:    []sdk.AccAddress{},
+	// 		Active:     true,
+	// 	},
+	// }
+	// pricefeedGenState.PostedPrices = []pricefeedtypes.PostedPrice{
+	// 	{
+	// 		MarketID:      "usdx:usd",
+	// 		OracleAddress: sdk.AccAddress{},
+	// 		Price:         sdk.MustNewDecFromStr("1.00"),
+	// 		Expiry:        time.Now().Add(1 * time.Hour),
+	// 	},
+	// 	{
+	// 		MarketID:      "usdc:usd",
+	// 		OracleAddress: sdk.AccAddress{},
+	// 		Price:         sdk.MustNewDecFromStr("1.00"),
+	// 		Expiry:        time.Now().Add(1 * time.Hour),
+	// 	},
+	// 	{
+	// 		MarketID:      "usdc:usd:30",
+	// 		OracleAddress: sdk.AccAddress{},
+	// 		Price:         sdk.MustNewDecFromStr("1.00"),
+	// 		Expiry:        time.Now().Add(1 * time.Hour),
+	// 	},
+	// }
 
 	genState := app.GenesisState{
 		evmtypes.ModuleName:       cdc.MustMarshalJSON(evmGs),
 		feemarkettypes.ModuleName: cdc.MustMarshalJSON(feemarketGenesis),
-		cdptypes.ModuleName:       cdc.MustMarshalJSON(&cdpGenState),
-		hardtypes.ModuleName:      cdc.MustMarshalJSON(&hardGenState),
-		pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pricefeedGenState),
+		// cdptypes.ModuleName:       cdc.MustMarshalJSON(&cdpGenState),
+		// hardtypes.ModuleName:      cdc.MustMarshalJSON(&hardGenState),
+		// pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pricefeedGenState),
 	}
 
 	// funds our test accounts with some ukava
@@ -487,40 +487,43 @@ func (suite *EIP712TestSuite) TestEIP712Tx() {
 		failCheckTx    bool
 		errMsg         string
 	}{
-		{
-			name:           "processes deposit eip712 messages successfully",
-			usdcDepositAmt: 100,
-			usdxToMintAmt:  99,
-		},
+		// TODO: need fix
+		// {
+		// 	name:           "processes deposit eip712 messages successfully",
+		// 	usdcDepositAmt: 100,
+		// 	usdxToMintAmt:  99,
+		// },
 		{
 			name:           "fails when convertion more erc20 usdc than balance",
 			usdcDepositAmt: 51_000,
 			usdxToMintAmt:  100,
 			errMsg:         "transfer amount exceeds balance",
 		},
-		{
-			name:           "fails when minting more usdx than allowed",
-			usdcDepositAmt: 100,
-			usdxToMintAmt:  100,
-			errMsg:         "proposed collateral ratio is below liquidation ratio",
-		},
-		{
-			name:           "fails when trying to convert usdc for another address",
-			usdcDepositAmt: 100,
-			usdxToMintAmt:  90,
-			errMsg:         "unauthorized",
-			failCheckTx:    true,
-			updateMsgs: func(msgs []sdk.Msg) []sdk.Msg {
-				convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin(
-					suite.testEVMAddr2,
-					suite.testAddr,
-					suite.usdcEVMAddr,
-					suite.getEVMAmount(100),
-				)
-				msgs[0] = &convertMsg
-				return msgs
-			},
-		},
+		// TODO: need fix
+		// {
+		// 	name:           "fails when minting more usdx than allowed",
+		// 	usdcDepositAmt: 100,
+		// 	usdxToMintAmt:  100,
+		// 	errMsg:         "proposed collateral ratio is below liquidation ratio",
+		// },
+		// TODO: need fix
+		// {
+		// 	name:           "fails when trying to convert usdc for another address",
+		// 	usdcDepositAmt: 100,
+		// 	usdxToMintAmt:  90,
+		// 	errMsg:         "unauthorized",
+		// 	failCheckTx:    true,
+		// 	updateMsgs: func(msgs []sdk.Msg) []sdk.Msg {
+		// 		convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin(
+		// 			suite.testEVMAddr2,
+		// 			suite.testAddr,
+		// 			suite.usdcEVMAddr,
+		// 			suite.getEVMAmount(100),
+		// 		)
+		// 		msgs[0] = &convertMsg
+		// 		return msgs
+		// 	},
+		// },
 		{
 			name:           "fails when trying to convert erc20 for non-whitelisted contract",
 			usdcDepositAmt: 100,
@@ -607,21 +610,21 @@ func (suite *EIP712TestSuite) TestEIP712Tx() {
 				suite.usdcEVMAddr,
 				usdcAmt,
 			)
-			usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(tc.usdxToMintAmt))
-			mintMsg := cdptypes.NewMsgCreateCDP(
-				suite.testAddr,
-				sdk.NewCoin(USDCCoinDenom, usdcAmt),
-				sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
-				USDCCDPType,
-			)
-			lendMsg := hardtypes.NewMsgDeposit(
-				suite.testAddr,
-				sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
-			)
+			// usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(tc.usdxToMintAmt))
+			// mintMsg := cdptypes.NewMsgCreateCDP(
+			// 	suite.testAddr,
+			// 	sdk.NewCoin(USDCCoinDenom, usdcAmt),
+			// 	sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
+			// 	USDCCDPType,
+			// )
+			// lendMsg := hardtypes.NewMsgDeposit(
+			// 	suite.testAddr,
+			// 	sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
+			// )
 			msgs := []sdk.Msg{
 				&convertMsg,
-				&mintMsg,
-				&lendMsg,
+				// &mintMsg,
+				// &lendMsg,
 			}
 			if tc.updateMsgs != nil {
 				msgs = tc.updateMsgs(msgs)
@@ -665,17 +668,17 @@ func (suite *EIP712TestSuite) TestEIP712Tx() {
 				suite.Require().Equal(sdk.ZeroInt(), amt.Amount)
 
 				// validate cdp
-				cdp, found := suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType)
-				suite.Require().True(found)
-				suite.Require().Equal(suite.testAddr, cdp.Owner)
-				suite.Require().Equal(sdk.NewCoin(USDCCoinDenom, suite.getEVMAmount(100)), cdp.Collateral)
-				suite.Require().Equal(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000)), cdp.Principal)
+				// cdp, found := suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType)
+				// suite.Require().True(found)
+				// suite.Require().Equal(suite.testAddr, cdp.Owner)
+				// suite.Require().Equal(sdk.NewCoin(USDCCoinDenom, suite.getEVMAmount(100)), cdp.Collateral)
+				// suite.Require().Equal(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000)), cdp.Principal)
 
-				// validate hard
-				hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
-				suite.Require().True(found)
-				suite.Require().Equal(suite.testAddr, hardDeposit.Depositor)
-				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount)
+				// // validate hard
+				// hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
+				// suite.Require().True(found)
+				// suite.Require().Equal(suite.testAddr, hardDeposit.Depositor)
+				// suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount)
 			} else {
 				suite.Require().NotEqual(resDeliverTx.Code, uint32(0), resCheckTx.Log)
 				suite.Require().Contains(resDeliverTx.Log, tc.errMsg)
@@ -695,21 +698,21 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
 		suite.usdcEVMAddr,
 		usdcAmt,
 	)
-	usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(99))
-	mintMsg := cdptypes.NewMsgCreateCDP(
-		suite.testAddr,
-		sdk.NewCoin(USDCCoinDenom, usdcAmt),
-		sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
-		USDCCDPType,
-	)
-	lendMsg := hardtypes.NewMsgDeposit(
-		suite.testAddr,
-		sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
-	)
+	// usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(99))
+	// mintMsg := cdptypes.NewMsgCreateCDP(
+	// 	suite.testAddr,
+	// 	sdk.NewCoin(USDCCoinDenom, usdcAmt),
+	// 	sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
+	// 	USDCCDPType,
+	// )
+	// lendMsg := hardtypes.NewMsgDeposit(
+	// 	suite.testAddr,
+	// 	sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
+	// )
 	depositMsgs := []sdk.Msg{
 		&convertMsg,
-		&mintMsg,
-		&lendMsg,
+		// &mintMsg,
+		// &lendMsg,
 	}
 
 	// deliver deposit msg
@@ -726,11 +729,11 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
 	)
 	suite.Require().Equal(resDeliverTx.Code, uint32(0), resDeliverTx.Log)
 
-	// validate hard
-	hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
-	suite.Require().True(found)
-	suite.Require().Equal(suite.testAddr, hardDeposit.Depositor)
-	suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount)
+	// // validate hard
+	// hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
+	// suite.Require().True(found)
+	// suite.Require().Equal(suite.testAddr, hardDeposit.Depositor)
+	// suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount)
 
 	// validate erc20 balance
 	coinBal, err := suite.evmutilKeeper.QueryERC20BalanceOf(suite.ctx, suite.usdcEVMAddr, suite.testEVMAddr)
@@ -743,18 +746,18 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
 		suite.testEVMAddr.String(),
 		sdk.NewCoin(USDCCoinDenom, usdcAmt),
 	)
-	cdpWithdrawMsg := cdptypes.NewMsgRepayDebt(
-		suite.testAddr,
-		USDCCDPType,
-		sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
-	)
-	hardWithdrawMsg := hardtypes.NewMsgWithdraw(
-		suite.testAddr,
-		sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
-	)
+	// cdpWithdrawMsg := cdptypes.NewMsgRepayDebt(
+	// 	suite.testAddr,
+	// 	USDCCDPType,
+	// 	sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
+	// )
+	// hardWithdrawMsg := hardtypes.NewMsgWithdraw(
+	// 	suite.testAddr,
+	// 	sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
+	// )
 	withdrawMsgs := []sdk.Msg{
-		&hardWithdrawMsg,
-		&cdpWithdrawMsg,
+		// &hardWithdrawMsg,
+		// &cdpWithdrawMsg,
 		&withdrawConvertMsg,
 	}
 
@@ -772,10 +775,10 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
 	suite.Require().Equal(resDeliverTx.Code, uint32(0), resDeliverTx.Log)
 
 	// validate hard & cdp should be repayed
-	_, found = suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
-	suite.Require().False(found)
-	_, found = suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType)
-	suite.Require().False(found)
+	// _, found = suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
+	// suite.Require().False(found)
+	// _, found = suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType)
+	// suite.Require().False(found)
 
 	// validate user cosmos erc20/usd balance
 	bk := suite.tApp.GetBankKeeper()
diff --git a/client/grpc/query/query.go b/client/grpc/query/query.go
index 8466c5d6..174ff435 100644
--- a/client/grpc/query/query.go
+++ b/client/grpc/query/query.go
@@ -24,21 +24,21 @@ import (
 	evmtypes "github.com/evmos/ethermint/x/evm/types"
 	feemarkettypes "github.com/evmos/ethermint/x/feemarket/types"
 
-	auctiontypes "github.com/kava-labs/kava/x/auction/types"
-	bep3types "github.com/kava-labs/kava/x/bep3/types"
-	cdptypes "github.com/kava-labs/kava/x/cdp/types"
-	committeetypes "github.com/kava-labs/kava/x/committee/types"
-	communitytypes "github.com/kava-labs/kava/x/community/types"
-	earntypes "github.com/kava-labs/kava/x/earn/types"
+	// auctiontypes "github.com/kava-labs/kava/x/auction/types"
+	// bep3types "github.com/kava-labs/kava/x/bep3/types"
+	// cdptypes "github.com/kava-labs/kava/x/cdp/types"
+	// committeetypes "github.com/kava-labs/kava/x/committee/types"
+	// communitytypes "github.com/kava-labs/kava/x/community/types"
+	// earntypes "github.com/kava-labs/kava/x/earn/types"
 	evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
-	hardtypes "github.com/kava-labs/kava/x/hard/types"
-	incentivetypes "github.com/kava-labs/kava/x/incentive/types"
-	issuancetypes "github.com/kava-labs/kava/x/issuance/types"
-	kavadisttypes "github.com/kava-labs/kava/x/kavadist/types"
-	liquidtypes "github.com/kava-labs/kava/x/liquid/types"
-	pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
-	savingstypes "github.com/kava-labs/kava/x/savings/types"
-	swaptypes "github.com/kava-labs/kava/x/swap/types"
+	// hardtypes "github.com/kava-labs/kava/x/hard/types"
+	// incentivetypes "github.com/kava-labs/kava/x/incentive/types"
+	// issuancetypes "github.com/kava-labs/kava/x/issuance/types"
+	// kavadisttypes "github.com/kava-labs/kava/x/kavadist/types"
+	// liquidtypes "github.com/kava-labs/kava/x/liquid/types"
+	// pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
+	// savingstypes "github.com/kava-labs/kava/x/savings/types"
+	// swaptypes "github.com/kava-labs/kava/x/swap/types"
 )
 
 // QueryClient is a wrapper with all Cosmos and Kava grpc query clients
@@ -70,21 +70,21 @@ type QueryClient struct {
 
 	// kava module query clients
 
-	Auction   auctiontypes.QueryClient
-	Bep3      bep3types.QueryClient
-	Cdp       cdptypes.QueryClient
-	Committee committeetypes.QueryClient
-	Community communitytypes.QueryClient
-	Earn      earntypes.QueryClient
-	Evmutil   evmutiltypes.QueryClient
-	Hard      hardtypes.QueryClient
-	Incentive incentivetypes.QueryClient
-	Issuance  issuancetypes.QueryClient
-	Kavadist  kavadisttypes.QueryClient
-	Liquid    liquidtypes.QueryClient
-	Pricefeed pricefeedtypes.QueryClient
-	Savings   savingstypes.QueryClient
-	Swap      swaptypes.QueryClient
+	// Auction   auctiontypes.QueryClient
+	// Bep3      bep3types.QueryClient
+	// Cdp       cdptypes.QueryClient
+	// Committee committeetypes.QueryClient
+	// Community communitytypes.QueryClient
+	// Earn      earntypes.QueryClient
+	Evmutil evmutiltypes.QueryClient
+	// Hard      hardtypes.QueryClient
+	// Incentive incentivetypes.QueryClient
+	// Issuance  issuancetypes.QueryClient
+	// Kavadist  kavadisttypes.QueryClient
+	// Liquid    liquidtypes.QueryClient
+	// Pricefeed pricefeedtypes.QueryClient
+	// Savings   savingstypes.QueryClient
+	// Swap      swaptypes.QueryClient
 }
 
 // NewQueryClient creates a new QueryClient and initializes all the module query clients
@@ -115,21 +115,21 @@ func NewQueryClient(grpcEndpoint string) (*QueryClient, error) {
 		IbcClient:   ibcclienttypes.NewQueryClient(conn),
 		IbcTransfer: ibctransfertypes.NewQueryClient(conn),
 
-		Auction:   auctiontypes.NewQueryClient(conn),
-		Bep3:      bep3types.NewQueryClient(conn),
-		Cdp:       cdptypes.NewQueryClient(conn),
-		Committee: committeetypes.NewQueryClient(conn),
-		Community: communitytypes.NewQueryClient(conn),
-		Earn:      earntypes.NewQueryClient(conn),
-		Evmutil:   evmutiltypes.NewQueryClient(conn),
-		Hard:      hardtypes.NewQueryClient(conn),
-		Incentive: incentivetypes.NewQueryClient(conn),
-		Issuance:  issuancetypes.NewQueryClient(conn),
-		Kavadist:  kavadisttypes.NewQueryClient(conn),
-		Liquid:    liquidtypes.NewQueryClient(conn),
-		Pricefeed: pricefeedtypes.NewQueryClient(conn),
-		Savings:   savingstypes.NewQueryClient(conn),
-		Swap:      swaptypes.NewQueryClient(conn),
+		// Auction:   auctiontypes.NewQueryClient(conn),
+		// Bep3:      bep3types.NewQueryClient(conn),
+		// Cdp:       cdptypes.NewQueryClient(conn),
+		// Committee: committeetypes.NewQueryClient(conn),
+		// Community: communitytypes.NewQueryClient(conn),
+		// Earn:      earntypes.NewQueryClient(conn),
+		Evmutil: evmutiltypes.NewQueryClient(conn),
+		// Hard:      hardtypes.NewQueryClient(conn),
+		// Incentive: incentivetypes.NewQueryClient(conn),
+		// Issuance:  issuancetypes.NewQueryClient(conn),
+		// Kavadist:  kavadisttypes.NewQueryClient(conn),
+		// Liquid:    liquidtypes.NewQueryClient(conn),
+		// Pricefeed: pricefeedtypes.NewQueryClient(conn),
+		// Savings:   savingstypes.NewQueryClient(conn),
+		// Swap:      swaptypes.NewQueryClient(conn),
 	}
 	return client, nil
 }
diff --git a/client/grpc/query/query_test.go b/client/grpc/query/query_test.go
index 86ed9dbc..08c71a30 100644
--- a/client/grpc/query/query_test.go
+++ b/client/grpc/query/query_test.go
@@ -55,20 +55,20 @@ func TestNewQueryClient_ValidClient(t *testing.T) {
 		require.NotNil(t, client.IbcTransfer)
 
 		// validate kava clients
-		require.NotNil(t, client.Auction)
-		require.NotNil(t, client.Bep3)
-		require.NotNil(t, client.Cdp)
-		require.NotNil(t, client.Committee)
-		require.NotNil(t, client.Community)
-		require.NotNil(t, client.Earn)
+		// require.NotNil(t, client.Auction)
+		// require.NotNil(t, client.Bep3)
+		// require.NotNil(t, client.Cdp)
+		// require.NotNil(t, client.Committee)
+		// require.NotNil(t, client.Community)
+		// require.NotNil(t, client.Earn)
 		require.NotNil(t, client.Evmutil)
-		require.NotNil(t, client.Hard)
-		require.NotNil(t, client.Incentive)
-		require.NotNil(t, client.Issuance)
-		require.NotNil(t, client.Kavadist)
-		require.NotNil(t, client.Liquid)
-		require.NotNil(t, client.Pricefeed)
-		require.NotNil(t, client.Savings)
-		require.NotNil(t, client.Swap)
+		// require.NotNil(t, client.Hard)
+		// require.NotNil(t, client.Incentive)
+		// require.NotNil(t, client.Issuance)
+		// require.NotNil(t, client.Kavadist)
+		// require.NotNil(t, client.Liquid)
+		// require.NotNil(t, client.Pricefeed)
+		// require.NotNil(t, client.Savings)
+		// require.NotNil(t, client.Swap)
 	})
 }
diff --git a/tests/e2e/e2e_community_update_params_test.go b/tests/e2e/e2e_community_update_params_test.go
index 59fe0ccb..e406dccf 100644
--- a/tests/e2e/e2e_community_update_params_test.go
+++ b/tests/e2e/e2e_community_update_params_test.go
@@ -1,186 +1,177 @@
 package e2e_test
 
 import (
-	"context"
 	"encoding/hex"
-	"time"
 
-	sdkmath "cosmossdk.io/math"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
-	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
-	govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
-
-	"github.com/kava-labs/kava/tests/e2e/testutil"
-	"github.com/kava-labs/kava/tests/util"
-	communitytypes "github.com/kava-labs/kava/x/community/types"
+	// communitytypes "github.com/kava-labs/kava/x/community/types"
 )
 
-func (suite *IntegrationTestSuite) TestCommunityUpdateParams_NonAuthority() {
-	// ARRANGE
-	// setup kava account
-	funds := ukava(1e5) // .1 KAVA
-	kavaAcc := suite.Kava.NewFundedAccount("community-non-authority", sdk.NewCoins(funds))
+// func (suite *IntegrationTestSuite) TestCommunityUpdateParams_NonAuthority() {
+// 	// ARRANGE
+// 	// setup kava account
+// 	funds := ukava(1e5) // .1 KAVA
+// 	kavaAcc := suite.Kava.NewFundedAccount("community-non-authority", sdk.NewCoins(funds))
 
-	gasLimit := int64(2e5)
-	fee := ukava(200)
+// 	gasLimit := int64(2e5)
+// 	fee := ukava(200)
 
-	msg := communitytypes.NewMsgUpdateParams(
-		kavaAcc.SdkAddress,
-		communitytypes.DefaultParams(),
-	)
+// 	msg := communitytypes.NewMsgUpdateParams(
+// 		kavaAcc.SdkAddress,
+// 		communitytypes.DefaultParams(),
+// 	)
 
-	// ACT
-	req := util.KavaMsgRequest{
-		Msgs:      []sdk.Msg{&msg},
-		GasLimit:  uint64(gasLimit),
-		FeeAmount: sdk.NewCoins(fee),
-		Memo:      "this is a failure!",
-	}
-	res := kavaAcc.SignAndBroadcastKavaTx(req)
+// 	// ACT
+// 	req := util.KavaMsgRequest{
+// 		Msgs:      []sdk.Msg{&msg},
+// 		GasLimit:  uint64(gasLimit),
+// 		FeeAmount: sdk.NewCoins(fee),
+// 		Memo:      "this is a failure!",
+// 	}
+// 	res := kavaAcc.SignAndBroadcastKavaTx(req)
 
-	// ASSERT
-	_, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second)
-	suite.Require().Error(err)
-	suite.Require().ErrorContains(
-		err,
-		govtypes.ErrInvalidSigner.Error(),
-		"should return with authority check error",
-	)
-}
+// 	// ASSERT
+// 	_, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second)
+// 	suite.Require().Error(err)
+// 	suite.Require().ErrorContains(
+// 		err,
+// 		govtypes.ErrInvalidSigner.Error(),
+// 		"should return with authority check error",
+// 	)
+// }
 
-func (suite *IntegrationTestSuite) TestCommunityUpdateParams_Authority() {
-	// ARRANGE
-	govParamsRes, err := suite.Kava.Grpc.Query.Gov.Params(context.Background(), &govv1.QueryParamsRequest{
-		ParamsType: govv1.ParamDeposit,
-	})
-	suite.NoError(err)
+// func (suite *IntegrationTestSuite) TestCommunityUpdateParams_Authority() {
+// 	// ARRANGE
+// 	govParamsRes, err := suite.Kava.Grpc.Query.Gov.Params(context.Background(), &govv1.QueryParamsRequest{
+// 		ParamsType: govv1.ParamDeposit,
+// 	})
+// 	suite.NoError(err)
 
-	// Check initial params
-	communityParamsResInitial, err := suite.Kava.Grpc.Query.Community.Params(
-		context.Background(),
-		&communitytypes.QueryParamsRequest{},
-	)
-	suite.Require().NoError(err)
+// 	// Check initial params
+// 	communityParamsResInitial, err := suite.Kava.Grpc.Query.Community.Params(
+// 		context.Background(),
+// 		&communitytypes.QueryParamsRequest{},
+// 	)
+// 	suite.Require().NoError(err)
 
-	// setup kava account
-	// .1 KAVA + min deposit amount for proposal
-	funds := sdk.NewCoins(ukava(1e5)).Add(govParamsRes.DepositParams.MinDeposit...)
-	kavaAcc := suite.Kava.NewFundedAccount("community-update-params", funds)
+// 	// setup kava account
+// 	// .1 KAVA + min deposit amount for proposal
+// 	funds := sdk.NewCoins(ukava(1e5)).Add(govParamsRes.DepositParams.MinDeposit...)
+// 	kavaAcc := suite.Kava.NewFundedAccount("community-update-params", funds)
 
-	gasLimit := int64(2e5)
-	fee := ukava(200)
+// 	gasLimit := int64(2e5)
+// 	fee := ukava(200)
 
-	// Wait until switchover actually happens - When testing without the upgrade
-	// handler that sets a relative switchover time, the switchover time in
-	// genesis should be set in the past so it runs immediately.
-	suite.Require().Eventually(
-		func() bool {
-			params, err := suite.Kava.Grpc.Query.Community.Params(
-				context.Background(),
-				&communitytypes.QueryParamsRequest{},
-			)
-			suite.Require().NoError(err)
+// 	// Wait until switchover actually happens - When testing without the upgrade
+// 	// handler that sets a relative switchover time, the switchover time in
+// 	// genesis should be set in the past so it runs immediately.
+// 	suite.Require().Eventually(
+// 		func() bool {
+// 			params, err := suite.Kava.Grpc.Query.Community.Params(
+// 				context.Background(),
+// 				&communitytypes.QueryParamsRequest{},
+// 			)
+// 			suite.Require().NoError(err)
 
-			return params.Params.UpgradeTimeDisableInflation.Equal(time.Time{})
-		},
-		20*time.Second,
-		1*time.Second,
-		"switchover should happen",
-	)
+// 			return params.Params.UpgradeTimeDisableInflation.Equal(time.Time{})
+// 		},
+// 		20*time.Second,
+// 		1*time.Second,
+// 		"switchover should happen",
+// 	)
 
-	// Add 1 to the staking rewards per second
-	newStakingRewardsPerSecond := communityParamsResInitial.Params.
-		StakingRewardsPerSecond.
-		Add(sdkmath.LegacyNewDec(1))
+// 	// Add 1 to the staking rewards per second
+// 	newStakingRewardsPerSecond := communityParamsResInitial.Params.
+// 		StakingRewardsPerSecond.
+// 		Add(sdkmath.LegacyNewDec(1))
 
-	// 1. Proposal
-	// Only modify stakingRewardsPerSecond, as to not re-run the switchover and
-	// to not influence other tests
-	updateParamsMsg := communitytypes.NewMsgUpdateParams(
-		authtypes.NewModuleAddress(govtypes.ModuleName), // authority
-		communitytypes.NewParams(
-			time.Time{},                // after switchover, is empty
-			newStakingRewardsPerSecond, // only modify stakingRewardsPerSecond
-			communityParamsResInitial.Params.UpgradeTimeSetStakingRewardsPerSecond,
-		),
-	)
+// 	// 1. Proposal
+// 	// Only modify stakingRewardsPerSecond, as to not re-run the switchover and
+// 	// to not influence other tests
+// 	updateParamsMsg := communitytypes.NewMsgUpdateParams(
+// 		authtypes.NewModuleAddress(govtypes.ModuleName), // authority
+// 		communitytypes.NewParams(
+// 			time.Time{},                // after switchover, is empty
+// 			newStakingRewardsPerSecond, // only modify stakingRewardsPerSecond
+// 			communityParamsResInitial.Params.UpgradeTimeSetStakingRewardsPerSecond,
+// 		),
+// 	)
 
-	// Make sure we're actually changing the params
-	suite.NotEqual(
-		updateParamsMsg.Params,
-		communityParamsResInitial.Params,
-		"new params should be different from existing",
-	)
+// 	// Make sure we're actually changing the params
+// 	suite.NotEqual(
+// 		updateParamsMsg.Params,
+// 		communityParamsResInitial.Params,
+// 		"new params should be different from existing",
+// 	)
 
-	proposalMsg, err := govv1.NewMsgSubmitProposal(
-		[]sdk.Msg{&updateParamsMsg},
-		govParamsRes.Params.MinDeposit,
-		kavaAcc.SdkAddress.String(),
-		"community-update-params",
-		"title",
-		"summary",
-	)
-	suite.NoError(err)
+// 	proposalMsg, err := govv1.NewMsgSubmitProposal(
+// 		[]sdk.Msg{&updateParamsMsg},
+// 		govParamsRes.Params.MinDeposit,
+// 		kavaAcc.SdkAddress.String(),
+// 		"community-update-params",
+// 		"title",
+// 		"summary",
+// 	)
+// 	suite.NoError(err)
 
-	req := util.KavaMsgRequest{
-		Msgs:      []sdk.Msg{proposalMsg},
-		GasLimit:  uint64(gasLimit),
-		FeeAmount: sdk.NewCoins(fee),
-		Memo:      "this is a proposal please accept me",
-	}
-	res := kavaAcc.SignAndBroadcastKavaTx(req)
-	suite.Require().NoError(res.Err)
+// 	req := util.KavaMsgRequest{
+// 		Msgs:      []sdk.Msg{proposalMsg},
+// 		GasLimit:  uint64(gasLimit),
+// 		FeeAmount: sdk.NewCoins(fee),
+// 		Memo:      "this is a proposal please accept me",
+// 	}
+// 	res := kavaAcc.SignAndBroadcastKavaTx(req)
+// 	suite.Require().NoError(res.Err)
 
-	// Wait for proposal to be submitted
-	txRes, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second)
-	suite.Require().NoError(err)
+// 	// Wait for proposal to be submitted
+// 	txRes, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second)
+// 	suite.Require().NoError(err)
 
-	// Parse tx response to get proposal id
-	var govRes govv1.MsgSubmitProposalResponse
-	suite.decodeTxMsgResponse(txRes, &govRes)
+// 	// Parse tx response to get proposal id
+// 	var govRes govv1.MsgSubmitProposalResponse
+// 	suite.decodeTxMsgResponse(txRes, &govRes)
 
-	// 2. Vote for proposal from whale account
-	whale := suite.Kava.GetAccount(testutil.FundedAccountName)
-	voteMsg := govv1.NewMsgVote(
-		whale.SdkAddress,
-		govRes.ProposalId,
-		govv1.OptionYes,
-		"",
-	)
+// 	// 2. Vote for proposal from whale account
+// 	whale := suite.Kava.GetAccount(testutil.FundedAccountName)
+// 	voteMsg := govv1.NewMsgVote(
+// 		whale.SdkAddress,
+// 		govRes.ProposalId,
+// 		govv1.OptionYes,
+// 		"",
+// 	)
 
-	voteReq := util.KavaMsgRequest{
-		Msgs:      []sdk.Msg{voteMsg},
-		GasLimit:  uint64(gasLimit),
-		FeeAmount: sdk.NewCoins(fee),
-		Memo:      "voting",
-	}
-	voteRes := whale.SignAndBroadcastKavaTx(voteReq)
-	suite.Require().NoError(voteRes.Err)
+// 	voteReq := util.KavaMsgRequest{
+// 		Msgs:      []sdk.Msg{voteMsg},
+// 		GasLimit:  uint64(gasLimit),
+// 		FeeAmount: sdk.NewCoins(fee),
+// 		Memo:      "voting",
+// 	}
+// 	voteRes := whale.SignAndBroadcastKavaTx(voteReq)
+// 	suite.Require().NoError(voteRes.Err)
 
-	_, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, voteRes.Result.TxHash, 6*time.Second)
-	suite.Require().NoError(err)
+// 	_, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, voteRes.Result.TxHash, 6*time.Second)
+// 	suite.Require().NoError(err)
 
-	// 3. Wait until proposal passes
-	suite.Require().Eventually(func() bool {
-		proposalRes, err := suite.Kava.Grpc.Query.Gov.Proposal(context.Background(), &govv1.QueryProposalRequest{
-			ProposalId: govRes.ProposalId,
-		})
-		suite.NoError(err)
+// 	// 3. Wait until proposal passes
+// 	suite.Require().Eventually(func() bool {
+// 		proposalRes, err := suite.Kava.Grpc.Query.Gov.Proposal(context.Background(), &govv1.QueryProposalRequest{
+// 			ProposalId: govRes.ProposalId,
+// 		})
+// 		suite.NoError(err)
 
-		return proposalRes.Proposal.Status == govv1.StatusPassed
-	}, 60*time.Second, 1*time.Second)
+// 		return proposalRes.Proposal.Status == govv1.StatusPassed
+// 	}, 60*time.Second, 1*time.Second)
 
-	// Check parameters are updated
-	communityParamsRes, err := suite.Kava.Grpc.Query.Community.Params(
-		context.Background(),
-		&communitytypes.QueryParamsRequest{},
-	)
-	suite.Require().NoError(err)
+// 	// Check parameters are updated
+// 	communityParamsRes, err := suite.Kava.Grpc.Query.Community.Params(
+// 		context.Background(),
+// 		&communitytypes.QueryParamsRequest{},
+// 	)
+// 	suite.Require().NoError(err)
 
-	suite.Equal(updateParamsMsg.Params, communityParamsRes.Params)
-}
+// 	suite.Equal(updateParamsMsg.Params, communityParamsRes.Params)
+// }
 
 func (suite *IntegrationTestSuite) decodeTxMsgResponse(txRes *sdk.TxResponse, ptr codec.ProtoMarshaler) {
 	// convert txRes.Data hex string to bytes
diff --git a/tests/e2e/e2e_evm_contracts_test.go b/tests/e2e/e2e_evm_contracts_test.go
index 404891a1..521448d2 100644
--- a/tests/e2e/e2e_evm_contracts_test.go
+++ b/tests/e2e/e2e_evm_contracts_test.go
@@ -11,8 +11,8 @@ import (
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 
 	"github.com/kava-labs/kava/app"
-	cdptypes "github.com/kava-labs/kava/x/cdp/types"
-	evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
+	// cdptypes "github.com/kava-labs/kava/x/cdp/types"
+	// evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
 
 	"github.com/kava-labs/kava/tests/e2e/contracts/greeter"
 	"github.com/kava-labs/kava/tests/util"
@@ -108,95 +108,95 @@ func (suite *IntegrationTestSuite) TestEip712BasicMessageAuthorization() {
 
 // Note that this test works because the deployed erc20 is configured in evmutil & cdp params.
 // This test matches the webapp's "USDT Earn" workflow
-func (suite *IntegrationTestSuite) TestEip712ConvertToCoinAndDepositToLend() {
-	// cdp requires minimum of $11 collateral
-	amount := sdk.NewInt(11e6) // 11 USDT
-	principal := sdk.NewCoin("usdx", sdk.NewInt(10e6))
-	sdkDenom := suite.DeployedErc20.CosmosDenom
+// func (suite *IntegrationTestSuite) TestEip712ConvertToCoinAndDepositToLend() {
+// 	// cdp requires minimum of $11 collateral
+// 	amount := sdk.NewInt(11e6) // 11 USDT
+// 	principal := sdk.NewCoin("usdx", sdk.NewInt(10e6))
+// 	sdkDenom := suite.DeployedErc20.CosmosDenom
 
-	// create new funded account
-	depositor := suite.Kava.NewFundedAccount("eip712-lend-depositor", sdk.NewCoins(ukava(1e5)))
-	// give them erc20 balance to deposit
-	fundRes := suite.FundKavaErc20Balance(depositor.EvmAddress, amount.BigInt())
-	suite.NoError(fundRes.Err)
+// 	// create new funded account
+// 	depositor := suite.Kava.NewFundedAccount("eip712-lend-depositor", sdk.NewCoins(ukava(1e5)))
+// 	// give them erc20 balance to deposit
+// 	fundRes := suite.FundKavaErc20Balance(depositor.EvmAddress, amount.BigInt())
+// 	suite.NoError(fundRes.Err)
 
-	// setup messages for convert to coin & deposit into earn
-	convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin(
-		evmutiltypes.NewInternalEVMAddress(depositor.EvmAddress),
-		depositor.SdkAddress,
-		evmutiltypes.NewInternalEVMAddress(suite.DeployedErc20.Address),
-		amount,
-	)
-	depositMsg := cdptypes.NewMsgCreateCDP(
-		depositor.SdkAddress,
-		sdk.NewCoin(sdkDenom, amount),
-		principal,
-		suite.DeployedErc20.CdpCollateralType,
-	)
-	msgs := []sdk.Msg{
-		// convert to coin
-		&convertMsg,
-		// deposit into cdp (Mint), take out USDX
-		&depositMsg,
-	}
+// 	// setup messages for convert to coin & deposit into earn
+// 	convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin(
+// 		evmutiltypes.NewInternalEVMAddress(depositor.EvmAddress),
+// 		depositor.SdkAddress,
+// 		evmutiltypes.NewInternalEVMAddress(suite.DeployedErc20.Address),
+// 		amount,
+// 	)
+// 	// depositMsg := cdptypes.NewMsgCreateCDP(
+// 	// 	depositor.SdkAddress,
+// 	// 	sdk.NewCoin(sdkDenom, amount),
+// 	// 	principal,
+// 	// 	suite.DeployedErc20.CdpCollateralType,
+// 	// )
+// 	msgs := []sdk.Msg{
+// 		// convert to coin
+// 		&convertMsg,
+// 		// deposit into cdp (Mint), take out USDX
+// 		// &depositMsg,
+// 	}
 
-	// create tx
-	tx := suite.NewEip712TxBuilder(
-		depositor,
-		suite.Kava,
-		1e6,
-		sdk.NewCoins(ukava(1e4)),
-		msgs,
-		"doing the USDT Earn workflow! erc20 -> sdk.Coin -> USDX hard deposit",
-	).GetTx()
+// 	// create tx
+// 	tx := suite.NewEip712TxBuilder(
+// 		depositor,
+// 		suite.Kava,
+// 		1e6,
+// 		sdk.NewCoins(ukava(1e4)),
+// 		msgs,
+// 		"doing the USDT Earn workflow! erc20 -> sdk.Coin -> USDX hard deposit",
+// 	).GetTx()
 
-	txBytes, err := suite.Kava.EncodingConfig.TxConfig.TxEncoder()(tx)
-	suite.NoError(err)
+// 	txBytes, err := suite.Kava.EncodingConfig.TxConfig.TxEncoder()(tx)
+// 	suite.NoError(err)
 
-	// broadcast tx
-	res, err := suite.Kava.Grpc.Query.Tx.BroadcastTx(context.Background(), &txtypes.BroadcastTxRequest{
-		TxBytes: txBytes,
-		Mode:    txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
-	})
-	suite.NoError(err)
-	suite.Equal(sdkerrors.SuccessABCICode, res.TxResponse.Code)
+// 	// broadcast tx
+// 	res, err := suite.Kava.Grpc.Query.Tx.BroadcastTx(context.Background(), &txtypes.BroadcastTxRequest{
+// 		TxBytes: txBytes,
+// 		Mode:    txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
+// 	})
+// 	suite.NoError(err)
+// 	suite.Equal(sdkerrors.SuccessABCICode, res.TxResponse.Code)
 
-	_, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.TxResponse.TxHash, 6*time.Second)
-	suite.Require().NoError(err)
+// 	_, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.TxResponse.TxHash, 6*time.Second)
+// 	suite.Require().NoError(err)
 
-	// check that depositor no longer has erc20 balance
-	balance := suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress)
-	suite.BigIntsEqual(big.NewInt(0), balance, "expected no erc20 balance")
+// 	// check that depositor no longer has erc20 balance
+// 	balance := suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress)
+// 	suite.BigIntsEqual(big.NewInt(0), balance, "expected no erc20 balance")
 
-	// check that account has cdp
-	cdpRes, err := suite.Kava.Grpc.Query.Cdp.Cdp(context.Background(), &cdptypes.QueryCdpRequest{
-		CollateralType: suite.DeployedErc20.CdpCollateralType,
-		Owner:          depositor.SdkAddress.String(),
-	})
-	suite.NoError(err)
-	suite.True(cdpRes.Cdp.Collateral.Amount.Equal(amount))
-	suite.True(cdpRes.Cdp.Principal.Equal(principal))
+// 	// check that account has cdp
+// 	// cdpRes, err := suite.Kava.Grpc.Query.Cdp.Cdp(context.Background(), &cdptypes.QueryCdpRequest{
+// 	// 	CollateralType: suite.DeployedErc20.CdpCollateralType,
+// 	// 	Owner:          depositor.SdkAddress.String(),
+// 	// })
+// 	// suite.NoError(err)
+// 	// suite.True(cdpRes.Cdp.Collateral.Amount.Equal(amount))
+// 	// suite.True(cdpRes.Cdp.Principal.Equal(principal))
 
-	// withdraw deposit & convert back to erc20 (this allows refund to recover erc20s used in test)
-	withdraw := cdptypes.NewMsgRepayDebt(
-		depositor.SdkAddress,
-		suite.DeployedErc20.CdpCollateralType,
-		principal,
-	)
-	convertBack := evmutiltypes.NewMsgConvertCoinToERC20(
-		depositor.SdkAddress.String(),
-		depositor.EvmAddress.Hex(),
-		sdk.NewCoin(sdkDenom, amount),
-	)
-	withdrawAndConvertBack := util.KavaMsgRequest{
-		Msgs:      []sdk.Msg{&withdraw, &convertBack},
-		GasLimit:  1e6,
-		FeeAmount: sdk.NewCoins(ukava(1000)),
-		Data:      "withdrawing from mint & converting back to erc20",
-	}
-	lastRes := depositor.SignAndBroadcastKavaTx(withdrawAndConvertBack)
-	suite.NoError(lastRes.Err)
+// 	// withdraw deposit & convert back to erc20 (this allows refund to recover erc20s used in test)
+// 	// withdraw := cdptypes.NewMsgRepayDebt(
+// 	// 	depositor.SdkAddress,
+// 	// 	suite.DeployedErc20.CdpCollateralType,
+// 	// 	principal,
+// 	// )
+// 	convertBack := evmutiltypes.NewMsgConvertCoinToERC20(
+// 		depositor.SdkAddress.String(),
+// 		depositor.EvmAddress.Hex(),
+// 		sdk.NewCoin(sdkDenom, amount),
+// 	)
+// 	withdrawAndConvertBack := util.KavaMsgRequest{
+// 		Msgs:      []sdk.Msg{&withdraw, &convertBack},
+// 		GasLimit:  1e6,
+// 		FeeAmount: sdk.NewCoins(ukava(1000)),
+// 		Data:      "withdrawing from mint & converting back to erc20",
+// 	}
+// 	lastRes := depositor.SignAndBroadcastKavaTx(withdrawAndConvertBack)
+// 	suite.NoError(lastRes.Err)
 
-	balance = suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress)
-	suite.BigIntsEqual(amount.BigInt(), balance, "expected returned erc20 balance")
-}
+// 	balance = suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress)
+// 	suite.BigIntsEqual(amount.BigInt(), balance, "expected returned erc20 balance")
+// }
diff --git a/tests/e2e/e2e_min_fees_test.go b/tests/e2e/e2e_min_fees_test.go
index 0ff51ce8..bf908f53 100644
--- a/tests/e2e/e2e_min_fees_test.go
+++ b/tests/e2e/e2e_min_fees_test.go
@@ -21,16 +21,16 @@ func (suite *IntegrationTestSuite) TestEthGasPriceReturnsMinFee() {
 
 	// read expected min fee from app.toml
 	minGasPrices, err := getMinFeeFromAppToml(util.KavaHomePath())
-	suite.NoError(err)
+	suite.NoError(err, "failed to read min fee from app.toml")
 
 	// evm uses akava, get akava min fee
 	evmMinGas := minGasPrices.AmountOf("akava").TruncateInt().BigInt()
 
 	// returns eth_gasPrice, units in kava
 	gasPrice, err := suite.Kava.EvmClient.SuggestGasPrice(context.Background())
-	suite.NoError(err)
+	suite.NoError(err, "failed to get gas price")
 
-	suite.Equal(evmMinGas, gasPrice)
+	suite.Equal(evmMinGas, gasPrice, "gas price should be equal to min fee")
 }
 
 func (suite *IntegrationTestSuite) TestEvmRespectsMinFee() {
diff --git a/tests/e2e/testutil/init_evm.go b/tests/e2e/testutil/init_evm.go
index 61baaebf..9c44f063 100644
--- a/tests/e2e/testutil/init_evm.go
+++ b/tests/e2e/testutil/init_evm.go
@@ -8,7 +8,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/kava-labs/kava/tests/e2e/contracts/greeter"
-	"github.com/kava-labs/kava/x/cdp/types"
+	// "github.com/kava-labs/kava/x/cdp/types"
 	evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
 )
 
@@ -46,21 +46,21 @@ func (suite *E2eTestSuite) InitKavaEvmData() {
 	suite.Kava.RegisterErc20(suite.DeployedErc20.Address)
 
 	// expect the erc20's cosmos denom to be a supported cdp collateral type
-	cdpParams, err := suite.Kava.Grpc.Query.Cdp.Params(context.Background(), &types.QueryParamsRequest{})
-	suite.Require().NoError(err)
-	found = false
-	for _, cp := range cdpParams.Params.CollateralParams {
-		if cp.Denom == suite.DeployedErc20.CosmosDenom {
-			found = true
-			suite.DeployedErc20.CdpCollateralType = cp.Type
-		}
-	}
-	if !found {
-		panic(fmt.Sprintf(
-			"erc20's cosmos denom %s must be valid cdp collateral type",
-			suite.DeployedErc20.CosmosDenom),
-		)
-	}
+	// cdpParams, err := suite.Kava.Grpc.Query.Cdp.Params(context.Background(), &types.QueryParamsRequest{})
+	// suite.Require().NoError(err)
+	// found = false
+	// for _, cp := range cdpParams.Params.CollateralParams {
+	// 	if cp.Denom == suite.DeployedErc20.CosmosDenom {
+	// 		found = true
+	// 		suite.DeployedErc20.CdpCollateralType = cp.Type
+	// 	}
+	// }
+	// if !found {
+	// 	panic(fmt.Sprintf(
+	// 		"erc20's cosmos denom %s must be valid cdp collateral type",
+	// 		suite.DeployedErc20.CosmosDenom),
+	// 	)
+	// }
 
 	// deploy an example contract
 	greeterAddr, _, _, err := greeter.DeployGreeter(