cerc-io/laconicd-deprecated
19
0
Fork 1
Code Issues 21 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

rpc: fix inconsistent logging levels (#265)

Browse Source 
* rpc: fix incosistent logging levels

* minor changes
This commit is contained in:
Federico Kunze Küllmer 2021-07-12 14:39:35 -04:00 committed by GitHub
parent 1a48e09e78
commit 74b7eaf431
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 248 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ethereum/rpc/apis.go
View File

@ -4,6 +4,8 @@ package rpc
import (
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/server"
"github.com/ethereum/go-ethereum/rpc"
"github.com/tharsis/ethermint/ethereum/rpc/backend"
"github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth"
@ -29,10 +31,10 @@ const (
)
// GetRPCAPIs returns the list of all APIs
func GetRPCAPIs(clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc.API {
func GetRPCAPIs(ctx *server.Context, clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc.API {
nonceLock := new(types.AddrLocker)
backend := backend.NewEVMBackend(clientCtx)
ethAPI := eth.NewPublicAPI(clientCtx, backend, nonceLock)
backend := backend.NewEVMBackend(ctx.Logger, clientCtx)
ethAPI := eth.NewPublicAPI(ctx.Logger, clientCtx, backend, nonceLock)
return []rpc.API{
{
@ -50,7 +52,7 @@ func GetRPCAPIs(clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc.
{
Namespace: EthNamespace,
Version: apiVersion,
Service: filters.NewPublicAPI(tmWSClient, backend),
Service: filters.NewPublicAPI(ctx.Logger, tmWSClient, backend),
Public: true,
},
{
@ -62,13 +64,13 @@ func GetRPCAPIs(clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc.
{
Namespace: PersonalNamespace,
Version: apiVersion,
Service: personal.NewAPI(ethAPI),
Service: personal.NewAPI(ctx.Logger, ethAPI),
Public: true,
},
{
Namespace: TxPoolNamespace,
Version: apiVersion,
Service: txpool.NewPublicAPI(),
Service: txpool.NewPublicAPI(ctx.Logger),
Public: true,
},
}

50
ethereum/rpc/backend/backend.go
View File

@ -9,8 +9,8 @@ import (
"github.com/tharsis/ethermint/ethereum/rpc/types"
"github.com/pkg/errors"
"github.com/tendermint/tendermint/libs/log"
tmtypes "github.com/tendermint/tendermint/types"
log "github.com/xlab/suplog"
"github.com/cosmos/cosmos-sdk/client"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -58,7 +58,7 @@ type EVMBackend struct {
}
// NewEVMBackend creates a new EVMBackend instance
func NewEVMBackend(clientCtx client.Context) *EVMBackend {
func NewEVMBackend(logger log.Logger, clientCtx client.Context) *EVMBackend {
chainID, err := ethermint.ParseChainID(clientCtx.ChainID)
if err != nil {
panic(err)
@ -67,7 +67,7 @@ func NewEVMBackend(clientCtx client.Context) *EVMBackend {
ctx: context.Background(),
clientCtx: clientCtx,
queryClient: types.NewQueryClient(clientCtx),
logger: log.WithField("module", "evm-backend"),
logger: logger.With("module", "evm-backend"),
chainID: chainID,
}
}
@ -110,21 +110,21 @@ func (e *EVMBackend) GetBlockByNumber(blockNum types.BlockNumber, fullTx bool) (
resBlock, err := e.clientCtx.Client.Block(e.ctx, &height)
if err != nil {
// e.logger.Debugf("GetBlockByNumber safely bumping down from %d to latest", height)
// e.logger.Debug("GetBlockByNumber safely bumping down from %d to latest", height)
if resBlock, err = e.clientCtx.Client.Block(e.ctx, nil); err != nil {
e.logger.WithError(err).Debugln("GetBlockByNumber failed to get latest block")
e.logger.Debug("GetBlockByNumber failed to get latest block", "error", err.Error())
return nil, nil
}
}
if resBlock.Block == nil {
e.logger.Debugln("GetBlockByNumber block not found", "height", height)
e.logger.Debug("GetBlockByNumber block not found", "height", height)
return nil, nil
}
res, err := e.EthBlockFromTendermint(e.clientCtx, e.queryClient, resBlock.Block, fullTx)
if err != nil {
e.logger.WithError(err).Debugf("EthBlockFromTendermint failed with block %s", resBlock.Block.String())
e.logger.Debug("EthBlockFromTendermint failed", "height", height, "error", err.Error())
}
return res, err
@ -134,12 +134,12 @@ func (e *EVMBackend) GetBlockByNumber(blockNum types.BlockNumber, fullTx bool) (
func (e *EVMBackend) GetBlockByHash(hash common.Hash, fullTx bool) (map[string]interface{}, error) {
resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, hash.Bytes())
if err != nil {
e.logger.WithError(err).Debugln("BlockByHash block not found", "hash", hash.Hex())
e.logger.Debug("BlockByHash block not found", "hash", hash.Hex(), "error", err.Error())
return nil, err
}
if resBlock.Block == nil {
e.logger.Debugln("BlockByHash block not found", "hash", hash.Hex())
e.logger.Debug("BlockByHash block not found", "hash", hash.Hex())
return nil, nil
}
@ -161,7 +161,7 @@ func (e *EVMBackend) EthBlockFromTendermint(
for i, txBz := range block.Txs {
tx, err := e.clientCtx.TxConfig.TxDecoder()(txBz)
if err != nil {
e.logger.WithError(err).Warningln("failed to decode transaction in block at height ", block.Height)
e.logger.Debug("failed to decode transaction in block", "height", block.Height, "error", err.Error())
continue
}
@ -183,13 +183,13 @@ func (e *EVMBackend) EthBlockFromTendermint(
// get full transaction from message data
from, err := ethMsg.GetSender(e.chainID)
if err != nil {
e.logger.WithError(err).Warningln("failed to get sender from already included transaction ", hash)
e.logger.Debug("failed to get sender from already included transaction", "hash", hash.Hex(), "error", err.Error())
from = common.HexToAddress(ethMsg.From)
}
txData, err := evmtypes.UnpackTxData(ethMsg.Data)
if err != nil {
e.logger.WithError(err).Debugln("decoding failed")
e.logger.Debug("decoding failed", "error", err.Error())
return nil, fmt.Errorf("failed to unpack tx data: %w", err)
}
@ -202,7 +202,7 @@ func (e *EVMBackend) EthBlockFromTendermint(
uint64(i),
)
if err != nil {
e.logger.WithError(err).Debugln("NewTransactionFromData for receipt failed", "hash", hash.Hex)
e.logger.Debug("NewTransactionFromData for receipt failed", "hash", hash.Hex(), "error", err.Error())
continue
}
ethRPCTxs = append(ethRPCTxs, ethTx)
@ -211,15 +211,13 @@ func (e *EVMBackend) EthBlockFromTendermint(
blockBloomResp, err := queryClient.BlockBloom(types.ContextWithHeight(block.Height), &evmtypes.QueryBlockBloomRequest{})
if err != nil {
e.logger.WithError(err).Debugln("failed to query BlockBloom", "height", block.Height)
e.logger.Debug("failed to query BlockBloom", "height", block.Height, "error", err.Error())
blockBloomResp = &evmtypes.QueryBlockBloomResponse{Bloom: ethtypes.Bloom{}.Bytes()}
}
bloom := ethtypes.BytesToBloom(blockBloomResp.Bloom)
formattedBlock := types.FormatBlock(block.Header, block.Size(), ethermint.DefaultRPCGasLimit, new(big.Int).SetUint64(gasUsed), ethRPCTxs, bloom)
e.logger.Infoln(formattedBlock)
return formattedBlock, nil
}
@ -241,14 +239,13 @@ func (e *EVMBackend) HeaderByNumber(blockNum types.BlockNumber) (*ethtypes.Heade
height = 1
default:
if blockNum < 0 {
err := errors.Errorf("incorrect block height: %d", height)
return nil, err
return nil, errors.Errorf("incorrect block height: %d", height)
}
}
resBlock, err := e.clientCtx.Client.Block(e.ctx, &height)
if err != nil {
e.logger.Warningf("HeaderByNumber failed")
e.logger.Debug("HeaderByNumber failed")
return nil, err
}
@ -256,7 +253,7 @@ func (e *EVMBackend) HeaderByNumber(blockNum types.BlockNumber) (*ethtypes.Heade
res, err := e.queryClient.BlockBloom(types.ContextWithHeight(resBlock.Block.Height), req)
if err != nil {
e.logger.Warningf("HeaderByNumber BlockBloom fail %d", resBlock.Block.Height)
e.logger.Debug("HeaderByNumber BlockBloom failed", "height", resBlock.Block.Height)
return nil, err
}
@ -269,7 +266,7 @@ func (e *EVMBackend) HeaderByNumber(blockNum types.BlockNumber) (*ethtypes.Heade
func (e *EVMBackend) HeaderByHash(blockHash common.Hash) (*ethtypes.Header, error) {
resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, blockHash.Bytes())
if err != nil {
e.logger.Warningf("HeaderByHash fail")
e.logger.Debug("HeaderByHash failed", "hash", blockHash.Hex())
return nil, err
}
@ -277,7 +274,7 @@ func (e *EVMBackend) HeaderByHash(blockHash common.Hash) (*ethtypes.Header, erro
res, err := e.queryClient.BlockBloom(types.ContextWithHeight(resBlock.Block.Height), req)
if err != nil {
e.logger.Warningf("HeaderByHash BlockBloom fail %d", resBlock.Block.Height)
e.logger.Debug("HeaderByHash BlockBloom failed", "height", resBlock.Block.Height)
return nil, err
}
@ -296,7 +293,7 @@ func (e *EVMBackend) GetTransactionLogs(txHash common.Hash) ([]*ethtypes.Log, er
res, err := e.queryClient.TxLogs(e.ctx, req)
if err != nil {
e.logger.Warningf("TxLogs fail")
e.logger.Debug("TxLogs failed", "tx-hash", req.Hash)
return nil, err
}
@ -332,7 +329,7 @@ func (e *EVMBackend) GetLogs(blockHash common.Hash) ([][]*ethtypes.Log, error) {
res, err := e.queryClient.BlockLogs(e.ctx, req)
if err != nil {
e.logger.Warningf("BlockLogs fail")
e.logger.Debug("BlockLogs failed", "hash", req.Hash)
return nil, err
}
@ -364,8 +361,7 @@ func (e *EVMBackend) GetLogsByNumber(blockNum types.BlockNumber) ([][]*ethtypes.
height = 1
default:
if blockNum < 0 {
err := errors.Errorf("incorrect block height: %d", height)
return nil, err
return nil, errors.Errorf("incorrect block height: %d", height)
}
}
@ -375,7 +371,7 @@ func (e *EVMBackend) GetLogsByNumber(blockNum types.BlockNumber) ([][]*ethtypes.
return [][]*ethtypes.Log{}, nil
}
e.logger.Warningf("failed to query block at %d", height)
e.logger.Debug("failed to query block", "height", height)
return nil, err
}

153
ethereum/rpc/namespaces/eth/api.go
View File

@ -10,7 +10,7 @@ import (
"github.com/pkg/errors"
"github.com/spf13/viper"
log "github.com/xlab/suplog"
"github.com/tendermint/tendermint/libs/log"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
@ -48,6 +48,7 @@ type PublicAPI struct {
// NewPublicAPI creates an instance of the public ETH Web3 API.
func NewPublicAPI(
logger log.Logger,
clientCtx client.Context,
backend backend.Backend,
nonceLock *rpctypes.AddrLocker,
@ -80,7 +81,7 @@ func NewPublicAPI(
clientCtx: clientCtx,
queryClient: rpctypes.NewQueryClient(clientCtx),
chainIDEpoch: epoch,
logger: log.WithField("module", "json-rpc"),
logger: logger.With("client", "json-rpc"),
backend: backend,
nonceLock: nonceLock,
}
@ -95,20 +96,20 @@ func (e *PublicAPI) ClientCtx() client.Context {
// ProtocolVersion returns the supported Ethereum protocol version.
func (e *PublicAPI) ProtocolVersion() hexutil.Uint {
e.logger.Debugln("eth_protocolVersion")
e.logger.Debug("eth_protocolVersion")
return hexutil.Uint(ethermint.ProtocolVersion)
}
// ChainId returns the chain's identifier in hex format
func (e *PublicAPI) ChainId() (hexutil.Uint, error) { // nolint
e.logger.Debugln("eth_chainId")
e.logger.Debug("eth_chainId")
return hexutil.Uint(uint(e.chainIDEpoch.Uint64())), nil
}
// Syncing returns whether or not the current node is syncing with other peers. Returns false if not, or a struct
// outlining the state of the sync if it is.
func (e *PublicAPI) Syncing() (interface{}, error) {
e.logger.Debugln("eth_syncing")
e.logger.Debug("eth_syncing")
status, err := e.clientCtx.Client.Status(e.ctx)
if err != nil {
@ -130,7 +131,7 @@ func (e *PublicAPI) Syncing() (interface{}, error) {
// Coinbase is the address that staking rewards will be send to (alias for Etherbase).
func (e *PublicAPI) Coinbase() (string, error) {
e.logger.Debugln("eth_coinbase")
e.logger.Debug("eth_coinbase")
node, err := e.clientCtx.GetNode()
if err != nil {
@ -158,19 +159,19 @@ func (e *PublicAPI) Coinbase() (string, error) {
// Mining returns whether or not this node is currently mining. Always false.
func (e *PublicAPI) Mining() bool {
e.logger.Debugln("eth_mining")
e.logger.Debug("eth_mining")
return false
}
// Hashrate returns the current node's hashrate. Always 0.
func (e *PublicAPI) Hashrate() hexutil.Uint64 {
e.logger.Debugln("eth_hashrate")
e.logger.Debug("eth_hashrate")
return 0
}
// GasPrice returns the current gas price based on Ethermint's gas price oracle.
func (e *PublicAPI) GasPrice() *hexutil.Big {
e.logger.Debugln("eth_gasPrice")
e.logger.Debug("eth_gasPrice")
// TODO: use minimum value defined in config instead of default or implement oracle
out := big.NewInt(ethermint.DefaultGasPrice)
return (*hexutil.Big)(out)
@ -178,7 +179,7 @@ func (e *PublicAPI) GasPrice() *hexutil.Big {
// Accounts returns the list of accounts available to this node.
func (e *PublicAPI) Accounts() ([]common.Address, error) {
e.logger.Debugln("eth_accounts")
e.logger.Debug("eth_accounts")
addresses := make([]common.Address, 0) // return [] instead of nil if empty
@ -197,13 +198,13 @@ func (e *PublicAPI) Accounts() ([]common.Address, error) {
// BlockNumber returns the current block number.
func (e *PublicAPI) BlockNumber() (hexutil.Uint64, error) {
// e.logger.Debugln("eth_blockNumber")
e.logger.Debug("eth_blockNumber")
return e.backend.BlockNumber()
}
// GetBalance returns the provided account's balance up to the provided block number.
func (e *PublicAPI) GetBalance(address common.Address, blockNum rpctypes.BlockNumber) (*hexutil.Big, error) { // nolint: interfacer
e.logger.Debugln("eth_getBalance", "address", address.String(), "block number", blockNum)
e.logger.Debug("eth_getBalance", "address", address.String(), "block number", blockNum)
req := &evmtypes.QueryBalanceRequest{
Address: address.String(),
@ -224,7 +225,7 @@ func (e *PublicAPI) GetBalance(address common.Address, blockNum rpctypes.BlockNu
// GetStorageAt returns the contract storage at the given address, block number, and key.
func (e *PublicAPI) GetStorageAt(address common.Address, key string, blockNum rpctypes.BlockNumber) (hexutil.Bytes, error) { // nolint: interfacer
e.logger.Debugln("eth_getStorageAt", "address", address.Hex(), "key", key, "block number", blockNum)
e.logger.Debug("eth_getStorageAt", "address", address.Hex(), "key", key, "block number", blockNum)
req := &evmtypes.QueryStorageRequest{
Address: address.String(),
@ -242,7 +243,7 @@ func (e *PublicAPI) GetStorageAt(address common.Address, key string, blockNum rp
// GetTransactionCount returns the number of transactions at the given address up to the given block number.
func (e *PublicAPI) GetTransactionCount(address common.Address, blockNum rpctypes.BlockNumber) (*hexutil.Uint64, error) {
e.logger.Debugln("eth_getTransactionCount", "address", address.Hex(), "block number", blockNum)
e.logger.Debug("eth_getTransactionCount", "address", address.Hex(), "block number", blockNum)
// Get nonce (sequence) from account
from := sdk.AccAddress(address.Bytes())
@ -267,7 +268,7 @@ func (e *PublicAPI) GetTransactionCount(address common.Address, blockNum rpctype
// GetBlockTransactionCountByHash returns the number of transactions in the block identified by hash.
func (e *PublicAPI) GetBlockTransactionCountByHash(hash common.Hash) *hexutil.Uint {
e.logger.Debugln("eth_getBlockTransactionCountByHash", "hash", hash.Hex())
e.logger.Debug("eth_getBlockTransactionCountByHash", "hash", hash.Hex())
resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, hash.Bytes())
if err != nil {
@ -280,7 +281,7 @@ func (e *PublicAPI) GetBlockTransactionCountByHash(hash common.Hash) *hexutil.Ui
// GetBlockTransactionCountByNumber returns the number of transactions in the block identified by number.
func (e *PublicAPI) GetBlockTransactionCountByNumber(blockNum rpctypes.BlockNumber) *hexutil.Uint {
e.logger.Debugln("eth_getBlockTransactionCountByNumber", "block number", blockNum)
e.logger.Debug("eth_getBlockTransactionCountByNumber", "block number", blockNum)
resBlock, err := e.clientCtx.Client.Block(e.ctx, blockNum.TmHeight())
if err != nil {
return nil
@ -302,7 +303,7 @@ func (e *PublicAPI) GetUncleCountByBlockNumber(blockNum rpctypes.BlockNumber) he
// GetCode returns the contract code at the given address and block number.
func (e *PublicAPI) GetCode(address common.Address, blockNumber rpctypes.BlockNumber) (hexutil.Bytes, error) { // nolint: interfacer
e.logger.Debugln("eth_getCode", "address", address.Hex(), "block number", blockNumber)
e.logger.Debug("eth_getCode", "address", address.Hex(), "block number", blockNumber)
req := &evmtypes.QueryCodeRequest{
Address: address.String(),
@ -318,26 +319,26 @@ func (e *PublicAPI) GetCode(address common.Address, blockNumber rpctypes.BlockNu
// GetTransactionLogs returns the logs given a transaction hash.
func (e *PublicAPI) GetTransactionLogs(txHash common.Hash) ([]*ethtypes.Log, error) {
e.logger.Debugln("eth_getTransactionLogs", "hash", txHash)
e.logger.Debug("eth_getTransactionLogs", "hash", txHash)
return e.backend.GetTransactionLogs(txHash)
}
// Sign signs the provided data using the private key of address via Geth's signature standard.
func (e *PublicAPI) Sign(address common.Address, data hexutil.Bytes) (hexutil.Bytes, error) {
e.logger.Debugln("eth_sign", "address", address.Hex(), "data", common.Bytes2Hex(data))
e.logger.Debug("eth_sign", "address", address.Hex(), "data", common.Bytes2Hex(data))
from := sdk.AccAddress(address.Bytes())
_, err := e.clientCtx.Keyring.KeyByAddress(from)
if err != nil {
e.logger.Errorln("failed to find key in keyring", "address", address.String())
e.logger.Error("failed to find key in keyring", "address", address.String())
return nil, fmt.Errorf("%s; %s", keystore.ErrNoMatch, err.Error())
}
// Sign the requested hash with the wallet
signature, _, err := e.clientCtx.Keyring.SignByAddress(from, data)
if err != nil {
e.logger.Panicln("keyring.SignByAddress failed")
e.logger.Error("keyring.SignByAddress failed", "address", address.Hex())
return nil, err
}
@ -347,12 +348,12 @@ func (e *PublicAPI) Sign(address common.Address, data hexutil.Bytes) (hexutil.By
// SendTransaction sends an Ethereum transaction.
func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, error) {
e.logger.Debugln("eth_sendTransaction", "args", args.String())
e.logger.Debug("eth_sendTransaction", "args", args.String())
// Look up the wallet containing the requested signer
_, err := e.clientCtx.Keyring.KeyByAddress(sdk.AccAddress(args.From.Bytes()))
if err != nil {
e.logger.WithError(err).Errorln("failed to find key in keyring", "address", args.From)
e.logger.Error("failed to find key in keyring", "address", args.From, "error", err.Error())
return common.Hash{}, fmt.Errorf("%s; %s", keystore.ErrNoMatch, err.Error())
}
@ -364,7 +365,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro
msg := args.ToTransaction()
if err := msg.ValidateBasic(); err != nil {
e.logger.WithError(err).Debugln("tx failed basic validation")
e.logger.Debug("tx failed basic validation", "error", err.Error())
return common.Hash{}, err
}
@ -373,38 +374,38 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro
// Sign transaction
if err := msg.Sign(signer, e.clientCtx.Keyring); err != nil {
e.logger.Debugln("failed to sign tx", "error", err)
e.logger.Debug("failed to sign tx", "error", err.Error())
return common.Hash{}, err
}
// Assemble transaction from fields
builder, ok := e.clientCtx.TxConfig.NewTxBuilder().(authtx.ExtensionOptionsTxBuilder)
if !ok {
e.logger.WithError(err).Panicln("clientCtx.TxConfig.NewTxBuilder returns unsupported builder")
e.logger.Error("clientCtx.TxConfig.NewTxBuilder returns unsupported builder", "error", err.Error())
}
option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{})
if err != nil {
e.logger.WithError(err).Panicln("codectypes.NewAnyWithValue failed to pack an obvious value")
e.logger.Error("codectypes.NewAnyWithValue failed to pack an obvious value", "error", err.Error())
return common.Hash{}, err
}
builder.SetExtensionOptions(option)
err = builder.SetMsgs(msg)
if err != nil {
e.logger.WithError(err).Panicln("builder.SetMsgs failed")
e.logger.Error("builder.SetMsgs failed", "error", err.Error())
}
// Query params to use the EVM denomination
res, err := e.queryClient.QueryClient.Params(e.ctx, &evmtypes.QueryParamsRequest{})
if err != nil {
e.logger.WithError(err).Errorln("failed to query evm params")
e.logger.Error("failed to query evm params", "error", err.Error())
return common.Hash{}, err
}
txData, err := evmtypes.UnpackTxData(msg.Data)
if err != nil {
e.logger.WithError(err).Errorln("failed to unpack tx data")
e.logger.Error("failed to unpack tx data", "error", err.Error())
return common.Hash{}, err
}
@ -416,7 +417,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro
txEncoder := e.clientCtx.TxConfig.TxEncoder()
txBytes, err := txEncoder(builder.GetTx())
if err != nil {
e.logger.WithError(err).Errorln("failed to encode eth tx using default encoder")
e.logger.Error("failed to encode eth tx using default encoder", "error", err.Error())
return common.Hash{}, err
}
@ -430,7 +431,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro
if err == nil {
err = errors.New(rsp.RawLog)
}
e.logger.WithError(err).Errorln("failed to broadcast tx")
e.logger.Error("failed to broadcast tx", "error", err.Error())
return txHash, err
}
@ -440,53 +441,53 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro
// SendRawTransaction send a raw Ethereum transaction.
func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) {
e.logger.Debugln("eth_sendRawTransaction", "data_len", len(data))
e.logger.Debug("eth_sendRawTransaction", "length", len(data))
// RLP decode raw transaction bytes
tx, err := e.clientCtx.TxConfig.TxDecoder()(data)
if err != nil {
e.logger.WithError(err).Errorln("transaction decoding failed")
e.logger.Error("transaction decoding failed", "error", err.Error())
return common.Hash{}, err
}
ethereumTx, isEthTx := tx.(*evmtypes.MsgEthereumTx)
if !isEthTx {
e.logger.Debugln("invalid transaction type", "type", fmt.Sprintf("%T", tx))
e.logger.Debug("invalid transaction type", "type", fmt.Sprintf("%T", tx))
return common.Hash{}, fmt.Errorf("invalid transaction type %T", tx)
}
if err := ethereumTx.ValidateBasic(); err != nil {
e.logger.WithError(err).Debugln("tx failed basic validation")
e.logger.Debug("tx failed basic validation", "error", err.Error())
return common.Hash{}, err
}
builder, ok := e.clientCtx.TxConfig.NewTxBuilder().(authtx.ExtensionOptionsTxBuilder)
if !ok {
e.logger.Panicln("clientCtx.TxConfig.NewTxBuilder returns unsupported builder")
e.logger.Error("clientCtx.TxConfig.NewTxBuilder returns unsupported builder")
}
option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{})
if err != nil {
e.logger.WithError(err).Panicln("codectypes.NewAnyWithValue failed to pack an obvious value")
e.logger.Error("codectypes.NewAnyWithValue failed to pack an obvious value", "error", err.Error())
}
builder.SetExtensionOptions(option)
err = builder.SetMsgs(tx.GetMsgs()...)
if err != nil {
e.logger.WithError(err).Panicln("builder.SetMsgs failed")
e.logger.Error("builder.SetMsgs failed", "error", err.Error())
}
// Query params to use the EVM denomination
res, err := e.queryClient.QueryClient.Params(e.ctx, &evmtypes.QueryParamsRequest{})
if err != nil {
e.logger.WithError(err).Errorln("failed to query evm params")
e.logger.Error("failed to query evm params", "error", err.Error())
return common.Hash{}, err
}
txData, err := evmtypes.UnpackTxData(ethereumTx.Data)
if err != nil {
e.logger.WithError(err).Errorln("failed to unpack tx data")
e.logger.Error("failed to unpack tx data", "error", err.Error())
return common.Hash{}, err
}
@ -497,7 +498,7 @@ func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error)
// Encode transaction by default Tx encoder
txBytes, err := e.clientCtx.TxConfig.TxEncoder()(builder.GetTx())
if err != nil {
e.logger.WithError(err).Errorln("failed to encode eth tx using default encoder")
e.logger.Error("failed to encode eth tx using default encoder", "error", err.Error())
return common.Hash{}, err
}
@ -509,7 +510,7 @@ func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error)
if err == nil {
err = errors.New(rsp.RawLog)
}
e.logger.WithError(err).Errorln("failed to broadcast tx")
e.logger.Error("failed to broadcast tx", "error", err.Error())
return txHash, err
}
@ -518,7 +519,7 @@ func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error)
// Call performs a raw contract call.
func (e *PublicAPI) Call(args evmtypes.CallArgs, blockNr rpctypes.BlockNumber, _ *rpctypes.StateOverride) (hexutil.Bytes, error) {
e.logger.Debugln("eth_call", "args", args.String(), "block number", blockNr)
e.logger.Debug("eth_call", "args", args.String(), "block number", blockNr)
data, err := e.doCall(args, blockNr)
if err != nil {
return []byte{}, err
@ -549,11 +550,9 @@ func (e *PublicAPI) doCall(
return res, nil
}
//EstimateGas returns an estimate of gas usage for the given smart contract call.
// It adds 1,000 gas to the returned value instead of using the gas adjustment
// param from the SDK.
// EstimateGas returns an estimate of gas usage for the given smart contract call.
func (e *PublicAPI) EstimateGas(args evmtypes.CallArgs) (hexutil.Uint64, error) {
e.logger.Debugln("eth_estimateGas")
e.logger.Debug("eth_estimateGas")
// From ContextWithHeight: if the provided height is 0,
// it will return an empty context and the gRPC query will use
@ -572,13 +571,13 @@ func (e *PublicAPI) EstimateGas(args evmtypes.CallArgs) (hexutil.Uint64, error)
// GetBlockByHash returns the block identified by hash.
func (e *PublicAPI) GetBlockByHash(hash common.Hash, fullTx bool) (map[string]interface{}, error) {
e.logger.Debugln("eth_getBlockByHash", "hash", hash.Hex(), "full", fullTx)
e.logger.Debug("eth_getBlockByHash", "hash", hash.Hex(), "full", fullTx)
return e.backend.GetBlockByHash(hash, fullTx)
}
// GetBlockByNumber returns the block identified by number.
func (e *PublicAPI) GetBlockByNumber(ethBlockNum rpctypes.BlockNumber, fullTx bool) (map[string]interface{}, error) {
e.logger.Debugln("eth_getBlockByNumber", "number", ethBlockNum, "full", fullTx)
e.logger.Debug("eth_getBlockByNumber", "number", ethBlockNum, "full", fullTx)
return e.backend.GetBlockByNumber(ethBlockNum, fullTx)
}
@ -599,11 +598,11 @@ func (e *PublicAPI) GetTxByEthHash(hash common.Hash) (*tmrpctypes.ResultTx, erro
// GetTransactionByHash returns the transaction identified by hash.
func (e *PublicAPI) GetTransactionByHash(hash common.Hash) (*rpctypes.RPCTransaction, error) {
e.logger.Debugln("eth_getTransactionByHash", "hash", hash.Hex())
e.logger.Debug("eth_getTransactionByHash", "hash", hash.Hex())
res, err := e.GetTxByEthHash(hash)
if err != nil {
e.logger.WithError(err).Debugln("tx not found", "hash", hash.Hex())
e.logger.Debug("tx not found", "hash", hash.Hex(), "error", err.Error())
// try to find tx in mempool
txs, err := e.backend.PendingTransactions()
@ -634,19 +633,19 @@ func (e *PublicAPI) GetTransactionByHash(hash common.Hash) (*rpctypes.RPCTransac
resBlock, err := e.clientCtx.Client.Block(e.ctx, &res.Height)
if err != nil {
e.logger.WithError(err).Debugln("block not found", "height", res.Height)
e.logger.Debug("block not found", "height", res.Height, "error", err.Error())
return nil, nil
}
tx, err := e.clientCtx.TxConfig.TxDecoder()(res.Tx)
if err != nil {
e.logger.WithError(err).Debugln("decoding failed")
e.logger.Debug("decoding failed", "error", err.Error())
return nil, fmt.Errorf("failed to decode tx: %w", err)
}
msg, err := evmtypes.UnwrapEthereumMsg(&tx)
if err != nil {
e.logger.WithError(err).Debugln("invalid tx")
e.logger.Debug("invalid tx", "error", err.Error())
return nil, err
}
@ -661,30 +660,30 @@ func (e *PublicAPI) GetTransactionByHash(hash common.Hash) (*rpctypes.RPCTransac
// GetTransactionByBlockHashAndIndex returns the transaction identified by hash and index.
func (e *PublicAPI) GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) (*rpctypes.RPCTransaction, error) {
e.logger.Debugln("eth_getTransactionByBlockHashAndIndex", "hash", hash.Hex(), "index", idx)
e.logger.Debug("eth_getTransactionByBlockHashAndIndex", "hash", hash.Hex(), "index", idx)
resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, hash.Bytes())
if err != nil {
e.logger.WithError(err).Debugln("block not found", "hash", hash.Hex())
e.logger.Debug("block not found", "hash", hash.Hex(), "error", err.Error())
return nil, nil
}
i := int(idx)
if i >= len(resBlock.Block.Txs) {
e.logger.Debugln("block txs index out of bound", "index", i)
e.logger.Debug("block txs index out of bound", "index", i)
return nil, nil
}
txBz := resBlock.Block.Txs[i]
tx, err := e.clientCtx.TxConfig.TxDecoder()(txBz)
if err != nil {
e.logger.WithError(err).Debugln("decoding failed")
e.logger.Debug("decoding failed", "error", err.Error())
return nil, fmt.Errorf("failed to decode tx: %w", err)
}
msg, err := evmtypes.UnwrapEthereumMsg(&tx)
if err != nil {
e.logger.WithError(err).Debugln("invalid tx")
e.logger.Debug("invalid tx", "error", err.Error())
return nil, err
}
@ -699,30 +698,30 @@ func (e *PublicAPI) GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexu
// GetTransactionByBlockNumberAndIndex returns the transaction identified by number and index.
func (e *PublicAPI) GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockNumber, idx hexutil.Uint) (*rpctypes.RPCTransaction, error) {
e.logger.Debugln("eth_getTransactionByBlockNumberAndIndex", "number", blockNum, "index", idx)
e.logger.Debug("eth_getTransactionByBlockNumberAndIndex", "number", blockNum, "index", idx)
resBlock, err := e.clientCtx.Client.Block(e.ctx, blockNum.TmHeight())
if err != nil {
e.logger.WithError(err).Debugln("block not found", "height", blockNum.Int64())
e.logger.Debug("block not found", "height", blockNum.Int64(), "error", err.Error())
return nil, nil
}
i := int(idx)
if i >= len(resBlock.Block.Txs) {
e.logger.Debugln("block txs index out of bound", "index", i)
e.logger.Debug("block txs index out of bound", "index", i)
return nil, nil
}
txBz := resBlock.Block.Txs[i]
tx, err := e.clientCtx.TxConfig.TxDecoder()(txBz)
if err != nil {
e.logger.WithError(err).Debugln("decoding failed")
e.logger.Debug("decoding failed", "error", err.Error())
return nil, fmt.Errorf("failed to decode tx: %w", err)
}
msg, err := evmtypes.UnwrapEthereumMsg(&tx)
if err != nil {
e.logger.WithError(err).Debugln("invalid tx")
e.logger.Debug("invalid tx", "error", err.Error())
return nil, err
}
@ -737,42 +736,42 @@ func (e *PublicAPI) GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockN
// GetTransactionReceipt returns the transaction receipt identified by hash.
func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interface{}, error) {
e.logger.Debugln("eth_getTransactionReceipt", "hash", hash.Hex())
e.logger.Debug("eth_getTransactionReceipt", "hash", hash.Hex())
res, err := e.GetTxByEthHash(hash)
if err != nil {
e.logger.WithError(err).Debugln("tx not found", "hash", hash.Hex())
e.logger.Debug("tx not found", "hash", hash.Hex(), "error", err.Error())
return nil, nil
}
resBlock, err := e.clientCtx.Client.Block(e.ctx, &res.Height)
if err != nil {
e.logger.WithError(err).Debugln("block not found", "height", res.Height)
e.logger.Debug("block not found", "height", res.Height, "error", err.Error())
return nil, nil
}
tx, err := e.clientCtx.TxConfig.TxDecoder()(res.Tx)
if err != nil {
e.logger.WithError(err).Debugln("decoding failed")
e.logger.Debug("decoding failed", "error", err.Error())
return nil, fmt.Errorf("failed to decode tx: %w", err)
}
msg, err := evmtypes.UnwrapEthereumMsg(&tx)
if err != nil {
e.logger.WithError(err).Debugln("invalid tx")
e.logger.Debug("invalid tx", "error", err.Error())
return nil, err
}
txData, err := evmtypes.UnpackTxData(msg.Data)
if err != nil {
e.logger.WithError(err).Errorln("failed to unpack tx data")
e.logger.Error("failed to unpack tx data", "error", err.Error())
return nil, err
}
cumulativeGasUsed := uint64(0)
blockRes, err := e.clientCtx.Client.BlockResults(e.ctx, &res.Height)
if err != nil {
e.logger.WithError(err).Debugln("failed to retrieve block results", "height", res.Height)
e.logger.Debug("failed to retrieve block results", "height", res.Height, "error", err.Error())
return nil, nil
}
@ -795,7 +794,7 @@ func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interfac
resLogs, err := e.queryClient.TxLogs(e.ctx, &evmtypes.QueryTxLogsRequest{Hash: hash.Hex()})
if err != nil {
e.logger.WithError(err).Debugln("logs not found", "hash", hash.Hex())
e.logger.Debug("logs not found", "hash", hash.Hex(), "error", err.Error())
resLogs = &evmtypes.QueryTxLogsResponse{Logs: []*evmtypes.Log{}}
}
@ -841,7 +840,7 @@ func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interfac
// PendingTransactions returns the transactions that are in the transaction pool
// and have a from address that is one of the accounts this node manages.
func (e *PublicAPI) PendingTransactions() ([]*rpctypes.RPCTransaction, error) {
e.logger.Debugln("eth_getPendingTransactions")
e.logger.Debug("eth_getPendingTransactions")
txs, err := e.backend.PendingTransactions()
if err != nil {
@ -886,7 +885,7 @@ func (e *PublicAPI) GetUncleByBlockNumberAndIndex(number hexutil.Uint, idx hexut
// GetProof returns an account object with proof and any storage proofs
func (e *PublicAPI) GetProof(address common.Address, storageKeys []string, blockNumber rpctypes.BlockNumber) (*rpctypes.AccountResult, error) {
height := blockNumber.Int64()
e.logger.Debugln("eth_getProof", "address", address.Hex(), "keys", storageKeys, "number", height)
e.logger.Debug("eth_getProof", "address", address.Hex(), "keys", storageKeys, "number", height)
ctx := rpctypes.ContextWithHeight(height)
clientCtx := e.clientCtx.WithHeight(height)
@ -1011,7 +1010,7 @@ func (e *PublicAPI) setTxDefaults(args rpctypes.SendTxArgs) (rpctypes.SendTxArgs
return args, err
}
args.Gas = &estimated
e.logger.Debugln("estimate gas usage automatically", "gas", args.Gas)
e.logger.Debug("estimate gas usage automatically", "gas", args.Gas)
}
if args.ChainID == nil {
@ -1046,7 +1045,7 @@ func (e *PublicAPI) getAccountNonce(accAddr common.Address, pending bool, height
// to manually add them.
pendingTxs, err := e.backend.PendingTransactions()
if err != nil {
logger.WithError(err).Errorln("fails to fetch pending transactions")
logger.Error("failed to fetch pending transactions", "error", err.Error())
return nonce, nil
}

47
ethereum/rpc/namespaces/eth/filters/api.go
View File

@ -8,7 +8,7 @@ import (
"github.com/tharsis/ethermint/ethereum/rpc/types"
log "github.com/xlab/suplog"
"github.com/tendermint/tendermint/libs/log"
coretypes "github.com/tendermint/tendermint/rpc/core/types"
rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
@ -51,6 +51,7 @@ type filter struct {
// PublicFilterAPI offers support to create and manage filters. This will allow external clients to retrieve various
// information related to the Ethereum protocol such as blocks, transactions and logs.
type PublicFilterAPI struct {
logger log.Logger
backend Backend
events *EventSystem
filtersMu sync.Mutex
@ -58,11 +59,13 @@ type PublicFilterAPI struct {
}
// NewPublicAPI returns a new PublicFilterAPI instance.
func NewPublicAPI(tmWSClient *rpcclient.WSClient, backend Backend) *PublicFilterAPI {
func NewPublicAPI(logger log.Logger, tmWSClient *rpcclient.WSClient, backend Backend) *PublicFilterAPI {
logger = logger.With("api", "filter")
api := &PublicFilterAPI{
logger: logger,
backend: backend,
filters: make(map[rpc.ID]*filter),
events: NewEventSystem(tmWSClient),
events: NewEventSystem(logger, tmWSClient),
}
go api.timeoutLoop()
@ -125,10 +128,7 @@ func (api *PublicFilterAPI) NewPendingTransactionFilter() rpc.ID {
data, ok := ev.Data.(tmtypes.EventDataTx)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataTx",
"actual": fmt.Sprintf("%T", ev.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
continue
}
@ -185,10 +185,7 @@ func (api *PublicFilterAPI) NewPendingTransactions(ctx context.Context) (*rpc.Su
data, ok := ev.Data.(tmtypes.EventDataTx)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataTx",
"actual": fmt.Sprintf("%T", ev.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
continue
}
@ -243,10 +240,7 @@ func (api *PublicFilterAPI) NewBlockFilter() rpc.ID {
data, ok := ev.Data.(tmtypes.EventDataNewBlockHeader)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataNewBlockHeader",
"actual": fmt.Sprintf("%T", ev.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
continue
}
@ -296,10 +290,7 @@ func (api *PublicFilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, er
data, ok := ev.Data.(tmtypes.EventDataNewBlockHeader)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataNewBlockHeader",
"actual": fmt.Sprintf("%T", ev.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
continue
}
@ -359,10 +350,7 @@ func (api *PublicFilterAPI) Logs(ctx context.Context, crit filters.FilterCriteri
// get transaction result data
dataTx, ok := ev.Data.(tmtypes.EventDataTx)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataTx",
"actual": fmt.Sprintf("%T", ev.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
continue
}
@ -436,10 +424,7 @@ func (api *PublicFilterAPI) NewFilter(criteria filters.FilterCriteria) (rpc.ID,
}
dataTx, ok := ev.Data.(tmtypes.EventDataTx)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataTx",
"actual": fmt.Sprintf("%T", ev.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
continue
}
@ -474,7 +459,7 @@ func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit filters.FilterCrit
var filter *Filter
if crit.BlockHash != nil {
// Block filter requested, construct a single-shot filter
filter = NewBlockFilter(api.backend, crit)
filter = NewBlockFilter(api.logger, api.backend, crit)
} else {
// Convert the RPC block numbers into internal representations
begin := rpc.LatestBlockNumber.Int64()
@ -486,7 +471,7 @@ func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit filters.FilterCrit
end = crit.ToBlock.Int64()
}
// Construct the range filter
filter = NewRangeFilter(api.backend, begin, end, crit.Addresses, crit.Topics)
filter = NewRangeFilter(api.logger, api.backend, begin, end, crit.Addresses, crit.Topics)
}
// Run the filter and return all the logs
@ -536,7 +521,7 @@ func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*et
var filter *Filter
if f.crit.BlockHash != nil {
// Block filter requested, construct a single-shot filter
filter = NewBlockFilter(api.backend, f.crit)
filter = NewBlockFilter(api.logger, api.backend, f.crit)
} else {
// Convert the RPC block numbers into internal representations
begin := rpc.LatestBlockNumber.Int64()
@ -548,7 +533,7 @@ func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*et
end = f.crit.ToBlock.Int64()
}
// Construct the range filter
filter = NewRangeFilter(api.backend, begin, end, f.crit.Addresses, f.crit.Topics)
filter = NewRangeFilter(api.logger, api.backend, begin, end, f.crit.Addresses, f.crit.Topics)
}
// Run the filter and return all the logs
logs, err := filter.Logs(ctx)

18
ethereum/rpc/namespaces/eth/filters/filter_system.go
View File

@ -7,9 +7,9 @@ import (
"time"
"github.com/pkg/errors"
log "github.com/xlab/suplog"
tmjson "github.com/tendermint/tendermint/libs/json"
"github.com/tendermint/tendermint/libs/log"
tmquery "github.com/tendermint/tendermint/libs/pubsub/query"
coretypes "github.com/tendermint/tendermint/rpc/core/types"
rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
@ -35,6 +35,7 @@ var (
// EventSystem creates subscriptions, processes events and broadcasts them to the
// subscription which match the subscription criteria using the Tendermint's RPC client.
type EventSystem struct {
logger log.Logger
ctx context.Context
tmWSClient *rpcclient.WSClient
@ -57,13 +58,14 @@ type EventSystem struct {
//
// The returned manager has a loop that needs to be stopped with the Stop function
// or by stopping the given mux.
func NewEventSystem(tmWSClient *rpcclient.WSClient) *EventSystem {
func NewEventSystem(logger log.Logger, tmWSClient *rpcclient.WSClient) *EventSystem {
index := make(filterIndex)
for i := filters.UnknownSubscription; i < filters.LastIndexSubscription; i++ {
index[i] = make(map[rpc.ID]*Subscription)
}
es := &EventSystem{
logger: logger,
ctx: context.Background(),
tmWSClient: tmWSClient,
lightMode: false,
@ -222,7 +224,7 @@ func (es *EventSystem) eventLoop() {
ch := make(chan coretypes.ResultEvent)
es.topicChans[f.event] = ch
if err := es.eventBus.AddTopic(f.event, ch); err != nil {
log.WithField("topic", f.event).WithError(err).Errorln("failed to add event topic to event bus")
es.logger.Error("failed to add event topic to event bus", "topic", f.event, "error", err.Error())
}
es.indexMux.Unlock()
close(f.installed)
@ -241,7 +243,7 @@ func (es *EventSystem) eventLoop() {
// remove topic only when channel is not used by other subscriptions
if !channelInUse {
if err := es.tmWSClient.Unsubscribe(es.ctx, f.event); err != nil {
log.WithError(err).WithField("query", f.event).Errorln("failed to unsubscribe from query")
es.logger.Error("failed to unsubscribe from query", "query", f.event, "error", err.Error())
}
ch, ok := es.topicChans[f.event]
@ -267,7 +269,7 @@ func (es *EventSystem) consumeEvents() {
time.Sleep(5 * time.Second)
continue
} else if err := tmjson.Unmarshal(rpcResp.Result, &ev); err != nil {
log.WithError(err).Warningln("failed to JSON unmarshal ResponsesCh result event")
es.logger.Error("failed to JSON unmarshal ResponsesCh result event", "error", err.Error())
continue
}
@ -280,8 +282,8 @@ func (es *EventSystem) consumeEvents() {
ch, ok := es.topicChans[ev.Query]
es.indexMux.RUnlock()
if !ok {
log.WithField("topic", ev.Query).Warningln("channel for subscription not found, lol")
log.Infoln("available channels:", es.eventBus.Topics())
es.logger.Debug("channel for subscription not found", "topic", ev.Query)
es.logger.Debug("list of available channels", "channels", es.eventBus.Topics())
continue
}
@ -289,7 +291,7 @@ func (es *EventSystem) consumeEvents() {
t := time.NewTimer(time.Second)
select {
case <-t.C:
log.WithField("topic", ev.Query).Warningln("dropped event during lagging subscription")
es.logger.Debug("dropped event during lagging subscription", "topic", ev.Query)
case ch <- ev:
}
}

69
ethereum/rpc/namespaces/eth/filters/filters.go
View File

@ -8,7 +8,7 @@ import (
"github.com/tharsis/ethermint/ethereum/rpc/types"
"github.com/pkg/errors"
log "github.com/xlab/suplog"
"github.com/tendermint/tendermint/libs/log"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/bloombits"
@ -18,6 +18,7 @@ import (
// Filter can be used to retrieve and filter logs.
type Filter struct {
logger log.Logger
backend Backend
criteria filters.FilterCriteria
matcher *bloombits.Matcher
@ -25,14 +26,14 @@ type Filter struct {
// NewBlockFilter creates a new filter which directly inspects the contents of
// a block to figure out whether it is interesting or not.
func NewBlockFilter(backend Backend, criteria filters.FilterCriteria) *Filter {
func NewBlockFilter(logger log.Logger, backend Backend, criteria filters.FilterCriteria) *Filter {
// Create a generic filter and convert it into a block filter
return newFilter(backend, criteria, nil)
return newFilter(logger, backend, criteria, nil)
}
// NewRangeFilter creates a new filter which uses a bloom filter on blocks to
// figure out whether a particular block is interesting or not.
func NewRangeFilter(backend Backend, begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter {
func NewRangeFilter(logger log.Logger, backend Backend, begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter {
// Flatten the address and topic filter clauses into a single bloombits filter
// system. Since the bloombits are not positional, nil topics are permitted,
// which get flattened into a nil byte slice.
@ -63,12 +64,13 @@ func NewRangeFilter(backend Backend, begin, end int64, addresses []common.Addres
Topics: topics,
}
return newFilter(backend, criteria, bloombits.NewMatcher(size, filtersBz))
return newFilter(logger, backend, criteria, bloombits.NewMatcher(size, filtersBz))
}
// newFilter returns a new Filter
func newFilter(backend Backend, criteria filters.FilterCriteria, matcher *bloombits.Matcher) *Filter {
func newFilter(logger log.Logger, backend Backend, criteria filters.FilterCriteria, matcher *bloombits.Matcher) *Filter {
return &Filter{
logger: logger,
backend: backend,
criteria: criteria,
matcher: matcher,
@ -90,13 +92,11 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) {
if f.criteria.BlockHash != nil && *f.criteria.BlockHash != (common.Hash{}) {
header, err := f.backend.HeaderByHash(*f.criteria.BlockHash)
if err != nil {
err = errors.Wrap(err, "failed to fetch header by hash")
return nil, err
return nil, errors.Wrap(err, "failed to fetch header by hash")
}
if header == nil {
err := errors.Errorf("unknown block header %s", f.criteria.BlockHash.String())
return nil, err
return nil, errors.Errorf("unknown block header %s", f.criteria.BlockHash.String())
}
return f.blockLogs(header)
@ -105,12 +105,11 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) {
// Figure out the limits of the filter range
header, err := f.backend.HeaderByNumber(types.EthLatestBlockNumber)
if err != nil {
err = errors.Wrap(err, "failed to fetch header by number (latest)")
return nil, err
return nil, errors.Wrap(err, "failed to fetch header by number (latest)")
}
if header == nil || header.Number == nil {
log.Warningln("header not found or has no number")
f.logger.Debug("header not found or has no number")
return nil, nil
}
@ -123,8 +122,7 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) {
}
if f.criteria.ToBlock.Int64()-f.criteria.FromBlock.Int64() > maxFilterBlocks {
err := errors.Errorf("maximum [from, to] blocks distance: %d", maxFilterBlocks)
return nil, err
return nil, errors.Errorf("maximum [from, to] blocks distance: %d", maxFilterBlocks)
}
// check bounds
@ -137,9 +135,10 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) {
for i := f.criteria.FromBlock.Int64(); i <= f.criteria.ToBlock.Int64(); i++ {
block, err := f.backend.GetBlockByNumber(types.BlockNumber(i), false)
if err != nil {
err = errors.Wrapf(err, "failed to fetch block by number %d", i)
return logs, err
} else if block["transactions"] == nil {
return logs, errors.Wrapf(err, "failed to fetch block by number %d", i)
}
if block["transactions"] == nil {
continue
}
@ -147,28 +146,32 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) {
txs, ok := block["transactions"].([]interface{})
if !ok {
txHashes, ok = block["transactions"].([]common.Hash)
_, ok = block["transactions"].([]common.Hash)
if !ok {
log.WithField(
"transactions",
fmt.Sprintf("%T", block["transactions"]),
).Errorln("reading transactions from block data: bad field type")
continue
f.logger.Error(
"reading transactions from block data failed",
"type", fmt.Sprintf("%T", block["transactions"]),
)
}
} else if len(txs) == 0 && len(txHashes) == 0 {
continue
}
if len(txs) == 0 {
continue
}
for _, tx := range txs {
txHash, ok := tx.(common.Hash)
if !ok {
log.WithField(
"tx",
fmt.Sprintf("%T", tx),
).Errorln("transactions list contains non-hash element")
} else {
txHashes = append(txHashes, txHash)
f.logger.Error(
"transactions list contains non-hash element",
"type", fmt.Sprintf("%T", tx),
)
continue
}
txHashes = append(txHashes, txHash)
}
logsMatched := f.checkMatches(txHashes)
@ -188,9 +191,7 @@ func (f *Filter) blockLogs(header *ethtypes.Header) ([]*ethtypes.Log, error) {
// eth header's hash doesn't match tm block hash
logsList, err := f.backend.GetLogsByNumber(types.BlockNumber(header.Number.Int64()))
if err != nil {
err = errors.Wrapf(err, "failed to fetch logs block number %d", header.Number.Int64())
return []*ethtypes.Log{}, err
return []*ethtypes.Log{}, errors.Wrapf(err, "failed to fetch logs block number %d", header.Number.Int64())
}
var unfiltered []*ethtypes.Log // nolint: prealloc

18
ethereum/rpc/namespaces/personal/api.go
View File

@ -9,7 +9,7 @@ import (
"github.com/tharsis/ethermint/crypto/hd"
ethermint "github.com/tharsis/ethermint/types"
log "github.com/xlab/suplog"
"github.com/tendermint/tendermint/libs/log"
sdkcrypto "github.com/cosmos/cosmos-sdk/crypto"
"github.com/cosmos/cosmos-sdk/crypto/keyring"
@ -32,10 +32,10 @@ type PrivateAccountAPI struct {
}
// NewAPI creates an instance of the public Personal Eth API.
func NewAPI(ethAPI *eth.PublicAPI) *PrivateAccountAPI {
func NewAPI(logger log.Logger, ethAPI *eth.PublicAPI) *PrivateAccountAPI {
return &PrivateAccountAPI{
ethAPI: ethAPI,
logger: log.WithField("module", "personal"),
logger: logger.With("api", "personal"),
}
}
@ -96,7 +96,7 @@ func (api *PrivateAccountAPI) ListAccounts() ([]common.Address, error) {
// LockAccount will lock the account associated with the given address when it's unlocked.
// It removes the key corresponding to the given address from the API's local keys.
func (api *PrivateAccountAPI) LockAccount(address common.Address) bool { // nolint: interfacer
api.logger.Debugln("personal_lockAccount", "address", address.String())
api.logger.Debug("personal_lockAccount", "address", address.String())
api.logger.Info("personal_lockAccount not supported")
// TODO: Not supported. See underlying issue https://github.com/99designs/keyring/issues/85
return false
@ -115,9 +115,9 @@ func (api *PrivateAccountAPI) NewAccount(password string) (common.Address, error
}
addr := common.BytesToAddress(info.GetPubKey().Address().Bytes())
api.logger.Infoln("Your new key was generated", "address", addr.String())
api.logger.Infoln("Please backup your key file!", "path", os.Getenv("HOME")+"/.ethermint/"+name)
api.logger.Infoln("Please remember your password!")
api.logger.Info("Your new key was generated", "address", addr.String())
api.logger.Info("Please backup your key file!", "path", os.Getenv("HOME")+"/.ethermint/"+name)
api.logger.Info("Please remember your password!")
return addr, nil
}
@ -125,7 +125,7 @@ func (api *PrivateAccountAPI) NewAccount(password string) (common.Address, error
// the given password for duration seconds. If duration is nil it will use a
// default of 300 seconds. It returns an indication if the account was unlocked.
func (api *PrivateAccountAPI) UnlockAccount(_ context.Context, addr common.Address, _ string, _ *uint64) (bool, error) { // nolint: interfacer
api.logger.Debugln("personal_unlockAccount", "address", addr.String())
api.logger.Debug("personal_unlockAccount", "address", addr.String())
// TODO: Not supported. See underlying issue https://github.com/99designs/keyring/issues/85
return false, nil
}
@ -154,7 +154,7 @@ func (api *PrivateAccountAPI) Sign(_ context.Context, data hexutil.Bytes, addr c
sig, _, err := api.ethAPI.ClientCtx().Keyring.SignByAddress(cosmosAddr, accounts.TextHash(data))
if err != nil {
api.logger.WithError(err).Debugln("failed to sign with key", "data", data, "address", addr.String())
api.logger.Error("failed to sign with key", "data", data, "address", addr.String(), "error", err.Error())
return nil, err
}

8
ethereum/rpc/namespaces/txpool/api.go
View File

@ -1,9 +1,11 @@
package txpool
import (
"github.com/tendermint/tendermint/libs/log"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/tharsis/ethermint/ethereum/rpc/types"
log "github.com/xlab/suplog"
)
// PublicAPI offers and API for the transaction pool. It only operates on data that is non-confidential.
@ -13,9 +15,9 @@ type PublicAPI struct {
}
// NewPublicAPI creates a new tx pool service that gives information about the transaction pool.
func NewPublicAPI() *PublicAPI {
func NewPublicAPI(logger log.Logger) *PublicAPI {
return &PublicAPI{
logger: log.WithField("module", "txpool"),
logger: logger.With("module", "txpool"),
}
}

101
ethereum/rpc/websockets.go
View File

@ -9,22 +9,20 @@ import (
"net/http"
"sync"
"github.com/ethereum/go-ethereum/eth/filters"
rpcfilters "github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth/filters"
"github.com/gorilla/mux"
"github.com/gorilla/websocket"
"github.com/pkg/errors"
log "github.com/xlab/suplog"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/eth/filters"
"github.com/ethereum/go-ethereum/rpc"
"github.com/tendermint/tendermint/libs/log"
coretypes "github.com/tendermint/tendermint/rpc/core/types"
rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
tmtypes "github.com/tendermint/tendermint/types"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rpc"
rpcfilters "github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth/filters"
"github.com/tharsis/ethermint/ethereum/rpc/types"
evmtypes "github.com/tharsis/ethermint/x/evm/types"
)
@ -68,12 +66,13 @@ type websocketsServer struct {
logger log.Logger
}
func NewWebsocketsServer(tmWSClient *rpcclient.WSClient, rpcAddr, wsAddr string) WebsocketsServer {
func NewWebsocketsServer(logger log.Logger, tmWSClient *rpcclient.WSClient, rpcAddr, wsAddr string) WebsocketsServer {
logger = logger.With("module", "websocket-server")
return &websocketsServer{
rpcAddr: rpcAddr,
wsAddr: wsAddr,
api: newPubSubAPI(tmWSClient),
logger: log.WithField("module", "websocket-server"),
api: newPubSubAPI(logger, tmWSClient),
logger: logger,
}
}
@ -88,7 +87,7 @@ func (s *websocketsServer) Start() {
return
}
s.logger.WithError(err).Errorln("failed to start HTTP server for WS")
s.logger.Error("failed to start HTTP server for WS", "error", err.Error())
}
}()
}
@ -102,7 +101,7 @@ func (s *websocketsServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
s.logger.WithError(err).Warningln("websocket upgrade failed")
s.logger.Debug("websocket upgrade failed", "error", err.Error())
return
}
@ -280,12 +279,13 @@ type pubSubAPI struct {
}
// newPubSubAPI creates an instance of the ethereum PubSub API.
func newPubSubAPI(tmWSClient *rpcclient.WSClient) *pubSubAPI {
func newPubSubAPI(logger log.Logger, tmWSClient *rpcclient.WSClient) *pubSubAPI {
logger = logger.With("module", "websocket-client")
return &pubSubAPI{
events: rpcfilters.NewEventSystem(tmWSClient),
events: rpcfilters.NewEventSystem(logger, tmWSClient),
filtersMu: new(sync.RWMutex),
filters: make(map[rpc.ID]*wsSubscription),
logger: log.WithField("module", "websocket-client"),
logger: logger,
}
}
@ -358,10 +358,7 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) {
data, ok := event.Data.(tmtypes.EventDataNewBlockHeader)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataNewBlockHeader",
"actual": fmt.Sprintf("%T", event.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", event.Data))
continue
}
@ -386,7 +383,7 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) {
err = wsSub.wsConn.WriteJSON(res)
if err != nil {
api.logger.WithError(err).Error("error writing header, will drop peer")
api.logger.Error("error writing header, will drop peer", "error", err.Error())
try(func() {
api.filtersMu.RUnlock()
@ -411,7 +408,7 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) {
api.unsubscribe(subID)
return
}
log.WithError(err).Debugln("dropping NewHeads WebSocket subscription", subID)
api.logger.Debug("dropping NewHeads WebSocket subscription", "subscription-id", subID, "error", err.Error())
api.unsubscribe(subID)
case <-unsubscribed:
return
@ -423,20 +420,15 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) {
}
func try(fn func(), l log.Logger, desc string) {
if l == nil {
l = log.DefaultLogger
}
defer func() {
if x := recover(); x != nil {
if err, ok := x.(error); ok {
// debug.PrintStack()
l.WithError(err).Debugln("panic during", desc)
l.Debug("panic during "+desc, "error", err.Error())
return
}
// debug.PrintStack()
l.Debugf("panic during %s: %+v", desc, x)
l.Debug(fmt.Sprintf("panic during %s: %+v", desc, x))
return
}
}()
@ -451,9 +443,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
params, ok := extra.(map[string]interface{})
if !ok {
err := errors.New("invalid criteria")
log.WithFields(log.Fields{
"criteria": fmt.Sprintf("expected: map[string]interface{}, got %T", extra),
}).Errorln(err)
api.logger.Debug("invalid criteria", "type", fmt.Sprintf("%T", extra))
return "", err
}
@ -461,12 +451,8 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
address, ok := params["address"].(string)
addresses, sok := params["address"].([]interface{})
if !ok && !sok {
err := errors.New("invalid address; must be address or array of addresses")
log.WithFields(log.Fields{
"address": ok,
"addresses": sok,
"type": fmt.Sprintf("%T", params["address"]),
}).Errorln(err)
err := errors.New("invalid addresses; must be address or array of addresses")
api.logger.Debug("invalid addresses", "type", fmt.Sprintf("%T", params["address"]))
return "", err
}
@ -480,7 +466,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
address, ok := addr.(string)
if !ok {
err := errors.New("invalid address")
log.WithField("type", fmt.Sprintf("%T", addr)).Errorln(err)
api.logger.Debug("invalid address", "type", fmt.Sprintf("%T", addr))
return "", err
}
@ -492,12 +478,8 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
if params["topics"] != nil {
topics, ok := params["topics"].([]interface{})
if !ok {
err := errors.New("invalid topics")
log.WithFields(log.Fields{
"type": fmt.Sprintf("expected []interface{}, got %T", params["topics"]),
}).Errorln(err)
err := errors.Errorf("invalid topics: %s", topics)
api.logger.Error("invalid topics", "type", fmt.Sprintf("%T", topics))
return "", err
}
@ -507,7 +489,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
tstr, ok := topic.(string)
if !ok {
err := errors.Errorf("invalid topic: %s", topic)
log.WithField("type", fmt.Sprintf("expected string, got %T", topic)).Errorln(err)
api.logger.Error("invalid topic", "type", fmt.Sprintf("%T", topic))
return err
}
@ -533,11 +515,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
subtopicsList, ok := subtopics.([]interface{})
if !ok {
err := errors.New("invalid subtopics")
log.WithFields(log.Fields{
"type": fmt.Sprintf("expected []interface{}, got %T", subtopics),
}).Errorln(err)
api.logger.Error("invalid subtopic", "type", fmt.Sprintf("%T", subtopics))
return "", err
}
@ -546,7 +524,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
tstr, ok := subtopic.(string)
if !ok {
err := errors.Errorf("invalid subtopic: %s", subtopic)
log.WithField("type", fmt.Sprintf("expected string, got %T", subtopic)).Errorln(err)
api.logger.Error("invalid subtopic", "type", fmt.Sprintf("%T", subtopic))
return "", err
}
@ -560,7 +538,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
critBz, err := json.Marshal(crit)
if err != nil {
log.WithError(err).Errorln("failed to JSON marshal criteria")
api.logger.Error("failed to JSON marshal criteria", "error", err.Error())
return rpc.ID(""), err
}
@ -569,7 +547,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
sub, _, err := api.events.SubscribeLogs(crit)
if err != nil {
log.WithError(err).Errorln("failed to subscribe logs")
api.logger.Error("failed to subscribe logs", "error", err.Error())
return rpc.ID(""), err
}
@ -594,16 +572,13 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
dataTx, ok := event.Data.(tmtypes.EventDataTx)
if !ok {
log.WithFields(log.Fields{
"expected": "tmtypes.EventDataTx",
"actual": fmt.Sprintf("%T", event.Data),
}).Warningln("event Data type mismatch")
api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", event.Data))
continue
}
txResponse, err := evmtypes.DecodeTxResponse(dataTx.TxResult.Result.Data)
if err != nil {
log.WithError(err).Errorln("failed to decode tx response")
api.logger.Error("failed to decode tx response", "error", err.Error())
return
}
@ -615,7 +590,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
api.filtersMu.RLock()
wsSub, ok := api.filters[subID]
if !ok {
log.Warningln("subID not in filters", subID)
api.logger.Debug("subID not in filters", subID)
return
}
api.filtersMu.RUnlock()
@ -650,7 +625,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID,
api.unsubscribe(subID)
return
}
log.WithError(err).Warningln("dropping Logs WebSocket subscription", subID)
api.logger.Debug("dropping Logs WebSocket subscription", "subscription-id", subID, "error", err.Error())
api.unsubscribe(subID)
case <-unsubscribed:
return
@ -706,7 +681,7 @@ func (api *pubSubAPI) subscribePendingTransactions(wsConn *wsConn) (rpc.ID, erro
err = wsSub.wsConn.WriteJSON(res)
if err != nil {
api.logger.WithError(err).Warningln("error writing header, will drop peer")
api.logger.Debug("error writing header, will drop peer", "error", err.Error())
try(func() {
api.filtersMu.Lock()
@ -727,7 +702,7 @@ func (api *pubSubAPI) subscribePendingTransactions(wsConn *wsConn) (rpc.ID, erro
api.unsubscribe(subID)
return
}
log.WithError(err).Warningln("dropping PendingTransactions WebSocket subscription", subID)
api.logger.Debug("dropping PendingTransactions WebSocket subscription", subID, "error", err.Error())
api.unsubscribe(subID)
case <-unsubscribed:
return

51
server/start.go
View File

@ -15,7 +15,6 @@ import (
"github.com/rs/cors"
"github.com/spf13/cobra"
"github.com/xlab/closer"
log "github.com/xlab/suplog"
"google.golang.org/grpc"
tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
@ -168,17 +167,18 @@ which accepts a path for the resulting pprof file.
func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator types.AppCreator) error {
cfg := ctx.Config
home := cfg.RootDir
logger := ctx.Logger
traceWriterFile := ctx.Viper.GetString(flagTraceStore)
db, err := openDB(home)
if err != nil {
log.WithError(err).Errorln("failed to open DB")
logger.Error("failed to open DB", "error", err.Error())
return err
}
traceWriter, err := openTraceWriter(traceWriterFile)
if err != nil {
log.WithError(err).Errorln("failed to open trace writer")
logger.Error("failed to open trace writer", "error", err.Error())
return err
}
@ -186,7 +186,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile())
if err != nil {
log.WithError(err).Errorln("failed load or gen node key")
logger.Error("failed load or gen node key", "error", err.Error())
return err
}
@ -202,12 +202,12 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
ctx.Logger.With("module", "node"),
)
if err != nil {
log.WithError(err).Errorln("failed init node")
logger.Error("failed init node", "error", err.Error())
return err
}
if err := tmNode.Start(); err != nil {
log.WithError(err).Errorln("failed start tendermint server")
logger.Error("failed start tendermint server", "error", err.Error())
return err
}
@ -228,7 +228,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
if config.GRPC.Enable {
grpcSrv, err = servergrpc.StartGRPCServer(clientCtx, app, config.GRPC.Address)
if err != nil {
log.WithError(err).Errorln("failed to boot GRPC server")
logger.Error("failed to boot GRPC server", "error", err.Error())
return err
}
}
@ -241,18 +241,19 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
if config.EVMRPC.Enable {
tmEndpoint := "/websocket"
tmRPCAddr := cfg.RPC.ListenAddress
log.Infoln("EVM RPC Connecting to Tendermint WebSocket at", tmRPCAddr+tmEndpoint)
logger.Info("EVM RPC Connecting to Tendermint WebSocket at", tmRPCAddr+tmEndpoint)
tmWsClient := ConnectTmWS(tmRPCAddr, tmEndpoint)
rpcServer := ethrpc.NewServer()
apis := rpc.GetRPCAPIs(clientCtx, tmWsClient)
apis := rpc.GetRPCAPIs(ctx, clientCtx, tmWsClient)
for _, api := range apis {
if err := rpcServer.RegisterName(api.Namespace, api.Service); err != nil {
log.WithFields(log.Fields{
"namespace": api.Namespace,
"service": api.Service,
}).WithError(err).Fatalln("failed to register service in EVM RPC namespace")
logger.Error(
"failed to register service in EVM RPC namespace",
"namespace", api.Namespace,
"service", api.Service,
)
return err
}
}
@ -286,31 +287,31 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
errCh := make(chan error)
go func() {
log.Infoln("Starting EVM RPC server on", config.EVMRPC.RPCAddress)
logger.Info("Starting EVM RPC server", "address", config.EVMRPC.RPCAddress)
if err := httpSrv.ListenAndServe(); err != nil {
if err == http.ErrServerClosed {
close(httpSrvDone)
return
}
log.WithError(err).Errorln("failed to start EVM RPC server")
logger.Error("failed to start EVM RPC server", "error", err.Error())
errCh <- err
}
}()
select {
case err := <-errCh:
log.WithError(err).Errorln("failed to boot EVM RPC server")
logger.Error("failed to boot EVM RPC server", "error", err.Error())
return err
case <-time.After(1 * time.Second): // assume EVM RPC server started successfully
}
log.Infoln("Starting EVM WebSocket server on", config.EVMRPC.WsAddress)
logger.Info("Starting EVM WebSocket server", "address", config.EVMRPC.WsAddress)
_, port, _ := net.SplitHostPort(config.EVMRPC.RPCAddress)
// allocate separate WS connection to Tendermint
tmWsClient = ConnectTmWS(tmRPCAddr, tmEndpoint)
wsSrv = rpc.NewWebsocketsServer(tmWsClient, "localhost:"+port, config.EVMRPC.WsAddress)
wsSrv = rpc.NewWebsocketsServer(logger, tmWsClient, "localhost:"+port, config.EVMRPC.WsAddress)
go wsSrv.Start()
}
@ -329,7 +330,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
select {
case err := <-errCh:
log.WithError(err).Errorln("failed to boot API server")
logger.Error("failed to boot API server", "error", err.Error())
return err
case <-time.After(5 * time.Second): // assume server started successfully
}
@ -340,17 +341,17 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
if cpuProfile := ctx.Viper.GetString(flagCPUProfile); cpuProfile != "" {
f, err := os.Create(cpuProfile)
if err != nil {
log.WithError(err).Errorln("failed to create CP profile")
logger.Error("failed to create CP profile", "error", err.Error())
return err
}
log.WithField("profile", cpuProfile).Infoln("starting CPU profiler")
logger.Info("starting CPU profiler", "profile", cpuProfile)
if err := pprof.StartCPUProfile(f); err != nil {
return err
}
cpuProfileCleanup = func() {
log.WithField("profile", cpuProfile).Infoln("stopping CPU profiler")
logger.Info("stopping CPU profiler", "profile", cpuProfile)
pprof.StopCPUProfile()
f.Close()
}
@ -370,9 +371,9 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
defer cancelFn()
if err := httpSrv.Shutdown(shutdownCtx); err != nil {
log.WithError(err).Warningln("HTTP server shutdown produced a warning")
logger.Error("HTTP server shutdown produced a warning", "error", err.Error())
} else {
log.Infoln("HTTP server shut down, waiting 5 sec")
logger.Info("HTTP server shut down, waiting 5 sec")
select {
case <-time.Tick(5 * time.Second):
case <-httpSrvDone:
@ -384,7 +385,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
grpcSrv.Stop()
}
log.Infoln("Bye!")
logger.Info("Bye!")
})
closer.Hold()

2
tests/solidity/init-test-node.sh
View File

@ -40,4 +40,4 @@ ethermintd collect-gentxs
ethermintd validate-genesis
# Start the node (remove the --pruning=nothing flag if historical queries are not needed)
ethermintd start --pruning=nothing --rpc.unsafe --keyring-backend test --trace --log_level "info"
ethermintd start --pruning=nothing --rpc.unsafe --keyring-backend test --trace --log_level info

2
testutil/network/util.go
View File

@ -121,7 +121,7 @@ func startInProcess(cfg Config, val *Validator) error {
val.jsonRPC = jsonrpc.NewServer()
apis := rpc.GetRPCAPIs(val.ClientCtx, tmWsClient)
apis := rpc.GetRPCAPIs(val.Ctx, val.ClientCtx, tmWsClient)
for _, api := range apis {
if err := val.jsonRPC.RegisterName(api.Namespace, api.Service); err != nil {
return fmt.Errorf("failed to register JSON-RPC namespace %s: %w", api.Namespace, err)