smeb_y/0g-chain
1
0
Fork 0
mirror of https://github.com/0glabs/0g-chain.git synced 2024-12-26 00:05:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix some tests

Browse Source
This commit is contained in:
Solovyov1796 2024-04-24 14:30:36 +08:00
parent 4dc6a77045
commit d130229312
8 changed files with 544 additions and 552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
app/ante/ante_test.go
View File

@ -6,12 +6,10 @@ import (
"testing" "testing"
"time" "time"
sdkmath "cosmossdk.io/math"
tmdb "github.com/cometbft/cometbft-db" tmdb "github.com/cometbft/cometbft-db"
abci "github.com/cometbft/cometbft/abci/types" abci "github.com/cometbft/cometbft/abci/types"
"github.com/cometbft/cometbft/libs/log" "github.com/cometbft/cometbft/libs/log"
"github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
"github.com/cosmos/cosmos-sdk/testutil/sims" "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
@ -23,8 +21,8 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/kava-labs/kava/app" "github.com/kava-labs/kava/app"
bep3types "github.com/kava-labs/kava/x/bep3/types" // bep3types "github.com/kava-labs/kava/x/bep3/types"
pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types" // pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
) )
func TestMain(m *testing.M) { func TestMain(m *testing.M) {
@ -36,10 +34,10 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
testPrivKeys, testAddresses := app.GeneratePrivKeyAddressPairs(10) testPrivKeys, testAddresses := app.GeneratePrivKeyAddressPairs(10)
unauthed := testAddresses[0:2] unauthed := testAddresses[0:2]
unauthedKeys := testPrivKeys[0:2] unauthedKeys := testPrivKeys[0:2]
deputy := testAddresses[2] // deputy := testAddresses[2]
deputyKey := testPrivKeys[2] // deputyKey := testPrivKeys[2]
oracles := testAddresses[3:6] // oracles := testAddresses[3:6]
oraclesKeys := testPrivKeys[3:6] // oraclesKeys := testPrivKeys[3:6]
manual := testAddresses[6:] manual := testAddresses[6:]
manualKeys := testPrivKeys[6:] manualKeys := testPrivKeys[6:]
@ -70,8 +68,8 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
sdk.NewCoins(sdk.NewInt64Coin("ukava", 1e9)), sdk.NewCoins(sdk.NewInt64Coin("ukava", 1e9)),
testAddresses, testAddresses,
), ),
newBep3GenStateMulti(tApp.AppCodec(), deputy), // newBep3GenStateMulti(tApp.AppCodec(), deputy),
newPricefeedGenStateMulti(tApp.AppCodec(), oracles), // newPricefeedGenStateMulti(tApp.AppCodec(), oracles),
) )
testcases := []struct { testcases := []struct {
@ -86,18 +84,18 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
privKey: unauthedKeys[1], privKey: unauthedKeys[1],
expectPass: false, expectPass: false,
}, },
{ // {
name: "oracle", // name: "oracle",
address: oracles[1], // address: oracles[1],
privKey: oraclesKeys[1], // privKey: oraclesKeys[1],
expectPass: true, // expectPass: true,
}, // },
{ // {
name: "deputy", // name: "deputy",
address: deputy, // address: deputy,
privKey: deputyKey, // privKey: deputyKey,
expectPass: true, // expectPass: true,
}, // },
{ {
name: "manual", name: "manual",
address: manual[1], address: manual[1],
@ -145,53 +143,53 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
} }
} }
func newPricefeedGenStateMulti(cdc codec.JSONCodec, oracles []sdk.AccAddress) app.GenesisState { // func newPricefeedGenStateMulti(cdc codec.JSONCodec, oracles []sdk.AccAddress) app.GenesisState {
pfGenesis := pricefeedtypes.GenesisState{ // pfGenesis := pricefeedtypes.GenesisState{
Params: pricefeedtypes.Params{ // Params: pricefeedtypes.Params{
Markets: []pricefeedtypes.Market{ // Markets: []pricefeedtypes.Market{
{MarketID: "btc:usd", BaseAsset: "btc", QuoteAsset: "usd", Oracles: oracles, Active: true}, // {MarketID: "btc:usd", BaseAsset: "btc", QuoteAsset: "usd", Oracles: oracles, Active: true},
}, // },
}, // },
} // }
return app.GenesisState{pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pfGenesis)} // return app.GenesisState{pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pfGenesis)}
} // }
func newBep3GenStateMulti(cdc codec.JSONCodec, deputyAddress sdk.AccAddress) app.GenesisState { // func newBep3GenStateMulti(cdc codec.JSONCodec, deputyAddress sdk.AccAddress) app.GenesisState {
bep3Genesis := bep3types.GenesisState{ // bep3Genesis := bep3types.GenesisState{
Params: bep3types.Params{ // Params: bep3types.Params{
AssetParams: bep3types.AssetParams{ // AssetParams: bep3types.AssetParams{
bep3types.AssetParam{ // bep3types.AssetParam{
Denom: "bnb", // Denom: "bnb",
CoinID: 714, // CoinID: 714,
SupplyLimit: bep3types.SupplyLimit{ // SupplyLimit: bep3types.SupplyLimit{
Limit: sdkmath.NewInt(350000000000000), // Limit: sdkmath.NewInt(350000000000000),
TimeLimited: false, // TimeLimited: false,
TimeBasedLimit: sdk.ZeroInt(), // TimeBasedLimit: sdk.ZeroInt(),
TimePeriod: time.Hour, // TimePeriod: time.Hour,
}, // },
Active: true, // Active: true,
DeputyAddress: deputyAddress, // DeputyAddress: deputyAddress,
FixedFee: sdkmath.NewInt(1000), // FixedFee: sdkmath.NewInt(1000),
MinSwapAmount: sdk.OneInt(), // MinSwapAmount: sdk.OneInt(),
MaxSwapAmount: sdkmath.NewInt(1000000000000), // MaxSwapAmount: sdkmath.NewInt(1000000000000),
MinBlockLock: bep3types.DefaultMinBlockLock, // MinBlockLock: bep3types.DefaultMinBlockLock,
MaxBlockLock: bep3types.DefaultMaxBlockLock, // MaxBlockLock: bep3types.DefaultMaxBlockLock,
}, // },
}, // },
}, // },
Supplies: bep3types.AssetSupplies{ // Supplies: bep3types.AssetSupplies{
bep3types.NewAssetSupply( // bep3types.NewAssetSupply(
sdk.NewCoin("bnb", sdk.ZeroInt()), // sdk.NewCoin("bnb", sdk.ZeroInt()),
sdk.NewCoin("bnb", sdk.ZeroInt()), // sdk.NewCoin("bnb", sdk.ZeroInt()),
sdk.NewCoin("bnb", sdk.ZeroInt()), // sdk.NewCoin("bnb", sdk.ZeroInt()),
sdk.NewCoin("bnb", sdk.ZeroInt()), // sdk.NewCoin("bnb", sdk.ZeroInt()),
time.Duration(0), // time.Duration(0),
), // ),
}, // },
PreviousBlockTime: bep3types.DefaultPreviousBlockTime, // PreviousBlockTime: bep3types.DefaultPreviousBlockTime,
} // }
return app.GenesisState{bep3types.ModuleName: cdc.MustMarshalJSON(&bep3Genesis)} // return app.GenesisState{bep3types.ModuleName: cdc.MustMarshalJSON(&bep3Genesis)}
} // }
func TestAppAnteHandler_RejectMsgsInAuthz(t *testing.T) { func TestAppAnteHandler_RejectMsgsInAuthz(t *testing.T) {
testPrivKeys, testAddresses := app.GeneratePrivKeyAddressPairs(10) testPrivKeys, testAddresses := app.GeneratePrivKeyAddressPairs(10)

349
app/ante/eip712_test.go
View File

@ -34,12 +34,12 @@ import (
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
"github.com/kava-labs/kava/app" "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" evmutilkeeper "github.com/kava-labs/kava/x/evmutil/keeper"
evmutiltestutil "github.com/kava-labs/kava/x/evmutil/testutil" evmutiltestutil "github.com/kava-labs/kava/x/evmutil/testutil"
evmutiltypes "github.com/kava-labs/kava/x/evmutil/types" evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
hardtypes "github.com/kava-labs/kava/x/hard/types" // hardtypes "github.com/kava-labs/kava/x/hard/types"
pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types" // pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
) )
const ( const (
@ -173,98 +173,98 @@ func (suite *EIP712TestSuite) SetupTest() {
feemarketGenesis.Params.EnableHeight = 1 feemarketGenesis.Params.EnableHeight = 1
feemarketGenesis.Params.NoBaseFee = false feemarketGenesis.Params.NoBaseFee = false
cdpGenState := cdptypes.DefaultGenesisState() // cdpGenState := cdptypes.DefaultGenesisState()
cdpGenState.Params.GlobalDebtLimit = sdk.NewInt64Coin("usdx", 53000000000000) // cdpGenState.Params.GlobalDebtLimit = sdk.NewInt64Coin("usdx", 53000000000000)
cdpGenState.Params.CollateralParams = cdptypes.CollateralParams{ // cdpGenState.Params.CollateralParams = cdptypes.CollateralParams{
{ // {
Denom: USDCCoinDenom, // Denom: USDCCoinDenom,
Type: USDCCDPType, // Type: USDCCDPType,
LiquidationRatio: sdk.MustNewDecFromStr("1.01"), // LiquidationRatio: sdk.MustNewDecFromStr("1.01"),
DebtLimit: sdk.NewInt64Coin("usdx", 500000000000), // DebtLimit: sdk.NewInt64Coin("usdx", 500000000000),
StabilityFee: sdk.OneDec(), // StabilityFee: sdk.OneDec(),
AuctionSize: sdkmath.NewIntFromUint64(10000000000), // AuctionSize: sdkmath.NewIntFromUint64(10000000000),
LiquidationPenalty: sdk.MustNewDecFromStr("0.05"), // LiquidationPenalty: sdk.MustNewDecFromStr("0.05"),
CheckCollateralizationIndexCount: sdkmath.NewInt(10), // CheckCollateralizationIndexCount: sdkmath.NewInt(10),
KeeperRewardPercentage: sdk.MustNewDecFromStr("0.01"), // KeeperRewardPercentage: sdk.MustNewDecFromStr("0.01"),
SpotMarketID: "usdc:usd", // SpotMarketID: "usdc:usd",
LiquidationMarketID: "usdc:usd:30", // LiquidationMarketID: "usdc:usd:30",
ConversionFactor: sdkmath.NewInt(18), // ConversionFactor: sdkmath.NewInt(18),
}, // },
} // }
hardGenState := hardtypes.DefaultGenesisState() // hardGenState := hardtypes.DefaultGenesisState()
hardGenState.Params.MoneyMarkets = []hardtypes.MoneyMarket{ // hardGenState.Params.MoneyMarkets = []hardtypes.MoneyMarket{
{ // {
Denom: "usdx", // Denom: "usdx",
BorrowLimit: hardtypes.BorrowLimit{ // BorrowLimit: hardtypes.BorrowLimit{
HasMaxLimit: true, // HasMaxLimit: true,
MaximumLimit: sdk.MustNewDecFromStr("100000000000"), // MaximumLimit: sdk.MustNewDecFromStr("100000000000"),
LoanToValue: sdk.MustNewDecFromStr("1"), // LoanToValue: sdk.MustNewDecFromStr("1"),
}, // },
SpotMarketID: "usdx:usd", // SpotMarketID: "usdx:usd",
ConversionFactor: sdkmath.NewInt(1_000_000), // ConversionFactor: sdkmath.NewInt(1_000_000),
InterestRateModel: hardtypes.InterestRateModel{ // InterestRateModel: hardtypes.InterestRateModel{
BaseRateAPY: sdk.MustNewDecFromStr("0.05"), // BaseRateAPY: sdk.MustNewDecFromStr("0.05"),
BaseMultiplier: sdk.MustNewDecFromStr("2"), // BaseMultiplier: sdk.MustNewDecFromStr("2"),
Kink: sdk.MustNewDecFromStr("0.8"), // Kink: sdk.MustNewDecFromStr("0.8"),
JumpMultiplier: sdk.MustNewDecFromStr("10"), // JumpMultiplier: sdk.MustNewDecFromStr("10"),
}, // },
ReserveFactor: sdk.MustNewDecFromStr("0.05"), // ReserveFactor: sdk.MustNewDecFromStr("0.05"),
KeeperRewardPercentage: sdk.ZeroDec(), // KeeperRewardPercentage: sdk.ZeroDec(),
}, // },
} // }
pricefeedGenState := pricefeedtypes.DefaultGenesisState() // pricefeedGenState := pricefeedtypes.DefaultGenesisState()
pricefeedGenState.Params.Markets = []pricefeedtypes.Market{ // pricefeedGenState.Params.Markets = []pricefeedtypes.Market{
{ // {
MarketID: "usdx:usd", // MarketID: "usdx:usd",
BaseAsset: "usdx", // BaseAsset: "usdx",
QuoteAsset: "usd", // QuoteAsset: "usd",
Oracles: []sdk.AccAddress{}, // Oracles: []sdk.AccAddress{},
Active: true, // Active: true,
}, // },
{ // {
MarketID: "usdc:usd", // MarketID: "usdc:usd",
BaseAsset: "usdc", // BaseAsset: "usdc",
QuoteAsset: "usd", // QuoteAsset: "usd",
Oracles: []sdk.AccAddress{}, // Oracles: []sdk.AccAddress{},
Active: true, // Active: true,
}, // },
{ // {
MarketID: "usdc:usd:30", // MarketID: "usdc:usd:30",
BaseAsset: "usdc", // BaseAsset: "usdc",
QuoteAsset: "usd", // QuoteAsset: "usd",
Oracles: []sdk.AccAddress{}, // Oracles: []sdk.AccAddress{},
Active: true, // Active: true,
}, // },
} // }
pricefeedGenState.PostedPrices = []pricefeedtypes.PostedPrice{ // pricefeedGenState.PostedPrices = []pricefeedtypes.PostedPrice{
{ // {
MarketID: "usdx:usd", // MarketID: "usdx:usd",
OracleAddress: sdk.AccAddress{}, // OracleAddress: sdk.AccAddress{},
Price: sdk.MustNewDecFromStr("1.00"), // Price: sdk.MustNewDecFromStr("1.00"),
Expiry: time.Now().Add(1 * time.Hour), // Expiry: time.Now().Add(1 * time.Hour),
}, // },
{ // {
MarketID: "usdc:usd", // MarketID: "usdc:usd",
OracleAddress: sdk.AccAddress{}, // OracleAddress: sdk.AccAddress{},
Price: sdk.MustNewDecFromStr("1.00"), // Price: sdk.MustNewDecFromStr("1.00"),
Expiry: time.Now().Add(1 * time.Hour), // Expiry: time.Now().Add(1 * time.Hour),
}, // },
{ // {
MarketID: "usdc:usd:30", // MarketID: "usdc:usd:30",
OracleAddress: sdk.AccAddress{}, // OracleAddress: sdk.AccAddress{},
Price: sdk.MustNewDecFromStr("1.00"), // Price: sdk.MustNewDecFromStr("1.00"),
Expiry: time.Now().Add(1 * time.Hour), // Expiry: time.Now().Add(1 * time.Hour),
}, // },
} // }
genState := app.GenesisState{ genState := app.GenesisState{
evmtypes.ModuleName: cdc.MustMarshalJSON(evmGs), evmtypes.ModuleName: cdc.MustMarshalJSON(evmGs),
feemarkettypes.ModuleName: cdc.MustMarshalJSON(feemarketGenesis), feemarkettypes.ModuleName: cdc.MustMarshalJSON(feemarketGenesis),
cdptypes.ModuleName: cdc.MustMarshalJSON(&cdpGenState), // cdptypes.ModuleName: cdc.MustMarshalJSON(&cdpGenState),
hardtypes.ModuleName: cdc.MustMarshalJSON(&hardGenState), // hardtypes.ModuleName: cdc.MustMarshalJSON(&hardGenState),
pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pricefeedGenState), // pricefeedtypes.ModuleName: cdc.MustMarshalJSON(&pricefeedGenState),
} }
// funds our test accounts with some ukava // funds our test accounts with some ukava
@ -487,40 +487,43 @@ func (suite *EIP712TestSuite) TestEIP712Tx() {
failCheckTx bool failCheckTx bool
errMsg string errMsg string
}{ }{
{ // TODO: need fix
name: "processes deposit eip712 messages successfully", // {
usdcDepositAmt: 100, // name: "processes deposit eip712 messages successfully",
usdxToMintAmt: 99, // usdcDepositAmt: 100,
}, // usdxToMintAmt: 99,
// },
{ {
name: "fails when convertion more erc20 usdc than balance", name: "fails when convertion more erc20 usdc than balance",
usdcDepositAmt: 51_000, usdcDepositAmt: 51_000,
usdxToMintAmt: 100, usdxToMintAmt: 100,
errMsg: "transfer amount exceeds balance", errMsg: "transfer amount exceeds balance",
}, },
{ // TODO: need fix
name: "fails when minting more usdx than allowed", // {
usdcDepositAmt: 100, // name: "fails when minting more usdx than allowed",
usdxToMintAmt: 100, // usdcDepositAmt: 100,
errMsg: "proposed collateral ratio is below liquidation ratio", // usdxToMintAmt: 100,
}, // errMsg: "proposed collateral ratio is below liquidation ratio",
{ // },
name: "fails when trying to convert usdc for another address", // TODO: need fix
usdcDepositAmt: 100, // {
usdxToMintAmt: 90, // name: "fails when trying to convert usdc for another address",
errMsg: "unauthorized", // usdcDepositAmt: 100,
failCheckTx: true, // usdxToMintAmt: 90,
updateMsgs: func(msgs []sdk.Msg) []sdk.Msg { // errMsg: "unauthorized",
convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin( // failCheckTx: true,
suite.testEVMAddr2, // updateMsgs: func(msgs []sdk.Msg) []sdk.Msg {
suite.testAddr, // convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin(
suite.usdcEVMAddr, // suite.testEVMAddr2,
suite.getEVMAmount(100), // suite.testAddr,
) // suite.usdcEVMAddr,
msgs[0] = &convertMsg // suite.getEVMAmount(100),
return msgs // )
}, // msgs[0] = &convertMsg
}, // return msgs
// },
// },
{ {
name: "fails when trying to convert erc20 for non-whitelisted contract", name: "fails when trying to convert erc20 for non-whitelisted contract",
usdcDepositAmt: 100, usdcDepositAmt: 100,
@ -607,21 +610,21 @@ func (suite *EIP712TestSuite) TestEIP712Tx() {
suite.usdcEVMAddr, suite.usdcEVMAddr,
usdcAmt, usdcAmt,
) )
usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(tc.usdxToMintAmt)) // usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(tc.usdxToMintAmt))
mintMsg := cdptypes.NewMsgCreateCDP( // mintMsg := cdptypes.NewMsgCreateCDP(
suite.testAddr, // suite.testAddr,
sdk.NewCoin(USDCCoinDenom, usdcAmt), // sdk.NewCoin(USDCCoinDenom, usdcAmt),
sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt), // sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
USDCCDPType, // USDCCDPType,
) // )
lendMsg := hardtypes.NewMsgDeposit( // lendMsg := hardtypes.NewMsgDeposit(
suite.testAddr, // suite.testAddr,
sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)), // sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
) // )
msgs := []sdk.Msg{ msgs := []sdk.Msg{
&convertMsg, &convertMsg,
&mintMsg, // &mintMsg,
&lendMsg, // &lendMsg,
} }
if tc.updateMsgs != nil { if tc.updateMsgs != nil {
msgs = tc.updateMsgs(msgs) msgs = tc.updateMsgs(msgs)
@ -665,17 +668,17 @@ func (suite *EIP712TestSuite) TestEIP712Tx() {
suite.Require().Equal(sdk.ZeroInt(), amt.Amount) suite.Require().Equal(sdk.ZeroInt(), amt.Amount)
// validate cdp // validate cdp
cdp, found := suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType) // cdp, found := suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType)
suite.Require().True(found) // suite.Require().True(found)
suite.Require().Equal(suite.testAddr, cdp.Owner) // suite.Require().Equal(suite.testAddr, cdp.Owner)
suite.Require().Equal(sdk.NewCoin(USDCCoinDenom, suite.getEVMAmount(100)), cdp.Collateral) // suite.Require().Equal(sdk.NewCoin(USDCCoinDenom, suite.getEVMAmount(100)), cdp.Collateral)
suite.Require().Equal(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000)), cdp.Principal) // suite.Require().Equal(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000)), cdp.Principal)
// validate hard // // validate hard
hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr) // hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
suite.Require().True(found) // suite.Require().True(found)
suite.Require().Equal(suite.testAddr, hardDeposit.Depositor) // suite.Require().Equal(suite.testAddr, hardDeposit.Depositor)
suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount) // suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount)
} else { } else {
suite.Require().NotEqual(resDeliverTx.Code, uint32(0), resCheckTx.Log) suite.Require().NotEqual(resDeliverTx.Code, uint32(0), resCheckTx.Log)
suite.Require().Contains(resDeliverTx.Log, tc.errMsg) suite.Require().Contains(resDeliverTx.Log, tc.errMsg)
@ -695,21 +698,21 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
suite.usdcEVMAddr, suite.usdcEVMAddr,
usdcAmt, usdcAmt,
) )
usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(99)) // usdxAmt := sdkmath.NewInt(1_000_000).Mul(sdkmath.NewInt(99))
mintMsg := cdptypes.NewMsgCreateCDP( // mintMsg := cdptypes.NewMsgCreateCDP(
suite.testAddr, // suite.testAddr,
sdk.NewCoin(USDCCoinDenom, usdcAmt), // sdk.NewCoin(USDCCoinDenom, usdcAmt),
sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt), // sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
USDCCDPType, // USDCCDPType,
) // )
lendMsg := hardtypes.NewMsgDeposit( // lendMsg := hardtypes.NewMsgDeposit(
suite.testAddr, // suite.testAddr,
sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)), // sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
) // )
depositMsgs := []sdk.Msg{ depositMsgs := []sdk.Msg{
&convertMsg, &convertMsg,
&mintMsg, // &mintMsg,
&lendMsg, // &lendMsg,
} }
// deliver deposit msg // deliver deposit msg
@ -726,11 +729,11 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
) )
suite.Require().Equal(resDeliverTx.Code, uint32(0), resDeliverTx.Log) suite.Require().Equal(resDeliverTx.Code, uint32(0), resDeliverTx.Log)
// validate hard // // validate hard
hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr) // hardDeposit, found := suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
suite.Require().True(found) // suite.Require().True(found)
suite.Require().Equal(suite.testAddr, hardDeposit.Depositor) // suite.Require().Equal(suite.testAddr, hardDeposit.Depositor)
suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount) // suite.Require().Equal(sdk.NewCoins(sdk.NewCoin("usdx", sdkmath.NewInt(99_000_000))), hardDeposit.Amount)
// validate erc20 balance // validate erc20 balance
coinBal, err := suite.evmutilKeeper.QueryERC20BalanceOf(suite.ctx, suite.usdcEVMAddr, suite.testEVMAddr) coinBal, err := suite.evmutilKeeper.QueryERC20BalanceOf(suite.ctx, suite.usdcEVMAddr, suite.testEVMAddr)
@ -743,18 +746,18 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
suite.testEVMAddr.String(), suite.testEVMAddr.String(),
sdk.NewCoin(USDCCoinDenom, usdcAmt), sdk.NewCoin(USDCCoinDenom, usdcAmt),
) )
cdpWithdrawMsg := cdptypes.NewMsgRepayDebt( // cdpWithdrawMsg := cdptypes.NewMsgRepayDebt(
suite.testAddr, // suite.testAddr,
USDCCDPType, // USDCCDPType,
sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt), // sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt),
) // )
hardWithdrawMsg := hardtypes.NewMsgWithdraw( // hardWithdrawMsg := hardtypes.NewMsgWithdraw(
suite.testAddr, // suite.testAddr,
sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)), // sdk.NewCoins(sdk.NewCoin(cdptypes.DefaultStableDenom, usdxAmt)),
) // )
withdrawMsgs := []sdk.Msg{ withdrawMsgs := []sdk.Msg{
&hardWithdrawMsg, // &hardWithdrawMsg,
&cdpWithdrawMsg, // &cdpWithdrawMsg,
&withdrawConvertMsg, &withdrawConvertMsg,
} }
@ -772,10 +775,10 @@ func (suite *EIP712TestSuite) TestEIP712Tx_DepositAndWithdraw() {
suite.Require().Equal(resDeliverTx.Code, uint32(0), resDeliverTx.Log) suite.Require().Equal(resDeliverTx.Code, uint32(0), resDeliverTx.Log)
// validate hard & cdp should be repayed // validate hard & cdp should be repayed
_, found = suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr) // _, found = suite.tApp.GetHardKeeper().GetDeposit(suite.ctx, suite.testAddr)
suite.Require().False(found) // suite.Require().False(found)
_, found = suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType) // _, found = suite.tApp.GetCDPKeeper().GetCdpByOwnerAndCollateralType(suite.ctx, suite.testAddr, USDCCDPType)
suite.Require().False(found) // suite.Require().False(found)
// validate user cosmos erc20/usd balance // validate user cosmos erc20/usd balance
bk := suite.tApp.GetBankKeeper() bk := suite.tApp.GetBankKeeper()

