deep-stack/laconicd-deprecated
6
0
Fork 0
forked from cerc-io/laconicd-deprecated
Code Pull Requests Activity

all: cleanup imports (#524)

Browse Source
This commit is contained in:
Federico Kunze Küllmer 2021-09-03 20:06:36 +02:00 committed by GitHub
parent 945fa64853
commit c73ce0f812
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 238 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
crypto/ethsecp256k1/ethsecp256k1.go
View File

@ -6,11 +6,10 @@ import (
"crypto/subtle"
"fmt"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/cosmos-sdk/codec"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/ethereum/go-ethereum/crypto"
tmcrypto "github.com/tendermint/tendermint/crypto"
)
@ -43,13 +42,13 @@ var (
// GenerateKey generates a new random private key. It returns an error upon
// failure.
func GenerateKey() (*PrivKey, error) {
priv, err := ethcrypto.GenerateKey()
priv, err := crypto.GenerateKey()
if err != nil {
return nil, err
}
return &PrivKey{
Key: ethcrypto.FromECDSA(priv),
Key: crypto.FromECDSA(priv),
}, nil
}
@ -62,7 +61,7 @@ func (privKey PrivKey) Bytes() []byte {
func (privKey PrivKey) PubKey() cryptotypes.PubKey {
ecdsaPrivKey := privKey.ToECDSA()
return &PubKey{
Key: ethcrypto.CompressPubkey(&ecdsaPrivKey.PublicKey),
Key: crypto.CompressPubkey(&ecdsaPrivKey.PublicKey),
}
}
@ -107,17 +106,17 @@ func (privKey *PrivKey) UnmarshalAminoJSON(bz []byte) error {
// provided hash of the message. The produced signature is 65 bytes
// where the last byte contains the recovery ID.
func (privKey PrivKey) Sign(digestBz []byte) ([]byte, error) {
if len(digestBz) != ethcrypto.DigestLength {
digestBz = ethcrypto.Keccak256Hash(digestBz).Bytes()
if len(digestBz) != crypto.DigestLength {
digestBz = crypto.Keccak256Hash(digestBz).Bytes()
}
return ethcrypto.Sign(digestBz, privKey.ToECDSA())
return crypto.Sign(digestBz, privKey.ToECDSA())
}
// ToECDSA returns the ECDSA private key as a reference to ecdsa.PrivateKey type.
// The function will panic if the private key is invalid.
func (privKey PrivKey) ToECDSA() *ecdsa.PrivateKey {
key, err := ethcrypto.ToECDSA(privKey.Bytes())
key, err := crypto.ToECDSA(privKey.Bytes())
if err != nil {
panic(err)
}
@ -135,12 +134,12 @@ var (
// Address returns the address of the ECDSA public key.
// The function will panic if the public key is invalid.
func (pubKey PubKey) Address() tmcrypto.Address {
pubk, err := ethcrypto.DecompressPubkey(pubKey.Key)
pubk, err := crypto.DecompressPubkey(pubKey.Key)
if err != nil {
panic(err)
}
return tmcrypto.Address(ethcrypto.PubkeyToAddress(*pubk).Bytes())
return tmcrypto.Address(crypto.PubkeyToAddress(*pubk).Bytes())
}
// Bytes returns the raw bytes of the ECDSA public key.
@ -196,11 +195,11 @@ func (pubKey *PubKey) UnmarshalAminoJSON(bz []byte) error {
//
// CONTRACT: The signature should be in [R || S] format.
func (pubKey PubKey) VerifySignature(msg []byte, sig []byte) bool {
if len(sig) == ethcrypto.SignatureLength {
if len(sig) == crypto.SignatureLength {
// remove recovery ID (V) if contained in the signature
sig = sig[:len(sig)-1]
}
// the signature needs to be in [R || S] format when provided to VerifySignature
return ethcrypto.VerifySignature(pubKey.Key, ethcrypto.Keccak256Hash(msg).Bytes(), sig)
return crypto.VerifySignature(pubKey.Key, crypto.Keccak256Hash(msg).Bytes(), sig)
}

6
crypto/ethsecp256k1/ethsecp256k1_test.go
View File

@ -8,7 +8,7 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/secp256k1"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
@ -28,12 +28,12 @@ func TestPrivKey(t *testing.T) {
// validate Ethereum address equality
addr := privKey.PubKey().Address()
expectedAddr := ethcrypto.PubkeyToAddress(privKey.ToECDSA().PublicKey)
expectedAddr := crypto.PubkeyToAddress(privKey.ToECDSA().PublicKey)
require.Equal(t, expectedAddr.Bytes(), addr.Bytes())
// validate we can sign some bytes
msg := []byte("hello world")
sigHash := ethcrypto.Keccak256Hash(msg)
sigHash := crypto.Keccak256Hash(msg)
expectedSig, err := secp256k1.Sign(sigHash.Bytes(), privKey.Bytes())
require.NoError(t, err)

8
crypto/hd/algorithm.go
View File

@ -5,8 +5,8 @@ import (
"github.com/btcsuite/btcutil/hdkeychain"
bip39 "github.com/tyler-smith/go-bip39"
ethaccounts "github.com/ethereum/go-ethereum/accounts"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/cosmos-sdk/crypto/hd"
"github.com/cosmos/cosmos-sdk/crypto/keyring"
@ -59,7 +59,7 @@ func (s ethSecp256k1Algo) Name() hd.PubKeyType {
// Derive derives and returns the eth_secp256k1 private key for the given mnemonic and HD path.
func (s ethSecp256k1Algo) Derive() hd.DeriveFn {
return func(mnemonic string, bip39Passphrase, path string) ([]byte, error) {
hdpath, err := ethaccounts.ParseDerivationPath(path)
hdpath, err := accounts.ParseDerivationPath(path)
if err != nil {
return nil, err
}
@ -88,7 +88,7 @@ func (s ethSecp256k1Algo) Derive() hd.DeriveFn {
}
privateKeyECDSA := privateKey.ToECDSA()
derivedKey := ethcrypto.FromECDSA(privateKeyECDSA)
derivedKey := crypto.FromECDSA(privateKeyECDSA)
return derivedKey, nil
}

86
docs/architecture/adr-002-evm-hooks.md
View File

@ -29,9 +29,9 @@ add custom logic to process transaction logs.
This ADR proposes to add an `EvmHooks` interface and a method to register hooks in the `EvmKeeper`:
```golang
```go
type EvmHooks interface {
PostTxProcessing(ctx sdk.Context, txHash ethcmn.Hash, logs []*ethtypes.Log) error
PostTxProcessing(ctx sdk.Context, txHash common.Hash, logs []*ethtypes.Log) error
}
func (k *EvmKeeper) SetHooks(eh types.EvmHooks) *Keeper;
@ -48,9 +48,13 @@ func (k *EvmKeeper) SetHooks(eh types.EvmHooks) *Keeper;
The EVM state transition method `ApplyTransaction` should be changed like this:
```golang
```go
// Need to create a snapshot explicitly to cover both tx processing and post processing logic
revision := k.Snapshot()
var revision int
if k.hooks != nil {
revision = k.Snapshot()
}
res, err := k.ApplyMessage(evm, msg, ethCfg, false)
if err != nil {
@ -96,50 +100,50 @@ function withdraw_to_native_token(amount uint256) public {
And the application registers a `BankSendHook` to `EvmKeeper`, it recognizes the log and converts it to a call to the bank
module's `SendCoinsFromAccountToAccount` method:
```golang
```go
var (
// BankSendEvent represent the signature of
// `event __CosmosNativeBankSend(address recipient, uint256 amount, string denom)`
BankSendEvent abi.Event
// BankSendEvent represent the signature of
// `event __CosmosNativeBankSend(address recipient, uint256 amount, string denom)`
BankSendEvent abi.Event
)
func init() {
addressType, _ := abi.NewType("address", "", nil)
uint256Type, _ := abi.NewType("uint256", "", nil)
stringType, _ := abi.NewType("string", "", nil)
BankSendEvent = abi.NewEvent(
"__CosmosNativeBankSend",
"__CosmosNativeBankSend",
false,
abi.Arguments{abi.Argument{
Name: "recipient",
Type: addressType,
Indexed: false,
}, abi.Argument{
Name: "amount",
Type: uint256Type,
Indexed: false,
}, abi.Argument{
Name: "denom",
Type: stringType,
Indexed: false,
}},
)
addressType, _ := abi.NewType("address", "", nil)
uint256Type, _ := abi.NewType("uint256", "", nil)
stringType, _ := abi.NewType("string", "", nil)
BankSendEvent = abi.NewEvent(
"__CosmosNativeBankSend",
"__CosmosNativeBankSend",
false,
abi.Arguments{abi.Argument{
Name: "recipient",
Type: addressType,
Indexed: false,
}, abi.Argument{
Name: "amount",
Type: uint256Type,
Indexed: false,
}, abi.Argument{
Name: "denom",
Type: stringType,
Indexed: false,
}},
)
}
type BankSendHook struct {
bankKeeper bankkeeper.Keeper
bankKeeper bankkeeper.Keeper
}
func NewBankSendHook(bankKeeper bankkeeper.Keeper) *BankSendHook {
return &BankSendHook{
bankKeeper: bankKeeper,
}
return &BankSendHook{
bankKeeper: bankKeeper,
}
}
func (h BankSendHook) PostTxProcessing(ctx sdk.Context, txHash ethcmn.Hash, logs []*ethtypes.Log) error {
for _, log := range logs {
if len(log.Topics) == 0 || log.Topics[0] != BankSendEvent.ID {
func (h BankSendHook) PostTxProcessing(ctx sdk.Context, txHash common.Hash, logs []*ethtypes.Log) error {
for _, log := range logs {
if len(log.Topics) == 0 || log.Topics[0] != BankSendEvent.ID {
continue
}
if !ContractAllowed(log.Address) {
@ -152,21 +156,21 @@ func (h BankSendHook) PostTxProcessing(ctx sdk.Context, txHash ethcmn.Hash, logs
continue
}
contract := sdk.AccAddress(log.Address.Bytes())
recipient := sdk.AccAddress(unpacked[0].(ethcmn.Address).Bytes())
recipient := sdk.AccAddress(unpacked[0].(common.Address).Bytes())
coins := sdk.NewCoins(sdk.NewCoin(unpacked[2].(string), sdk.NewIntFromBigInt(unpacked[1].(*big.Int))))
err = h.bankKeeper.SendCoins(ctx, contract, recipient, coins)
if err != nil {
return err
}
}
}
return nil
}
}
return nil
}
```
Register the hook in `app.go`:
```golang
```go
evmKeeper.SetHooks(NewBankSendHook(bankKeeper));
```

12
tests/importer/chain_ctx.go
View File

@ -3,7 +3,7 @@ package importer
import (
"math/big"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethcons "github.com/ethereum/go-ethereum/consensus"
ethstate "github.com/ethereum/go-ethereum/core/state"
ethtypes "github.com/ethereum/go-ethereum/core/types"
@ -20,7 +20,7 @@ import (
// NOTE: Ethermint will distribute the fees out to validators, so the structure
// and functionality of this is a WIP and subject to change.
type ChainContext struct {
Coinbase ethcmn.Address
Coinbase common.Address
headersByNumber map[uint64]*ethtypes.Header
}
@ -48,7 +48,7 @@ func (cc *ChainContext) SetHeader(number uint64, header *ethtypes.Header) {
//
// TODO: The Cosmos SDK supports retreiving such information in contexts and
// multi-store, so this will be need to be integrated.
func (cc *ChainContext) GetHeader(_ ethcmn.Hash, number uint64) *ethtypes.Header {
func (cc *ChainContext) GetHeader(_ common.Hash, number uint64) *ethtypes.Header {
if header, ok := cc.headersByNumber[number]; ok {
return header
}
@ -62,7 +62,7 @@ func (cc *ChainContext) GetHeader(_ ethcmn.Hash, number uint64) *ethtypes.Header
//
// NOTE: Ethermint will distribute the fees out to validators, so the structure
// and functionality of this is a WIP and subject to change.
func (cc *ChainContext) Author(_ *ethtypes.Header) (ethcmn.Address, error) {
func (cc *ChainContext) Author(_ *ethtypes.Header) (common.Address, error) {
return cc.Coinbase, nil
}
@ -119,8 +119,8 @@ func (cc *ChainContext) Seal(_ ethcons.ChainHeaderReader, _ *ethtypes.Block, _ c
// SealHash implements Ethereum's consensus.Engine interface. It returns the
// hash of a block prior to it being sealed.
func (cc *ChainContext) SealHash(header *ethtypes.Header) ethcmn.Hash {
return ethcmn.Hash{}
func (cc *ChainContext) SealHash(header *ethtypes.Header) common.Hash {
return common.Hash{}
}
// VerifyHeader implements Ethereum's consensus.Engine interface. It currently

6
tests/importer/chain_ctx_test.go
View File

@ -9,7 +9,7 @@ import (
"github.com/stretchr/testify/require"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethcons "github.com/ethereum/go-ethereum/consensus"
ethcore "github.com/ethereum/go-ethereum/core"
ethtypes "github.com/ethereum/go-ethereum/core/types"
@ -47,8 +47,8 @@ func TestChainContextGetHeader(t *testing.T) {
}
cc.SetHeader(uint64(header.Number.Int64()), header)
require.Equal(t, header, cc.GetHeader(ethcmn.Hash{}, uint64(header.Number.Int64())))
require.Nil(t, cc.GetHeader(ethcmn.Hash{}, 0))
require.Equal(t, header, cc.GetHeader(common.Hash{}, uint64(header.Number.Int64())))
require.Nil(t, cc.GetHeader(common.Hash{}, 0))
}
func TestChainContextAuthor(t *testing.T) {

14
tests/importer/importer_test.go
View File

@ -35,12 +35,12 @@ package importer
// evmkeeper "github.com/tharsis/ethermint/x/evm/keeper"
// evmtypes "github.com/tharsis/ethermint/x/evm/types"
// ethcmn "github.com/ethereum/go-ethereum/common"
// "github.com/ethereum/go-ethereum/common"
// "github.com/ethereum/go-ethereum/consensus/ethash"
// ethcore "github.com/ethereum/go-ethereum/core"
// ethtypes "github.com/ethereum/go-ethereum/core/types"
// ethvm "github.com/ethereum/go-ethereum/core/vm"
// ethcrypto "github.com/ethereum/go-ethereum/crypto"
// "github.com/ethereum/go-ethereum/crypto"
// ethparams "github.com/ethereum/go-ethereum/params"
// ethrlp "github.com/ethereum/go-ethereum/rlp"
@ -56,7 +56,7 @@ package importer
// flagBlockchain string
// flagCPUProfile string
// genInvestor = ethcmn.HexToAddress("0x756F45E3FA69347A9A973A725E3C98bC4db0b5a0")
// genInvestor = common.HexToAddress("0x756F45E3FA69347A9A973A725E3C98bC4db0b5a0")
// logger = tmlog.NewNopLogger()
@ -125,7 +125,7 @@ package importer
// sort.Strings(genAddrs)
// for _, addrStr := range genAddrs {
// addr := ethcmn.HexToAddress(addrStr)
// addr := common.HexToAddress(addrStr)
// acc := genBlock.Alloc[addr]
// evmKeeper.AddBalance(addr, acc.Balance)
@ -348,7 +348,7 @@ package importer
// // Function is also pulled from go-ethereum 1.9 because of the incompatible usage
// // Ref: https://github.com/ethereum/go-ethereum/blob/52f2461774bcb8cdd310f86b4bc501df5b783852/core/state_processor.go#L88
// func applyTransaction(
// config *ethparams.ChainConfig, bc ethcore.ChainContext, author *ethcmn.Address,
// config *ethparams.ChainConfig, bc ethcore.ChainContext, author *common.Address,
// gp *ethcore.GasPool, evmKeeper *evmkeeper.Keeper, header *ethtypes.Header,
// tx *ethtypes.Transaction, usedGas *uint64, cfg ethvm.Config,
// ) (*ethtypes.Receipt, uint64, error) {
@ -376,7 +376,7 @@ package importer
// return nil, execResult.UsedGas, err
// }
// root := ethcmn.Hash{}.Bytes()
// root := common.Hash{}.Bytes()
// *usedGas += execResult.UsedGas
// // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx
@ -387,7 +387,7 @@ package importer
// // if the transaction created a contract, store the creation address in the receipt.
// if msg.To() == nil {
// receipt.ContractAddress = ethcrypto.CreateAddress(vmenv.TxContext.Origin, tx.Nonce())
// receipt.ContractAddress = crypto.CreateAddress(vmenv.TxContext.Origin, tx.Nonce())
// }
// // Set the receipt logs and create a bloom for filtering

8
tests/rpc/personal_test.go
View File

@ -8,7 +8,7 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto"
)
func TestPersonal_ListAccounts(t *testing.T) {
@ -47,18 +47,18 @@ func TestPersonal_Sign(t *testing.T) {
}
func TestPersonal_ImportRawKey(t *testing.T) {
privkey, err := ethcrypto.GenerateKey()
privkey, err := crypto.GenerateKey()
require.NoError(t, err)
// parse priv key to hex
hexPriv := common.Bytes2Hex(ethcrypto.FromECDSA(privkey))
hexPriv := common.Bytes2Hex(crypto.FromECDSA(privkey))
rpcRes := Call(t, "personal_importRawKey", []string{hexPriv, "password"})
var res hexutil.Bytes
err = json.Unmarshal(rpcRes.Result, &res)
require.NoError(t, err)
addr := ethcrypto.PubkeyToAddress(privkey.PublicKey)
addr := crypto.PubkeyToAddress(privkey.PublicKey)
resAddr := common.BytesToAddress(res)
require.Equal(t, addr.String(), resAddr.String())

8
tests/rpc/rpc_test.go
View File

@ -23,7 +23,7 @@ import (
ethermint "github.com/tharsis/ethermint/types"
evmtypes "github.com/tharsis/ethermint/x/evm/types"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
ethtypes "github.com/ethereum/go-ethereum/core/types"
)
@ -339,7 +339,7 @@ func TestEth_blockNumber(t *testing.T) {
}
func TestEth_coinbase(t *testing.T) {
zeroAddress := hexutil.Bytes(ethcmn.Address{}.Bytes())
zeroAddress := hexutil.Bytes(common.Address{}.Bytes())
rpcRes := call(t, "eth_coinbase", []string{})
var res hexutil.Bytes
@ -470,7 +470,7 @@ func TestEth_GetFilterChanges_BlockFilter(t *testing.T) {
time.Sleep(5 * time.Second)
changesRes := call(t, "eth_getFilterChanges", []string{ID})
var hashes []ethcmn.Hash
var hashes []common.Hash
err = json.Unmarshal(changesRes.Result, &hashes)
require.NoError(t, err)
require.GreaterOrEqual(t, len(hashes), 1)
@ -579,7 +579,7 @@ func TestEth_GetTransactionReceipt_ContractDeployment(t *testing.T) {
require.NoError(t, err)
require.Equal(t, "0x1", receipt["status"].(string))
require.NotEqual(t, ethcmn.Address{}.String(), receipt["contractAddress"].(string))
require.NotEqual(t, common.Address{}.String(), receipt["contractAddress"].(string))
require.NotNil(t, receipt["logs"])
}

4
types/account.go
View File

@ -5,7 +5,7 @@ import (
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
"github.com/ethereum/go-ethereum/common"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto"
)
var (
@ -23,7 +23,7 @@ var (
func ProtoAccount() authtypes.AccountI {
return &EthAccount{
BaseAccount: &authtypes.BaseAccount{},
CodeHash: common.BytesToHash(ethcrypto.Keccak256(nil)).String(),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(),
}
}

9
types/validation.go
View File

@ -3,24 +3,23 @@ package types
import (
"bytes"
ethcmn "github.com/ethereum/go-ethereum/common"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/ethereum/go-ethereum/common"
)
// IsEmptyHash returns true if the hash corresponds to an empty ethereum hex hash.
func IsEmptyHash(hash string) bool {
return bytes.Equal(ethcmn.HexToHash(hash).Bytes(), ethcmn.Hash{}.Bytes())
return bytes.Equal(common.HexToHash(hash).Bytes(), common.Hash{}.Bytes())
}
// IsZeroAddress returns true if the address corresponds to an empty ethereum hex address.
func IsZeroAddress(address string) bool {
return bytes.Equal(ethcmn.HexToAddress(address).Bytes(), ethcmn.Address{}.Bytes())
return bytes.Equal(common.HexToAddress(address).Bytes(), common.Address{}.Bytes())
}
// ValidateAddress returns an error if the provided string is either not a hex formatted string address
func ValidateAddress(address string) error {
if !ethcmn.IsHexAddress(address) {
if !common.IsHexAddress(address) {
return sdkerrors.Wrapf(
sdkerrors.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address",
address,

11
types/validation_test.go
View File

@ -3,9 +3,8 @@ package types
import (
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/require"
ethcmn "github.com/ethereum/go-ethereum/common"
)
func TestIsEmptyHash(t *testing.T) {
@ -18,11 +17,11 @@ func TestIsEmptyHash(t *testing.T) {
"empty string", "", true,
},
{
"zero hash", ethcmn.Hash{}.String(), true,
"zero hash", common.Hash{}.String(), true,
},
{
"non-empty hash", ethcmn.BytesToHash([]byte{1, 2, 3, 4}).String(), false,
"non-empty hash", common.BytesToHash([]byte{1, 2, 3, 4}).String(), false,
},
}
@ -41,11 +40,11 @@ func TestIsZeroAddress(t *testing.T) {
"empty string", "", true,
},
{
"zero address", ethcmn.Address{}.String(), true,
"zero address", common.Address{}.String(), true,
},
{
"non-empty address", ethcmn.BytesToAddress([]byte{1, 2, 3, 4}).String(), false,
"non-empty address", common.BytesToAddress([]byte{1, 2, 3, 4}).String(), false,
},
}

2
x/evm/atlas/atlas-v0.3.1.md
View File

@ -130,7 +130,7 @@ type GenesisAccount struct {
type TransactionLogs struct {
Hash ethcmn.Hash `json:"hash"`
Hash common.Hash `json:"hash"`
Logs []*ethtypes.Log `json:"logs"`
}

12
x/evm/genesis.go
View File

@ -5,7 +5,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
abci "github.com/tendermint/tendermint/abci/types"
ethermint "github.com/tharsis/ethermint/types"
@ -31,7 +31,7 @@ func InitGenesis(
}
for _, account := range data.Accounts {
address := ethcmn.HexToAddress(account.Address)
address := common.HexToAddress(account.Address)
accAddress := sdk.AccAddress(address.Bytes())
// check that the EVM balance the matches the account balance
acc := accountKeeper.GetAccount(ctx, accAddress)
@ -48,15 +48,15 @@ func InitGenesis(
)
}
k.SetCode(address, ethcmn.Hex2Bytes(account.Code))
k.SetCode(address, common.Hex2Bytes(account.Code))
for _, storage := range account.Storage {
k.SetState(address, ethcmn.HexToHash(storage.Key), ethcmn.HexToHash(storage.Value))
k.SetState(address, common.HexToHash(storage.Key), common.HexToHash(storage.Value))
}
}
for _, txLog := range data.TxsLogs {
k.SetLogs(ethcmn.HexToHash(txLog.Hash), txLog.EthLogs())
k.SetLogs(common.HexToHash(txLog.Hash), txLog.EthLogs())
}
return []abci.ValidatorUpdate{}
@ -83,7 +83,7 @@ func ExportGenesis(ctx sdk.Context, k *keeper.Keeper, ak types.AccountKeeper) *t
genAccount := types.GenesisAccount{
Address: addr.String(),
Code: ethcmn.Bytes2Hex(k.GetCode(addr)),
Code: common.Bytes2Hex(k.GetCode(addr)),
Storage: storage,
}

14
x/evm/handler_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/stretchr/testify/suite"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
"github.com/cosmos/cosmos-sdk/codec"
@ -33,7 +33,7 @@ type EvmTestSuite struct {
signer keyring.Signer
ethSigner ethtypes.Signer
from ethcmn.Address
from common.Address
to sdk.AccAddress
}
@ -57,7 +57,7 @@ func (suite *EvmTestSuite) SetupTest() {
suite.signer = tests.NewSigner(privKey)
suite.ethSigner = ethtypes.LatestSignerForChainID(suite.chainID)
suite.from = ethcmn.BytesToAddress(privKey.PubKey().Address().Bytes())
suite.from = common.BytesToAddress(privKey.PubKey().Address().Bytes())
}
@ -77,7 +77,7 @@ func TestEvmTestSuite(t *testing.T) {
// {
// "passed",
// func() {
// to := ethcmn.BytesToAddress(suite.to)
// to := common.BytesToAddress(suite.to)
// tx = types.NewTx(suite.chainID, 0, &to, big.NewInt(100), 0, big.NewInt(10000), nil, nil)
// tx.From = suite.from.String()
@ -181,10 +181,10 @@ func TestEvmTestSuite(t *testing.T) {
// suite.Require().Equal(len(txResponse.Logs[0].Topics), 2)
// hash := []byte{1}
// suite.app.EvmKeeper.SetLogs(ethcmn.BytesToHash(hash), types.LogsToEthereum(txResponse.Logs))
// suite.app.EvmKeeper.SetLogs(common.BytesToHash(hash), types.LogsToEthereum(txResponse.Logs))
// suite.Require().NoError(err)
// logs := suite.app.EvmKeeper.GetTxLogs(ethcmn.BytesToHash(hash))
// logs := suite.app.EvmKeeper.GetTxLogs(common.BytesToHash(hash))
// suite.Require().Equal(logs, txResponse.Logs)
// }
@ -302,7 +302,7 @@ func TestEvmTestSuite(t *testing.T) {
// gasPrice := big.NewInt(0x55ae82600)
// // send simple value transfer with gasLimit=21000
// tx := types.NewTx(suite.chainID, 1, &ethcmn.Address{0x1}, big.NewInt(1), gasLimit, gasPrice, nil, nil)
// tx := types.NewTx(suite.chainID, 1, &common.Address{0x1}, big.NewInt(1), gasLimit, gasPrice, nil, nil)
// tx.From = suite.from.String()
// err := tx.Sign(suite.ethSigner, suite.signer)
// suite.Require().NoError(err)

16
x/evm/keeper/grpc_query.go
View File

@ -15,7 +15,7 @@ import (
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/types/query"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core"
ethtypes "github.com/ethereum/go-ethereum/core/types"
@ -40,7 +40,7 @@ func (k Keeper) Account(c context.Context, req *types.QueryAccountRequest) (*typ
)
}
addr := ethcmn.HexToAddress(req.Address)
addr := common.HexToAddress(req.Address)
ctx := sdk.UnwrapSDKContext(c)
k.WithContext(ctx)
@ -66,7 +66,7 @@ func (k Keeper) CosmosAccount(c context.Context, req *types.QueryCosmosAccountRe
ctx := sdk.UnwrapSDKContext(c)
k.WithContext(ctx)
ethAddr := ethcmn.HexToAddress(req.Address)
ethAddr := common.HexToAddress(req.Address)
cosmosAddr := sdk.AccAddress(ethAddr.Bytes())
account := k.accountKeeper.GetAccount(ctx, cosmosAddr)
@ -134,7 +134,7 @@ func (k Keeper) Balance(c context.Context, req *types.QueryBalanceRequest) (*typ
ctx := sdk.UnwrapSDKContext(c)
k.WithContext(ctx)
balanceInt := k.GetBalance(ethcmn.HexToAddress(req.Address))
balanceInt := k.GetBalance(common.HexToAddress(req.Address))
return &types.QueryBalanceResponse{
Balance: balanceInt.String(),
@ -157,8 +157,8 @@ func (k Keeper) Storage(c context.Context, req *types.QueryStorageRequest) (*typ
ctx := sdk.UnwrapSDKContext(c)
k.WithContext(ctx)
address := ethcmn.HexToAddress(req.Address)
key := ethcmn.HexToHash(req.Key)
address := common.HexToAddress(req.Address)
key := common.HexToHash(req.Key)
state := k.GetState(address, key)
stateHex := state.Hex()
@ -184,7 +184,7 @@ func (k Keeper) Code(c context.Context, req *types.QueryCodeRequest) (*types.Que
ctx := sdk.UnwrapSDKContext(c)
k.WithContext(ctx)
address := ethcmn.HexToAddress(req.Address)
address := common.HexToAddress(req.Address)
code := k.GetCode(address)
return &types.QueryCodeResponse{
@ -208,7 +208,7 @@ func (k Keeper) TxLogs(c context.Context, req *types.QueryTxLogsRequest) (*types
ctx := sdk.UnwrapSDKContext(c)
k.WithContext(ctx)
hash := ethcmn.HexToHash(req.Hash)
hash := common.HexToHash(req.Hash)
logs := k.GetTxLogs(hash)
return &types.QueryTxLogsResponse{

57
x/evm/keeper/grpc_query_test.go
View File

@ -8,10 +8,9 @@ import (
"google.golang.org/grpc/metadata"
"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"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -40,7 +39,7 @@ func (suite *KeeperTestSuite) TestQueryAccount() {
func() {
expAccount = &types.QueryAccountResponse{
Balance: "0",
CodeHash: common.BytesToHash(ethcrypto.Keccak256(nil)).Hex(),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).Hex(),
Nonce: 0,
}
req = &types.QueryAccountRequest{
@ -60,7 +59,7 @@ func (suite *KeeperTestSuite) TestQueryAccount() {
expAccount = &types.QueryAccountResponse{
Balance: "100",
CodeHash: common.BytesToHash(ethcrypto.Keccak256(nil)).Hex(),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).Hex(),
Nonce: 0,
}
req = &types.QueryAccountRequest{
@ -105,7 +104,7 @@ func (suite *KeeperTestSuite) TestQueryCosmosAccount() {
{"invalid address",
func() {
expAccount = &types.QueryCosmosAccountResponse{
CosmosAddress: sdk.AccAddress(ethcmn.Address{}.Bytes()).String(),
CosmosAddress: sdk.AccAddress(common.Address{}.Bytes()).String(),
}
req = &types.QueryCosmosAccountRequest{
Address: invalidAddress,
@ -248,8 +247,8 @@ func (suite *KeeperTestSuite) TestQueryStorage() {
{
"success",
func() {
key := ethcmn.BytesToHash([]byte("key"))
value := ethcmn.BytesToHash([]byte("value"))
key := common.BytesToHash([]byte("key"))
value := common.BytesToHash([]byte("value"))
expValue = value.String()
suite.app.EvmKeeper.SetState(suite.address, key, value)
req = &types.QueryStorageRequest{
@ -350,14 +349,14 @@ func (suite *KeeperTestSuite) TestQueryTxLogs() {
{"empty hash",
func() {
req = &types.QueryTxLogsRequest{
Hash: ethcmn.Hash{}.String(),
Hash: common.Hash{}.String(),
}
},
false,
},
{"logs not found",
func() {
hash := ethcmn.BytesToHash([]byte("hash"))
hash := common.BytesToHash([]byte("hash"))
req = &types.QueryTxLogsRequest{
Hash: hash.String(),
}
@ -367,17 +366,17 @@ func (suite *KeeperTestSuite) TestQueryTxLogs() {
{
"success",
func() {
hash := ethcmn.BytesToHash([]byte("tx_hash"))
hash := common.BytesToHash([]byte("tx_hash"))
expLogs = []*types.Log{
{
Address: suite.address.String(),
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
Topics: []string{common.BytesToHash([]byte("topic")).String()},
Data: []byte("data"),
BlockNumber: 1,
TxHash: hash.String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 0,
Removed: false,
},
@ -427,14 +426,14 @@ func (suite *KeeperTestSuite) TestQueryBlockLogs() {
{"empty hash",
func() {
req = &types.QueryBlockLogsRequest{
Hash: ethcmn.Hash{}.String(),
Hash: common.Hash{}.String(),
}
},
false,
},
{"logs not found",
func() {
hash := ethcmn.BytesToHash([]byte("hash"))
hash := common.BytesToHash([]byte("hash"))
req = &types.QueryBlockLogsRequest{
Hash: hash.String(),
}
@ -445,46 +444,46 @@ func (suite *KeeperTestSuite) TestQueryBlockLogs() {
"success",
func() {
hash := ethcmn.BytesToHash([]byte("block_hash"))
hash := common.BytesToHash([]byte("block_hash"))
expLogs = []types.TransactionLogs{
{
Hash: ethcmn.BytesToHash([]byte("tx_hash_0")).String(),
Hash: common.BytesToHash([]byte("tx_hash_0")).String(),
Logs: []*types.Log{
{
Address: suite.address.String(),
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
Topics: []string{common.BytesToHash([]byte("topic")).String()},
Data: []byte("data"),
BlockNumber: 1,
TxHash: ethcmn.BytesToHash([]byte("tx_hash_0")).String(),
TxHash: common.BytesToHash([]byte("tx_hash_0")).String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 0,
Removed: false,
},
},
},
{
Hash: ethcmn.BytesToHash([]byte("tx_hash_1")).String(),
Hash: common.BytesToHash([]byte("tx_hash_1")).String(),
Logs: []*types.Log{
{
Address: suite.address.String(),
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
Topics: []string{common.BytesToHash([]byte("topic")).String()},
Data: []byte("data"),
BlockNumber: 1,
TxHash: ethcmn.BytesToHash([]byte("tx_hash_1")).String(),
TxHash: common.BytesToHash([]byte("tx_hash_1")).String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 1,
Removed: false,
},
{
Address: suite.address.String(),
Topics: []string{ethcmn.BytesToHash([]byte("topic_1")).String()},
Topics: []string{common.BytesToHash([]byte("topic_1")).String()},
Data: []byte("data_1"),
BlockNumber: 1,
TxHash: ethcmn.BytesToHash([]byte("tx_hash_1")).String(),
TxHash: common.BytesToHash([]byte("tx_hash_1")).String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 2,
Removed: false,
},
@ -492,8 +491,8 @@ func (suite *KeeperTestSuite) TestQueryBlockLogs() {
},
}
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))
suite.app.EvmKeeper.SetLogs(common.BytesToHash([]byte("tx_hash_0")), types.LogsToEthereum(expLogs[0].Logs))
suite.app.EvmKeeper.SetLogs(common.BytesToHash([]byte("tx_hash_1")), types.LogsToEthereum(expLogs[1].Logs))
req = &types.QueryBlockLogsRequest{
Hash: hash.String(),
@ -618,7 +617,7 @@ func (suite *KeeperTestSuite) TestQueryValidatorAccount() {
{"invalid address",
func() {
expAccount = &types.QueryValidatorAccountResponse{
AccountAddress: sdk.AccAddress(ethcmn.Address{}.Bytes()).String(),
AccountAddress: sdk.AccAddress(common.Address{}.Bytes()).String(),
}
req = &types.QueryValidatorAccountRequest{
ConsAddress: "",

4
x/evm/keeper/hooks.go
View File

@ -3,7 +3,7 @@ package keeper
import (
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
"github.com/tharsis/ethermint/x/evm/types"
)
@ -21,7 +21,7 @@ func NewMultiEvmHooks(hooks ...types.EvmHooks) MultiEvmHooks {
}
// PostTxProcessing delegate the call to underlying hooks
func (mh MultiEvmHooks) PostTxProcessing(ctx sdk.Context, txHash ethcmn.Hash, logs []*ethtypes.Log) error {
func (mh MultiEvmHooks) PostTxProcessing(ctx sdk.Context, txHash common.Hash, logs []*ethtypes.Log) error {
for i := range mh {
if err := mh[i].PostTxProcessing(ctx, txHash, logs); err != nil {
return sdkerrors.Wrapf(err, "EVM hook %T failed", mh[i])

8
x/evm/keeper/keeper_test.go
View File

@ -28,11 +28,9 @@ import (
"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"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/tmhash"
@ -72,7 +70,7 @@ type KeeperTestSuite struct {
ctx sdk.Context
app *app.EthermintApp
queryClient types.QueryClient
address ethcmn.Address
address common.Address
consAddress sdk.ConsAddress
// for generate test tx
@ -90,7 +88,7 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
// account key
priv, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
suite.address = ethcmn.BytesToAddress(priv.PubKey().Address().Bytes())
suite.address = common.BytesToAddress(priv.PubKey().Address().Bytes())
suite.signer = tests.NewSigner(priv)
// consensus key
@ -130,7 +128,7 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
acc := &ethermint.EthAccount{
BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(suite.address.Bytes()), nil, 0, 0),
CodeHash: common.BytesToHash(ethcrypto.Keccak256(nil)).String(),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(),
}
suite.app.AccountKeeper.SetAccount(suite.ctx, acc)

9
x/evm/keeper/statedb_test.go
View File

@ -16,7 +16,6 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/tharsis/ethermint/tests"
"github.com/tharsis/ethermint/x/evm/types"
evmtypes "github.com/tharsis/ethermint/x/evm/types"
)
func (suite *KeeperTestSuite) TestCreateAccount() {
@ -533,8 +532,8 @@ func (suite *KeeperTestSuite) TestSnapshot() {
}
}
func (suite *KeeperTestSuite) CreateTestTx(msg *evmtypes.MsgEthereumTx, priv cryptotypes.PrivKey) authsigning.Tx {
option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{})
func (suite *KeeperTestSuite) CreateTestTx(msg *types.MsgEthereumTx, priv cryptotypes.PrivKey) authsigning.Tx {
option, err := codectypes.NewAnyWithValue(&types.ExtensionOptionsEthereumTx{})
suite.Require().NoError(err)
txBuilder := suite.clientCtx.TxConfig.NewTxBuilder()
@ -558,14 +557,14 @@ func (suite *KeeperTestSuite) TestAddLog() {
msg.From = addr.Hex()
tx := suite.CreateTestTx(msg, privKey)
msg, _ = tx.GetMsgs()[0].(*evmtypes.MsgEthereumTx)
msg, _ = tx.GetMsgs()[0].(*types.MsgEthereumTx)
txHash := msg.AsTransaction().Hash()
msg2 := types.NewTx(big.NewInt(1), 1, &suite.address, big.NewInt(1), 100000, big.NewInt(1), []byte("test"), nil)
msg2.From = addr.Hex()
tx2 := suite.CreateTestTx(msg2, privKey)
msg2, _ = tx2.GetMsgs()[0].(*evmtypes.MsgEthereumTx)
msg2, _ = tx2.GetMsgs()[0].(*types.MsgEthereumTx)
txHash2 := msg2.AsTransaction().Hash()
testCases := []struct {

8
x/evm/types/access_list.go
View File

@ -1,7 +1,7 @@
package types
import (
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
)
@ -39,14 +39,14 @@ func (al AccessList) ToEthAccessList() *ethtypes.AccessList {
var ethAccessList ethtypes.AccessList
for _, tuple := range al {
storageKeys := make([]ethcmn.Hash, len(tuple.StorageKeys))
storageKeys := make([]common.Hash, len(tuple.StorageKeys))
for i := range tuple.StorageKeys {
storageKeys[i] = ethcmn.HexToHash(tuple.StorageKeys[i])
storageKeys[i] = common.HexToHash(tuple.StorageKeys[i])
}
ethAccessList = append(ethAccessList, ethtypes.AccessTuple{
Address: ethcmn.HexToAddress(tuple.Address),
Address: common.HexToAddress(tuple.Address),
StorageKeys: storageKeys,
})
}

15
x/evm/types/genesis_test.go
View File

@ -3,10 +3,9 @@ package types
import (
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/suite"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/tharsis/ethermint/crypto/ethsecp256k1"
)
@ -14,7 +13,7 @@ type GenesisTestSuite struct {
suite.Suite
address string
hash ethcmn.Hash
hash common.Hash
code string
}
@ -22,9 +21,9 @@ func (suite *GenesisTestSuite) SetupTest() {
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
suite.address = ethcmn.BytesToAddress(priv.PubKey().Address().Bytes()).String()
suite.hash = ethcmn.BytesToHash([]byte("hash"))
suite.code = ethcmn.Bytes2Hex([]byte{1, 2, 3})
suite.address = common.BytesToAddress(priv.PubKey().Address().Bytes()).String()
suite.hash = common.BytesToHash([]byte("hash"))
suite.code = common.Bytes2Hex([]byte{1, 2, 3})
}
func TestGenesisTestSuite(t *testing.T) {
@ -141,7 +140,7 @@ func (suite *GenesisTestSuite) TestValidateGenesis() {
genState: &GenesisState{
Accounts: []GenesisAccount{
{
Address: ethcmn.Address{}.String(),
Address: common.Address{}.String(),
},
},
},
@ -234,7 +233,7 @@ func (suite *GenesisTestSuite) TestValidateGenesis() {
},
},
},
TxsLogs: []TransactionLogs{NewTransactionLogs(ethcmn.Hash{}, nil)},
TxsLogs: []TransactionLogs{NewTransactionLogs(common.Hash{}, nil)},
},
expPass: false,
},

4
x/evm/types/interfaces.go
View File

@ -4,7 +4,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
)
@ -43,5 +43,5 @@ type StakingKeeper interface {
// EvmHooks event hooks for evm tx processing
type EvmHooks interface {
// Must be called after tx is processed successfully, if return an error, the whole transaction is reverted.
PostTxProcessing(ctx sdk.Context, txHash ethcmn.Hash, logs []*ethtypes.Log) error
PostTxProcessing(ctx sdk.Context, txHash common.Hash, logs []*ethtypes.Log) error
}

12
x/evm/types/key.go
View File

@ -3,8 +3,8 @@ package types
import (
sdk "github.com/cosmos/cosmos-sdk/types"
ethcmn "github.com/ethereum/go-ethereum/common"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
)
const (
@ -73,18 +73,18 @@ func BloomKey(height int64) []byte {
}
// AddressStoragePrefix returns a prefix to iterate over a given account storage.
func AddressStoragePrefix(address ethcmn.Address) []byte {
func AddressStoragePrefix(address common.Address) []byte {
return append(KeyPrefixStorage, address.Bytes()...)
}
// StateKey defines the full key under which an account state is stored.
func StateKey(address ethcmn.Address, key []byte) []byte {
func StateKey(address common.Address, key []byte) []byte {
return append(AddressStoragePrefix(address), key...)
}
// KeyAddressStorage returns the key hash to access a given account state. The composite key
// (address + hash) is hashed using Keccak256.
func KeyAddressStorage(address ethcmn.Address, hash ethcmn.Hash) ethcmn.Hash {
func KeyAddressStorage(address common.Address, hash common.Hash) common.Hash {
prefix := address.Bytes()
key := hash.Bytes()
@ -93,5 +93,5 @@ func KeyAddressStorage(address ethcmn.Address, hash ethcmn.Hash) ethcmn.Hash {
copy(compositeKey, prefix)
copy(compositeKey[len(prefix):], key)
return ethcrypto.Keccak256Hash(compositeKey)
return crypto.Keccak256Hash(compositeKey)
}

16
x/evm/types/logs.go
View File

@ -4,14 +4,14 @@ import (
"errors"
"fmt"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
ethermint "github.com/tharsis/ethermint/types"
)
// NewTransactionLogs creates a new NewTransactionLogs instance.
func NewTransactionLogs(hash ethcmn.Hash, logs []*Log) TransactionLogs { // nolint: interfacer
func NewTransactionLogs(hash common.Hash, logs []*Log) TransactionLogs { // nolint: interfacer
return TransactionLogs{
Hash: hash.String(),
Logs: logs,
@ -19,7 +19,7 @@ func NewTransactionLogs(hash ethcmn.Hash, logs []*Log) TransactionLogs { // noli
}
// NewTransactionLogsFromEth creates a new NewTransactionLogs instance using []*ethtypes.Log.
func NewTransactionLogsFromEth(hash ethcmn.Hash, ethlogs []*ethtypes.Log) TransactionLogs { // nolint: interfacer
func NewTransactionLogsFromEth(hash common.Hash, ethlogs []*ethtypes.Log) TransactionLogs { // nolint: interfacer
return TransactionLogs{
Hash: hash.String(),
Logs: NewLogsFromEth(ethlogs),
@ -70,20 +70,20 @@ func (log *Log) Validate() error {
// ToEthereum returns the Ethereum type Log from a Ethermint proto compatible Log.
func (log *Log) ToEthereum() *ethtypes.Log {
var topics []ethcmn.Hash // nolint: prealloc
var topics []common.Hash // nolint: prealloc
for i := range log.Topics {
topics = append(topics, ethcmn.HexToHash(log.Topics[i]))
topics = append(topics, common.HexToHash(log.Topics[i]))
}
return &ethtypes.Log{
Address: ethcmn.HexToAddress(log.Address),
Address: common.HexToAddress(log.Address),
Topics: topics,
Data: log.Data,
BlockNumber: log.BlockNumber,
TxHash: ethcmn.HexToHash(log.TxHash),
TxHash: common.HexToHash(log.TxHash),
TxIndex: uint(log.TxIndex),
Index: uint(log.Index),
BlockHash: ethcmn.HexToHash(log.BlockHash),
BlockHash: common.HexToHash(log.BlockHash),
Removed: log.Removed,
}
}

44
x/evm/types/logs_test.go
View File

@ -7,14 +7,14 @@ import (
"github.com/tharsis/ethermint/crypto/ethsecp256k1"
ethcmn "github.com/ethereum/go-ethereum/common"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
)
func TestTransactionLogsValidate(t *testing.T) {
priv, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey).String()
addr := crypto.PubkeyToAddress(priv.ToECDSA().PublicKey).String()
testCases := []struct {
name string
@ -24,16 +24,16 @@ func TestTransactionLogsValidate(t *testing.T) {
{
"valid log",
TransactionLogs{
Hash: ethcmn.BytesToHash([]byte("tx_hash")).String(),
Hash: common.BytesToHash([]byte("tx_hash")).String(),
Logs: []*Log{
{
Address: addr,
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
Topics: []string{common.BytesToHash([]byte("topic")).String()},
Data: []byte("data"),
BlockNumber: 1,
TxHash: ethcmn.BytesToHash([]byte("tx_hash")).String(),
TxHash: common.BytesToHash([]byte("tx_hash")).String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 1,
Removed: false,
},
@ -44,14 +44,14 @@ func TestTransactionLogsValidate(t *testing.T) {
{
"empty hash",
TransactionLogs{
Hash: ethcmn.Hash{}.String(),
Hash: common.Hash{}.String(),
},
false,
},
{
"invalid log",
TransactionLogs{
Hash: ethcmn.BytesToHash([]byte("tx_hash")).String(),
Hash: common.BytesToHash([]byte("tx_hash")).String(),
Logs: []*Log{{}},
},
false,
@ -59,16 +59,16 @@ func TestTransactionLogsValidate(t *testing.T) {
{
"hash mismatch log",
TransactionLogs{
Hash: ethcmn.BytesToHash([]byte("tx_hash")).String(),
Hash: common.BytesToHash([]byte("tx_hash")).String(),
Logs: []*Log{
{
Address: addr,
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
Topics: []string{common.BytesToHash([]byte("topic")).String()},
Data: []byte("data"),
BlockNumber: 1,
TxHash: ethcmn.BytesToHash([]byte("other_hash")).String(),
TxHash: common.BytesToHash([]byte("other_hash")).String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 1,
Removed: false,
},
@ -92,7 +92,7 @@ func TestTransactionLogsValidate(t *testing.T) {
func TestValidateLog(t *testing.T) {
priv, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey).String()
addr := crypto.PubkeyToAddress(priv.ToECDSA().PublicKey).String()
testCases := []struct {
name string
@ -103,12 +103,12 @@ func TestValidateLog(t *testing.T) {
"valid log",
&Log{
Address: addr,
Topics: []string{ethcmn.BytesToHash([]byte("topic")).String()},
Topics: []string{common.BytesToHash([]byte("topic")).String()},
Data: []byte("data"),
BlockNumber: 1,
TxHash: ethcmn.BytesToHash([]byte("tx_hash")).String(),
TxHash: common.BytesToHash([]byte("tx_hash")).String(),
TxIndex: 1,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
Index: 1,
Removed: false,
},
@ -120,7 +120,7 @@ func TestValidateLog(t *testing.T) {
{
"zero address",
&Log{
Address: ethcmn.Address{}.String(),
Address: common.Address{}.String(),
},
false,
},
@ -128,7 +128,7 @@ func TestValidateLog(t *testing.T) {
"empty block hash",
&Log{
Address: addr,
BlockHash: ethcmn.Hash{}.String(),
BlockHash: common.Hash{}.String(),
},
false,
},
@ -136,7 +136,7 @@ func TestValidateLog(t *testing.T) {
"zero block number",
&Log{
Address: addr,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
BlockNumber: 0,
},
false,
@ -145,9 +145,9 @@ func TestValidateLog(t *testing.T) {
"empty tx hash",
&Log{
Address: addr,
BlockHash: ethcmn.BytesToHash([]byte("block_hash")).String(),
BlockHash: common.BytesToHash([]byte("block_hash")).String(),
BlockNumber: 1,
TxHash: ethcmn.Hash{}.String(),
TxHash: common.Hash{}.String(),
},
false,
},

38
x/evm/types/msg_test.go
View File

@ -12,9 +12,7 @@ import (
"github.com/tharsis/ethermint/tests"
"github.com/ethereum/go-ethereum/common"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
ethtypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
)
@ -24,8 +22,8 @@ type MsgsTestSuite struct {
suite.Suite
signer keyring.Signer
from ethcmn.Address
to ethcmn.Address
from common.Address
to common.Address
chainID *big.Int
}
@ -74,12 +72,12 @@ func (suite *MsgsTestSuite) TestMsgEthereumTx_ValidateBasic() {
amount *sdk.Int
gasPrice *sdk.Int
from string
accessList *ethtypes.AccessList
accessList *types.AccessList
chainID *sdk.Int
expectPass bool
}{
{msg: "pass with recipient - Legacy Tx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &hundredInt, expectPass: true},
{msg: "pass with recipient - AccessList Tx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, accessList: &ethtypes.AccessList{}, chainID: &hundredInt, expectPass: true},
{msg: "pass with recipient - AccessList Tx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, accessList: &types.AccessList{}, chainID: &hundredInt, expectPass: true},
{msg: "pass contract - Legacy Tx", to: "", amount: &hundredInt, gasPrice: &hundredInt, expectPass: true},
// {msg: "invalid recipient", to: invalidFromAddress, amount: &minusOneInt, gasPrice: &hundredInt, expectPass: false},
{msg: "nil amount - Legacy Tx", to: suite.to.Hex(), amount: nil, gasPrice: &hundredInt, expectPass: true},
@ -88,13 +86,13 @@ func (suite *MsgsTestSuite) TestMsgEthereumTx_ValidateBasic() {
{msg: "negative gas price - Legacy Tx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &minusOneInt, expectPass: false},
{msg: "zero gas price - Legacy Tx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, expectPass: true},
{msg: "invalid from address - Legacy Tx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, from: invalidFromAddress, expectPass: false},
{msg: "nil amount - AccessListTx", to: suite.to.Hex(), amount: nil, gasPrice: &hundredInt, accessList: &ethtypes.AccessList{}, chainID: &hundredInt, expectPass: true},
{msg: "negative amount - AccessListTx", to: suite.to.Hex(), amount: &minusOneInt, gasPrice: &hundredInt, accessList: &ethtypes.AccessList{}, chainID: nil, expectPass: false},
{msg: "nil gas price - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: nil, accessList: &ethtypes.AccessList{}, chainID: &hundredInt, expectPass: false},
{msg: "negative gas price - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &minusOneInt, accessList: &ethtypes.AccessList{}, chainID: nil, expectPass: false},
{msg: "zero gas price - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, accessList: &ethtypes.AccessList{}, chainID: &hundredInt, expectPass: true},
{msg: "invalid from address - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, from: invalidFromAddress, accessList: &ethtypes.AccessList{}, chainID: &hundredInt, expectPass: false},
{msg: "chain ID not set on AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, accessList: &ethtypes.AccessList{}, chainID: nil, expectPass: false},
{msg: "nil amount - AccessListTx", to: suite.to.Hex(), amount: nil, gasPrice: &hundredInt, accessList: &types.AccessList{}, chainID: &hundredInt, expectPass: true},
{msg: "negative amount - AccessListTx", to: suite.to.Hex(), amount: &minusOneInt, gasPrice: &hundredInt, accessList: &types.AccessList{}, chainID: nil, expectPass: false},
{msg: "nil gas price - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: nil, accessList: &types.AccessList{}, chainID: &hundredInt, expectPass: false},
{msg: "negative gas price - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &minusOneInt, accessList: &types.AccessList{}, chainID: nil, expectPass: false},
{msg: "zero gas price - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, accessList: &types.AccessList{}, chainID: &hundredInt, expectPass: true},
{msg: "invalid from address - AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, from: invalidFromAddress, accessList: &types.AccessList{}, chainID: &hundredInt, expectPass: false},
{msg: "chain ID not set on AccessListTx", to: suite.to.Hex(), amount: &hundredInt, gasPrice: &zeroInt, accessList: &types.AccessList{}, chainID: nil, expectPass: false},
}
for i, tc := range testCases {
@ -128,49 +126,49 @@ func (suite *MsgsTestSuite) TestMsgEthereumTx_Sign() {
testCases := []struct {
msg string
tx *MsgEthereumTx
ethSigner ethtypes.Signer
ethSigner types.Signer
malleate func(tx *MsgEthereumTx)
expectPass bool
}{
{
"pass - EIP2930 signer",
NewTx(suite.chainID, 0, &suite.to, nil, 100000, nil, []byte("test"), &types.AccessList{}),
ethtypes.NewEIP2930Signer(suite.chainID),
types.NewEIP2930Signer(suite.chainID),
func(tx *MsgEthereumTx) { tx.From = suite.from.Hex() },
true,
},
{
"pass - EIP155 signer",
NewTx(suite.chainID, 0, &suite.to, nil, 100000, nil, []byte("test"), nil),
ethtypes.NewEIP155Signer(suite.chainID),
types.NewEIP155Signer(suite.chainID),
func(tx *MsgEthereumTx) { tx.From = suite.from.Hex() },
true,
},
{
"pass - Homestead signer",
NewTx(suite.chainID, 0, &suite.to, nil, 100000, nil, []byte("test"), nil),
ethtypes.HomesteadSigner{},
types.HomesteadSigner{},
func(tx *MsgEthereumTx) { tx.From = suite.from.Hex() },
true,
},
{
"pass - Frontier signer",
NewTx(suite.chainID, 0, &suite.to, nil, 100000, nil, []byte("test"), nil),
ethtypes.FrontierSigner{},
types.FrontierSigner{},
func(tx *MsgEthereumTx) { tx.From = suite.from.Hex() },
true,
},
{
"no from address ",
NewTx(suite.chainID, 0, &suite.to, nil, 100000, nil, []byte("test"), &types.AccessList{}),
ethtypes.NewEIP2930Signer(suite.chainID),
types.NewEIP2930Signer(suite.chainID),
func(tx *MsgEthereumTx) { tx.From = "" },
false,
},
{
"from address ≠ signer address",
NewTx(suite.chainID, 0, &suite.to, nil, 100000, nil, []byte("test"), &types.AccessList{}),
ethtypes.NewEIP2930Signer(suite.chainID),
types.NewEIP2930Signer(suite.chainID),
func(tx *MsgEthereumTx) { tx.From = suite.to.Hex() },
false,
},

5
x/evm/types/storage.go
View File

@ -4,10 +4,9 @@ import (
"fmt"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/ethereum/go-ethereum/common"
"github.com/tharsis/ethermint/types"
ethcmn "github.com/ethereum/go-ethereum/common"
)
// Storage represents the account Storage map as a slice of single key value
@ -59,7 +58,7 @@ func (s State) Validate() error {
}
// NewState creates a new State instance
func NewState(key, value ethcmn.Hash) State { // nolint: interfacer
func NewState(key, value common.Hash) State { // nolint: interfacer
return State{
Key: key.String(),
Value: value.String(),

17
x/evm/types/storage_test.go
View File

@ -3,9 +3,8 @@ package types
import (
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/require"
ethcmn "github.com/ethereum/go-ethereum/common"
)
func TestStorageValidate(t *testing.T) {
@ -17,22 +16,22 @@ func TestStorageValidate(t *testing.T) {
{
"valid storage",
Storage{
NewState(ethcmn.BytesToHash([]byte{1, 2, 3}), ethcmn.BytesToHash([]byte{1, 2, 3})),
NewState(common.BytesToHash([]byte{1, 2, 3}), common.BytesToHash([]byte{1, 2, 3})),
},
true,
},
{
"empty storage key bytes",
Storage{
{Key: ethcmn.Hash{}.String()},
{Key: common.Hash{}.String()},
},
false,
},
{
"duplicated storage key",
Storage{
{Key: ethcmn.BytesToHash([]byte{1, 2, 3}).String()},
{Key: ethcmn.BytesToHash([]byte{1, 2, 3}).String()},
{Key: common.BytesToHash([]byte{1, 2, 3}).String()},
{Key: common.BytesToHash([]byte{1, 2, 3}).String()},
},
false,
},
@ -57,13 +56,13 @@ func TestStorageCopy(t *testing.T) {
{
"single storage",
Storage{
NewState(ethcmn.BytesToHash([]byte{1, 2, 3}), ethcmn.BytesToHash([]byte{1, 2, 3})),
NewState(common.BytesToHash([]byte{1, 2, 3}), common.BytesToHash([]byte{1, 2, 3})),
},
},
{
"empty storage key value bytes",
Storage{
{Key: ethcmn.Hash{}.String(), Value: ethcmn.Hash{}.String()},
{Key: common.Hash{}.String(), Value: common.Hash{}.String()},
},
},
{
@ -79,7 +78,7 @@ func TestStorageCopy(t *testing.T) {
}
func TestStorageString(t *testing.T) {
storage := Storage{NewState(ethcmn.BytesToHash([]byte("key")), ethcmn.BytesToHash([]byte("value")))}
storage := Storage{NewState(common.BytesToHash([]byte("key")), common.BytesToHash([]byte("value")))}
str := "key:\"0x00000000000000000000000000000000000000000000000000000000006b6579\" value:\"0x00000000000000000000000000000000000000000000000000000076616c7565\" \n"
require.Equal(t, str, storage.String())
}

7
x/evm/types/utils_test.go
View File

@ -17,18 +17,17 @@ import (
"github.com/stretchr/testify/require"
"github.com/ethereum/go-ethereum/common"
ethcmn "github.com/ethereum/go-ethereum/common"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto"
)
// GenerateEthAddress generates an Ethereum address.
func GenerateEthAddress() ethcmn.Address {
func GenerateEthAddress() common.Address {
priv, err := ethsecp256k1.GenerateKey()
if err != nil {
panic(err)
}
return ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
return crypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
}
func TestEvmDataEncoding(t *testing.T) {