forked from cerc-io/laconicd-deprecated
828 lines
20 KiB
Go
828 lines
20 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
_ "embed"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"google.golang.org/grpc/metadata"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
ethcmn "github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
ethtypes "github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
ethcrypto "github.com/ethereum/go-ethereum/crypto"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
ethermint "github.com/tharsis/ethermint/types"
|
|
"github.com/tharsis/ethermint/x/evm/types"
|
|
|
|
grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
|
|
)
|
|
|
|
//Not valid Ethereum address
|
|
const invalidAddress = "0x0000"
|
|
|
|
var (
|
|
//go:embed ERC20Contract.json
|
|
compiledContractJSON []byte
|
|
contractBin []byte
|
|
contractABI abi.ABI
|
|
)
|
|
|
|
func init() {
|
|
var tmp struct {
|
|
Abi string
|
|
Bin string
|
|
}
|
|
err := json.Unmarshal(compiledContractJSON, &tmp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
contractBin = common.FromHex(tmp.Bin)
|
|
err = json.Unmarshal([]byte(tmp.Abi), &contractABI)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryAccount() {
|
|
var (
|
|
req *types.QueryAccountRequest
|
|
expAccount *types.QueryAccountResponse
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{
|
|
"invalid address",
|
|
func() {
|
|
expAccount = &types.QueryAccountResponse{
|
|
Balance: "0",
|
|
CodeHash: common.BytesToHash(ethcrypto.Keccak256(nil)).Hex(),
|
|
Nonce: 0,
|
|
}
|
|
req = &types.QueryAccountRequest{
|
|
Address: invalidAddress,
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
amt := sdk.Coins{ethermint.NewPhotonCoinInt64(100)}
|
|
err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
|
|
suite.Require().NoError(err)
|
|
err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)
|
|
suite.Require().NoError(err)
|
|
|
|
expAccount = &types.QueryAccountResponse{
|
|
Balance: "100",
|
|
CodeHash: common.BytesToHash(ethcrypto.Keccak256(nil)).Hex(),
|
|
Nonce: 0,
|
|
}
|
|
req = &types.QueryAccountRequest{
|
|
Address: suite.address.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.Account(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expAccount, res)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryCosmosAccount() {
|
|
var (
|
|
req *types.QueryCosmosAccountRequest
|
|
expAccount *types.QueryCosmosAccountResponse
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"invalid address",
|
|
func() {
|
|
expAccount = &types.QueryCosmosAccountResponse{
|
|
CosmosAddress: sdk.AccAddress(ethcmn.Address{}.Bytes()).String(),
|
|
}
|
|
req = &types.QueryCosmosAccountRequest{
|
|
Address: invalidAddress,
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
expAccount = &types.QueryCosmosAccountResponse{
|
|
CosmosAddress: sdk.AccAddress(suite.address.Bytes()).String(),
|
|
Sequence: 0,
|
|
AccountNumber: 0,
|
|
}
|
|
req = &types.QueryCosmosAccountRequest{
|
|
Address: suite.address.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"success with seq and account number",
|
|
func() {
|
|
acc := suite.app.AccountKeeper.GetAccount(suite.ctx, suite.address.Bytes())
|
|
suite.Require().NoError(acc.SetSequence(10))
|
|
suite.Require().NoError(acc.SetAccountNumber(1))
|
|
suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
|
|
|
|
expAccount = &types.QueryCosmosAccountResponse{
|
|
CosmosAddress: sdk.AccAddress(suite.address.Bytes()).String(),
|
|
Sequence: 10,
|
|
AccountNumber: 1,
|
|
}
|
|
req = &types.QueryCosmosAccountRequest{
|
|
Address: suite.address.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.CosmosAccount(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expAccount, res)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryBalance() {
|
|
var (
|
|
req *types.QueryBalanceRequest
|
|
expBalance string
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"invalid address",
|
|
func() {
|
|
expBalance = "0"
|
|
req = &types.QueryBalanceRequest{
|
|
Address: invalidAddress,
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
amt := sdk.Coins{ethermint.NewPhotonCoinInt64(100)}
|
|
err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
|
|
suite.Require().NoError(err)
|
|
err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)
|
|
suite.Require().NoError(err)
|
|
|
|
expBalance = "100"
|
|
req = &types.QueryBalanceRequest{
|
|
Address: suite.address.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.Balance(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expBalance, res.Balance)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryStorage() {
|
|
var (
|
|
req *types.QueryStorageRequest
|
|
expValue string
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"invalid address",
|
|
func() {
|
|
req = &types.QueryStorageRequest{
|
|
Address: invalidAddress,
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
key := ethcmn.BytesToHash([]byte("key"))
|
|
value := ethcmn.BytesToHash([]byte("value"))
|
|
expValue = value.String()
|
|
suite.app.EvmKeeper.SetState(suite.address, key, value)
|
|
req = &types.QueryStorageRequest{
|
|
Address: suite.address.String(),
|
|
Key: key.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.Storage(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expValue, res.Value)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryCode() {
|
|
var (
|
|
req *types.QueryCodeRequest
|
|
expCode []byte
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"invalid address",
|
|
func() {
|
|
req = &types.QueryCodeRequest{
|
|
Address: invalidAddress,
|
|
}
|
|
exp := &types.QueryCodeResponse{}
|
|
expCode = exp.Code
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
expCode = []byte("code")
|
|
suite.app.EvmKeeper.SetCode(suite.address, expCode)
|
|
|
|
req = &types.QueryCodeRequest{
|
|
Address: suite.address.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.Code(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expCode, res.Code)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryTxLogs() {
|
|
var (
|
|
req *types.QueryTxLogsRequest
|
|
expLogs []*types.Log
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"empty hash",
|
|
func() {
|
|
req = &types.QueryTxLogsRequest{
|
|
Hash: ethcmn.Hash{}.String(),
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{"logs not found",
|
|
func() {
|
|
hash := ethcmn.BytesToHash([]byte("hash"))
|
|
req = &types.QueryTxLogsRequest{
|
|
Hash: hash.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
hash := ethcmn.BytesToHash([]byte("tx_hash"))
|
|
|
|
expLogs = []*types.Log{
|
|
{
|
|
Address: suite.address.String(),
|
|
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
|
|
Data: []byte("data"),
|
|
BlockNumber: 1,
|
|
TxHash: hash.String(),
|
|
TxIndex: 1,
|
|
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
|
|
Index: 0,
|
|
Removed: false,
|
|
},
|
|
}
|
|
|
|
suite.app.EvmKeeper.SetLogs(hash, types.LogsToEthereum(expLogs))
|
|
|
|
req = &types.QueryTxLogsRequest{
|
|
Hash: hash.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.TxLogs(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expLogs, res.Logs)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryBlockLogs() {
|
|
var (
|
|
req *types.QueryBlockLogsRequest
|
|
expLogs []types.TransactionLogs
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"empty hash",
|
|
func() {
|
|
req = &types.QueryBlockLogsRequest{
|
|
Hash: ethcmn.Hash{}.String(),
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{"logs not found",
|
|
func() {
|
|
hash := ethcmn.BytesToHash([]byte("hash"))
|
|
req = &types.QueryBlockLogsRequest{
|
|
Hash: hash.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
|
|
hash := ethcmn.BytesToHash([]byte("block_hash"))
|
|
expLogs = []types.TransactionLogs{
|
|
{
|
|
Hash: ethcmn.BytesToHash([]byte("tx_hash_0")).String(),
|
|
Logs: []*types.Log{
|
|
{
|
|
Address: suite.address.String(),
|
|
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
|
|
Data: []byte("data"),
|
|
BlockNumber: 1,
|
|
TxHash: ethcmn.BytesToHash([]byte("tx_hash_0")).String(),
|
|
TxIndex: 1,
|
|
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
|
|
Index: 0,
|
|
Removed: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Hash: ethcmn.BytesToHash([]byte("tx_hash_1")).String(),
|
|
Logs: []*types.Log{
|
|
{
|
|
Address: suite.address.String(),
|
|
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
|
|
Data: []byte("data"),
|
|
BlockNumber: 1,
|
|
TxHash: ethcmn.BytesToHash([]byte("tx_hash_1")).String(),
|
|
TxIndex: 1,
|
|
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
|
|
Index: 0,
|
|
Removed: false,
|
|
},
|
|
{
|
|
Address: suite.address.String(),
|
|
Topics: []string{ethcmn.BytesToHash([]byte("topic_1")).String()},
|
|
Data: []byte("data_1"),
|
|
BlockNumber: 1,
|
|
TxHash: ethcmn.BytesToHash([]byte("tx_hash_1")).String(),
|
|
TxIndex: 1,
|
|
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
|
|
Index: 0,
|
|
Removed: false,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
suite.app.EvmKeeper.SetLogs(ethcmn.BytesToHash([]byte("tx_hash_0")), types.LogsToEthereum(expLogs[0].Logs))
|
|
suite.app.EvmKeeper.SetLogs(ethcmn.BytesToHash([]byte("tx_hash_1")), types.LogsToEthereum(expLogs[1].Logs))
|
|
|
|
req = &types.QueryBlockLogsRequest{
|
|
Hash: hash.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.BlockLogs(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expLogs, res.TxLogs)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryBlockBloom() {
|
|
var (
|
|
req *types.QueryBlockBloomRequest
|
|
expBloom []byte
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"bad height",
|
|
func() {
|
|
req = &types.QueryBlockBloomRequest{Height: -2}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"bloom from transient store",
|
|
func() {
|
|
req = &types.QueryBlockBloomRequest{Height: 1}
|
|
bloom := ethtypes.BytesToBloom([]byte("bloom"))
|
|
expBloom = bloom.Bytes()
|
|
suite.app.EvmKeeper.WithContext(suite.ctx.WithBlockHeight(1))
|
|
suite.app.EvmKeeper.SetBlockBloomTransient(bloom.Big())
|
|
},
|
|
true,
|
|
},
|
|
{"bloom not found for height",
|
|
func() {
|
|
req = &types.QueryBlockBloomRequest{Height: 100}
|
|
bloom := ethtypes.BytesToBloom([]byte("bloom"))
|
|
expBloom = bloom.Bytes()
|
|
suite.ctx = suite.ctx.WithBlockHeight(100)
|
|
suite.app.EvmKeeper.SetBlockBloom(suite.ctx, 2, bloom)
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
req = &types.QueryBlockBloomRequest{Height: 3}
|
|
bloom := ethtypes.BytesToBloom([]byte("bloom"))
|
|
expBloom = bloom.Bytes()
|
|
suite.ctx = suite.ctx.WithBlockHeight(3)
|
|
suite.app.EvmKeeper.SetBlockBloom(suite.ctx, 3, bloom)
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
ctx = metadata.AppendToOutgoingContext(ctx, grpctypes.GRPCBlockHeightHeader, fmt.Sprintf("%d", suite.ctx.BlockHeight()))
|
|
res, err := suite.queryClient.BlockBloom(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expBloom, res.Bloom)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryParams() {
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
expParams := types.DefaultParams()
|
|
|
|
res, err := suite.queryClient.Params(ctx, &types.QueryParamsRequest{})
|
|
suite.Require().NoError(err)
|
|
suite.Require().Equal(expParams, res.Params)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryValidatorAccount() {
|
|
var (
|
|
req *types.QueryValidatorAccountRequest
|
|
expAccount *types.QueryValidatorAccountResponse
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{"invalid address",
|
|
func() {
|
|
expAccount = &types.QueryValidatorAccountResponse{
|
|
AccountAddress: sdk.AccAddress(ethcmn.Address{}.Bytes()).String(),
|
|
}
|
|
req = &types.QueryValidatorAccountRequest{
|
|
ConsAddress: "",
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
expAccount = &types.QueryValidatorAccountResponse{
|
|
AccountAddress: sdk.AccAddress(suite.address.Bytes()).String(),
|
|
Sequence: 0,
|
|
AccountNumber: 0,
|
|
}
|
|
req = &types.QueryValidatorAccountRequest{
|
|
ConsAddress: suite.consAddress.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"success with seq and account number",
|
|
func() {
|
|
acc := suite.app.AccountKeeper.GetAccount(suite.ctx, suite.address.Bytes())
|
|
suite.Require().NoError(acc.SetSequence(10))
|
|
suite.Require().NoError(acc.SetAccountNumber(1))
|
|
suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
|
|
|
|
expAccount = &types.QueryValidatorAccountResponse{
|
|
AccountAddress: sdk.AccAddress(suite.address.Bytes()).String(),
|
|
Sequence: 10,
|
|
AccountNumber: 1,
|
|
}
|
|
req = &types.QueryValidatorAccountRequest{
|
|
ConsAddress: suite.consAddress.String(),
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
res, err := suite.queryClient.ValidatorAccount(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
suite.Require().Equal(expAccount, res)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// DeployTestContract deploy a test erc20 contract and returns the contract address
|
|
func (suite *KeeperTestSuite) deployTestContract(owner common.Address, supply *big.Int) common.Address {
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
chainID := suite.app.EvmKeeper.ChainID()
|
|
|
|
ctorArgs, err := contractABI.Pack("", owner, supply)
|
|
suite.Require().NoError(err)
|
|
|
|
data := append(contractBin, ctorArgs...)
|
|
args, err := json.Marshal(&types.CallArgs{
|
|
From: &suite.address,
|
|
Data: (*hexutil.Bytes)(&data),
|
|
})
|
|
suite.Require().NoError(err)
|
|
|
|
res, err := suite.queryClient.EstimateGas(ctx, &types.EthCallRequest{
|
|
Args: args,
|
|
GasCap: uint64(ethermint.DefaultRPCGasLimit),
|
|
})
|
|
suite.Require().NoError(err)
|
|
|
|
nonce := suite.app.EvmKeeper.GetNonce(suite.address)
|
|
erc20DeployTx := types.NewTxContract(
|
|
chainID,
|
|
nonce,
|
|
nil, // amount
|
|
res.Gas, // gasLimit
|
|
nil, // gasPrice
|
|
data, // input
|
|
nil, // accesses
|
|
)
|
|
erc20DeployTx.From = suite.address.Hex()
|
|
err = erc20DeployTx.Sign(ethtypes.LatestSignerForChainID(chainID), suite.signer)
|
|
suite.Require().NoError(err)
|
|
rsp, err := suite.app.EvmKeeper.EthereumTx(ctx, erc20DeployTx)
|
|
suite.Require().NoError(err)
|
|
suite.Require().Empty(rsp.VmError)
|
|
return crypto.CreateAddress(suite.address, nonce)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestEstimateGas() {
|
|
ctx := sdk.WrapSDKContext(suite.ctx)
|
|
gasHelper := hexutil.Uint64(20000)
|
|
|
|
var (
|
|
args types.CallArgs
|
|
gasCap uint64
|
|
)
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
expGas uint64
|
|
}{
|
|
// should success, because transfer value is zero
|
|
{"default args", func() {
|
|
args = types.CallArgs{To: &common.Address{}}
|
|
}, true, 21000},
|
|
// should fail, because the default From address(zero address) don't have fund
|
|
{"not enough balance", func() {
|
|
args = types.CallArgs{To: &common.Address{}, Value: (*hexutil.Big)(big.NewInt(100))}
|
|
}, false, 0},
|
|
// should success, enough balance now
|
|
{"enough balance", func() {
|
|
args = types.CallArgs{To: &common.Address{}, From: &suite.address, Value: (*hexutil.Big)(big.NewInt(100))}
|
|
}, false, 0},
|
|
// should success, because gas limit lower than 21000 is ignored
|
|
{"gas exceed allowance", func() {
|
|
args = types.CallArgs{To: &common.Address{}, Gas: &gasHelper}
|
|
}, true, 21000},
|
|
// should fail, invalid gas cap
|
|
{"gas exceed global allowance", func() {
|
|
args = types.CallArgs{To: &common.Address{}}
|
|
gasCap = 20000
|
|
}, false, 0},
|
|
// estimate gas of an erc20 contract deployment, the exact gas number is checked with geth
|
|
{"contract deployment", func() {
|
|
ctorArgs, err := contractABI.Pack("", &suite.address, sdk.NewIntWithDecimal(1000, 18).BigInt())
|
|
suite.Require().NoError(err)
|
|
data := append(contractBin, ctorArgs...)
|
|
args = types.CallArgs{
|
|
From: &suite.address,
|
|
Data: (*hexutil.Bytes)(&data),
|
|
}
|
|
}, true, 1144643},
|
|
// estimate gas of an erc20 transfer, the exact gas number is checked with geth
|
|
{"erc20 transfer", func() {
|
|
contractAddr := suite.deployTestContract(suite.address, sdk.NewIntWithDecimal(1000, 18).BigInt())
|
|
suite.Commit()
|
|
transferData, err := contractABI.Pack("transfer", common.HexToAddress("0x378c50D9264C63F3F92B806d4ee56E9D86FfB3Ec"), big.NewInt(1000))
|
|
suite.Require().NoError(err)
|
|
args = types.CallArgs{To: &contractAddr, From: &suite.address, Data: (*hexutil.Bytes)(&transferData)}
|
|
}, true, 51880},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest()
|
|
gasCap = ethermint.DefaultRPCGasLimit
|
|
tc.malleate()
|
|
|
|
args, err := json.Marshal(&args)
|
|
suite.Require().NoError(err)
|
|
req := types.EthCallRequest{
|
|
Args: args,
|
|
GasCap: gasCap,
|
|
}
|
|
|
|
rsp, err := suite.queryClient.EstimateGas(ctx, &req)
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().Equal(tc.expGas, rsp.Gas)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|