84
client/grpc/query/query.go
View File

@ -24,21 +24,21 @@ import (
evmtypes "github.com/evmos/ethermint/x/evm/types" evmtypes "github.com/evmos/ethermint/x/evm/types"
feemarkettypes "github.com/evmos/ethermint/x/feemarket/types" feemarkettypes "github.com/evmos/ethermint/x/feemarket/types"
auctiontypes "github.com/kava-labs/kava/x/auction/types" // auctiontypes "github.com/kava-labs/kava/x/auction/types"
bep3types "github.com/kava-labs/kava/x/bep3/types" // bep3types "github.com/kava-labs/kava/x/bep3/types"
cdptypes "github.com/kava-labs/kava/x/cdp/types" // cdptypes "github.com/kava-labs/kava/x/cdp/types"
committeetypes "github.com/kava-labs/kava/x/committee/types" // committeetypes "github.com/kava-labs/kava/x/committee/types"
communitytypes "github.com/kava-labs/kava/x/community/types" // communitytypes "github.com/kava-labs/kava/x/community/types"
earntypes "github.com/kava-labs/kava/x/earn/types" // earntypes "github.com/kava-labs/kava/x/earn/types"
evmutiltypes "github.com/kava-labs/kava/x/evmutil/types" evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
hardtypes "github.com/kava-labs/kava/x/hard/types" // hardtypes "github.com/kava-labs/kava/x/hard/types"
incentivetypes "github.com/kava-labs/kava/x/incentive/types" // incentivetypes "github.com/kava-labs/kava/x/incentive/types"
issuancetypes "github.com/kava-labs/kava/x/issuance/types" // issuancetypes "github.com/kava-labs/kava/x/issuance/types"
kavadisttypes "github.com/kava-labs/kava/x/kavadist/types" // kavadisttypes "github.com/kava-labs/kava/x/kavadist/types"
liquidtypes "github.com/kava-labs/kava/x/liquid/types" // liquidtypes "github.com/kava-labs/kava/x/liquid/types"
pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types" // pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
savingstypes "github.com/kava-labs/kava/x/savings/types" // savingstypes "github.com/kava-labs/kava/x/savings/types"
swaptypes "github.com/kava-labs/kava/x/swap/types" // swaptypes "github.com/kava-labs/kava/x/swap/types"
) )
// QueryClient is a wrapper with all Cosmos and Kava grpc query clients // QueryClient is a wrapper with all Cosmos and Kava grpc query clients
@ -70,21 +70,21 @@ type QueryClient struct {
// kava module query clients // kava module query clients
Auction auctiontypes.QueryClient // Auction auctiontypes.QueryClient
Bep3 bep3types.QueryClient // Bep3 bep3types.QueryClient
Cdp cdptypes.QueryClient // Cdp cdptypes.QueryClient
Committee committeetypes.QueryClient // Committee committeetypes.QueryClient
Community communitytypes.QueryClient // Community communitytypes.QueryClient
Earn earntypes.QueryClient // Earn earntypes.QueryClient
Evmutil evmutiltypes.QueryClient Evmutil evmutiltypes.QueryClient
Hard hardtypes.QueryClient // Hard hardtypes.QueryClient
Incentive incentivetypes.QueryClient // Incentive incentivetypes.QueryClient
Issuance issuancetypes.QueryClient // Issuance issuancetypes.QueryClient
Kavadist kavadisttypes.QueryClient // Kavadist kavadisttypes.QueryClient
Liquid liquidtypes.QueryClient // Liquid liquidtypes.QueryClient
Pricefeed pricefeedtypes.QueryClient // Pricefeed pricefeedtypes.QueryClient
Savings savingstypes.QueryClient // Savings savingstypes.QueryClient
Swap swaptypes.QueryClient // Swap swaptypes.QueryClient
} }
// NewQueryClient creates a new QueryClient and initializes all the module query clients // 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), IbcClient: ibcclienttypes.NewQueryClient(conn),
IbcTransfer: ibctransfertypes.NewQueryClient(conn), IbcTransfer: ibctransfertypes.NewQueryClient(conn),
Auction: auctiontypes.NewQueryClient(conn), // Auction: auctiontypes.NewQueryClient(conn),
Bep3: bep3types.NewQueryClient(conn), // Bep3: bep3types.NewQueryClient(conn),
Cdp: cdptypes.NewQueryClient(conn), // Cdp: cdptypes.NewQueryClient(conn),
Committee: committeetypes.NewQueryClient(conn), // Committee: committeetypes.NewQueryClient(conn),
Community: communitytypes.NewQueryClient(conn), // Community: communitytypes.NewQueryClient(conn),
Earn: earntypes.NewQueryClient(conn), // Earn: earntypes.NewQueryClient(conn),
Evmutil: evmutiltypes.NewQueryClient(conn), Evmutil: evmutiltypes.NewQueryClient(conn),
Hard: hardtypes.NewQueryClient(conn), // Hard: hardtypes.NewQueryClient(conn),
Incentive: incentivetypes.NewQueryClient(conn), // Incentive: incentivetypes.NewQueryClient(conn),
Issuance: issuancetypes.NewQueryClient(conn), // Issuance: issuancetypes.NewQueryClient(conn),
Kavadist: kavadisttypes.NewQueryClient(conn), // Kavadist: kavadisttypes.NewQueryClient(conn),
Liquid: liquidtypes.NewQueryClient(conn), // Liquid: liquidtypes.NewQueryClient(conn),
Pricefeed: pricefeedtypes.NewQueryClient(conn), // Pricefeed: pricefeedtypes.NewQueryClient(conn),
Savings: savingstypes.NewQueryClient(conn), // Savings: savingstypes.NewQueryClient(conn),
Swap: swaptypes.NewQueryClient(conn), // Swap: swaptypes.NewQueryClient(conn),
} }
return client, nil return client, nil
} }

