0g-chain/x/evmutil/keeper/evm_test.go
2024-08-02 12:22:00 +08:00

138 lines
3.9 KiB
Go

package keeper_test
import (
"math/big"
"testing"
"time"
sdk "github.com/cosmos/cosmos-sdk/types"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"
"github.com/stretchr/testify/suite"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
"github.com/evmos/ethermint/tests"
etherminttypes "github.com/evmos/ethermint/types"
"github.com/evmos/ethermint/x/evm/statedb"
"github.com/evmos/ethermint/x/evm/types"
"github.com/0glabs/0g-chain/x/evmutil/testutil"
)
type evmKeeperTestSuite struct {
testutil.Suite
}
func (suite *evmKeeperTestSuite) SetupTest() {
suite.Suite.SetupTest()
}
func (suite *evmKeeperTestSuite) StateDB() *statedb.StateDB {
return statedb.New(suite.Ctx, suite.App.GetEvmKeeper(), statedb.NewEmptyTxConfig(common.BytesToHash(suite.Ctx.HeaderHash().Bytes())))
}
func (suite *evmKeeperTestSuite) TestEvmKeeper_SetAccount() {
baseAddr := tests.GenerateAddress()
baseAcc := &authtypes.BaseAccount{Address: sdk.AccAddress(baseAddr.Bytes()).String()}
ethAddr := tests.GenerateAddress()
ethAcc := &etherminttypes.EthAccount{BaseAccount: &authtypes.BaseAccount{Address: sdk.AccAddress(ethAddr.Bytes()).String()}, CodeHash: common.BytesToHash(types.EmptyCodeHash).String()}
vestingAddr := tests.GenerateAddress()
vestingAcc := vestingtypes.NewBaseVestingAccount(&authtypes.BaseAccount{Address: sdk.AccAddress(vestingAddr.Bytes()).String()}, sdk.NewCoins(), time.Now().Unix())
testCases := []struct {
name string
address common.Address
account statedb.Account
expectedErr error
}{
{
"new account, non-contract account",
tests.GenerateAddress(),
statedb.Account{10, big.NewInt(100), types.EmptyCodeHash},
nil,
},
{
"new account, contract account",
tests.GenerateAddress(),
statedb.Account{10, big.NewInt(100), crypto.Keccak256Hash([]byte("some code hash")).Bytes()},
nil,
},
{
"existing eth account, non-contract account",
ethAddr,
statedb.Account{10, big.NewInt(1), types.EmptyCodeHash},
nil,
},
{
"existing eth account, contract account",
ethAddr,
statedb.Account{10, big.NewInt(0), crypto.Keccak256Hash([]byte("some code hash")).Bytes()},
nil,
},
{
"existing base account, non-contract account",
baseAddr,
statedb.Account{10, big.NewInt(10), types.EmptyCodeHash},
nil,
},
{
"existing base account, contract account",
baseAddr,
statedb.Account{10, big.NewInt(99), crypto.Keccak256Hash([]byte("some code hash")).Bytes()},
nil,
},
{
"existing vesting account, non-contract account",
vestingAddr,
statedb.Account{10, big.NewInt(1000), types.EmptyCodeHash},
nil,
},
{
"existing vesting account, contract account",
vestingAddr,
statedb.Account{10, big.NewInt(1001), crypto.Keccak256Hash([]byte("some code hash")).Bytes()},
types.ErrInvalidAccount,
},
}
for _, tc := range testCases {
suite.Run(tc.name, func() {
suite.SetupTest()
if tc.address == baseAddr {
suite.AccountKeeper.SetAccount(suite.Ctx, baseAcc)
}
if tc.address == ethAddr {
suite.AccountKeeper.SetAccount(suite.Ctx, ethAcc)
}
if tc.address == vestingAddr {
suite.AccountKeeper.SetAccount(suite.Ctx, vestingAcc)
}
vmdb := suite.StateDB()
err := vmdb.Keeper().SetAccount(suite.Ctx, tc.address, tc.account)
if tc.expectedErr == nil {
suite.Require().NoError(err)
} else {
suite.Require().Error(tc.expectedErr)
return
}
nonce := vmdb.GetNonce(tc.address)
suite.Equal(nonce, tc.account.Nonce, "expected nonce to be set")
hash := vmdb.GetCodeHash(tc.address)
suite.Equal(common.BytesToHash(tc.account.CodeHash), hash, "expected code hash to be set")
balance := vmdb.GetBalance(tc.address)
suite.Equal(balance, tc.account.Balance, "expected balance to be set")
})
}
}
func TestEvmKeeperTestSuite(t *testing.T) {
suite.Run(t, new(evmKeeperTestSuite))
}