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 unit test

Browse Source
This commit is contained in:
Solovyov1796 2024-05-05 15:00:03 +08:00 committed by 0g-wh
parent 73668e408a
commit 8999139ddf
10 changed files with 214 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/ante/ante_test.go
View File

@ -66,7 +66,7 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
chainID, chainID,
app.NewFundedGenStateWithSameCoins( app.NewFundedGenStateWithSameCoins(
tApp.AppCodec(), tApp.AppCodec(),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 1e9)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 1e9)),
testAddresses, testAddresses,
), ),
newBep3GenStateMulti(tApp.AppCodec(), deputy), newBep3GenStateMulti(tApp.AppCodec(), deputy),
@ -114,7 +114,7 @@ func TestAppAnteHandler_AuthorizedMempool(t *testing.T) {
banktypes.NewMsgSend( banktypes.NewMsgSend(
tc.address, tc.address,
testAddresses[0], testAddresses[0],
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 1_000_000)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 1_000_000)),
), ),
}, },
sdk.NewCoins(), // no fee sdk.NewCoins(), // no fee

9
app/ante/authorized_test.go
View File

@ -12,7 +12,6 @@ import (
"github.com/0glabs/0g-chain/app" "github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/app/ante" "github.com/0glabs/0g-chain/app/ante"
"github.com/0glabs/0g-chain/chaincfg"
) )
var _ sdk.AnteHandler = (&MockAnteHandler{}).AnteHandle var _ sdk.AnteHandler = (&MockAnteHandler{}).AnteHandle
@ -46,7 +45,7 @@ func TestAuthenticatedMempoolDecorator_AnteHandle_NotCheckTx(t *testing.T) {
banktypes.NewMsgSend( banktypes.NewMsgSend(
testAddresses[0], testAddresses[0],
testAddresses[1], testAddresses[1],
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 100_000_000)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 100_000_000)),
), ),
}, },
sdk.NewCoins(), // no fee sdk.NewCoins(), // no fee
@ -81,12 +80,12 @@ func TestAuthenticatedMempoolDecorator_AnteHandle_Pass(t *testing.T) {
banktypes.NewMsgSend( banktypes.NewMsgSend(
testAddresses[0], testAddresses[0],
testAddresses[1], testAddresses[1],
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 100)),
), ),
banktypes.NewMsgSend( banktypes.NewMsgSend(
testAddresses[2], testAddresses[2],
testAddresses[1], testAddresses[1],
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 100)),
), ),
}, },
sdk.NewCoins(), // no fee sdk.NewCoins(), // no fee
@ -122,7 +121,7 @@ func TestAuthenticatedMempoolDecorator_AnteHandle_Reject(t *testing.T) {
banktypes.NewMsgSend( banktypes.NewMsgSend(
testAddresses[0], testAddresses[0],
testAddresses[1], testAddresses[1],
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 100)),
), ),
}, },
sdk.NewCoins(), // no fee sdk.NewCoins(), // no fee

3
tests/e2e/e2e_evm_contracts_test.go
View File