28
client/grpc/query/query_test.go
View File

@ -55,20 +55,20 @@ func TestNewQueryClient_ValidClient(t *testing.T) {
require.NotNil(t, client.IbcTransfer) require.NotNil(t, client.IbcTransfer)
// validate kava clients // validate kava clients
require.NotNil(t, client.Auction) // require.NotNil(t, client.Auction)
require.NotNil(t, client.Bep3) // require.NotNil(t, client.Bep3)
require.NotNil(t, client.Cdp) // require.NotNil(t, client.Cdp)
require.NotNil(t, client.Committee) // require.NotNil(t, client.Committee)
require.NotNil(t, client.Community) // require.NotNil(t, client.Community)
require.NotNil(t, client.Earn) // require.NotNil(t, client.Earn)
require.NotNil(t, client.Evmutil) require.NotNil(t, client.Evmutil)
require.NotNil(t, client.Hard) // require.NotNil(t, client.Hard)
require.NotNil(t, client.Incentive) // require.NotNil(t, client.Incentive)
require.NotNil(t, client.Issuance) // require.NotNil(t, client.Issuance)
require.NotNil(t, client.Kavadist) // require.NotNil(t, client.Kavadist)
require.NotNil(t, client.Liquid) // require.NotNil(t, client.Liquid)
require.NotNil(t, client.Pricefeed) // require.NotNil(t, client.Pricefeed)
require.NotNil(t, client.Savings) // require.NotNil(t, client.Savings)
require.NotNil(t, client.Swap) // require.NotNil(t, client.Swap)
}) })
} }

