From ba5bf33f19d99f833b9219c23c12885901bc5553 Mon Sep 17 00:00:00 2001
From: Federico Kunze <31522760+fedekunze@users.noreply.github.com>
Date: Fri, 14 May 2021 02:52:18 -0400
Subject: [PATCH] proto, evm: use string for address and hash protobuf message
fields (#23)
* proto, evm: use string for address and hash protobuf message fields
* fix tests
* msg test
---
docs/core/proto-docs.md | 26 +-
ethereum/rpc/backend.go | 6 +-
ethereum/rpc/eth_api.go | 25 +-
ethereum/rpc/types/types.go | 2 +-
ethereum/rpc/types/utils.go | 20 +-
go.mod | 2 +-
go.sum | 4 +-
proto/ethermint/evm/v1alpha1/evm.proto | 22 +-
tests/importer/chain_ctx.go | 164 +++++++++
tests/importer/chain_ctx_test.go | 119 ++++++
tests/importer/importer_test.go | 3 +-
types/validation.go | 19 +
x/evm/keeper/keeper.go | 6 +-
x/evm/keeper/msg_server.go | 18 +-
x/evm/types/access_list.go | 16 +-
x/evm/types/evm.pb.go | 483 ++++++++-----------------
x/evm/types/msg.go | 31 +-
x/evm/types/msg_test.go | 17 +-
18 files changed, 536 insertions(+), 447 deletions(-)
create mode 100644 tests/importer/chain_ctx.go
create mode 100644 tests/importer/chain_ctx_test.go
diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md
index 46e7f537..0a8127a1 100644
--- a/docs/core/proto-docs.md
+++ b/docs/core/proto-docs.md
@@ -9,7 +9,6 @@
- [PubKey](#ethermint.crypto.v1alpha1.ethsecp256k1.PubKey)
- [ethermint/evm/v1alpha1/evm.proto](#ethermint/evm/v1alpha1/evm.proto)
- - [AccessList](#ethermint.evm.v1alpha1.AccessList)
- [AccessTuple](#ethermint.evm.v1alpha1.AccessTuple)
- [BytesList](#ethermint.evm.v1alpha1.BytesList)
- [ChainConfig](#ethermint.evm.v1alpha1.ChainConfig)
@@ -126,21 +125,6 @@ key format.
-
-
-### AccessList
-AccessList is an EIP-2930 access list defined as a proto message.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `tuples` | [AccessTuple](#ethermint.evm.v1alpha1.AccessTuple) | repeated | access list tuples |
-
-
-
-
-
-
### AccessTuple
@@ -301,10 +285,10 @@ solely as intended in Ethereum abiding by the protocol.
| `nonce` | [uint64](#uint64) | | nonce corresponds to the account nonce (transaction sequence). |
| `gas_price` | [bytes](#bytes) | | price defines the unsigned integer value of the gas price in bytes. |
| `gas` | [uint64](#uint64) | | gas defines the gas limit defined for the transaction. |
-| `to` | [bytes](#bytes) | | |
+| `to` | [string](#string) | | hex formatted address of the recipient |
| `value` | [bytes](#bytes) | | value defines the unsigned integer value of the transaction amount. |
| `input` | [bytes](#bytes) | | input defines the data payload bytes of the transaction. |
-| `accesses` | [AccessList](#ethermint.evm.v1alpha1.AccessList) | | |
+| `accesses` | [AccessTuple](#ethermint.evm.v1alpha1.AccessTuple) | repeated | |
| `v` | [bytes](#bytes) | | v defines the signature value |
| `r` | [bytes](#bytes) | | r defines the signature value |
| `s` | [bytes](#bytes) | | s define the signature value |
@@ -322,13 +306,13 @@ TxReceipt defines the receipt type stored in KV for each EVM transaction.
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
-| `hash` | [bytes](#bytes) | | |
-| `from` | [bytes](#bytes) | | |
+| `hash` | [string](#string) | | |
+| `from` | [string](#string) | | |
| `data` | [TxData](#ethermint.evm.v1alpha1.TxData) | | |
| `result` | [TxResult](#ethermint.evm.v1alpha1.TxResult) | | |
| `index` | [uint64](#uint64) | | |
| `block_height` | [uint64](#uint64) | | |
-| `block_hash` | [bytes](#bytes) | | |
+| `block_hash` | [string](#string) | | |
diff --git a/ethereum/rpc/backend.go b/ethereum/rpc/backend.go
index 2f9575e7..85d73c58 100644
--- a/ethereum/rpc/backend.go
+++ b/ethereum/rpc/backend.go
@@ -148,14 +148,14 @@ func (e *EVMBackend) EthBlockFromTendermint(
ethRPCTxs := make([]interface{}, 0, len(txReceiptsResp.Receipts))
for _, receipt := range txReceiptsResp.Receipts {
- hash := common.BytesToHash(receipt.Hash)
+ hash := common.HexToHash(receipt.Hash)
if fullTx {
// full txs from receipts
tx, err := types.NewTransactionFromData(
receipt.Data,
- common.BytesToAddress(receipt.From),
+ common.HexToAddress(receipt.From),
hash,
- common.BytesToHash(receipt.BlockHash),
+ common.HexToHash(receipt.BlockHash),
receipt.BlockHeight,
receipt.Index,
)
diff --git a/ethereum/rpc/eth_api.go b/ethereum/rpc/eth_api.go
index 7d20287f..20a0460e 100644
--- a/ethereum/rpc/eth_api.go
+++ b/ethereum/rpc/eth_api.go
@@ -667,9 +667,9 @@ func (e *PublicEthAPI) GetTransactionByHash(hash common.Hash) (*types.RPCTransac
return types.NewTransactionFromData(
resp.Receipt.Data,
- common.BytesToAddress(resp.Receipt.From),
- common.BytesToHash(resp.Receipt.Hash),
- common.BytesToHash(resp.Receipt.BlockHash),
+ common.HexToAddress(resp.Receipt.From),
+ common.HexToHash(resp.Receipt.Hash),
+ common.HexToHash(resp.Receipt.BlockHash),
resp.Receipt.BlockHeight,
resp.Receipt.Index,
)
@@ -714,20 +714,19 @@ func (e *PublicEthAPI) getReceiptByIndex(receipts []*evmtypes.TxReceipt, blockHa
receipt := receipts[idx]
if (blockHash != common.Hash{}) {
- if !bytes.Equal(receipt.BlockHash, blockHash.Bytes()) {
- err := errors.Errorf("receipt found but block hashes don't match %s != %s",
- common.Bytes2Hex(receipt.BlockHash),
- blockHash.Hex(),
+ hexBlockHash := blockHash.Hex()
+ if receipt.BlockHash != hexBlockHash {
+ return nil, errors.Errorf("receipt found but block hashes don't match %s != %s",
+ receipt.BlockHash,
+ hexBlockHash,
)
-
- return nil, err
}
}
return types.NewTransactionFromData(
receipt.Data,
- common.BytesToAddress(receipt.From),
- common.BytesToHash(receipt.Hash),
+ common.HexToAddress(receipt.From),
+ common.HexToHash(receipt.Hash),
blockHash,
receipt.BlockHeight,
uint64(idx),
@@ -769,7 +768,7 @@ func (e *PublicEthAPI) GetTransactionReceipt(hash common.Hash) (map[string]inter
toHex := common.Address{}
if len(tx.Receipt.Data.To) > 0 {
- toHex = common.BytesToAddress(tx.Receipt.Data.To)
+ toHex = common.HexToAddress(tx.Receipt.Data.To)
}
contractAddress := common.HexToAddress(tx.Receipt.Result.ContractAddress)
@@ -794,7 +793,7 @@ func (e *PublicEthAPI) GetTransactionReceipt(hash common.Hash) (map[string]inter
"transactionIndex": hexutil.Uint64(tx.Receipt.Index),
// sender and receiver (contract or EOA) addreses
- "from": common.BytesToAddress(tx.Receipt.From),
+ "from": common.HexToAddress(tx.Receipt.From),
"to": toHex,
}
diff --git a/ethereum/rpc/types/types.go b/ethereum/rpc/types/types.go
index 2f744d33..14f00f59 100644
--- a/ethereum/rpc/types/types.go
+++ b/ethereum/rpc/types/types.go
@@ -79,7 +79,7 @@ func (args *SendTxArgs) ToTransaction() *evmtypes.MsgEthereumTx {
}
data := &evmtypes.TxData{
- To: args.To.Bytes(),
+ To: args.To.Hex(),
ChainID: args.ChainID.ToInt().Bytes(),
Nonce: uint64(*args.Nonce),
GasLimit: uint64(*args.Gas),
diff --git a/ethereum/rpc/types/utils.go b/ethereum/rpc/types/utils.go
index 7e047ba3..228fafdc 100644
--- a/ethereum/rpc/types/utils.go
+++ b/ethereum/rpc/types/utils.go
@@ -304,7 +304,7 @@ func NewTransactionFromData(
var to *common.Address
if len(txData.To) > 0 {
- recipient := common.BytesToAddress(txData.To)
+ recipient := common.HexToAddress(txData.To)
to = &recipient
}
@@ -334,21 +334,3 @@ func NewTransactionFromData(
return rpcTx, nil
}
-
-var zeroHash = hexutil.Bytes(make([]byte, 32))
-
-func hashOrZero(data []byte) hexutil.Bytes {
- if len(data) == 0 {
- return zeroHash
- }
-
- return hexutil.Bytes(data)
-}
-
-func bigOrZero(i *big.Int) *hexutil.Big {
- if i == nil {
- return new(hexutil.Big)
- }
-
- return (*hexutil.Big)(i)
-}
diff --git a/go.mod b/go.mod
index 40e53b1d..04ff6d9c 100644
--- a/go.mod
+++ b/go.mod
@@ -43,7 +43,7 @@ require (
github.com/tyler-smith/go-bip39 v1.1.0
github.com/xlab/closer v0.0.0-20190328110542-03326addb7c2
github.com/xlab/suplog v1.3.0
- golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf
+ golang.org/x/crypto v0.0.0-20210513122933-cd7d49e622d5
golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 // indirect
google.golang.org/genproto v0.0.0-20210510173355-fb37daa5cd7a
google.golang.org/grpc v1.37.1
diff --git a/go.sum b/go.sum
index 0fa19115..2aabe6f4 100644
--- a/go.sum
+++ b/go.sum
@@ -916,8 +916,8 @@ golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPh
golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf h1:B2n+Zi5QeYRDAEodEu72OS36gmTWjgpXr2+cWcBW90o=
-golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/crypto v0.0.0-20210513122933-cd7d49e622d5 h1:N6Jp/LCiEoIBX56BZSR2bepK5GtbSC2DDOYT742mMfE=
+golang.org/x/crypto v0.0.0-20210513122933-cd7d49e622d5/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
diff --git a/proto/ethermint/evm/v1alpha1/evm.proto b/proto/ethermint/evm/v1alpha1/evm.proto
index 6f6c4dab..70daeb47 100644
--- a/proto/ethermint/evm/v1alpha1/evm.proto
+++ b/proto/ethermint/evm/v1alpha1/evm.proto
@@ -174,13 +174,13 @@ message Log {
message TxReceipt {
option (gogoproto.goproto_getters) = false;
- bytes hash = 1;
- bytes from = 2;
+ string hash = 1;
+ string from = 2;
TxData data = 3;
TxResult result = 4;
uint64 index = 5;
uint64 block_height = 6;
- bytes block_hash = 7;
+ string block_hash = 7;
}
// TxResult stores results of Tx execution.
@@ -220,12 +220,17 @@ message TxData {
bytes gas_price = 3 [(gogoproto.customname) = "GasPrice"];
// gas defines the gas limit defined for the transaction.
uint64 gas = 4 [(gogoproto.customname) = "GasLimit"];
- bytes to = 5;
+ // hex formatted address of the recipient
+ string to = 5;
// value defines the unsigned integer value of the transaction amount.
bytes value = 6 [(gogoproto.customname) = "Amount"];
// input defines the data payload bytes of the transaction.
bytes input = 7;
- AccessList accesses = 8 [(gogoproto.jsontag) = "accessList"];
+ repeated AccessTuple accesses = 8 [
+ (gogoproto.castrepeated) = "AccessList",
+ (gogoproto.jsontag) = "accessList",
+ (gogoproto.nullable) = false
+ ];
// v defines the signature value
bytes v = 9;
// r defines the signature value
@@ -240,13 +245,6 @@ message BytesList {
repeated bytes bytes = 1;
}
-// AccessList is an EIP-2930 access list defined as a proto message.
-message AccessList {
- // access list tuples
- repeated AccessTuple tuples = 1 [(gogoproto.nullable) = false];
-}
-
-
// AccessTuple is the element type of an access list.
message AccessTuple {
option (gogoproto.goproto_getters) = false;
diff --git a/tests/importer/chain_ctx.go b/tests/importer/chain_ctx.go
new file mode 100644
index 00000000..424375c8
--- /dev/null
+++ b/tests/importer/chain_ctx.go
@@ -0,0 +1,164 @@
+package importer
+
+import (
+ "math/big"
+
+ ethcmn "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"
+ ethrpc "github.com/ethereum/go-ethereum/rpc"
+)
+
+// ChainContext implements Ethereum's core.ChainContext and consensus.Engine
+// interfaces. It is needed in order to apply and process Ethereum
+// transactions. There should only be a single implementation in Ethermint. For
+// the purposes of Ethermint, it should be support retrieving headers and
+// consensus parameters from the current blockchain to be used during
+// transaction processing.
+//
+// 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
+ headersByNumber map[uint64]*ethtypes.Header
+}
+
+// NewChainContext generates new ChainContext based on Ethereum's core.ChainContext and
+// consensus.Engine interfaces in order to process Ethereum transactions.
+func NewChainContext() *ChainContext {
+ return &ChainContext{
+ headersByNumber: make(map[uint64]*ethtypes.Header),
+ }
+}
+
+// Engine implements Ethereum's core.ChainContext interface. As a ChainContext
+// implements the consensus.Engine interface, it is simply returned.
+func (cc *ChainContext) Engine() ethcons.Engine {
+ return cc
+}
+
+// SetHeader implements Ethereum's core.ChainContext interface. It sets the
+// header for the given block number.
+func (cc *ChainContext) SetHeader(number uint64, header *ethtypes.Header) {
+ cc.headersByNumber[number] = header
+}
+
+// GetHeader implements Ethereum's core.ChainContext interface.
+//
+// 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 {
+ if header, ok := cc.headersByNumber[number]; ok {
+ return header
+ }
+
+ return nil
+}
+
+// Author implements Ethereum's consensus.Engine interface. It is responsible
+// for returned the address of the validtor to receive any fees. This function
+// is only invoked if the given author in the ApplyTransaction call is nil.
+//
+// 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) {
+ return cc.Coinbase, nil
+}
+
+// APIs implements Ethereum's consensus.Engine interface. It currently performs
+// a no-op.
+//
+// TODO: Do we need to support such RPC APIs? This will tie into a bigger
+// discussion on if we want to support web3.
+func (cc *ChainContext) APIs(_ ethcons.ChainHeaderReader) []ethrpc.API {
+ return nil
+}
+
+// CalcDifficulty implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+func (cc *ChainContext) CalcDifficulty(_ ethcons.ChainHeaderReader, _ uint64, _ *ethtypes.Header) *big.Int {
+ return nil
+}
+
+// Finalize implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+//
+// TODO: Figure out if this needs to be hooked up to any part of the ABCI?
+func (cc *ChainContext) Finalize(
+ _ ethcons.ChainHeaderReader, _ *ethtypes.Header, _ *ethstate.StateDB,
+ _ []*ethtypes.Transaction, _ []*ethtypes.Header) {
+}
+
+// FinalizeAndAssemble runs any post-transaction state modifications (e.g. block
+// rewards) and assembles the final block.
+//
+// Note: The block header and state database might be updated to reflect any
+// consensus rules that happen at finalization (e.g. block rewards).
+// TODO: Figure out if this needs to be hooked up to any part of the ABCI?
+func (cc *ChainContext) FinalizeAndAssemble(_ ethcons.ChainHeaderReader, _ *ethtypes.Header, _ *ethstate.StateDB, _ []*ethtypes.Transaction,
+ _ []*ethtypes.Header, _ []*ethtypes.Receipt) (*ethtypes.Block, error) {
+ return nil, nil
+}
+
+// Prepare implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+//
+// TODO: Figure out if this needs to be hooked up to any part of the ABCI?
+func (cc *ChainContext) Prepare(_ ethcons.ChainHeaderReader, _ *ethtypes.Header) error {
+ return nil
+}
+
+// Seal implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+//
+// TODO: Figure out if this needs to be hooked up to any part of the ABCI?
+func (cc *ChainContext) Seal(_ ethcons.ChainHeaderReader, _ *ethtypes.Block, _ chan<- *ethtypes.Block, _ <-chan struct{}) error {
+ return nil
+}
+
+// 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{}
+}
+
+// VerifyHeader implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+//
+// TODO: Figure out if this needs to be hooked up to any part of the Cosmos SDK
+// handlers?
+func (cc *ChainContext) VerifyHeader(_ ethcons.ChainHeaderReader, _ *ethtypes.Header, _ bool) error {
+ return nil
+}
+
+// VerifyHeaders implements Ethereum's consensus.Engine interface. It
+// currently performs a no-op.
+//
+// TODO: Figure out if this needs to be hooked up to any part of the Cosmos SDK
+// handlers?
+func (cc *ChainContext) VerifyHeaders(_ ethcons.ChainHeaderReader, _ []*ethtypes.Header, _ []bool) (chan<- struct{}, <-chan error) {
+ return nil, nil
+}
+
+// VerifySeal implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+//
+// TODO: Figure out if this needs to be hooked up to any part of the Cosmos SDK
+// handlers?
+func (cc *ChainContext) VerifySeal(_ ethcons.ChainHeaderReader, _ *ethtypes.Header) error {
+ return nil
+}
+
+// VerifyUncles implements Ethereum's consensus.Engine interface. It currently
+// performs a no-op.
+func (cc *ChainContext) VerifyUncles(_ ethcons.ChainReader, _ *ethtypes.Block) error {
+ return nil
+}
+
+// Close implements Ethereum's consensus.Engine interface. It terminates any
+// background threads maintained by the consensus engine. It currently performs
+// a no-op.
+func (cc *ChainContext) Close() error {
+ return nil
+}
diff --git a/tests/importer/chain_ctx_test.go b/tests/importer/chain_ctx_test.go
new file mode 100644
index 00000000..9bd4b3d1
--- /dev/null
+++ b/tests/importer/chain_ctx_test.go
@@ -0,0 +1,119 @@
+package importer
+
+// NOTE: A bulk of these unit tests will change and evolve as the context and
+// implementation of ChainConext evolves.
+
+import (
+ "math/big"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ ethcmn "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"
+)
+
+func TestChainContextInterface(t *testing.T) {
+ require.Implements(t, (*ethcore.ChainContext)(nil), new(ChainContext))
+ require.Implements(t, (*ethcons.Engine)(nil), new(ChainContext))
+}
+
+func TestNewChainContext(t *testing.T) {
+ cc := NewChainContext()
+ require.NotNil(t, cc.headersByNumber)
+}
+
+func TestChainContextEngine(t *testing.T) {
+ cc := NewChainContext()
+ require.Equal(t, cc, cc.Engine())
+}
+
+func TestChainContextSetHeader(t *testing.T) {
+ cc := NewChainContext()
+ header := ðtypes.Header{
+ Number: big.NewInt(64),
+ }
+
+ cc.SetHeader(uint64(header.Number.Int64()), header)
+ require.Equal(t, header, cc.headersByNumber[uint64(header.Number.Int64())])
+}
+
+func TestChainContextGetHeader(t *testing.T) {
+ cc := NewChainContext()
+ header := ðtypes.Header{
+ Number: big.NewInt(64),
+ }
+
+ 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))
+}
+
+func TestChainContextAuthor(t *testing.T) {
+ cc := NewChainContext()
+
+ cb, err := cc.Author(nil)
+ require.Nil(t, err)
+ require.Equal(t, cc.Coinbase, cb)
+}
+
+func TestChainContextAPIs(t *testing.T) {
+ cc := NewChainContext()
+ require.Nil(t, cc.APIs(nil))
+}
+
+func TestChainContextCalcDifficulty(t *testing.T) {
+ cc := NewChainContext()
+ require.Nil(t, cc.CalcDifficulty(nil, 0, nil))
+}
+
+func TestChainContextFinalize(t *testing.T) {
+ cc := NewChainContext()
+
+ cc.Finalize(nil, nil, nil, nil, nil)
+}
+
+func TestChainContextPrepare(t *testing.T) {
+ cc := NewChainContext()
+
+ err := cc.Prepare(nil, nil)
+ require.Nil(t, err)
+}
+
+func TestChainContextSeal(t *testing.T) {
+ cc := NewChainContext()
+
+ err := cc.Seal(nil, nil, nil, nil)
+ require.Nil(t, err)
+}
+
+func TestChainContextVerifyHeader(t *testing.T) {
+ cc := NewChainContext()
+
+ err := cc.VerifyHeader(nil, nil, false)
+ require.Nil(t, err)
+}
+
+func TestChainContextVerifyHeaders(t *testing.T) {
+ cc := NewChainContext()
+
+ ch, err := cc.VerifyHeaders(nil, nil, []bool{false})
+ require.Nil(t, err)
+ require.Nil(t, ch)
+}
+
+func TestChainContextVerifySeal(t *testing.T) {
+ cc := NewChainContext()
+
+ err := cc.VerifySeal(nil, nil)
+ require.Nil(t, err)
+}
+
+func TestChainContextVerifyUncles(t *testing.T) {
+ cc := NewChainContext()
+
+ err := cc.VerifyUncles(nil, nil)
+ require.Nil(t, err)
+}
diff --git a/tests/importer/importer_test.go b/tests/importer/importer_test.go
index a2a4846d..a50692fc 100644
--- a/tests/importer/importer_test.go
+++ b/tests/importer/importer_test.go
@@ -29,7 +29,6 @@ import (
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
"github.com/cosmos/ethermint/codec"
- "github.com/cosmos/ethermint/core"
"github.com/cosmos/ethermint/types"
evmkeeper "github.com/cosmos/ethermint/x/evm/keeper"
evmtypes "github.com/cosmos/ethermint/x/evm/types"
@@ -226,7 +225,7 @@ func TestImportBlocks(t *testing.T) {
}()
// ethereum mainnet config
- chainContext := core.NewChainContext()
+ chainContext := NewChainContext()
vmConfig := ethvm.Config{}
chainConfig := ethparams.MainnetChainConfig
diff --git a/types/validation.go b/types/validation.go
index 11b8c917..c9229b0b 100644
--- a/types/validation.go
+++ b/types/validation.go
@@ -4,6 +4,8 @@ import (
"bytes"
ethcmn "github.com/ethereum/go-ethereum/common"
+
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
// IsEmptyHash returns true if the hash corresponds to an empty ethereum hex hash.
@@ -15,3 +17,20 @@ func IsEmptyHash(hash string) bool {
func IsZeroAddress(address string) bool {
return bytes.Equal(ethcmn.HexToAddress(address).Bytes(), ethcmn.Address{}.Bytes())
}
+
+// ValidateAddress returns an error if the provided string is either not a hex formatted string address
+// the it matches the zero address 0x00000000000000000000.
+func ValidateAddress(address string) error {
+ if !ethcmn.IsHexAddress(address) {
+ return sdkerrors.Wrapf(
+ sdkerrors.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address",
+ address,
+ )
+ }
+
+ if IsZeroAddress(address) {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "provided address cannot be the zero address")
+ }
+
+ return nil
+}
diff --git a/x/evm/keeper/keeper.go b/x/evm/keeper/keeper.go
index 2bed9209..88e17316 100644
--- a/x/evm/keeper/keeper.go
+++ b/x/evm/keeper/keeper.go
@@ -98,14 +98,14 @@ func (k Keeper) SetBlockBloom(ctx sdk.Context, height int64, bloom ethtypes.Bloo
}
// GetBlockHash gets block height from block consensus hash
-func (k Keeper) GetBlockHashFromHeight(ctx sdk.Context, height int64) ([]byte, bool) {
+func (k Keeper) GetBlockHashFromHeight(ctx sdk.Context, height int64) (common.Hash, bool) {
store := ctx.KVStore(k.storeKey)
bz := store.Get(types.KeyBlockHeightHash(uint64(height)))
if len(bz) == 0 {
- return common.Hash{}.Bytes(), false
+ return common.Hash{}, false
}
- return common.BytesToHash(bz).Bytes(), true
+ return common.BytesToHash(bz), true
}
// SetBlockHash sets the mapping from block consensus hash to block height
diff --git a/x/evm/keeper/msg_server.go b/x/evm/keeper/msg_server.go
index 22c9f00d..87da20e8 100644
--- a/x/evm/keeper/msg_server.go
+++ b/x/evm/keeper/msg_server.go
@@ -35,7 +35,6 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
txHash := tmtypes.Tx(ctx.TxBytes()).Hash()
ethHash := ethcmn.BytesToHash(txHash)
blockHash, _ := k.GetBlockHashFromHeight(ctx, ctx.BlockHeight())
- ethBlockHash := ethcmn.BytesToHash(blockHash)
st := &types.StateTransition{
Message: ethMsg,
@@ -50,7 +49,7 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
// other nodes, causing a consensus error
if !st.Simulate {
// Prepare db for logs
- k.Prepare(ctx, ethHash, ethBlockHash, k.TxCount)
+ k.Prepare(ctx, ethHash, blockHash, k.TxCount)
k.TxCount++
}
@@ -62,11 +61,11 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
if !st.Simulate {
k.SetTxReceiptToHash(ctx, ethHash, &types.TxReceipt{
- Hash: ethHash.Bytes(),
- From: sender.Bytes(),
+ Hash: ethHash.Hex(),
+ From: sender.Hex(),
Data: msg.Data,
BlockHeight: uint64(ctx.BlockHeight()),
- BlockHash: blockHash,
+ BlockHash: blockHash.Hex(),
Result: &types.TxResult{
ContractAddress: executionResult.Response.ContractAddress,
Bloom: executionResult.Response.Bloom,
@@ -96,12 +95,12 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
blockHash, _ := k.GetBlockHashFromHeight(ctx, ctx.BlockHeight())
k.SetTxReceiptToHash(ctx, ethHash, &types.TxReceipt{
- Hash: ethHash.Bytes(),
- From: sender.Bytes(),
+ Hash: ethHash.Hex(),
+ From: sender.Hex(),
Data: msg.Data,
Index: uint64(st.Csdb.TxIndex()),
BlockHeight: uint64(ctx.BlockHeight()),
- BlockHash: blockHash,
+ BlockHash: blockHash.Hex(),
Result: &types.TxResult{
ContractAddress: executionResult.Response.ContractAddress,
Bloom: executionResult.Response.Bloom,
@@ -134,11 +133,10 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
})
if len(msg.Data.To) > 0 {
- ethAddr := ethcmn.BytesToAddress(msg.Data.To)
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypeEthereumTx,
- sdk.NewAttribute(types.AttributeKeyRecipient, ethAddr.Hex()),
+ sdk.NewAttribute(types.AttributeKeyRecipient, msg.Data.To),
),
)
}
diff --git a/x/evm/types/access_list.go b/x/evm/types/access_list.go
index 74df86f4..c880f6b7 100644
--- a/x/evm/types/access_list.go
+++ b/x/evm/types/access_list.go
@@ -135,14 +135,18 @@ func (al *accessList) DeleteAddress(address common.Address) {
delete(al.addresses, address)
}
+// AccessList is an EIP-2930 access list that represents the slice of
+// the protobuf AccessTuples.
+type AccessList []AccessTuple
+
// NewAccessList creates a new protobuf-compatible AccessList from an ethereum
// core AccessList type
-func NewAccessList(ethAccessList *ethtypes.AccessList) *AccessList {
+func NewAccessList(ethAccessList *ethtypes.AccessList) AccessList {
if ethAccessList == nil {
return nil
}
- var tuples []AccessTuple
+ var accessList AccessList
for _, tuple := range *ethAccessList {
storageKeys := make([]string, len(tuple.StorageKeys))
@@ -150,15 +154,13 @@ func NewAccessList(ethAccessList *ethtypes.AccessList) *AccessList {
storageKeys[i] = tuple.StorageKeys[i].String()
}
- tuples = append(tuples, AccessTuple{
+ accessList = append(accessList, AccessTuple{
Address: tuple.Address.String(),
StorageKeys: storageKeys,
})
}
- return &AccessList{
- Tuples: tuples,
- }
+ return accessList
}
// ToEthAccessList is an utility function to convert the protobuf compatible
@@ -166,7 +168,7 @@ func NewAccessList(ethAccessList *ethtypes.AccessList) *AccessList {
func (al AccessList) ToEthAccessList() *ethtypes.AccessList {
var accessList ethtypes.AccessList
- for _, tuple := range al.Tuples {
+ for _, tuple := range al {
storageKeys := make([]ethcmn.Hash, len(tuple.StorageKeys))
for i := range tuple.StorageKeys {
diff --git a/x/evm/types/evm.pb.go b/x/evm/types/evm.pb.go
index 9569fe46..b632dbc8 100644
--- a/x/evm/types/evm.pb.go
+++ b/x/evm/types/evm.pb.go
@@ -421,13 +421,13 @@ func (m *Log) GetRemoved() bool {
// TxReceipt defines the receipt type stored in KV for each EVM transaction.
type TxReceipt struct {
- Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
- From []byte `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
+ Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+ From string `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
Data *TxData `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
Result *TxResult `protobuf:"bytes,4,opt,name=result,proto3" json:"result,omitempty"`
Index uint64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"`
BlockHeight uint64 `protobuf:"varint,6,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
- BlockHash []byte `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
+ BlockHash string `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
}
func (m *TxReceipt) Reset() { *m = TxReceipt{} }
@@ -526,12 +526,13 @@ type TxData struct {
GasPrice []byte `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
// gas defines the gas limit defined for the transaction.
GasLimit uint64 `protobuf:"varint,4,opt,name=gas,proto3" json:"gas,omitempty"`
- To []byte `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
+ // hex formatted address of the recipient
+ To string `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
// value defines the unsigned integer value of the transaction amount.
Amount []byte `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"`
// input defines the data payload bytes of the transaction.
- Input []byte `protobuf:"bytes,7,opt,name=input,proto3" json:"input,omitempty"`
- Accesses *AccessList `protobuf:"bytes,8,opt,name=accesses,proto3" json:"accessList"`
+ Input []byte `protobuf:"bytes,7,opt,name=input,proto3" json:"input,omitempty"`
+ Accesses AccessList `protobuf:"bytes,8,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"`
// v defines the signature value
V []byte `protobuf:"bytes,9,opt,name=v,proto3" json:"v,omitempty"`
// r defines the signature value
@@ -610,52 +611,6 @@ func (m *BytesList) XXX_DiscardUnknown() {
var xxx_messageInfo_BytesList proto.InternalMessageInfo
-// AccessList is an EIP-2930 access list defined as a proto message.
-type AccessList struct {
- // access list tuples
- Tuples []AccessTuple `protobuf:"bytes,1,rep,name=tuples,proto3" json:"tuples"`
-}
-
-func (m *AccessList) Reset() { *m = AccessList{} }
-func (m *AccessList) String() string { return proto.CompactTextString(m) }
-func (*AccessList) ProtoMessage() {}
-func (*AccessList) Descriptor() ([]byte, []int) {
- return fileDescriptor_98f00fcca8b6b943, []int{9}
-}
-func (m *AccessList) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *AccessList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_AccessList.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *AccessList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AccessList.Merge(m, src)
-}
-func (m *AccessList) XXX_Size() int {
- return m.Size()
-}
-func (m *AccessList) XXX_DiscardUnknown() {
- xxx_messageInfo_AccessList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AccessList proto.InternalMessageInfo
-
-func (m *AccessList) GetTuples() []AccessTuple {
- if m != nil {
- return m.Tuples
- }
- return nil
-}
-
// AccessTuple is the element type of an access list.
type AccessTuple struct {
// hex formatted ethereum address
@@ -668,7 +623,7 @@ func (m *AccessTuple) Reset() { *m = AccessTuple{} }
func (m *AccessTuple) String() string { return proto.CompactTextString(m) }
func (*AccessTuple) ProtoMessage() {}
func (*AccessTuple) Descriptor() ([]byte, []int) {
- return fileDescriptor_98f00fcca8b6b943, []int{10}
+ return fileDescriptor_98f00fcca8b6b943, []int{9}
}
func (m *AccessTuple) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -707,109 +662,108 @@ func init() {
proto.RegisterType((*TxResult)(nil), "ethermint.evm.v1alpha1.TxResult")
proto.RegisterType((*TxData)(nil), "ethermint.evm.v1alpha1.TxData")
proto.RegisterType((*BytesList)(nil), "ethermint.evm.v1alpha1.BytesList")
- proto.RegisterType((*AccessList)(nil), "ethermint.evm.v1alpha1.AccessList")
proto.RegisterType((*AccessTuple)(nil), "ethermint.evm.v1alpha1.AccessTuple")
}
func init() { proto.RegisterFile("ethermint/evm/v1alpha1/evm.proto", fileDescriptor_98f00fcca8b6b943) }
var fileDescriptor_98f00fcca8b6b943 = []byte{
- // 1516 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcb, 0x6f, 0x1b, 0x45,
- 0x18, 0x8f, 0x1f, 0x71, 0xec, 0xf1, 0xc6, 0x31, 0xd3, 0x10, 0xdc, 0x56, 0x78, 0xcd, 0x22, 0xd1,
- 0x20, 0xb5, 0x49, 0xe3, 0x2a, 0x22, 0xaa, 0xc4, 0xc1, 0x6e, 0xd2, 0x26, 0x6a, 0xda, 0x46, 0xd3,
- 0xd0, 0x22, 0x2e, 0xd6, 0x78, 0x3d, 0x5d, 0x2f, 0xd9, 0xdd, 0x31, 0x3b, 0x63, 0xd7, 0x46, 0x42,
- 0xe2, 0xc8, 0x11, 0x6e, 0x1c, 0xf9, 0x2b, 0xf8, 0x1b, 0x2a, 0x4e, 0x3d, 0x22, 0x0e, 0x2b, 0xe4,
- 0x72, 0xca, 0xd1, 0x67, 0x24, 0xd0, 0x3c, 0xd6, 0x8f, 0x3c, 0x2a, 0x59, 0x39, 0x79, 0xbe, 0x6f,
- 0xbe, 0xf9, 0xfd, 0xe6, 0x7b, 0xce, 0x1a, 0x54, 0x08, 0x6f, 0x93, 0xd0, 0x77, 0x03, 0xbe, 0x49,
- 0x7a, 0xfe, 0x66, 0x6f, 0x0b, 0x7b, 0x9d, 0x36, 0xde, 0x12, 0xc2, 0x46, 0x27, 0xa4, 0x9c, 0xc2,
- 0xb5, 0xb1, 0xc5, 0x86, 0x50, 0xc6, 0x16, 0x37, 0x56, 0x1d, 0xea, 0x50, 0x69, 0xb2, 0x29, 0x56,
- 0xca, 0xda, 0xfa, 0x37, 0x01, 0x32, 0x47, 0x38, 0xc4, 0x3e, 0x83, 0x5b, 0x20, 0x47, 0x7a, 0x7e,
- 0xa3, 0x45, 0x02, 0xea, 0x97, 0x12, 0x95, 0xc4, 0x7a, 0xae, 0xbe, 0x3a, 0x8a, 0xcc, 0xe2, 0x00,
- 0xfb, 0xde, 0x7d, 0x6b, 0xbc, 0x65, 0xa1, 0x2c, 0xe9, 0xf9, 0xbb, 0x62, 0x09, 0xbf, 0x04, 0xcb,
- 0x24, 0xc0, 0x4d, 0x8f, 0x34, 0xec, 0x90, 0x60, 0x4e, 0x4a, 0xc9, 0x4a, 0x62, 0x3d, 0x5b, 0x2f,
- 0x8d, 0x22, 0x73, 0x55, 0x1f, 0x9b, 0xde, 0xb6, 0x90, 0xa1, 0xe4, 0x07, 0x52, 0x84, 0x5f, 0x80,
- 0x7c, 0xbc, 0x8f, 0x3d, 0xaf, 0x94, 0x92, 0x87, 0xd7, 0x46, 0x91, 0x09, 0x67, 0x0f, 0x63, 0xcf,
- 0xb3, 0x10, 0xd0, 0x47, 0xb1, 0xe7, 0xc1, 0x1a, 0x00, 0xa4, 0xcf, 0x43, 0xdc, 0x20, 0x6e, 0x87,
- 0x95, 0xd2, 0x95, 0xd4, 0x7a, 0xaa, 0x6e, 0x0d, 0x23, 0x33, 0xb7, 0x27, 0xb4, 0x7b, 0x07, 0x47,
- 0x6c, 0x14, 0x99, 0x1f, 0x68, 0x90, 0xb1, 0xa1, 0x85, 0x72, 0x52, 0xd8, 0x73, 0x3b, 0xec, 0x7e,
- 0xfa, 0xd7, 0xdf, 0xcc, 0x05, 0xeb, 0xf7, 0x65, 0x90, 0x7f, 0xd0, 0xc6, 0x6e, 0xf0, 0x80, 0x06,
- 0xaf, 0x5c, 0x07, 0x7e, 0x07, 0x56, 0xda, 0xd4, 0x27, 0x8c, 0x13, 0xdc, 0x6a, 0x34, 0x3d, 0x6a,
- 0x9f, 0xe8, 0x48, 0xec, 0xbf, 0x89, 0xcc, 0x85, 0xbf, 0x22, 0xf3, 0x33, 0xc7, 0xe5, 0xed, 0x6e,
- 0x73, 0xc3, 0xa6, 0xfe, 0xa6, 0x4d, 0x99, 0x4f, 0x99, 0xfe, 0xb9, 0xc3, 0x5a, 0x27, 0x9b, 0x7c,
- 0xd0, 0x21, 0x6c, 0xe3, 0x20, 0xe0, 0xa3, 0xc8, 0x5c, 0x53, 0xf4, 0x67, 0xe0, 0x2c, 0x54, 0x18,
- 0x6b, 0xea, 0x42, 0x01, 0x7f, 0x00, 0x85, 0x16, 0xa6, 0x8d, 0x57, 0x34, 0x3c, 0xd1, 0x8c, 0x49,
- 0xc9, 0xf8, 0x72, 0x3e, 0xc6, 0x61, 0x64, 0x1a, 0xbb, 0xb5, 0x67, 0x0f, 0x69, 0x78, 0x22, 0x71,
- 0x47, 0x91, 0xf9, 0xa1, 0xba, 0xc1, 0x2c, 0xba, 0x85, 0x8c, 0x16, 0xa6, 0x63, 0x33, 0xf8, 0x12,
- 0x14, 0xc7, 0x06, 0xac, 0xdb, 0xe9, 0xd0, 0x90, 0xeb, 0x44, 0xdc, 0x19, 0x46, 0x66, 0x41, 0x43,
- 0x3e, 0x57, 0x3b, 0xa3, 0xc8, 0xfc, 0xe8, 0x0c, 0xa8, 0x3e, 0x63, 0xa1, 0x82, 0x86, 0xd5, 0xa6,
- 0xf0, 0x35, 0x30, 0x88, 0xdb, 0xd9, 0xda, 0xbe, 0xab, 0xbd, 0x4a, 0x4b, 0xaf, 0x8e, 0xe7, 0xf6,
- 0x2a, 0xbf, 0x77, 0x70, 0xb4, 0xb5, 0x7d, 0x37, 0x76, 0xea, 0x9a, 0xce, 0xea, 0x14, 0xb4, 0x85,
- 0xf2, 0x4a, 0x54, 0x1e, 0x1d, 0x00, 0x2d, 0x36, 0xda, 0x98, 0xb5, 0x4b, 0x8b, 0x92, 0x77, 0x7d,
- 0x18, 0x99, 0x40, 0x21, 0xed, 0x63, 0xd6, 0x9e, 0xe4, 0xa7, 0x39, 0xf8, 0x1e, 0x07, 0xdc, 0xed,
- 0xfa, 0x31, 0x16, 0x50, 0x87, 0x85, 0xd5, 0xd8, 0x87, 0x6d, 0xed, 0x43, 0xe6, 0x4a, 0x3e, 0x6c,
- 0x5f, 0xe4, 0xc3, 0xf6, 0xac, 0x0f, 0xca, 0x66, 0x4c, 0xbc, 0xa3, 0x89, 0x97, 0xae, 0x44, 0xbc,
- 0x73, 0x11, 0xf1, 0xce, 0x2c, 0xb1, 0xb2, 0x11, 0x0d, 0x70, 0x26, 0x22, 0xa5, 0xec, 0xd5, 0x1a,
- 0xe0, 0x5c, 0x80, 0x0b, 0x63, 0x8d, 0xa2, 0xfc, 0x31, 0x01, 0x56, 0x6d, 0x1a, 0x30, 0x2e, 0x94,
- 0x01, 0xed, 0x78, 0x44, 0x13, 0xe7, 0x24, 0xf1, 0x93, 0xb9, 0x89, 0x6f, 0x2a, 0xe2, 0x8b, 0x30,
- 0x2d, 0x74, 0x6d, 0x56, 0xad, 0xae, 0xc0, 0x41, 0xb1, 0x43, 0x38, 0x09, 0x59, 0xb3, 0x1b, 0x3a,
- 0x9a, 0x1d, 0x48, 0xf6, 0x83, 0xb9, 0xd9, 0x75, 0x83, 0x9c, 0xc5, 0xb3, 0xd0, 0xca, 0x44, 0xa5,
- 0x58, 0x03, 0x50, 0x70, 0xc5, 0x55, 0x9a, 0x5d, 0x4f, 0x73, 0xe6, 0x25, 0xe7, 0xa3, 0xb9, 0x39,
- 0x75, 0xa7, 0xcf, 0xa2, 0x59, 0x68, 0x39, 0x56, 0x28, 0xbe, 0x01, 0x80, 0x7e, 0xd7, 0x0d, 0x1b,
- 0x8e, 0x87, 0x6d, 0x97, 0x84, 0x9a, 0xd3, 0x90, 0x9c, 0x8f, 0xe7, 0xe6, 0xbc, 0xae, 0x38, 0xcf,
- 0x23, 0x5a, 0xa8, 0x28, 0x94, 0x8f, 0x94, 0x4e, 0x51, 0x7f, 0x0b, 0x96, 0x07, 0xd4, 0xa3, 0x8d,
- 0xde, 0x3d, 0xcd, 0xba, 0x2c, 0x59, 0x1f, 0xce, 0xcd, 0xaa, 0x9f, 0x95, 0x19, 0x30, 0x0b, 0xe5,
- 0x85, 0xfc, 0xe2, 0x9e, 0xe2, 0x62, 0x20, 0x4f, 0x5e, 0x63, 0x16, 0x97, 0x6f, 0x41, 0x32, 0xa1,
- 0xb9, 0x5b, 0x07, 0xec, 0xbd, 0xac, 0x3d, 0x7f, 0x12, 0x77, 0x4e, 0xfc, 0x22, 0x4d, 0x80, 0xc5,
- 0xa4, 0x10, 0xd2, 0x38, 0x97, 0x36, 0xe6, 0xd8, 0x1b, 0x30, 0xae, 0x79, 0x57, 0xae, 0x96, 0xcb,
- 0x59, 0x34, 0x0b, 0x2d, 0xc7, 0x0a, 0xc9, 0x67, 0x6d, 0x82, 0xc5, 0xe7, 0x5c, 0xbc, 0xa1, 0x45,
- 0x90, 0x3a, 0x21, 0x03, 0xf5, 0x4a, 0x21, 0xb1, 0x84, 0xab, 0x60, 0xb1, 0x87, 0xbd, 0xae, 0x7a,
- 0x8c, 0x73, 0x48, 0x09, 0xd6, 0x0b, 0xb0, 0x72, 0x1c, 0xe2, 0x80, 0x61, 0x9b, 0xbb, 0x34, 0x38,
- 0xa4, 0x0e, 0x83, 0x10, 0xa4, 0xe5, 0x84, 0x54, 0x67, 0xe5, 0x1a, 0x6e, 0x82, 0xb4, 0x47, 0x1d,
- 0x56, 0x4a, 0x56, 0x52, 0xeb, 0xf9, 0xea, 0xcd, 0x8d, 0x8b, 0x3f, 0x26, 0x36, 0x0e, 0xa9, 0x83,
- 0xa4, 0xa1, 0xf5, 0x47, 0x12, 0xa4, 0x0e, 0xa9, 0x03, 0x4b, 0x60, 0x09, 0xb7, 0x5a, 0x21, 0x61,
- 0x4c, 0xe3, 0xc5, 0x22, 0x5c, 0x03, 0x19, 0x4e, 0x3b, 0xae, 0xad, 0x40, 0x73, 0x48, 0x4b, 0x82,
- 0xbe, 0x85, 0x39, 0x96, 0xaf, 0x8d, 0x81, 0xe4, 0x1a, 0x56, 0x81, 0x21, 0xfd, 0x6d, 0x04, 0x5d,
- 0xbf, 0x49, 0x42, 0xf9, 0x68, 0xa4, 0xeb, 0x2b, 0xa7, 0x91, 0x99, 0x97, 0xfa, 0xa7, 0x52, 0x8d,
- 0xa6, 0x05, 0x78, 0x1b, 0x2c, 0xf1, 0xfe, 0xf4, 0xac, 0xbf, 0x76, 0x1a, 0x99, 0x2b, 0x7c, 0xe2,
- 0xac, 0x18, 0xe5, 0x28, 0xc3, 0xfb, 0xfb, 0xca, 0xc1, 0x2c, 0xef, 0x37, 0xdc, 0xa0, 0x45, 0xfa,
- 0x72, 0x9c, 0xa7, 0xeb, 0xab, 0xa7, 0x91, 0x59, 0x9c, 0x32, 0x3f, 0x10, 0x7b, 0x68, 0x89, 0xf7,
- 0xe5, 0x02, 0xde, 0x06, 0x40, 0x5d, 0x49, 0x32, 0xa8, 0x41, 0xbc, 0x7c, 0x1a, 0x99, 0x39, 0xa9,
- 0x95, 0xd8, 0x93, 0x25, 0xb4, 0xc0, 0xa2, 0xc2, 0xce, 0x4a, 0x6c, 0xe3, 0x34, 0x32, 0xb3, 0x1e,
- 0x75, 0x14, 0xa6, 0xda, 0x12, 0xa1, 0x0a, 0x89, 0x4f, 0x7b, 0xa4, 0x25, 0x47, 0x5c, 0x16, 0xc5,
- 0xa2, 0xf5, 0x5f, 0x02, 0xe4, 0x8e, 0xfb, 0x88, 0xd8, 0xc4, 0xed, 0xf0, 0x99, 0xfc, 0x18, 0x3a,
- 0x3f, 0x10, 0xa4, 0x5f, 0x85, 0xd4, 0x97, 0xb9, 0x35, 0x90, 0x5c, 0xc3, 0xea, 0x54, 0x20, 0xf3,
- 0xd5, 0xf2, 0x65, 0x39, 0x3b, 0xee, 0xef, 0x62, 0x8e, 0x75, 0xa0, 0x77, 0x40, 0x26, 0x24, 0xac,
- 0xeb, 0x71, 0x19, 0xe2, 0x7c, 0xb5, 0x72, 0xf9, 0x29, 0x24, 0xed, 0x90, 0xb6, 0x17, 0xe5, 0xa5,
- 0x3c, 0x14, 0xc1, 0x4e, 0xc7, 0x3e, 0x7d, 0x12, 0x27, 0xae, 0x4d, 0x5c, 0xa7, 0xcd, 0x55, 0x68,
- 0x75, 0x9e, 0xf6, 0xa5, 0x0a, 0x7e, 0x7c, 0x2e, 0x90, 0xc6, 0x54, 0xe4, 0xee, 0xa7, 0x7f, 0x12,
- 0x1f, 0x64, 0xbf, 0x24, 0x41, 0x36, 0xa6, 0x84, 0x0f, 0x41, 0xd1, 0xa6, 0x01, 0x0f, 0xb1, 0xcd,
- 0x1b, 0x33, 0xc5, 0x55, 0xbf, 0x39, 0x19, 0xb4, 0x67, 0x2d, 0x2c, 0xb4, 0x12, 0xab, 0x6a, 0xba,
- 0x02, 0x57, 0xc1, 0x62, 0xd3, 0xa3, 0xe3, 0xa8, 0x29, 0x01, 0x7e, 0x2d, 0xeb, 0x46, 0x56, 0xbb,
- 0x8a, 0xdc, 0xad, 0x4b, 0x63, 0x30, 0xdb, 0x38, 0xf5, 0x35, 0xd1, 0xd4, 0xa3, 0xc8, 0x2c, 0xa8,
- 0x1b, 0x68, 0x14, 0x4b, 0xd4, 0x98, 0x6c, 0xac, 0x22, 0x48, 0x85, 0x44, 0x45, 0xd6, 0x40, 0x62,
- 0x09, 0x6f, 0x80, 0x6c, 0x48, 0x7a, 0x24, 0xe4, 0xa4, 0x25, 0xe3, 0x96, 0x45, 0x63, 0x19, 0x5e,
- 0x07, 0x59, 0x07, 0xb3, 0x46, 0x97, 0x91, 0x96, 0x0e, 0xdb, 0x92, 0x83, 0xd9, 0x57, 0x8c, 0xb4,
- 0x74, 0x4c, 0xfe, 0x49, 0x82, 0x8c, 0x4a, 0x1e, 0xdc, 0x02, 0x59, 0x5b, 0x7c, 0xae, 0x36, 0xdc,
- 0x96, 0x2a, 0x8b, 0xfa, 0xda, 0x30, 0x32, 0x97, 0xe4, 0x27, 0xec, 0xc1, 0xee, 0x69, 0x64, 0x2e,
- 0xd9, 0x6a, 0x89, 0xf4, 0xa2, 0x25, 0x9c, 0x0f, 0x68, 0x60, 0xab, 0x71, 0x90, 0x46, 0x4a, 0x80,
- 0x9f, 0x83, 0x9c, 0x20, 0xed, 0x84, 0xae, 0x4d, 0x54, 0x07, 0xd6, 0x8d, 0x61, 0x64, 0x66, 0x1f,
- 0x61, 0x76, 0x24, 0x74, 0x48, 0xdc, 0x49, 0xae, 0x60, 0x19, 0xa4, 0x1c, 0xcc, 0x74, 0x2b, 0xc6,
- 0x46, 0x87, 0xae, 0xef, 0x72, 0x24, 0x36, 0x60, 0x01, 0x24, 0x39, 0x95, 0x5e, 0x19, 0x28, 0xc9,
- 0x29, 0xac, 0xc4, 0xf3, 0x27, 0x23, 0x61, 0xc1, 0x30, 0x32, 0x33, 0x35, 0x9f, 0x76, 0x03, 0xae,
- 0x67, 0x91, 0x2a, 0xa1, 0x4e, 0x97, 0xeb, 0x22, 0x50, 0x02, 0x7c, 0x0a, 0xb2, 0xd8, 0xb6, 0x09,
- 0x63, 0x84, 0xc9, 0xee, 0xc9, 0x57, 0xad, 0xcb, 0x12, 0x52, 0x93, 0x76, 0x87, 0x2e, 0xe3, 0xf5,
- 0xc2, 0x69, 0x64, 0x02, 0x3c, 0x96, 0xd1, 0x18, 0x03, 0x1a, 0x20, 0xd1, 0x93, 0x0d, 0x66, 0xa0,
- 0x44, 0x4f, 0x48, 0xa1, 0x7c, 0xd3, 0x0d, 0x94, 0x08, 0x85, 0xc4, 0xe4, 0x6b, 0x6b, 0xa0, 0x04,
- 0xd3, 0x61, 0xbe, 0x05, 0x72, 0xf5, 0x01, 0x27, 0x12, 0x46, 0x96, 0x8c, 0x10, 0x4a, 0x89, 0x4a,
- 0x4a, 0x96, 0x8c, 0x10, 0xb4, 0xe1, 0x33, 0x00, 0x26, 0x17, 0x80, 0x35, 0x90, 0xe1, 0xdd, 0x8e,
- 0xa7, 0x4d, 0xf3, 0xd5, 0x4f, 0xdf, 0x7f, 0xe9, 0x63, 0x61, 0x5b, 0x4f, 0x8b, 0x0a, 0x42, 0xfa,
- 0xa0, 0x85, 0x41, 0x7e, 0x6a, 0xf3, 0x3d, 0xa3, 0xb4, 0x0a, 0x0c, 0xc6, 0x69, 0x88, 0x1d, 0xd2,
- 0x38, 0x21, 0x03, 0x3d, 0x50, 0xd5, 0x78, 0xd4, 0xfa, 0xc7, 0x64, 0xc0, 0xd0, 0xb4, 0xa0, 0xee,
- 0x5c, 0xaf, 0xbd, 0x19, 0x96, 0x13, 0x6f, 0x87, 0xe5, 0xc4, 0xdf, 0xc3, 0x72, 0xe2, 0xe7, 0x77,
- 0xe5, 0x85, 0xb7, 0xef, 0xca, 0x0b, 0x7f, 0xbe, 0x2b, 0x2f, 0x7c, 0x73, 0xeb, 0xfc, 0xcb, 0x34,
- 0xf9, 0x8f, 0xd9, 0x97, 0xff, 0x32, 0xe5, 0xf3, 0xd4, 0xcc, 0xc8, 0x7f, 0x8c, 0xf7, 0xfe, 0x0f,
- 0x00, 0x00, 0xff, 0xff, 0xfa, 0x12, 0x92, 0x0e, 0x83, 0x0e, 0x00, 0x00,
+ // 1506 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4b, 0x6f, 0x1b, 0x47,
+ 0x12, 0x16, 0x1f, 0xa2, 0x86, 0xcd, 0x11, 0xc5, 0x6d, 0x6b, 0xb5, 0xb4, 0x8d, 0xe5, 0x70, 0x67,
+ 0x81, 0xb5, 0x16, 0xb0, 0x25, 0x4b, 0x86, 0xb0, 0x82, 0x81, 0x3d, 0x90, 0x96, 0x6c, 0x09, 0x96,
+ 0x77, 0x85, 0xb6, 0xd6, 0x5e, 0xe4, 0x42, 0x34, 0x67, 0xda, 0xc3, 0x89, 0x66, 0xa6, 0x99, 0xe9,
+ 0x26, 0x4d, 0x06, 0x08, 0x90, 0x63, 0x8e, 0xc9, 0x2d, 0xc7, 0x9c, 0xf3, 0x03, 0xf2, 0x1b, 0x8c,
+ 0x9c, 0x7c, 0x0c, 0x72, 0x98, 0x04, 0xf4, 0x4d, 0x47, 0x5e, 0x72, 0x09, 0x90, 0xa0, 0x1f, 0x43,
+ 0x91, 0x7a, 0x04, 0x20, 0x74, 0x62, 0x57, 0x75, 0xf5, 0xf7, 0x75, 0x55, 0x75, 0x55, 0x0d, 0x41,
+ 0x9d, 0xf0, 0x0e, 0x89, 0x43, 0x3f, 0xe2, 0x9b, 0xa4, 0x1f, 0x6e, 0xf6, 0xb7, 0x70, 0xd0, 0xed,
+ 0xe0, 0x2d, 0x21, 0x6c, 0x74, 0x63, 0xca, 0x29, 0x5c, 0x9b, 0x58, 0x6c, 0x08, 0x65, 0x6a, 0x71,
+ 0x67, 0xd5, 0xa3, 0x1e, 0x95, 0x26, 0x9b, 0x62, 0xa5, 0xac, 0xed, 0x5f, 0x33, 0xa0, 0x70, 0x8c,
+ 0x63, 0x1c, 0x32, 0xb8, 0x05, 0x8a, 0xa4, 0x1f, 0xb6, 0x5c, 0x12, 0xd1, 0xb0, 0x9a, 0xa9, 0x67,
+ 0xd6, 0x8b, 0xcd, 0xd5, 0x71, 0x62, 0x55, 0x86, 0x38, 0x0c, 0x1e, 0xdb, 0x93, 0x2d, 0x1b, 0x19,
+ 0xa4, 0x1f, 0xee, 0x89, 0x25, 0xfc, 0x37, 0x58, 0x26, 0x11, 0x6e, 0x07, 0xa4, 0xe5, 0xc4, 0x04,
+ 0x73, 0x52, 0xcd, 0xd6, 0x33, 0xeb, 0x46, 0xb3, 0x3a, 0x4e, 0xac, 0x55, 0x7d, 0x6c, 0x7a, 0xdb,
+ 0x46, 0xa6, 0x92, 0x9f, 0x48, 0x11, 0xfe, 0x0b, 0x94, 0xd2, 0x7d, 0x1c, 0x04, 0xd5, 0x9c, 0x3c,
+ 0xbc, 0x36, 0x4e, 0x2c, 0x38, 0x7b, 0x18, 0x07, 0x81, 0x8d, 0x80, 0x3e, 0x8a, 0x83, 0x00, 0x36,
+ 0x00, 0x20, 0x03, 0x1e, 0xe3, 0x16, 0xf1, 0xbb, 0xac, 0x9a, 0xaf, 0xe7, 0xd6, 0x73, 0x4d, 0x7b,
+ 0x94, 0x58, 0xc5, 0x7d, 0xa1, 0xdd, 0x3f, 0x3c, 0x66, 0xe3, 0xc4, 0xfa, 0x93, 0x06, 0x99, 0x18,
+ 0xda, 0xa8, 0x28, 0x85, 0x7d, 0xbf, 0xcb, 0x1e, 0xe7, 0xbf, 0xfe, 0xc6, 0x5a, 0xb0, 0xbf, 0x5b,
+ 0x06, 0xa5, 0x27, 0x1d, 0xec, 0x47, 0x4f, 0x68, 0xf4, 0xc6, 0xf7, 0xe0, 0x27, 0x60, 0xa5, 0x43,
+ 0x43, 0xc2, 0x38, 0xc1, 0x6e, 0xab, 0x1d, 0x50, 0xe7, 0x54, 0x47, 0xe2, 0xe0, 0x5d, 0x62, 0x2d,
+ 0xfc, 0x98, 0x58, 0xff, 0xf0, 0x7c, 0xde, 0xe9, 0xb5, 0x37, 0x1c, 0x1a, 0x6e, 0x3a, 0x94, 0x85,
+ 0x94, 0xe9, 0x9f, 0x07, 0xcc, 0x3d, 0xdd, 0xe4, 0xc3, 0x2e, 0x61, 0x1b, 0x87, 0x11, 0x1f, 0x27,
+ 0xd6, 0x9a, 0xa2, 0xbf, 0x00, 0x67, 0xa3, 0xf2, 0x44, 0xd3, 0x14, 0x0a, 0xf8, 0x19, 0x28, 0xbb,
+ 0x98, 0xb6, 0xde, 0xd0, 0xf8, 0x54, 0x33, 0x66, 0x25, 0xe3, 0xeb, 0xf9, 0x18, 0x47, 0x89, 0x65,
+ 0xee, 0x35, 0xfe, 0xfb, 0x94, 0xc6, 0xa7, 0x12, 0x77, 0x9c, 0x58, 0x7f, 0x56, 0x37, 0x98, 0x45,
+ 0xb7, 0x91, 0xe9, 0x62, 0x3a, 0x31, 0x83, 0xaf, 0x41, 0x65, 0x62, 0xc0, 0x7a, 0xdd, 0x2e, 0x8d,
+ 0xb9, 0x4e, 0xc4, 0x83, 0x51, 0x62, 0x95, 0x35, 0xe4, 0x4b, 0xb5, 0x33, 0x4e, 0xac, 0xbf, 0x5c,
+ 0x00, 0xd5, 0x67, 0x6c, 0x54, 0xd6, 0xb0, 0xda, 0x14, 0xbe, 0x05, 0x26, 0xf1, 0xbb, 0x5b, 0x3b,
+ 0x0f, 0xb5, 0x57, 0x79, 0xe9, 0xd5, 0xc9, 0xdc, 0x5e, 0x95, 0xf6, 0x0f, 0x8f, 0xb7, 0x76, 0x1e,
+ 0xa6, 0x4e, 0xdd, 0xd2, 0x59, 0x9d, 0x82, 0xb6, 0x51, 0x49, 0x89, 0xca, 0xa3, 0x43, 0xa0, 0xc5,
+ 0x56, 0x07, 0xb3, 0x4e, 0x75, 0x51, 0xf2, 0xae, 0x8f, 0x12, 0x0b, 0x28, 0xa4, 0x03, 0xcc, 0x3a,
+ 0xe7, 0xf9, 0x69, 0x0f, 0x3f, 0xc5, 0x11, 0xf7, 0x7b, 0x61, 0x8a, 0x05, 0xd4, 0x61, 0x61, 0x35,
+ 0xf1, 0x61, 0x47, 0xfb, 0x50, 0xb8, 0x91, 0x0f, 0x3b, 0x57, 0xf9, 0xb0, 0x33, 0xeb, 0x83, 0xb2,
+ 0x99, 0x10, 0xef, 0x6a, 0xe2, 0xa5, 0x1b, 0x11, 0xef, 0x5e, 0x45, 0xbc, 0x3b, 0x4b, 0xac, 0x6c,
+ 0x44, 0x01, 0x5c, 0x88, 0x48, 0xd5, 0xb8, 0x59, 0x01, 0x5c, 0x0a, 0x70, 0x79, 0xa2, 0x51, 0x94,
+ 0x9f, 0x67, 0xc0, 0xaa, 0x43, 0x23, 0xc6, 0x85, 0x32, 0xa2, 0xdd, 0x80, 0x68, 0xe2, 0xa2, 0x24,
+ 0x7e, 0x31, 0x37, 0xf1, 0x5d, 0x45, 0x7c, 0x15, 0xa6, 0x8d, 0x6e, 0xcd, 0xaa, 0xd5, 0x15, 0x38,
+ 0xa8, 0x74, 0x09, 0x27, 0x31, 0x6b, 0xf7, 0x62, 0x4f, 0xb3, 0x03, 0xc9, 0x7e, 0x38, 0x37, 0xbb,
+ 0x2e, 0x90, 0x8b, 0x78, 0x36, 0x5a, 0x39, 0x57, 0x29, 0xd6, 0x08, 0x94, 0x7d, 0x71, 0x95, 0x76,
+ 0x2f, 0xd0, 0x9c, 0x25, 0xc9, 0xf9, 0x6c, 0x6e, 0x4e, 0x5d, 0xe9, 0xb3, 0x68, 0x36, 0x5a, 0x4e,
+ 0x15, 0x8a, 0x6f, 0x08, 0x60, 0xd8, 0xf3, 0xe3, 0x96, 0x17, 0x60, 0xc7, 0x27, 0xb1, 0xe6, 0x34,
+ 0x25, 0xe7, 0xf3, 0xb9, 0x39, 0x6f, 0x2b, 0xce, 0xcb, 0x88, 0x36, 0xaa, 0x08, 0xe5, 0x33, 0xa5,
+ 0x53, 0xd4, 0x1f, 0x83, 0xe5, 0x21, 0x0d, 0x68, 0xab, 0xff, 0x48, 0xb3, 0x2e, 0x4b, 0xd6, 0xa7,
+ 0x73, 0xb3, 0xea, 0xb1, 0x32, 0x03, 0x66, 0xa3, 0x92, 0x90, 0x5f, 0x3d, 0x52, 0x5c, 0x0c, 0x94,
+ 0xc8, 0x5b, 0xcc, 0xd2, 0xe7, 0x5b, 0x96, 0x4c, 0x68, 0xee, 0xd2, 0x01, 0xfb, 0xaf, 0x1b, 0x2f,
+ 0x5f, 0xa4, 0x95, 0x93, 0x4e, 0xa4, 0x73, 0x60, 0xd1, 0x29, 0x84, 0x34, 0xc9, 0xa5, 0x83, 0x39,
+ 0x0e, 0x86, 0x8c, 0x6b, 0xde, 0x95, 0x9b, 0xe5, 0x72, 0x16, 0xcd, 0x46, 0xcb, 0xa9, 0x42, 0xf2,
+ 0xd9, 0x9b, 0x60, 0xf1, 0x25, 0x17, 0x33, 0xb4, 0x02, 0x72, 0xa7, 0x64, 0xa8, 0xa6, 0x14, 0x12,
+ 0x4b, 0xb8, 0x0a, 0x16, 0xfb, 0x38, 0xe8, 0xa9, 0x61, 0x5c, 0x44, 0x4a, 0xb0, 0x5f, 0x81, 0x95,
+ 0x93, 0x18, 0x47, 0x0c, 0x3b, 0xdc, 0xa7, 0xd1, 0x11, 0xf5, 0x18, 0x84, 0x20, 0x2f, 0x3b, 0xa4,
+ 0x3a, 0x2b, 0xd7, 0x70, 0x13, 0xe4, 0x03, 0xea, 0xb1, 0x6a, 0xb6, 0x9e, 0x5b, 0x2f, 0x6d, 0xdf,
+ 0xdd, 0xb8, 0xfa, 0x63, 0x62, 0xe3, 0x88, 0x7a, 0x48, 0x1a, 0xda, 0xdf, 0x67, 0x41, 0xee, 0x88,
+ 0x7a, 0xb0, 0x0a, 0x96, 0xb0, 0xeb, 0xc6, 0x84, 0x31, 0x8d, 0x97, 0x8a, 0x70, 0x0d, 0x14, 0x38,
+ 0xed, 0xfa, 0x8e, 0x02, 0x2d, 0x22, 0x2d, 0x09, 0x7a, 0x17, 0x73, 0x2c, 0xa7, 0x8d, 0x89, 0xe4,
+ 0x1a, 0x6e, 0x03, 0x53, 0xfa, 0xdb, 0x8a, 0x7a, 0x61, 0x9b, 0xc4, 0x72, 0x68, 0xe4, 0x9b, 0x2b,
+ 0x67, 0x89, 0x55, 0x92, 0xfa, 0xff, 0x48, 0x35, 0x9a, 0x16, 0xe0, 0x7d, 0xb0, 0xc4, 0x07, 0xd3,
+ 0xbd, 0xfe, 0xd6, 0x59, 0x62, 0xad, 0xf0, 0x73, 0x67, 0x45, 0x2b, 0x47, 0x05, 0x3e, 0x38, 0x50,
+ 0x0e, 0x1a, 0x7c, 0xd0, 0xf2, 0x23, 0x97, 0x0c, 0x64, 0x3b, 0xcf, 0x37, 0x57, 0xcf, 0x12, 0xab,
+ 0x32, 0x65, 0x7e, 0x28, 0xf6, 0xd0, 0x12, 0x1f, 0xc8, 0x05, 0xbc, 0x0f, 0x80, 0xba, 0x92, 0x64,
+ 0x50, 0x8d, 0x78, 0xf9, 0x2c, 0xb1, 0x8a, 0x52, 0x2b, 0xb1, 0xcf, 0x97, 0xd0, 0x06, 0x8b, 0x0a,
+ 0xdb, 0x90, 0xd8, 0xe6, 0x59, 0x62, 0x19, 0x01, 0xf5, 0x14, 0xa6, 0xda, 0x12, 0xa1, 0x8a, 0x49,
+ 0x48, 0xfb, 0xc4, 0x95, 0x2d, 0xce, 0x40, 0xa9, 0x68, 0xff, 0x96, 0x01, 0xc5, 0x93, 0x01, 0x22,
+ 0x0e, 0xf1, 0xbb, 0xfc, 0xca, 0xfc, 0x40, 0x90, 0x7f, 0x13, 0xd3, 0x50, 0xe7, 0x56, 0xae, 0xe1,
+ 0xf6, 0x54, 0x20, 0x4b, 0xdb, 0xb5, 0xeb, 0x72, 0x76, 0x32, 0xd8, 0xc3, 0x1c, 0xeb, 0x40, 0xef,
+ 0x82, 0x42, 0x4c, 0x58, 0x2f, 0xe0, 0x32, 0xc4, 0xa5, 0xed, 0xfa, 0xf5, 0xa7, 0x90, 0xb4, 0x43,
+ 0xda, 0x5e, 0x3c, 0x2f, 0xe5, 0xa1, 0x08, 0x76, 0x3e, 0xf5, 0xe9, 0x6f, 0x69, 0xe2, 0x3a, 0xc4,
+ 0xf7, 0x3a, 0x5c, 0x85, 0x56, 0xe7, 0xe9, 0x40, 0xaa, 0xe0, 0x5f, 0x2f, 0x07, 0x72, 0x2a, 0x72,
+ 0x8f, 0xf3, 0x5f, 0x88, 0x0f, 0xb2, 0xaf, 0xb2, 0xc0, 0x48, 0x29, 0xe1, 0x53, 0x50, 0x71, 0x68,
+ 0xc4, 0x63, 0xec, 0xf0, 0xd6, 0xcc, 0xe3, 0x6a, 0xde, 0x3d, 0x6f, 0xb4, 0x17, 0x2d, 0x6c, 0xb4,
+ 0x92, 0xaa, 0x1a, 0xfa, 0x05, 0xae, 0x82, 0xc5, 0x76, 0x40, 0x75, 0xd4, 0x4c, 0xa4, 0x04, 0xf8,
+ 0x7f, 0xf9, 0x6e, 0xe4, 0x6b, 0x57, 0x91, 0xbb, 0x77, 0x6d, 0x0c, 0x66, 0x0b, 0xa7, 0xb9, 0x26,
+ 0x8a, 0x7a, 0x9c, 0x58, 0x65, 0x75, 0x03, 0x8d, 0x62, 0x8b, 0x37, 0x26, 0x0b, 0xab, 0x02, 0x72,
+ 0x31, 0x51, 0x91, 0x35, 0x91, 0x58, 0xc2, 0x3b, 0xc0, 0x88, 0x49, 0x9f, 0xc4, 0x9c, 0xb8, 0x32,
+ 0x6e, 0x06, 0x9a, 0xc8, 0xf0, 0x36, 0x30, 0x3c, 0xcc, 0x5a, 0x3d, 0x46, 0x5c, 0x1d, 0xb6, 0x25,
+ 0x0f, 0xb3, 0xff, 0x31, 0xe2, 0xea, 0x98, 0xfc, 0x92, 0x05, 0x05, 0x95, 0x3c, 0xb8, 0x05, 0x0c,
+ 0x47, 0x7c, 0xae, 0xb6, 0x7c, 0x57, 0x46, 0xc2, 0x6c, 0xae, 0x8d, 0x12, 0x6b, 0x49, 0x7e, 0xc2,
+ 0x1e, 0xee, 0x9d, 0x25, 0xd6, 0x92, 0xa3, 0x96, 0x48, 0x2f, 0x5c, 0xe1, 0x7c, 0x44, 0x23, 0x47,
+ 0xb5, 0x83, 0x3c, 0x52, 0x02, 0xfc, 0x27, 0x28, 0x0a, 0xd2, 0x6e, 0xec, 0x3b, 0x44, 0x55, 0x60,
+ 0xd3, 0x1c, 0x25, 0x96, 0xf1, 0x0c, 0xb3, 0x63, 0xa1, 0x43, 0xe2, 0x4e, 0x72, 0x05, 0x6b, 0x20,
+ 0xe7, 0x61, 0xa6, 0x4b, 0x31, 0x35, 0x3a, 0xf2, 0x43, 0x9f, 0x23, 0xb1, 0x01, 0xcb, 0x20, 0xcb,
+ 0xa9, 0x2a, 0x3d, 0x94, 0xe5, 0x14, 0xd6, 0xd3, 0xfe, 0x53, 0x90, 0xb0, 0x60, 0x94, 0x58, 0x85,
+ 0x46, 0x48, 0x7b, 0x11, 0xd7, 0xbd, 0x48, 0x3d, 0xa1, 0x6e, 0x8f, 0xcb, 0x47, 0x60, 0x22, 0x25,
+ 0x40, 0x0c, 0x0c, 0xec, 0x38, 0x84, 0x31, 0xc2, 0xaa, 0x86, 0x6c, 0x3f, 0x7f, 0xbf, 0x2e, 0x21,
+ 0x0d, 0x69, 0x77, 0xd2, 0x13, 0x03, 0xbc, 0x2e, 0x92, 0x71, 0x96, 0x58, 0x40, 0x1d, 0x3e, 0xf2,
+ 0x19, 0xff, 0xf6, 0x27, 0x0b, 0x34, 0x26, 0x12, 0x9a, 0xc0, 0x42, 0x13, 0x64, 0xfa, 0xb2, 0xe6,
+ 0x4c, 0x94, 0xe9, 0x0b, 0x29, 0x96, 0x63, 0xde, 0x44, 0x99, 0x58, 0x48, 0x4c, 0x0e, 0x60, 0x13,
+ 0x65, 0x98, 0x8e, 0xfc, 0x3d, 0x50, 0x6c, 0x0e, 0x39, 0x91, 0x30, 0xf2, 0x15, 0x09, 0xa1, 0x9a,
+ 0xa9, 0xe7, 0xe4, 0x2b, 0x12, 0x82, 0x36, 0xc4, 0xa0, 0x34, 0x75, 0xa7, 0x3f, 0x68, 0x86, 0xdb,
+ 0xc0, 0x64, 0x9c, 0xc6, 0xd8, 0x23, 0xad, 0x53, 0x32, 0xd4, 0x2d, 0x51, 0x35, 0x38, 0xad, 0x7f,
+ 0x4e, 0x86, 0x0c, 0x4d, 0x0b, 0x8a, 0xa2, 0xd9, 0x78, 0x37, 0xaa, 0x65, 0xde, 0x8f, 0x6a, 0x99,
+ 0x9f, 0x47, 0xb5, 0xcc, 0x97, 0x1f, 0x6a, 0x0b, 0xef, 0x3f, 0xd4, 0x16, 0x7e, 0xf8, 0x50, 0x5b,
+ 0xf8, 0xe8, 0xde, 0xe5, 0xd9, 0x72, 0xfe, 0x2f, 0x71, 0x20, 0xff, 0x27, 0xca, 0x01, 0xd3, 0x2e,
+ 0xc8, 0xff, 0x7c, 0x8f, 0x7e, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x3d, 0x7c, 0x52, 0x45, 0x0e,
+ 0x00, 0x00,
}
func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -1405,17 +1359,19 @@ func (m *TxData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x4a
}
- if m.Accesses != nil {
- {
- size, err := m.Accesses.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
+ if len(m.Accesses) > 0 {
+ for iNdEx := len(m.Accesses) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Accesses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintEvm(dAtA, i, uint64(size))
}
- i -= size
- i = encodeVarintEvm(dAtA, i, uint64(size))
+ i--
+ dAtA[i] = 0x42
}
- i--
- dAtA[i] = 0x42
}
if len(m.Input) > 0 {
i -= len(m.Input)
@@ -1497,43 +1453,6 @@ func (m *BytesList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *AccessList) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *AccessList) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *AccessList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if len(m.Tuples) > 0 {
- for iNdEx := len(m.Tuples) - 1; iNdEx >= 0; iNdEx-- {
- {
- size, err := m.Tuples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintEvm(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0xa
- }
- }
- return len(dAtA) - i, nil
-}
-
func (m *AccessTuple) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -1827,9 +1746,11 @@ func (m *TxData) Size() (n int) {
if l > 0 {
n += 1 + l + sovEvm(uint64(l))
}
- if m.Accesses != nil {
- l = m.Accesses.Size()
- n += 1 + l + sovEvm(uint64(l))
+ if len(m.Accesses) > 0 {
+ for _, e := range m.Accesses {
+ l = e.Size()
+ n += 1 + l + sovEvm(uint64(l))
+ }
}
l = len(m.V)
if l > 0 {
@@ -1861,21 +1782,6 @@ func (m *BytesList) Size() (n int) {
return n
}
-func (m *AccessList) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if len(m.Tuples) > 0 {
- for _, e := range m.Tuples {
- l = e.Size()
- n += 1 + l + sovEvm(uint64(l))
- }
- }
- return n
-}
-
func (m *AccessTuple) Size() (n int) {
if m == nil {
return 0
@@ -3210,7 +3116,7 @@ func (m *TxReceipt) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
}
- var byteLen int
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvm
@@ -3220,31 +3126,29 @@ func (m *TxReceipt) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
return ErrInvalidLengthEvm
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthEvm
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
- if m.Hash == nil {
- m.Hash = []byte{}
- }
+ m.Hash = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
}
- var byteLen int
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvm
@@ -3254,25 +3158,23 @@ func (m *TxReceipt) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
return ErrInvalidLengthEvm
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthEvm
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.From = append(m.From[:0], dAtA[iNdEx:postIndex]...)
- if m.From == nil {
- m.From = []byte{}
- }
+ m.From = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
@@ -3388,7 +3290,7 @@ func (m *TxReceipt) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType)
}
- var byteLen int
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvm
@@ -3398,25 +3300,23 @@ func (m *TxReceipt) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
return ErrInvalidLengthEvm
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthEvm
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.BlockHash = append(m.BlockHash[:0], dAtA[iNdEx:postIndex]...)
- if m.BlockHash == nil {
- m.BlockHash = []byte{}
- }
+ m.BlockHash = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -3806,7 +3706,7 @@ func (m *TxData) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
}
- var byteLen int
+ var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvm
@@ -3816,25 +3716,23 @@ func (m *TxData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
return ErrInvalidLengthEvm
}
- postIndex := iNdEx + byteLen
+ postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthEvm
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.To = append(m.To[:0], dAtA[iNdEx:postIndex]...)
- if m.To == nil {
- m.To = []byte{}
- }
+ m.To = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 6:
if wireType != 2 {
@@ -3933,10 +3831,8 @@ func (m *TxData) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Accesses == nil {
- m.Accesses = &AccessList{}
- }
- if err := m.Accesses.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.Accesses = append(m.Accesses, AccessTuple{})
+ if err := m.Accesses[len(m.Accesses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -4151,93 +4047,6 @@ func (m *BytesList) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *AccessList) Unmarshal(dAtA []byte) error {
- l := len(dAtA)
- iNdEx := 0
- for iNdEx < l {
- preIndex := iNdEx
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowEvm
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: AccessList: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: AccessList: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Tuples", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowEvm
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthEvm
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthEvm
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- m.Tuples = append(m.Tuples, AccessTuple{})
- if err := m.Tuples[len(m.Tuples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipEvm(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if skippy < 0 {
- return ErrInvalidLengthEvm
- }
- if (iNdEx + skippy) < 0 {
- return ErrInvalidLengthEvm
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
func (m *AccessTuple) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
diff --git a/x/evm/types/msg.go b/x/evm/types/msg.go
index e93da936..887f55b5 100644
--- a/x/evm/types/msg.go
+++ b/x/evm/types/msg.go
@@ -8,6 +8,7 @@ import (
"github.com/cosmos/cosmos-sdk/crypto/keyring"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ "github.com/cosmos/ethermint/types"
ethcmn "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
@@ -52,9 +53,9 @@ func newMsgEthereumTx(
input = ethcmn.CopyBytes(input)
}
- var toBz []byte
+ var toHex string
if to != nil {
- toBz = to.Bytes()
+ toHex = to.Hex()
}
var chainIDBz []byte
@@ -65,7 +66,7 @@ func newMsgEthereumTx(
txData := &TxData{
ChainID: chainIDBz,
Nonce: nonce,
- To: toBz,
+ To: toHex,
Input: input,
GasLimit: gasLimit,
Amount: []byte{},
@@ -106,17 +107,29 @@ func (msg MsgEthereumTx) ValidateBasic() error {
return sdkerrors.Wrapf(ErrInvalidValue, "amount cannot be negative %s", amount)
}
+ if msg.Data.To != "" {
+ if err := types.ValidateAddress(msg.Data.To); err != nil {
+ return sdkerrors.Wrap(err, "invalid to address")
+ }
+ }
+
+ if msg.From != "" {
+ if err := types.ValidateAddress(msg.From); err != nil {
+ return sdkerrors.Wrap(err, "invalid from address")
+ }
+ }
+
return nil
}
// To returns the recipient address of the transaction. It returns nil if the
// transaction is a contract creation.
func (msg MsgEthereumTx) To() *ethcmn.Address {
- if len(msg.Data.To) == 0 {
+ if msg.Data.To == "" {
return nil
}
- recipient := ethcmn.BytesToAddress(msg.Data.To)
+ recipient := ethcmn.HexToAddress(msg.Data.To)
return &recipient
}
@@ -297,8 +310,8 @@ func (msg MsgEthereumTx) AsMessage() (core.Message, error) {
from := ethcmn.HexToAddress(msg.From)
var to *ethcmn.Address
- if msg.Data.To != nil {
- toAddr := ethcmn.BytesToAddress(msg.Data.To)
+ if msg.Data.To != "" {
+ toAddr := ethcmn.HexToAddress(msg.Data.To)
to = &toAddr
}
@@ -324,8 +337,8 @@ func (msg MsgEthereumTx) AsMessage() (core.Message, error) {
// TxData defined on the Cosmos EVM.
func (data TxData) AsEthereumData() ethtypes.TxData {
var to *ethcmn.Address
- if data.To != nil {
- toAddr := ethcmn.BytesToAddress(data.To)
+ if data.To != "" {
+ toAddr := ethcmn.HexToAddress(data.To)
to = &toAddr
}
diff --git a/x/evm/types/msg_test.go b/x/evm/types/msg_test.go
index a61c458d..6d43e703 100644
--- a/x/evm/types/msg_test.go
+++ b/x/evm/types/msg_test.go
@@ -47,7 +47,7 @@ func (suite *MsgsTestSuite) SetupTest() {
func (suite *MsgsTestSuite) TestMsgEthereumTx_Constructor() {
msg := NewMsgEthereumTx(nil, 0, &suite.to, nil, 100000, nil, []byte("test"), nil)
- suite.Require().Equal(msg.Data.To, suite.to.Bytes())
+ suite.Require().Equal(msg.Data.To, suite.to.Hex())
suite.Require().Equal(msg.Route(), RouterKey)
suite.Require().Equal(msg.Type(), TypeMsgEthereumTx)
suite.Require().NotNil(msg.To())
@@ -57,27 +57,30 @@ func (suite *MsgsTestSuite) TestMsgEthereumTx_Constructor() {
msg = NewMsgEthereumTxContract(nil, 0, nil, 100000, nil, []byte("test"), nil)
suite.Require().NotNil(msg)
- suite.Require().Nil(msg.Data.To)
+ suite.Require().Empty(msg.Data.To)
suite.Require().Nil(msg.To())
}
func (suite *MsgsTestSuite) TestMsgEthereumTx_ValidateBasic() {
testCases := []struct {
msg string
+ to *ethcmn.Address
amount *big.Int
gasPrice *big.Int
expectPass bool
}{
- {msg: "pass", amount: big.NewInt(100), gasPrice: big.NewInt(100000), expectPass: true},
+ {msg: "pass with recipient", to: &suite.to, amount: big.NewInt(100), gasPrice: big.NewInt(100000), expectPass: true},
+ {msg: "pass contract", to: nil, amount: big.NewInt(100), gasPrice: big.NewInt(100000), expectPass: true},
+ {msg: "invalid recipient", to: ðcmn.Address{}, amount: big.NewInt(-1), gasPrice: big.NewInt(1000), expectPass: true},
// NOTE: these can't be effectively tested because the SetBytes function from big.Int only sets
// the absolute value
- {msg: "negative amount", amount: big.NewInt(-1), gasPrice: big.NewInt(1000), expectPass: true},
- {msg: "negative gas price", amount: big.NewInt(100), gasPrice: big.NewInt(-1), expectPass: true},
- {msg: "zero gas price", amount: big.NewInt(100), gasPrice: big.NewInt(0), expectPass: true},
+ {msg: "negative amount", to: &suite.to, amount: big.NewInt(-1), gasPrice: big.NewInt(1000), expectPass: true},
+ {msg: "negative gas price", to: &suite.to, amount: big.NewInt(100), gasPrice: big.NewInt(-1), expectPass: true},
+ {msg: "zero gas price", to: &suite.to, amount: big.NewInt(100), gasPrice: big.NewInt(0), expectPass: true},
}
for i, tc := range testCases {
- msg := NewMsgEthereumTx(suite.chainID, 0, nil, tc.amount, 0, tc.gasPrice, nil, nil)
+ msg := NewMsgEthereumTx(suite.chainID, 0, tc.to, tc.amount, 0, tc.gasPrice, nil, nil)
err := msg.ValidateBasic()
if tc.expectPass {