@ -11,7 +11,6 @@ import (
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
"github.com/0glabs/0g-chain/app" "github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/tests/e2e/contracts/greeter" "github.com/0glabs/0g-chain/tests/e2e/contracts/greeter"
"github.com/0glabs/0g-chain/tests/util" "github.com/0glabs/0g-chain/tests/util"
@ -99,7 +98,7 @@ func (suite *IntegrationTestSuite) TestEip712BasicMessageAuthorization() {
// check that the message was processed & the a0gi is transferred. // check that the message was processed & the a0gi is transferred.
balRes, err := suite.ZgChain.Bank.Balance(context.Background(), &banktypes.QueryBalanceRequest{ balRes, err := suite.ZgChain.Bank.Balance(context.Background(), &banktypes.QueryBalanceRequest{
Address: receiver.String(), Address: receiver.String(),
Denom: chaincfg.DisplayDenom, Denom: "ua0gi",
}) })
suite.NoError(err) suite.NoError(err)
suite.Equal(sdk.NewInt(1e3), balRes.Balance.Amount) suite.Equal(sdk.NewInt(1e3), balRes.Balance.Amount)

5
tests/e2e/e2e_min_fees_test.go
View File

@ -13,7 +13,6 @@ import (
ethtypes "github.com/ethereum/go-ethereum/core/types" ethtypes "github.com/ethereum/go-ethereum/core/types"
"github.com/0glabs/0g-chain/app" "github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/tests/util" "github.com/0glabs/0g-chain/tests/util"
) )
@ -25,7 +24,7 @@ func (suite *IntegrationTestSuite) TestEthGasPriceReturnsMinFee() {
suite.NoError(err) suite.NoError(err)
// evm uses neuron, get neuron min fee // evm uses neuron, get neuron min fee
evmMinGas := minGasPrices.AmountOf(chaincfg.BaseDenom).TruncateInt().BigInt() evmMinGas := minGasPrices.AmountOf("neuron").TruncateInt().BigInt()
// returns eth_gasPrice, units in a0gi // returns eth_gasPrice, units in a0gi
gasPrice, err := suite.ZgChain.EvmClient.SuggestGasPrice(context.Background()) gasPrice, err := suite.ZgChain.EvmClient.SuggestGasPrice(context.Background())
@ -44,7 +43,7 @@ func (suite *IntegrationTestSuite) TestEvmRespectsMinFee() {
// get min gas price for evm (from app.toml) // get min gas price for evm (from app.toml)
minFees, err := getMinFeeFromAppToml(util.ZgChainHomePath()) minFees, err := getMinFeeFromAppToml(util.ZgChainHomePath())
suite.NoError(err) suite.NoError(err)
minGasPrice := minFees.AmountOf(chaincfg.BaseDenom).TruncateInt() minGasPrice := minFees.AmountOf("neuron").TruncateInt()
// attempt tx with less than min gas price (min fee - 1) // attempt tx with less than min gas price (min fee - 1)
tooLowGasPrice := minGasPrice.Sub(sdk.OneInt()).BigInt() tooLowGasPrice := minGasPrice.Sub(sdk.OneInt()).BigInt()

9
tests/e2e/e2e_test.go
View File

@ -19,7 +19,6 @@ import (
emtypes "github.com/evmos/ethermint/types" emtypes "github.com/evmos/ethermint/types"
"github.com/0glabs/0g-chain/app" "github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/tests/e2e/testutil" "github.com/0glabs/0g-chain/tests/e2e/testutil"
"github.com/0glabs/0g-chain/tests/util" "github.com/0glabs/0g-chain/tests/util"
) )
@ -29,7 +28,7 @@ var (
) )
func a0gi(amt *big.Int) sdk.Coin { func a0gi(amt *big.Int) sdk.Coin {
return sdk.NewCoin(chaincfg.DisplayDenom, sdkmath.NewIntFromBigInt(amt)) return sdk.NewCoin("ua0gi", sdkmath.NewIntFromBigInt(amt))
} }
type IntegrationTestSuite struct { type IntegrationTestSuite struct {
@ -67,7 +66,7 @@ func (suite *IntegrationTestSuite) TestFundedAccount() {
// check balance via SDK query // check balance via SDK query
res, err := suite.ZgChain.Bank.Balance(context.Background(), banktypes.NewQueryBalanceRequest( res, err := suite.ZgChain.Bank.Balance(context.Background(), banktypes.NewQueryBalanceRequest(
acc.SdkAddress, chaincfg.DisplayDenom, acc.SdkAddress, "ua0gi",
)) ))
suite.NoError(err) suite.NoError(err)
suite.Equal(funds, *res.Balance) suite.Equal(funds, *res.Balance)
@ -110,7 +109,7 @@ func (suite *IntegrationTestSuite) TestTransferOverEVM() {
// expect (9 - gas used) A0GI remaining in account. // expect (9 - gas used) A0GI remaining in account.
balance := suite.ZgChain.QuerySdkForBalances(acc.SdkAddress) balance := suite.ZgChain.QuerySdkForBalances(acc.SdkAddress)
suite.Equal(sdkmath.NewInt(9e5).Sub(a0giUsedForGas), balance.AmountOf(chaincfg.DisplayDenom)) suite.Equal(sdkmath.NewInt(9e5).Sub(a0giUsedForGas), balance.AmountOf("ua0gi"))
} }
// TestIbcTransfer transfers A0GI from the primary 0g-chain (suite.ZgChain) to the ibc chain (suite.Ibc). // TestIbcTransfer transfers A0GI from the primary 0g-chain (suite.ZgChain) to the ibc chain (suite.Ibc).
@ -158,7 +157,7 @@ func (suite *IntegrationTestSuite) TestIbcTransfer() {
// the balance should be deducted from 0g-chain account // the balance should be deducted from 0g-chain account
suite.Eventually(func() bool { suite.Eventually(func() bool {
balance := suite.ZgChain.QuerySdkForBalances(zgChainAcc.SdkAddress) balance := suite.ZgChain.QuerySdkForBalances(zgChainAcc.SdkAddress)
return balance.AmountOf(chaincfg.DisplayDenom).Equal(expectedSrcBalance.Amount) return balance.AmountOf("ua0gi").Equal(expectedSrcBalance.Amount)
}, 10*time.Second, 1*time.Second) }, 10*time.Second, 1*time.Second)
// expect the balance to be transferred to the ibc chain! // expect the balance to be transferred to the ibc chain!

3
tests/e2e/e2e_upgrade_gov_and_authz_test.go
View File

@ -12,7 +12,6 @@ import (
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/tests/e2e/testutil" "github.com/0glabs/0g-chain/tests/e2e/testutil"
"github.com/0glabs/0g-chain/tests/util" "github.com/0glabs/0g-chain/tests/util"
) )
@ -154,7 +153,7 @@ func (suite *IntegrationTestSuite) submitAndPassProposal(msgs []sdk.Msg) int64 {
suite.NoError(err) suite.NoError(err)
gasLimit := 1e6 gasLimit := 1e6
fee := sdk.NewCoin(chaincfg.BaseDenom, sdk.NewInt(1e15)) fee := sdk.NewCoin("neuron", sdk.NewInt(1e15))
req := util.ZgChainMsgRequest{ req := util.ZgChainMsgRequest{
Msgs: []sdk.Msg{proposalMsg}, Msgs: []sdk.Msg{proposalMsg},

4
tests/e2e/runner/chain.go
View File

@ -3,7 +3,7 @@ package runner
import ( import (
"errors" "errors"
"fmt" "fmt"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/ethclient"
rpchttpclient "github.com/tendermint/tendermint/rpc/client/http" rpchttpclient "github.com/tendermint/tendermint/rpc/client/http"
"google.golang.org/grpc" "google.golang.org/grpc"
@ -81,7 +81,7 @@ var (
EvmRpcUrl: "http://localhost:8545", EvmRpcUrl: "http://localhost:8545",
ChainId: "0gchainlocalnet_8888-1", ChainId: "0gchainlocalnet_8888-1",
StakingDenom: chaincfg.DisplayDenom, StakingDenom: "ua0gi",
} }
kvtoolIbcChain = ChainDetails{ kvtoolIbcChain = ChainDetails{
RpcUrl: "http://localhost:26658", RpcUrl: "http://localhost:26658",

393
x/evmutil/keeper/bank_keeper_test.go
View File

@ -6,7 +6,6 @@ import (
"time" "time"
sdkmath "cosmossdk.io/math" sdkmath "cosmossdk.io/math"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/x/evmutil/keeper" "github.com/0glabs/0g-chain/x/evmutil/keeper"
"github.com/0glabs/0g-chain/x/evmutil/testutil" "github.com/0glabs/0g-chain/x/evmutil/testutil"
"github.com/0glabs/0g-chain/x/evmutil/types" "github.com/0glabs/0g-chain/x/evmutil/types"
@ -27,7 +26,7 @@ func (suite *evmBankKeeperTestSuite) SetupTest() {
} }
func (suite *evmBankKeeperTestSuite) TestGetBalance_ReturnsSpendable() { func (suite *evmBankKeeperTestSuite) TestGetBalance_ReturnsSpendable() {
startingCoins := sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10)) startingCoins := sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10))
startingNeuron := sdkmath.NewInt(100) startingNeuron := sdkmath.NewInt(100)
now := tmtime.Now() now := tmtime.Now()
@ -41,16 +40,16 @@ func (suite *evmBankKeeperTestSuite) TestGetBalance_ReturnsSpendable() {
err = suite.Keeper.SetBalance(suite.Ctx, suite.Addrs[0], startingNeuron) err = suite.Keeper.SetBalance(suite.Ctx, suite.Addrs[0], startingNeuron)
suite.Require().NoError(err) suite.Require().NoError(err)
coin := suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.BaseDenom) coin := suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "neuron")
suite.Require().Equal(startingNeuron, coin.Amount) suite.Require().Equal(startingNeuron, coin.Amount)
ctx := suite.Ctx.WithBlockTime(now.Add(12 * time.Hour)) ctx := suite.Ctx.WithBlockTime(now.Add(12 * time.Hour))
coin = suite.EvmBankKeeper.GetBalance(ctx, suite.Addrs[0], chaincfg.BaseDenom) coin = suite.EvmBankKeeper.GetBalance(ctx, suite.Addrs[0], "neuron")
suite.Require().Equal(sdkmath.NewIntFromUint64(5_000_000_000_000_000_100), coin.Amount) suite.Require().Equal(sdkmath.NewIntFromUint64(5_000_000_000_100), coin.Amount)
} }
func (suite *evmBankKeeperTestSuite) TestGetBalance_NotEvmDenom() { func (suite *evmBankKeeperTestSuite) TestGetBalance_NotEvmDenom() {
suite.Require().Panics(func() { suite.Require().Panics(func() {
suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.DisplayDenom) suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "ua0gi")
}) })
suite.Require().Panics(func() { suite.Require().Panics(func() {
suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "busd") suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "busd")
@ -63,41 +62,41 @@ func (suite *evmBankKeeperTestSuite) TestGetBalance() {
expAmount sdkmath.Int expAmount sdkmath.Int
}{ }{
{ {
"a0gi with neuron", "ua0gi with neuron",
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 100), sdk.NewInt64Coin("neuron", 100),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewInt64Coin("ua0gi", 10),
), ),
sdk.NewIntFromBigInt(makeBigIntByString("10000000000000000100")), sdk.NewIntFromBigInt(makeBigIntByString("10000000000100")),
}, },
{ {
"just neuron", "just neuron",
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 100), sdk.NewInt64Coin("neuron", 100),
sdk.NewInt64Coin("busd", 100), sdk.NewInt64Coin("busd", 100),
), ),
sdkmath.NewInt(100), sdkmath.NewInt(100),
}, },
{ {
"just a0gi", "just ua0gi",
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewInt64Coin("ua0gi", 10),
sdk.NewInt64Coin("busd", 100), sdk.NewInt64Coin("busd", 100),
), ),
sdk.NewIntFromBigInt(makeBigIntByString("10000000000000000000")), sdk.NewIntFromBigInt(makeBigIntByString("10000000000000")),
}, },
{ {
"no a0gi or neuron", "no ua0gi or neuron",
sdk.NewCoins(), sdk.NewCoins(),
sdk.ZeroInt(), sdk.ZeroInt(),
}, },
{ {
"with avaka that is more than 1 a0gi", "with avaka that is more than 1 ua0gi",
sdk.NewCoins( sdk.NewCoins(
sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("20000000000000000220"))), sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("20000000000220"))),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 11), sdk.NewInt64Coin("ua0gi", 11),
), ),
sdk.NewIntFromBigInt(makeBigIntByString("31000000000000000220")), sdk.NewIntFromBigInt(makeBigIntByString("31000000000220")),
}, },
} }
@ -106,15 +105,15 @@ func (suite *evmBankKeeperTestSuite) TestGetBalance() {
suite.SetupTest() suite.SetupTest()
suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingAmount) suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingAmount)
coin := suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.BaseDenom) coin := suite.EvmBankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "neuron")
suite.Require().Equal(tt.expAmount, coin.Amount) suite.Require().Equal(tt.expAmount, coin.Amount)
}) })
} }
} }
func (suite *evmBankKeeperTestSuite) TestSendCoinsFromModuleToAccount() { func (suite *evmBankKeeperTestSuite) TestSendCoinsFromModuleToAccount() {
startingModuleCoins := sdk.NewCoins( startingModuleCoins := sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 200), sdk.NewInt64Coin("neuron", 200),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 100), sdk.NewInt64Coin("ua0gi", 100),
) )
tests := []struct { tests := []struct {
name string name string
@ -124,102 +123,102 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromModuleToAccount() {
hasErr bool hasErr bool
}{ }{
{ {
"send more than 1 a0gi", "send more than 1 ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12000000000000000010")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12000000000010")))),
sdk.Coins{}, sdk.Coins{},
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 10), sdk.NewInt64Coin("neuron", 10),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 12), sdk.NewInt64Coin("ua0gi", 12),
), ),
false, false,
}, },
{ {
"send less than 1 a0gi", "send less than 1 ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 122)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 122)),
sdk.Coins{}, sdk.Coins{},
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 122), sdk.NewInt64Coin("neuron", 122),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 0), sdk.NewInt64Coin("ua0gi", 0),
), ),
false, false,
}, },
{ {
"send an exact amount of a0gi", "send an exact amount of ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("98000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("98000000000000")))),
sdk.Coins{}, sdk.Coins{},
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 0), sdk.NewInt64Coin("neuron", 0),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 98), sdk.NewInt64Coin("ua0gi", 98),
), ),
false, false,
}, },
{ {
"send no neuron", "send no neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 0)),
sdk.Coins{}, sdk.Coins{},
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 0), sdk.NewInt64Coin("neuron", 0),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 0), sdk.NewInt64Coin("ua0gi", 0),
), ),
false, false,
}, },
{ {
"errors if sending other coins", "errors if sending other coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 500), sdk.NewInt64Coin("busd", 1000)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 500), sdk.NewInt64Coin("busd", 1000)),
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
true, true,
}, },
{ {
"errors if not enough total neuron to cover", "errors if not enough total neuron to cover",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("100000000000000001000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("100000000001000")))),
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
true, true,
}, },
{ {
"errors if not enough a0gi to cover", "errors if not enough ua0gi to cover",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("200000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("200000000000000")))),
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
true, true,
}, },
{ {
"converts receiver's neuron to a0gi if there's enough neuron after the transfer", "converts receiver's neuron to ua0gi if there's enough neuron after the transfer",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("99000000000200000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("99000000000200")))),
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 999_999_999_900_000_000), sdk.NewInt64Coin("neuron", 999_999_999_900),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 1), sdk.NewInt64Coin("ua0gi", 1),
), ),
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 100000000), sdk.NewInt64Coin("neuron", 100),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 101), sdk.NewInt64Coin("ua0gi", 101),
), ),
false, false,
}, },
{ {
"converts all of receiver's neuron to a0gi even if somehow receiver has more than 1a0gi of neuron", "converts all of receiver's neuron to ua0gi even if somehow receiver has more than 1a0gi of neuron",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12000000000000000100")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12000000000100")))),
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 5_999_999_999_999_999_990), sdk.NewInt64Coin("neuron", 5_999_999_999_990),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 1), sdk.NewInt64Coin("ua0gi", 1),
), ),
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 90), sdk.NewInt64Coin("neuron", 90),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 19), sdk.NewInt64Coin("ua0gi", 19),
), ),
false, false,
}, },
{ {
"swap 1 a0gi for neuron if module account doesn't have enough neuron", "swap 1 ua0gi for neuron if module account doesn't have enough neuron",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("99000000000000001000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("99000000001000")))),
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 200), sdk.NewInt64Coin("neuron", 200),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 1), sdk.NewInt64Coin("ua0gi", 1),
), ),
sdk.NewCoins( sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 1200), sdk.NewInt64Coin("neuron", 1200),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 100), sdk.NewInt64Coin("ua0gi", 100),
), ),
false, false,
}, },
@ -232,8 +231,8 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromModuleToAccount() {
suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingAccBal) suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingAccBal)
suite.FundModuleAccountWithZgChain(evmtypes.ModuleName, startingModuleCoins) suite.FundModuleAccountWithZgChain(evmtypes.ModuleName, startingModuleCoins)
// fund our module with some a0gi to account for converting extra neuron back to a0gi // fund our module with some ua0gi to account for converting extra neuron back to ua0gi
suite.FundModuleAccountWithZgChain(types.ModuleName, sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10))) suite.FundModuleAccountWithZgChain(types.ModuleName, sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10)))
err := suite.EvmBankKeeper.SendCoinsFromModuleToAccount(suite.Ctx, evmtypes.ModuleName, suite.Addrs[0], tt.sendCoins) err := suite.EvmBankKeeper.SendCoinsFromModuleToAccount(suite.Ctx, evmtypes.ModuleName, suite.Addrs[0], tt.sendCoins)
if tt.hasErr { if tt.hasErr {
@ -243,23 +242,23 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromModuleToAccount() {
suite.Require().NoError(err) suite.Require().NoError(err)
} }
// check a0gi // check ua0gi
a0giSender := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.DisplayDenom) a0giSender := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "ua0gi")
suite.Require().Equal(tt.expAccBal.AmountOf(chaincfg.DisplayDenom).Int64(), a0giSender.Amount.Int64()) suite.Require().Equal(tt.expAccBal.AmountOf("ua0gi").Int64(), a0giSender.Amount.Int64())
// check neuron // check neuron
actualNeuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0]) actualNeuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0])
suite.Require().Equal(tt.expAccBal.AmountOf(chaincfg.BaseDenom).Int64(), actualNeuron.Int64()) suite.Require().Equal(tt.expAccBal.AmountOf("neuron").Int64(), actualNeuron.Int64())
}) })
} }
} }
func (suite *evmBankKeeperTestSuite) TestSendCoinsFromAccountToModule() { func (suite *evmBankKeeperTestSuite) TestSendCoinsFromAccountToModule() {
startingAccCoins := sdk.NewCoins( startingAccCoins := sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 200), sdk.NewInt64Coin("neuron", 200),
sdk.NewInt64Coin(chaincfg.DisplayDenom, 100), sdk.NewInt64Coin("ua0gi", 100),
) )
startingModuleCoins := sdk.NewCoins( startingModuleCoins := sdk.NewCoins(
sdk.NewInt64Coin(chaincfg.BaseDenom, 100_000_000_000), sdk.NewInt64Coin("neuron", 100_000_000_000),
) )
tests := []struct { tests := []struct {
name string name string
@ -269,36 +268,36 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromAccountToModule() {
hasErr bool hasErr bool
}{ }{
{ {
"send more than 1 a0gi", "send more than 1 ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12000000000000000010")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12000000000010")))),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 190), sdk.NewInt64Coin(chaincfg.DisplayDenom, 88)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 190), sdk.NewInt64Coin("ua0gi", 88)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100_000_000_010), sdk.NewInt64Coin(chaincfg.DisplayDenom, 12)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100_000_000_010), sdk.NewInt64Coin("ua0gi", 12)),
false, false,
}, },
{ {
"send less than 1 a0gi", "send less than 1 ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 122)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 122)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 78), sdk.NewInt64Coin(chaincfg.DisplayDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 78), sdk.NewInt64Coin("ua0gi", 100)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100_000_000_122), sdk.NewInt64Coin(chaincfg.DisplayDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100_000_000_122), sdk.NewInt64Coin("ua0gi", 0)),
false, false,
}, },
{ {
"send an exact amount of a0gi", "send an exact amount of ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("98000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("98000000000000")))),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 200), sdk.NewInt64Coin(chaincfg.DisplayDenom, 2)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 200), sdk.NewInt64Coin("ua0gi", 2)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100_000_000_000), sdk.NewInt64Coin(chaincfg.DisplayDenom, 98)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100_000_000_000), sdk.NewInt64Coin("ua0gi", 98)),
false, false,
}, },
{ {
"send no neuron", "send no neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 0)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 200), sdk.NewInt64Coin(chaincfg.DisplayDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 200), sdk.NewInt64Coin("ua0gi", 100)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100_000_000_000), sdk.NewInt64Coin(chaincfg.DisplayDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100_000_000_000), sdk.NewInt64Coin("ua0gi", 0)),
false, false,
}, },
{ {
"errors if sending other coins", "errors if sending other coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 500), sdk.NewInt64Coin("busd", 1000)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 500), sdk.NewInt64Coin("busd", 1000)),
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
true, true,
@ -306,8 +305,8 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromAccountToModule() {
{ {
"errors if have dup coins", "errors if have dup coins",
sdk.Coins{ sdk.Coins{
sdk.NewInt64Coin(chaincfg.BaseDenom, 12_000_000_000_000), sdk.NewInt64Coin("neuron", 12_000_000_000_000),
sdk.NewInt64Coin(chaincfg.BaseDenom, 2_000_000_000_000), sdk.NewInt64Coin("neuron", 2_000_000_000_000),
}, },
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
@ -315,30 +314,30 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromAccountToModule() {
}, },
{ {
"errors if not enough total neuron to cover", "errors if not enough total neuron to cover",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("100000000001000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("100000000001000")))),
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
true, true,
}, },
{ {
"errors if not enough a0gi to cover", "errors if not enough ua0gi to cover",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("200000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("200000000000000")))),
sdk.Coins{}, sdk.Coins{},
sdk.Coins{}, sdk.Coins{},
true, true,
}, },
{ {
"converts 1 a0gi to neuron if not enough neuron to cover", "converts 1 ua0gi to neuron if not enough neuron to cover",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("99001000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("99001000000000")))),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 999_000_000_000_000_200), sdk.NewInt64Coin(chaincfg.DisplayDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 999_000_000_200), sdk.NewInt64Coin("ua0gi", 0)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 1_000_100_000_000_000), sdk.NewInt64Coin(chaincfg.DisplayDenom, 99)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 101_000_000_000), sdk.NewInt64Coin("ua0gi", 99)),
false, false,
}, },
{ {
"converts receiver's neuron to a0gi if there's enough neuron after the transfer", "converts receiver's neuron to ua0gi if there's enough neuron after the transfer",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 5_900_000_000_000_000_200)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 5_900_000_000_200)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100_000_000_000_000_000), sdk.NewInt64Coin(chaincfg.DisplayDenom, 94)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100_000_000_000), sdk.NewInt64Coin("ua0gi", 94)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 900_000_100_000_000_200), sdk.NewInt64Coin(chaincfg.DisplayDenom, 5)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 200), sdk.NewInt64Coin("ua0gi", 6)),
false, false,
}, },
} }
@ -358,17 +357,17 @@ func (suite *evmBankKeeperTestSuite) TestSendCoinsFromAccountToModule() {
} }
// check sender balance // check sender balance
a0giSender := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.DisplayDenom) a0giSender := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "ua0gi")
suite.Require().Equal(tt.expSenderCoins.AmountOf(chaincfg.DisplayDenom).Int64(), a0giSender.Amount.Int64()) suite.Require().Equal(tt.expSenderCoins.AmountOf("ua0gi").Int64(), a0giSender.Amount.Int64())
actualNeuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0]) actualNeuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0])
suite.Require().Equal(tt.expSenderCoins.AmountOf(chaincfg.BaseDenom).Int64(), actualNeuron.Int64()) suite.Require().Equal(tt.expSenderCoins.AmountOf("neuron").Int64(), actualNeuron.Int64())
// check module balance // check module balance
moduleAddr := suite.AccountKeeper.GetModuleAddress(evmtypes.ModuleName) moduleAddr := suite.AccountKeeper.GetModuleAddress(evmtypes.ModuleName)
a0giSender = suite.BankKeeper.GetBalance(suite.Ctx, moduleAddr, chaincfg.DisplayDenom) a0giSender = suite.BankKeeper.GetBalance(suite.Ctx, moduleAddr, "ua0gi")
suite.Require().Equal(tt.expModuleCoins.AmountOf(chaincfg.DisplayDenom).Int64(), a0giSender.Amount.Int64()) suite.Require().Equal(tt.expModuleCoins.AmountOf("ua0gi").Int64(), a0giSender.Amount.Int64())
actualNeuron = suite.Keeper.GetBalance(suite.Ctx, moduleAddr) actualNeuron = suite.Keeper.GetBalance(suite.Ctx, moduleAddr)
suite.Require().Equal(tt.expModuleCoins.AmountOf(chaincfg.BaseDenom).Int64(), actualNeuron.Int64()) suite.Require().Equal(tt.expModuleCoins.AmountOf("neuron").Int64(), actualNeuron.Int64())
}) })
} }
} }
@ -383,24 +382,24 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
neuronStart sdkmath.Int neuronStart sdkmath.Int
}{ }{
{ {
"burn more than 1 a0gi", "burn more than 1 ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12021000000002000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12021000000002")))),
sdkmath.NewInt(88), sdkmath.NewInt(88),
sdkmath.NewInt(100_000_000_000_000_000), sdkmath.NewInt(100_000_000_000),
false, false,
sdk.NewIntFromBigInt(makeBigIntByString("121000000002000000")), sdk.NewIntFromBigInt(makeBigIntByString("121000000002")),
}, },
{ {
"burn less than 1 a0gi", "burn less than 1 ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 122)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 122)),
sdkmath.NewInt(100), sdkmath.NewInt(100),
sdkmath.NewInt(878), sdkmath.NewInt(878),
false, false,
sdkmath.NewInt(1000), sdkmath.NewInt(1000),
}, },
{ {
"burn an exact amount of a0gi", "burn an exact amount of ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("98000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("98000000000000")))),
sdkmath.NewInt(2), sdkmath.NewInt(2),
sdkmath.NewInt(10), sdkmath.NewInt(10),
false, false,
@ -408,7 +407,7 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
}, },
{ {
"burn no neuron", "burn no neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 0)),
startingA0gi, startingA0gi,
sdk.ZeroInt(), sdk.ZeroInt(),
false, false,
@ -416,7 +415,7 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
}, },
{ {
"errors if burning other coins", "errors if burning other coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 500), sdk.NewInt64Coin("busd", 1000)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 500), sdk.NewInt64Coin("busd", 1000)),
startingA0gi, startingA0gi,
sdkmath.NewInt(100), sdkmath.NewInt(100),
true, true,
@ -425,8 +424,8 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
{ {
"errors if have dup coins", "errors if have dup coins",
sdk.Coins{ sdk.Coins{
sdk.NewInt64Coin(chaincfg.BaseDenom, 12_000_000_000_000), sdk.NewInt64Coin("neuron", 12_000_000_000_000),
sdk.NewInt64Coin(chaincfg.BaseDenom, 2_000_000_000_000), sdk.NewInt64Coin("neuron", 2_000_000_000_000),
}, },
startingA0gi, startingA0gi,
sdk.ZeroInt(), sdk.ZeroInt(),
@ -435,7 +434,7 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
}, },
{ {
"errors if burn amount is negative", "errors if burn amount is negative",
sdk.Coins{sdk.Coin{Denom: chaincfg.BaseDenom, Amount: sdkmath.NewInt(-100)}}, sdk.Coins{sdk.Coin{Denom: "neuron", Amount: sdkmath.NewInt(-100)}},
startingA0gi, startingA0gi,
sdkmath.NewInt(50), sdkmath.NewInt(50),
true, true,
@ -443,27 +442,27 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
}, },
{ {
"errors if not enough neuron to cover burn", "errors if not enough neuron to cover burn",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("100999000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("100999000000000")))),
sdkmath.NewInt(0), sdkmath.NewInt(0),
sdkmath.NewInt(99_000_000_000_000_000), sdkmath.NewInt(99_000_000_000),
true, true,
sdkmath.NewInt(99_000_000_000_000_000), sdkmath.NewInt(99_000_000_000),
}, },
{ {
"errors if not enough a0gi to cover burn", "errors if not enough ua0gi to cover burn",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("200000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("200000000000000")))),
sdkmath.NewInt(100), sdkmath.NewInt(100),
sdk.ZeroInt(), sdk.ZeroInt(),
true, true,
sdk.ZeroInt(), sdk.ZeroInt(),
}, },
{ {
"converts 1 a0gi to neuron if not enough neuron to cover", "converts 1 ua0gi to neuron if not enough neuron to cover",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12021000000002000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12021000000002")))),
sdkmath.NewInt(87), sdkmath.NewInt(87),
sdkmath.NewInt(980_000_000_000_000_000), sdkmath.NewInt(980_000_000_000),
false, false,
sdkmath.NewInt(1_000_000_002_000_000), sdkmath.NewInt(1_000_000_002),
}, },
} }
@ -471,8 +470,8 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
suite.Run(tt.name, func() { suite.Run(tt.name, func() {
suite.SetupTest() suite.SetupTest()
startingCoins := sdk.NewCoins( startingCoins := sdk.NewCoins(
sdk.NewCoin(chaincfg.DisplayDenom, startingA0gi), sdk.NewCoin("ua0gi", startingA0gi),
sdk.NewCoin(chaincfg.BaseDenom, tt.neuronStart), sdk.NewCoin("neuron", tt.neuronStart),
) )
suite.FundModuleAccountWithZgChain(evmtypes.ModuleName, startingCoins) suite.FundModuleAccountWithZgChain(evmtypes.ModuleName, startingCoins)
@ -484,8 +483,8 @@ func (suite *evmBankKeeperTestSuite) TestBurnCoins() {
suite.Require().NoError(err) suite.Require().NoError(err)
} }
// check a0gi // check ua0gi
a0giActual := suite.BankKeeper.GetBalance(suite.Ctx, suite.EvmModuleAddr, chaincfg.DisplayDenom) a0giActual := suite.BankKeeper.GetBalance(suite.Ctx, suite.EvmModuleAddr, "ua0gi")
suite.Require().Equal(tt.expA0gi, a0giActual.Amount) suite.Require().Equal(tt.expA0gi, a0giActual.Amount)
// check neuron // check neuron
@ -498,30 +497,30 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
tests := []struct { tests := []struct {
name string name string
mintCoins sdk.Coins mintCoins sdk.Coins
a0gi sdkmath.Int ua0gi sdkmath.Int
neuron sdkmath.Int neuron sdkmath.Int
hasErr bool hasErr bool
neuronStart sdkmath.Int neuronStart sdkmath.Int
}{ }{
{ {
"mint more than 1 a0gi", "mint more than 1 ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12021000000002000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12021000000002")))),
sdkmath.NewInt(12), sdkmath.NewInt(12),
sdkmath.NewInt(21_000_000_002_000_000), sdkmath.NewInt(21_000_000_002),
false, false,
sdk.ZeroInt(), sdk.ZeroInt(),
}, },
{ {
"mint less than 1 a0gi", "mint less than 1 ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 901_000_000_001)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 901_000_000_001)),
sdk.ZeroInt(), sdk.ZeroInt(),
sdkmath.NewInt(901_000_000_001), sdkmath.NewInt(901_000_000_001),
false, false,
sdk.ZeroInt(), sdk.ZeroInt(),
}, },
{ {
"mint an exact amount of a0gi", "mint an exact amount of ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("123000000000000000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("123000000000000000")))),
sdkmath.NewInt(123_000), sdkmath.NewInt(123_000),
sdk.ZeroInt(), sdk.ZeroInt(),
false, false,
@ -529,7 +528,7 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
}, },
{ {
"mint no neuron", "mint no neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 0)),
sdk.ZeroInt(), sdk.ZeroInt(),
sdk.ZeroInt(), sdk.ZeroInt(),
false, false,
@ -537,7 +536,7 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
}, },
{ {
"errors if minting other coins", "errors if minting other coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 500), sdk.NewInt64Coin("busd", 1000)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 500), sdk.NewInt64Coin("busd", 1000)),
sdk.ZeroInt(), sdk.ZeroInt(),
sdkmath.NewInt(100), sdkmath.NewInt(100),
true, true,
@ -546,8 +545,8 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
{ {
"errors if have dup coins", "errors if have dup coins",
sdk.Coins{ sdk.Coins{
sdk.NewInt64Coin(chaincfg.BaseDenom, 12_000_000_000_000), sdk.NewInt64Coin("neuron", 12_000_000_000_000),
sdk.NewInt64Coin(chaincfg.BaseDenom, 2_000_000_000_000), sdk.NewInt64Coin("neuron", 2_000_000_000_000),
}, },
sdk.ZeroInt(), sdk.ZeroInt(),
sdk.ZeroInt(), sdk.ZeroInt(),
@ -556,7 +555,7 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
}, },
{ {
"errors if mint amount is negative", "errors if mint amount is negative",
sdk.Coins{sdk.Coin{Denom: chaincfg.BaseDenom, Amount: sdkmath.NewInt(-100)}}, sdk.Coins{sdk.Coin{Denom: "neuron", Amount: sdkmath.NewInt(-100)}},
sdk.ZeroInt(), sdk.ZeroInt(),
sdkmath.NewInt(50), sdkmath.NewInt(50),
true, true,
@ -564,27 +563,27 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
}, },
{ {
"adds to existing neuron balance", "adds to existing neuron balance",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("12000000021000000002")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("12021000000002")))),
sdkmath.NewInt(12), sdkmath.NewInt(12),
sdkmath.NewInt(21_000_000_102), sdkmath.NewInt(21_000_000_102),
false, false,
sdkmath.NewInt(100), sdkmath.NewInt(100),
}, },
{ {
"convert neuron balance to a0gi if it exceeds 1 a0gi", "convert neuron balance to ua0gi if it exceeds 1 ua0gi",
sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("10000000999000000000")))), sdk.NewCoins(sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("10999000000000")))),
sdkmath.NewInt(11), sdkmath.NewInt(12),
sdkmath.NewInt(1_001_200_000_001), sdkmath.NewInt(1_200_000_001),
false, false,
sdkmath.NewIntFromBigInt(makeBigIntByString("1000000002200000001")), sdkmath.NewIntFromBigInt(makeBigIntByString("1002200000001")),
}, },
} }
for _, tt := range tests { for _, tt := range tests {
suite.Run(tt.name, func() { suite.Run(tt.name, func() {
suite.SetupTest() suite.SetupTest()
suite.FundModuleAccountWithZgChain(types.ModuleName, sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10))) suite.FundModuleAccountWithZgChain(types.ModuleName, sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10)))
suite.FundModuleAccountWithZgChain(evmtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(chaincfg.BaseDenom, tt.neuronStart))) suite.FundModuleAccountWithZgChain(evmtypes.ModuleName, sdk.NewCoins(sdk.NewCoin("neuron", tt.neuronStart)))
err := suite.EvmBankKeeper.MintCoins(suite.Ctx, evmtypes.ModuleName, tt.mintCoins) err := suite.EvmBankKeeper.MintCoins(suite.Ctx, evmtypes.ModuleName, tt.mintCoins)
if tt.hasErr { if tt.hasErr {
@ -594,9 +593,9 @@ func (suite *evmBankKeeperTestSuite) TestMintCoins() {
suite.Require().NoError(err) suite.Require().NoError(err)
} }
// check a0gi // check ua0gi
a0giActual := suite.BankKeeper.GetBalance(suite.Ctx, suite.EvmModuleAddr, chaincfg.DisplayDenom) a0giActual := suite.BankKeeper.GetBalance(suite.Ctx, suite.EvmModuleAddr, "ua0gi")
suite.Require().Equal(tt.a0gi, a0giActual.Amount) suite.Require().Equal(tt.ua0gi, a0giActual.Amount)
// check neuron // check neuron
neuronActual := suite.Keeper.GetBalance(suite.Ctx, suite.EvmModuleAddr) neuronActual := suite.Keeper.GetBalance(suite.Ctx, suite.EvmModuleAddr)
@ -613,22 +612,22 @@ func (suite *evmBankKeeperTestSuite) TestValidateEvmCoins() {
}{ }{
{ {
"valid coins", "valid coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 500)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 500)),
false, false,
}, },
{ {
"dup coins", "dup coins",
sdk.Coins{sdk.NewInt64Coin(chaincfg.BaseDenom, 500), sdk.NewInt64Coin(chaincfg.BaseDenom, 500)}, sdk.Coins{sdk.NewInt64Coin("neuron", 500), sdk.NewInt64Coin("neuron", 500)},
true, true,
}, },
{ {
"not evm coins", "not evm coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 500)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 500)),
true, true,
}, },
{ {
"negative coins", "negative coins",
sdk.Coins{sdk.Coin{Denom: chaincfg.BaseDenom, Amount: sdkmath.NewInt(-500)}}, sdk.Coins{sdk.Coin{Denom: "neuron", Amount: sdkmath.NewInt(-500)}},
true, true,
}, },
} }
@ -653,21 +652,21 @@ func (suite *evmBankKeeperTestSuite) TestConvertOneA0giToNeuronIfNeeded() {
success bool success bool
}{ }{
{ {
"not enough a0gi for conversion", "not enough ua0gi for conversion",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100)),
false, false,
}, },
{ {
"converts 1 a0gi to neuron", "converts 1 ua0gi to neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewInt64Coin(chaincfg.BaseDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10), sdk.NewInt64Coin("neuron", 100)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 9), sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("1000000000000000100")))), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 9), sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("1000000000100")))),
true, true,
}, },
{ {
"conversion not needed", "conversion not needed",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewInt64Coin(chaincfg.BaseDenom, 200)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10), sdk.NewInt64Coin("neuron", 200)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewInt64Coin(chaincfg.BaseDenom, 200)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10), sdk.NewInt64Coin("neuron", 200)),
true, true,
}, },
} }
@ -676,11 +675,11 @@ func (suite *evmBankKeeperTestSuite) TestConvertOneA0giToNeuronIfNeeded() {
suite.SetupTest() suite.SetupTest()
suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingCoins) suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingCoins)
err := suite.EvmBankKeeper.ConvertOneA0giToNeuronIfNeeded(suite.Ctx, suite.Addrs[0], neuronNeeded) err := suite.EvmBankKeeper.ConvertOneUa0giToNeuronIfNeeded(suite.Ctx, suite.Addrs[0], neuronNeeded)
moduleZgChain := suite.BankKeeper.GetBalance(suite.Ctx, suite.AccountKeeper.GetModuleAddress(types.ModuleName), chaincfg.DisplayDenom) moduleZgChain := suite.BankKeeper.GetBalance(suite.Ctx, suite.AccountKeeper.GetModuleAddress(types.ModuleName), "ua0gi")
if tt.success { if tt.success {
suite.Require().NoError(err) suite.Require().NoError(err)
if tt.startingCoins.AmountOf(chaincfg.BaseDenom).LT(neuronNeeded) { if tt.startingCoins.AmountOf("neuron").LT(neuronNeeded) {
suite.Require().Equal(sdk.OneInt(), moduleZgChain.Amount) suite.Require().Equal(sdk.OneInt(), moduleZgChain.Amount)
} }
} else { } else {
@ -689,9 +688,9 @@ func (suite *evmBankKeeperTestSuite) TestConvertOneA0giToNeuronIfNeeded() {
} }
neuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0]) neuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0])
suite.Require().Equal(tt.expectedCoins.AmountOf(chaincfg.BaseDenom), neuron) suite.Require().Equal(tt.expectedCoins.AmountOf("neuron"), neuron)
a0gi := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.DisplayDenom) ua0gi := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "ua0gi")
suite.Require().Equal(tt.expectedCoins.AmountOf(chaincfg.DisplayDenom), a0gi.Amount) suite.Require().Equal(tt.expectedCoins.AmountOf("ua0gi"), ua0gi.Amount)
}) })
} }
} }
@ -702,34 +701,34 @@ func (suite *evmBankKeeperTestSuite) TestConvertNeuronToA0gi() {
expectedCoins sdk.Coins expectedCoins sdk.Coins
}{ }{
{ {
"not enough a0gi", "not enough ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 100), sdk.NewInt64Coin(chaincfg.DisplayDenom, 0)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 100), sdk.NewInt64Coin("ua0gi", 0)),
}, },
{ {
"converts neuron for 1 a0gi", "converts neuron for 1 ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("1000000000003000000")))), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10), sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("1000000000003")))),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 11), sdk.NewInt64Coin(chaincfg.BaseDenom, 3_000_000)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 11), sdk.NewInt64Coin("neuron", 3)),
}, },
{ {
"converts more than 1 a0gi of neuron", "converts more than 1 ua0gi of neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10), sdk.NewCoin(chaincfg.BaseDenom, sdk.NewIntFromBigInt(makeBigIntByString("8000000000123000000")))), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10), sdk.NewCoin("neuron", sdk.NewIntFromBigInt(makeBigIntByString("8000000000123")))),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 18), sdk.NewInt64Coin(chaincfg.BaseDenom, 123_000_000)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 18), sdk.NewInt64Coin("neuron", 123)),
}, },
} }
for _, tt := range tests { for _, tt := range tests {
suite.Run(tt.name, func() { suite.Run(tt.name, func() {
suite.SetupTest() suite.SetupTest()
err := suite.App.FundModuleAccount(suite.Ctx, types.ModuleName, sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 10))) err := suite.App.FundModuleAccount(suite.Ctx, types.ModuleName, sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 10)))
suite.Require().NoError(err) suite.Require().NoError(err)
suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingCoins) suite.FundAccountWithZgChain(suite.Addrs[0], tt.startingCoins)
err = suite.EvmBankKeeper.ConvertNeuronToA0gi(suite.Ctx, suite.Addrs[0]) err = suite.EvmBankKeeper.ConvertNeuronToUa0gi(suite.Ctx, suite.Addrs[0])
suite.Require().NoError(err) suite.Require().NoError(err)
neuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0]) neuron := suite.Keeper.GetBalance(suite.Ctx, suite.Addrs[0])
suite.Require().Equal(tt.expectedCoins.AmountOf(chaincfg.BaseDenom), neuron) suite.Require().Equal(tt.expectedCoins.AmountOf("neuron"), neuron)
a0gi := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], chaincfg.DisplayDenom) ua0gi := suite.BankKeeper.GetBalance(suite.Ctx, suite.Addrs[0], "ua0gi")
suite.Require().Equal(tt.expectedCoins.AmountOf(chaincfg.DisplayDenom), a0gi.Amount) suite.Require().Equal(tt.expectedCoins.AmountOf("ua0gi"), ua0gi.Amount)
}) })
} }
} }
@ -742,7 +741,7 @@ func (suite *evmBankKeeperTestSuite) TestSplitNeuronCoins() {
}{ }{
{ {
"invalid coins", "invalid coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 500)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 500)),
nil, nil,
true, true,
}, },
@ -753,33 +752,33 @@ func (suite *evmBankKeeperTestSuite) TestSplitNeuronCoins() {
false, false,
}, },
{ {
"a0gi & neuron coins", "ua0gi & neuron coins",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 8_000_000_000_000_000_123)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 8_000_000_000_123)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 8), sdk.NewInt64Coin(chaincfg.BaseDenom, 123)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 8), sdk.NewInt64Coin("neuron", 123)),
false, false,
}, },
{ {
"only neuron", "only neuron",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 10_123)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 10_123)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 10_123)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 10_123)),
false, false,
}, },
{ {
"only a0gi", "only ua0gi",
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.BaseDenom, 5_000_000_000_000_000_000)), sdk.NewCoins(sdk.NewInt64Coin("neuron", 5_000_000_000_000)),
sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 5)), sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 5)),
false, false,
}, },
} }
for _, tt := range tests { for _, tt := range tests {
suite.Run(tt.name, func() { suite.Run(tt.name, func() {
a0gi, neuron, err := keeper.SplitNeuronCoins(tt.coins) ua0gi, neuron, err := keeper.SplitNeuronCoins(tt.coins)
if tt.shouldErr { if tt.shouldErr {
suite.Require().Error(err) suite.Require().Error(err)
} else { } else {
suite.Require().NoError(err) suite.Require().NoError(err)
suite.Require().Equal(tt.expectedCoins.AmountOf(chaincfg.DisplayDenom), a0gi.Amount) suite.Require().Equal(tt.expectedCoins.AmountOf("ua0gi"), ua0gi.Amount)
suite.Require().Equal(tt.expectedCoins.AmountOf(chaincfg.BaseDenom), neuron) suite.Require().Equal(tt.expectedCoins.AmountOf("neuron"), neuron)
} }
}) })
} }