291
tests/e2e/e2e_community_update_params_test.go
View File

@ -1,186 +1,177 @@
package e2e_test package e2e_test
import ( import (
"context"
"encoding/hex" "encoding/hex"
"time"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" // communitytypes "github.com/kava-labs/kava/x/community/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"
) )
func (suite *IntegrationTestSuite) TestCommunityUpdateParams_NonAuthority() { // func (suite *IntegrationTestSuite) TestCommunityUpdateParams_NonAuthority() {
// ARRANGE // // ARRANGE
// setup kava account // // setup kava account
funds := ukava(1e5) // .1 KAVA // funds := ukava(1e5) // .1 KAVA
kavaAcc := suite.Kava.NewFundedAccount("community-non-authority", sdk.NewCoins(funds)) // kavaAcc := suite.Kava.NewFundedAccount("community-non-authority", sdk.NewCoins(funds))
gasLimit := int64(2e5) // gasLimit := int64(2e5)
fee := ukava(200) // fee := ukava(200)
msg := communitytypes.NewMsgUpdateParams( // msg := communitytypes.NewMsgUpdateParams(
kavaAcc.SdkAddress, // kavaAcc.SdkAddress,
communitytypes.DefaultParams(), // communitytypes.DefaultParams(),
) // )
// ACT // // ACT
req := util.KavaMsgRequest{ // req := util.KavaMsgRequest{
Msgs: []sdk.Msg{&msg}, // Msgs: []sdk.Msg{&msg},
GasLimit: uint64(gasLimit), // GasLimit: uint64(gasLimit),
FeeAmount: sdk.NewCoins(fee), // FeeAmount: sdk.NewCoins(fee),
Memo: "this is a failure!", // Memo: "this is a failure!",
} // }
res := kavaAcc.SignAndBroadcastKavaTx(req) // res := kavaAcc.SignAndBroadcastKavaTx(req)
// ASSERT // // ASSERT
_, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second) // _, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second)
suite.Require().Error(err) // suite.Require().Error(err)
suite.Require().ErrorContains( // suite.Require().ErrorContains(
err, // err,
govtypes.ErrInvalidSigner.Error(), // govtypes.ErrInvalidSigner.Error(),
"should return with authority check error", // "should return with authority check error",
) // )
} // }
func (suite *IntegrationTestSuite) TestCommunityUpdateParams_Authority() { // func (suite *IntegrationTestSuite) TestCommunityUpdateParams_Authority() {
// ARRANGE // // ARRANGE
govParamsRes, err := suite.Kava.Grpc.Query.Gov.Params(context.Background(), &govv1.QueryParamsRequest{ // govParamsRes, err := suite.Kava.Grpc.Query.Gov.Params(context.Background(), &govv1.QueryParamsRequest{
ParamsType: govv1.ParamDeposit, // ParamsType: govv1.ParamDeposit,
}) // })
suite.NoError(err) // suite.NoError(err)
// Check initial params // // Check initial params
communityParamsResInitial, err := suite.Kava.Grpc.Query.Community.Params( // communityParamsResInitial, err := suite.Kava.Grpc.Query.Community.Params(
context.Background(), // context.Background(),
&communitytypes.QueryParamsRequest{}, // &communitytypes.QueryParamsRequest{},
) // )
suite.Require().NoError(err) // suite.Require().NoError(err)
// setup kava account // // setup kava account
// .1 KAVA + min deposit amount for proposal // // .1 KAVA + min deposit amount for proposal
funds := sdk.NewCoins(ukava(1e5)).Add(govParamsRes.DepositParams.MinDeposit...) // funds := sdk.NewCoins(ukava(1e5)).Add(govParamsRes.DepositParams.MinDeposit...)
kavaAcc := suite.Kava.NewFundedAccount("community-update-params", funds) // kavaAcc := suite.Kava.NewFundedAccount("community-update-params", funds)
gasLimit := int64(2e5) // gasLimit := int64(2e5)
fee := ukava(200) // fee := ukava(200)
// Wait until switchover actually happens - When testing without the upgrade // // Wait until switchover actually happens - When testing without the upgrade
// handler that sets a relative switchover time, the switchover time in // // handler that sets a relative switchover time, the switchover time in
// genesis should be set in the past so it runs immediately. // // genesis should be set in the past so it runs immediately.
suite.Require().Eventually( // suite.Require().Eventually(
func() bool { // func() bool {
params, err := suite.Kava.Grpc.Query.Community.Params( // params, err := suite.Kava.Grpc.Query.Community.Params(
context.Background(), // context.Background(),
&communitytypes.QueryParamsRequest{}, // &communitytypes.QueryParamsRequest{},
) // )
suite.Require().NoError(err) // suite.Require().NoError(err)
return params.Params.UpgradeTimeDisableInflation.Equal(time.Time{}) // return params.Params.UpgradeTimeDisableInflation.Equal(time.Time{})
}, // },
20*time.Second, // 20*time.Second,
1*time.Second, // 1*time.Second,
"switchover should happen", // "switchover should happen",
) // )
// Add 1 to the staking rewards per second // // Add 1 to the staking rewards per second
newStakingRewardsPerSecond := communityParamsResInitial.Params. // newStakingRewardsPerSecond := communityParamsResInitial.Params.
StakingRewardsPerSecond. // StakingRewardsPerSecond.
Add(sdkmath.LegacyNewDec(1)) // Add(sdkmath.LegacyNewDec(1))
// 1. Proposal // // 1. Proposal
// Only modify stakingRewardsPerSecond, as to not re-run the switchover and // // Only modify stakingRewardsPerSecond, as to not re-run the switchover and
// to not influence other tests // // to not influence other tests
updateParamsMsg := communitytypes.NewMsgUpdateParams( // updateParamsMsg := communitytypes.NewMsgUpdateParams(
authtypes.NewModuleAddress(govtypes.ModuleName), // authority // authtypes.NewModuleAddress(govtypes.ModuleName), // authority
communitytypes.NewParams( // communitytypes.NewParams(
time.Time{}, // after switchover, is empty // time.Time{}, // after switchover, is empty
newStakingRewardsPerSecond, // only modify stakingRewardsPerSecond // newStakingRewardsPerSecond, // only modify stakingRewardsPerSecond
communityParamsResInitial.Params.UpgradeTimeSetStakingRewardsPerSecond, // communityParamsResInitial.Params.UpgradeTimeSetStakingRewardsPerSecond,
), // ),
) // )
// Make sure we're actually changing the params // // Make sure we're actually changing the params
suite.NotEqual( // suite.NotEqual(
updateParamsMsg.Params, // updateParamsMsg.Params,
communityParamsResInitial.Params, // communityParamsResInitial.Params,
"new params should be different from existing", // "new params should be different from existing",
) // )
proposalMsg, err := govv1.NewMsgSubmitProposal( // proposalMsg, err := govv1.NewMsgSubmitProposal(
[]sdk.Msg{&updateParamsMsg}, // []sdk.Msg{&updateParamsMsg},
govParamsRes.Params.MinDeposit, // govParamsRes.Params.MinDeposit,
kavaAcc.SdkAddress.String(), // kavaAcc.SdkAddress.String(),
"community-update-params", // "community-update-params",
"title", // "title",
"summary", // "summary",
) // )
suite.NoError(err) // suite.NoError(err)
req := util.KavaMsgRequest{ // req := util.KavaMsgRequest{
Msgs: []sdk.Msg{proposalMsg}, // Msgs: []sdk.Msg{proposalMsg},
GasLimit: uint64(gasLimit), // GasLimit: uint64(gasLimit),
FeeAmount: sdk.NewCoins(fee), // FeeAmount: sdk.NewCoins(fee),
Memo: "this is a proposal please accept me", // Memo: "this is a proposal please accept me",
} // }
res := kavaAcc.SignAndBroadcastKavaTx(req) // res := kavaAcc.SignAndBroadcastKavaTx(req)
suite.Require().NoError(res.Err) // suite.Require().NoError(res.Err)
// Wait for proposal to be submitted // // Wait for proposal to be submitted
txRes, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second) // txRes, err := util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.Result.TxHash, 6*time.Second)
suite.Require().NoError(err) // suite.Require().NoError(err)
// Parse tx response to get proposal id // // Parse tx response to get proposal id
var govRes govv1.MsgSubmitProposalResponse // var govRes govv1.MsgSubmitProposalResponse
suite.decodeTxMsgResponse(txRes, &govRes) // suite.decodeTxMsgResponse(txRes, &govRes)
// 2. Vote for proposal from whale account // // 2. Vote for proposal from whale account
whale := suite.Kava.GetAccount(testutil.FundedAccountName) // whale := suite.Kava.GetAccount(testutil.FundedAccountName)
voteMsg := govv1.NewMsgVote( // voteMsg := govv1.NewMsgVote(
whale.SdkAddress, // whale.SdkAddress,
govRes.ProposalId, // govRes.ProposalId,
govv1.OptionYes, // govv1.OptionYes,
"", // "",
) // )
voteReq := util.KavaMsgRequest{ // voteReq := util.KavaMsgRequest{
Msgs: []sdk.Msg{voteMsg}, // Msgs: []sdk.Msg{voteMsg},
GasLimit: uint64(gasLimit), // GasLimit: uint64(gasLimit),
FeeAmount: sdk.NewCoins(fee), // FeeAmount: sdk.NewCoins(fee),
Memo: "voting", // Memo: "voting",
} // }
voteRes := whale.SignAndBroadcastKavaTx(voteReq) // voteRes := whale.SignAndBroadcastKavaTx(voteReq)
suite.Require().NoError(voteRes.Err) // suite.Require().NoError(voteRes.Err)
_, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, voteRes.Result.TxHash, 6*time.Second) // _, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, voteRes.Result.TxHash, 6*time.Second)
suite.Require().NoError(err) // suite.Require().NoError(err)
// 3. Wait until proposal passes // // 3. Wait until proposal passes
suite.Require().Eventually(func() bool { // suite.Require().Eventually(func() bool {
proposalRes, err := suite.Kava.Grpc.Query.Gov.Proposal(context.Background(), &govv1.QueryProposalRequest{ // proposalRes, err := suite.Kava.Grpc.Query.Gov.Proposal(context.Background(), &govv1.QueryProposalRequest{
ProposalId: govRes.ProposalId, // ProposalId: govRes.ProposalId,
}) // })
suite.NoError(err) // suite.NoError(err)
return proposalRes.Proposal.Status == govv1.StatusPassed // return proposalRes.Proposal.Status == govv1.StatusPassed
}, 60*time.Second, 1*time.Second) // }, 60*time.Second, 1*time.Second)
// Check parameters are updated // // Check parameters are updated
communityParamsRes, err := suite.Kava.Grpc.Query.Community.Params( // communityParamsRes, err := suite.Kava.Grpc.Query.Community.Params(
context.Background(), // context.Background(),
&communitytypes.QueryParamsRequest{}, // &communitytypes.QueryParamsRequest{},
) // )
suite.Require().NoError(err) // 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) { func (suite *IntegrationTestSuite) decodeTxMsgResponse(txRes *sdk.TxResponse, ptr codec.ProtoMarshaler) {
// convert txRes.Data hex string to bytes // convert txRes.Data hex string to bytes