3
x/evmutil/keeper/invariants_test.go
View File

@ -12,7 +12,6 @@ import (
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
"github.com/0glabs/0g-chain/app" "github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/x/evmutil/keeper" "github.com/0glabs/0g-chain/x/evmutil/keeper"
"github.com/0glabs/0g-chain/x/evmutil/testutil" "github.com/0glabs/0g-chain/x/evmutil/testutil"
"github.com/0glabs/0g-chain/x/evmutil/types" "github.com/0glabs/0g-chain/x/evmutil/types"
@ -161,7 +160,7 @@ func (suite *invariantTestSuite) TestSmallBalances() {
// increase minor balance at least above conversion multiplier // increase minor balance at least above conversion multiplier
suite.Keeper.AddBalance(suite.Ctx, suite.Addrs[0], keeper.ConversionMultiplier) suite.Keeper.AddBalance(suite.Ctx, suite.Addrs[0], keeper.ConversionMultiplier)
// add same number of a0gi to avoid breaking other invariants // add same number of a0gi to avoid breaking other invariants
amt := sdk.NewCoins(sdk.NewInt64Coin(chaincfg.DisplayDenom, 1)) amt := sdk.NewCoins(sdk.NewInt64Coin("ua0gi", 1))
suite.Require().NoError( suite.Require().NoError(
suite.App.FundModuleAccount(suite.Ctx, types.ModuleName, amt), suite.App.FundModuleAccount(suite.Ctx, types.ModuleName, amt),
) )

3
x/evmutil/testutil/suite.go
View File

@ -37,7 +37,6 @@ import (
"github.com/tendermint/tendermint/version" "github.com/tendermint/tendermint/version"
"github.com/0glabs/0g-chain/app" "github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/x/evmutil/keeper" "github.com/0glabs/0g-chain/x/evmutil/keeper"
"github.com/0glabs/0g-chain/x/evmutil/types" "github.com/0glabs/0g-chain/x/evmutil/types"
) )
@ -82,7 +81,7 @@ func (suite *Suite) SetupTest() {
suite.Addrs = addrs suite.Addrs = addrs
evmGenesis := evmtypes.DefaultGenesisState() evmGenesis := evmtypes.DefaultGenesisState()
evmGenesis.Params.EvmDenom = chaincfg.EvmDenom evmGenesis.Params.EvmDenom = keeper.EvmDenom
feemarketGenesis := feemarkettypes.DefaultGenesisState() feemarketGenesis := feemarkettypes.DefaultGenesisState()
feemarketGenesis.Params.EnableHeight = 1 feemarketGenesis.Params.EnableHeight = 1