168
tests/e2e/e2e_evm_contracts_test.go
View File

@ -11,8 +11,8 @@ import (
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
"github.com/kava-labs/kava/app" "github.com/kava-labs/kava/app"
cdptypes "github.com/kava-labs/kava/x/cdp/types" // cdptypes "github.com/kava-labs/kava/x/cdp/types"
evmutiltypes "github.com/kava-labs/kava/x/evmutil/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/e2e/contracts/greeter"
"github.com/kava-labs/kava/tests/util" "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. // Note that this test works because the deployed erc20 is configured in evmutil & cdp params.
// This test matches the webapp's "USDT Earn" workflow // This test matches the webapp's "USDT Earn" workflow
func (suite *IntegrationTestSuite) TestEip712ConvertToCoinAndDepositToLend() { // func (suite *IntegrationTestSuite) TestEip712ConvertToCoinAndDepositToLend() {
// cdp requires minimum of $11 collateral // // cdp requires minimum of $11 collateral
amount := sdk.NewInt(11e6) // 11 USDT // amount := sdk.NewInt(11e6) // 11 USDT
principal := sdk.NewCoin("usdx", sdk.NewInt(10e6)) // principal := sdk.NewCoin("usdx", sdk.NewInt(10e6))
sdkDenom := suite.DeployedErc20.CosmosDenom // sdkDenom := suite.DeployedErc20.CosmosDenom
// create new funded account // // create new funded account
depositor := suite.Kava.NewFundedAccount("eip712-lend-depositor", sdk.NewCoins(ukava(1e5))) // depositor := suite.Kava.NewFundedAccount("eip712-lend-depositor", sdk.NewCoins(ukava(1e5)))
// give them erc20 balance to deposit // // give them erc20 balance to deposit
fundRes := suite.FundKavaErc20Balance(depositor.EvmAddress, amount.BigInt()) // fundRes := suite.FundKavaErc20Balance(depositor.EvmAddress, amount.BigInt())
suite.NoError(fundRes.Err) // suite.NoError(fundRes.Err)
// setup messages for convert to coin & deposit into earn // // setup messages for convert to coin & deposit into earn
convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin( // convertMsg := evmutiltypes.NewMsgConvertERC20ToCoin(
evmutiltypes.NewInternalEVMAddress(depositor.EvmAddress), // evmutiltypes.NewInternalEVMAddress(depositor.EvmAddress),
depositor.SdkAddress, // depositor.SdkAddress,
evmutiltypes.NewInternalEVMAddress(suite.DeployedErc20.Address), // evmutiltypes.NewInternalEVMAddress(suite.DeployedErc20.Address),
amount, // amount,
) // )
depositMsg := cdptypes.NewMsgCreateCDP( // // depositMsg := cdptypes.NewMsgCreateCDP(
depositor.SdkAddress, // // depositor.SdkAddress,
sdk.NewCoin(sdkDenom, amount), // // sdk.NewCoin(sdkDenom, amount),
principal, // // principal,
suite.DeployedErc20.CdpCollateralType, // // suite.DeployedErc20.CdpCollateralType,
) // // )
msgs := []sdk.Msg{ // msgs := []sdk.Msg{
// convert to coin // // convert to coin
&convertMsg, // &convertMsg,
// deposit into cdp (Mint), take out USDX // // deposit into cdp (Mint), take out USDX
&depositMsg, // // &depositMsg,
} // }
// create tx // // create tx
tx := suite.NewEip712TxBuilder( // tx := suite.NewEip712TxBuilder(
depositor, // depositor,
suite.Kava, // suite.Kava,
1e6, // 1e6,
sdk.NewCoins(ukava(1e4)), // sdk.NewCoins(ukava(1e4)),
msgs, // msgs,
"doing the USDT Earn workflow! erc20 -> sdk.Coin -> USDX hard deposit", // "doing the USDT Earn workflow! erc20 -> sdk.Coin -> USDX hard deposit",
).GetTx() // ).GetTx()
txBytes, err := suite.Kava.EncodingConfig.TxConfig.TxEncoder()(tx) // txBytes, err := suite.Kava.EncodingConfig.TxConfig.TxEncoder()(tx)
suite.NoError(err) // suite.NoError(err)
// broadcast tx // // broadcast tx
res, err := suite.Kava.Grpc.Query.Tx.BroadcastTx(context.Background(), &txtypes.BroadcastTxRequest{ // res, err := suite.Kava.Grpc.Query.Tx.BroadcastTx(context.Background(), &txtypes.BroadcastTxRequest{
TxBytes: txBytes, // TxBytes: txBytes,
Mode: txtypes.BroadcastMode_BROADCAST_MODE_SYNC, // Mode: txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
}) // })
suite.NoError(err) // suite.NoError(err)
suite.Equal(sdkerrors.SuccessABCICode, res.TxResponse.Code) // suite.Equal(sdkerrors.SuccessABCICode, res.TxResponse.Code)
_, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.TxResponse.TxHash, 6*time.Second) // _, err = util.WaitForSdkTxCommit(suite.Kava.Grpc.Query.Tx, res.TxResponse.TxHash, 6*time.Second)
suite.Require().NoError(err) // suite.Require().NoError(err)
// check that depositor no longer has erc20 balance // // check that depositor no longer has erc20 balance
balance := suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress) // balance := suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress)
suite.BigIntsEqual(big.NewInt(0), balance, "expected no erc20 balance") // suite.BigIntsEqual(big.NewInt(0), balance, "expected no erc20 balance")
// check that account has cdp // // check that account has cdp
cdpRes, err := suite.Kava.Grpc.Query.Cdp.Cdp(context.Background(), &cdptypes.QueryCdpRequest{ // // cdpRes, err := suite.Kava.Grpc.Query.Cdp.Cdp(context.Background(), &cdptypes.QueryCdpRequest{
CollateralType: suite.DeployedErc20.CdpCollateralType, // // CollateralType: suite.DeployedErc20.CdpCollateralType,
Owner: depositor.SdkAddress.String(), // // Owner: depositor.SdkAddress.String(),
}) // // })
suite.NoError(err) // // suite.NoError(err)
suite.True(cdpRes.Cdp.Collateral.Amount.Equal(amount)) // // suite.True(cdpRes.Cdp.Collateral.Amount.Equal(amount))
suite.True(cdpRes.Cdp.Principal.Equal(principal)) // // suite.True(cdpRes.Cdp.Principal.Equal(principal))
// withdraw deposit & convert back to erc20 (this allows refund to recover erc20s used in test) // // withdraw deposit & convert back to erc20 (this allows refund to recover erc20s used in test)
withdraw := cdptypes.NewMsgRepayDebt( // // withdraw := cdptypes.NewMsgRepayDebt(
depositor.SdkAddress, // // depositor.SdkAddress,
suite.DeployedErc20.CdpCollateralType, // // suite.DeployedErc20.CdpCollateralType,
principal, // // principal,
) // // )
convertBack := evmutiltypes.NewMsgConvertCoinToERC20( // convertBack := evmutiltypes.NewMsgConvertCoinToERC20(
depositor.SdkAddress.String(), // depositor.SdkAddress.String(),
depositor.EvmAddress.Hex(), // depositor.EvmAddress.Hex(),
sdk.NewCoin(sdkDenom, amount), // sdk.NewCoin(sdkDenom, amount),
) // )
withdrawAndConvertBack := util.KavaMsgRequest{ // withdrawAndConvertBack := util.KavaMsgRequest{
Msgs: []sdk.Msg{&withdraw, &convertBack}, // Msgs: []sdk.Msg{&withdraw, &convertBack},
GasLimit: 1e6, // GasLimit: 1e6,
FeeAmount: sdk.NewCoins(ukava(1000)), // FeeAmount: sdk.NewCoins(ukava(1000)),
Data: "withdrawing from mint & converting back to erc20", // Data: "withdrawing from mint & converting back to erc20",
} // }
lastRes := depositor.SignAndBroadcastKavaTx(withdrawAndConvertBack) // lastRes := depositor.SignAndBroadcastKavaTx(withdrawAndConvertBack)
suite.NoError(lastRes.Err) // suite.NoError(lastRes.Err)
balance = suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress) // balance = suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, depositor.EvmAddress)
suite.BigIntsEqual(amount.BigInt(), balance, "expected returned erc20 balance") // suite.BigIntsEqual(amount.BigInt(), balance, "expected returned erc20 balance")
} // }

6
tests/e2e/e2e_min_fees_test.go
View File

@ -21,16 +21,16 @@ func (suite *IntegrationTestSuite) TestEthGasPriceReturnsMinFee() {
// read expected min fee from app.toml // read expected min fee from app.toml
minGasPrices, err := getMinFeeFromAppToml(util.KavaHomePath()) 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 // evm uses akava, get akava min fee
evmMinGas := minGasPrices.AmountOf("akava").TruncateInt().BigInt() evmMinGas := minGasPrices.AmountOf("akava").TruncateInt().BigInt()
// returns eth_gasPrice, units in kava // returns eth_gasPrice, units in kava
gasPrice, err := suite.Kava.EvmClient.SuggestGasPrice(context.Background()) 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() { func (suite *IntegrationTestSuite) TestEvmRespectsMinFee() {

32
tests/e2e/testutil/init_evm.go
View File

@ -8,7 +8,7 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/kava-labs/kava/tests/e2e/contracts/greeter" "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" evmutiltypes "github.com/kava-labs/kava/x/evmutil/types"
) )
@ -46,21 +46,21 @@ func (suite *E2eTestSuite) InitKavaEvmData() {
suite.Kava.RegisterErc20(suite.DeployedErc20.Address) suite.Kava.RegisterErc20(suite.DeployedErc20.Address)
// expect the erc20's cosmos denom to be a supported cdp collateral type // 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{}) // cdpParams, err := suite.Kava.Grpc.Query.Cdp.Params(context.Background(), &types.QueryParamsRequest{})
suite.Require().NoError(err) // suite.Require().NoError(err)
found = false // found = false
for _, cp := range cdpParams.Params.CollateralParams { // for _, cp := range cdpParams.Params.CollateralParams {
if cp.Denom == suite.DeployedErc20.CosmosDenom { // if cp.Denom == suite.DeployedErc20.CosmosDenom {
found = true // found = true
suite.DeployedErc20.CdpCollateralType = cp.Type // suite.DeployedErc20.CdpCollateralType = cp.Type
} // }
} // }
if !found { // if !found {
panic(fmt.Sprintf( // panic(fmt.Sprintf(
"erc20's cosmos denom %s must be valid cdp collateral type", // "erc20's cosmos denom %s must be valid cdp collateral type",
suite.DeployedErc20.CosmosDenom), // suite.DeployedErc20.CosmosDenom),
) // )
} // }
// deploy an example contract // deploy an example contract
greeterAddr, _, _, err := greeter.DeployGreeter( greeterAddr, _, _, err := greeter.DeployGreeter(