Miner namespace

ethereum/rpc/apis.go

@@ -10,6 +10,7 @@ import (
 	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/debug"
 	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth"
 	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth/filters"
+	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/miner"
 	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/net"
 	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/personal"
 	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/txpool"
@@ -27,6 +28,7 @@ const (
 	NetNamespace      = "net"
 	TxPoolNamespace   = "txpool"
 	DebugNamespace    = "debug"
+	MinerNamespace    = "miner"
 
 	apiVersion = "1.0"
 )
@@ -104,6 +106,15 @@ func GetRPCAPIs(ctx *server.Context, clientCtx client.Context, tmWSClient *rpccl
 					Public:    true,
 				},
 			)
+		case MinerNamespace:
+			apis = append(apis,
+				rpc.API{
+					Namespace: MinerNamespace,
+					Version:   apiVersion,
+					Service:   miner.NewMinerAPI(ctx, ethAPI),
+					Public:    true,
+				},
+			)
 		default:
 			ctx.Logger.Error("invalid namespace value", "namespace", selectedAPIs[index])
 		}

ethereum/rpc/namespaces/eth/api.go

@@ -95,6 +95,14 @@ func (e *PublicAPI) ClientCtx() client.Context {
 	return e.clientCtx
 }
 
+func (e *PublicAPI) QueryClient() *rpctypes.QueryClient {
+	return e.queryClient
+}
+
+func (e *PublicAPI) Ctx() context.Context {
+	return e.ctx
+}
+
 // ProtocolVersion returns the supported Ethereum protocol version.
 func (e *PublicAPI) ProtocolVersion() hexutil.Uint {
 	e.logger.Debug("eth_protocolVersion")
@@ -370,7 +378,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro
 		return common.Hash{}, fmt.Errorf("%s; %s", keystore.ErrNoMatch, err.Error())
 	}
 
-	args, err = e.setTxDefaults(args)
+	args, err = e.SetTxDefaults(args)
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -994,9 +1002,9 @@ func (e *PublicAPI) GetProof(address common.Address, storageKeys []string, block
 	}, nil
 }
 
-// setTxDefaults populates tx message with default values in case they are not
+// SetTxDefaults populates tx message with default values in case they are not
 // provided on the args
-func (e *PublicAPI) setTxDefaults(args rpctypes.SendTxArgs) (rpctypes.SendTxArgs, error) {
+func (e *PublicAPI) SetTxDefaults(args rpctypes.SendTxArgs) (rpctypes.SendTxArgs, error) {
 
 	if args.GasPrice == nil {
 		// TODO: Change to either:

ethereum/rpc/namespaces/miner/api.go

@@ -0,0 +1,163 @@
+package miner
+
+import (
+	"errors"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/server"
+	"github.com/cosmos/cosmos-sdk/server/config"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth"
+	rpctypes "github.com/tharsis/ethermint/ethereum/rpc/types"
+	evmtypes "github.com/tharsis/ethermint/x/evm/types"
+)
+
+// API is the miner prefixed set of APIs in the Miner JSON-RPC spec.
+type API struct {
+	ctx    *server.Context
+	logger log.Logger
+	ethAPI *eth.PublicAPI
+}
+
+// NewMinerAPI creates an instance of the Miner API.
+func NewMinerAPI(
+	ctx *server.Context,
+	ethAPI *eth.PublicAPI,
+) *API {
+	return &API{
+		ctx:    ctx,
+		ethAPI: ethAPI,
+		logger: ctx.Logger.With("module", "miner"),
+	}
+}
+
+// SetEtherbase sets the etherbase of the miner
+func (api *API) SetEtherbase(etherbase common.Address) bool {
+	api.logger.Debug("miner_setEtherbase")
+
+	list, err := api.ethAPI.ClientCtx().Keyring.List()
+	if err != nil || len(list) < 1 {
+		api.logger.Debug("Could not get list of addresses")
+		return false
+	}
+
+	addr := common.BytesToAddress(list[0].GetPubKey().Address())
+
+	api.logger.Info(addr.String())
+
+	args := rpctypes.SendTxArgs{}
+	args.From = addr
+	// TODO: set this as the message info
+	// delegatorAddress := addr
+	// withdrawAddress := etherbase
+	args.Data = &hexutil.Bytes{}
+	args, err = api.ethAPI.SetTxDefaults(args)
+	if err != nil {
+		api.logger.Debug("Unable to parse transaction args", "error", err.Error())
+		return false
+	}
+
+	msg := args.ToTransaction()
+
+	if err := msg.ValidateBasic(); err != nil {
+		api.logger.Debug("tx failed basic validation", "error", err.Error())
+		return false
+	}
+
+	signer := ethtypes.LatestSignerForChainID(args.ChainID.ToInt())
+
+	// Sign transaction
+	if err := msg.Sign(signer, api.ethAPI.ClientCtx().Keyring); err != nil {
+		api.logger.Debug("failed to sign tx", "error", err.Error())
+		return false
+	}
+
+	// Assemble transaction from fields
+	builder, ok := api.ethAPI.ClientCtx().TxConfig.NewTxBuilder().(authtx.ExtensionOptionsTxBuilder)
+	if !ok {
+		api.logger.Error("clientCtx.TxConfig.NewTxBuilder returns unsupported builder", "error", err.Error())
+	}
+
+	option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{})
+	if err != nil {
+		api.logger.Error("codectypes.NewAnyWithValue failed to pack an obvious value", "error", err.Error())
+		return false
+	}
+
+	builder.SetExtensionOptions(option)
+	err = builder.SetMsgs(msg)
+	if err != nil {
+		api.logger.Error("builder.SetMsgs failed", "error", err.Error())
+	}
+
+	// Query params to use the EVM denomination
+	res, err := api.ethAPI.QueryClient().QueryClient.Params(api.ethAPI.Ctx(), &evmtypes.QueryParamsRequest{})
+	if err != nil {
+		api.logger.Error("failed to query evm params", "error", err.Error())
+		return false
+	}
+
+	txData, err := evmtypes.UnpackTxData(msg.Data)
+	if err != nil {
+		api.logger.Error("failed to unpack tx data", "error", err.Error())
+		return false
+	}
+
+	fees := sdk.Coins{sdk.NewCoin(res.Params.EvmDenom, sdk.NewIntFromBigInt(txData.Fee()))}
+	builder.SetFeeAmount(fees)
+	builder.SetGasLimit(msg.GetGas())
+
+	// Encode transaction by default Tx encoder
+	txEncoder := api.ethAPI.ClientCtx().TxConfig.TxEncoder()
+	txBytes, err := txEncoder(builder.GetTx())
+	if err != nil {
+		api.logger.Error("failed to encode eth tx using default encoder", "error", err.Error())
+		return false
+	}
+
+	txHash := msg.AsTransaction().Hash()
+
+	// Broadcast transaction in sync mode (default)
+	// NOTE: If error is encountered on the node, the broadcast will not return an error
+	syncCtx := api.ethAPI.ClientCtx().WithBroadcastMode(flags.BroadcastSync)
+	rsp, err := syncCtx.BroadcastTx(txBytes)
+	if err != nil || rsp.Code != 0 {
+		if err == nil {
+			err = errors.New(rsp.RawLog)
+		}
+		api.logger.Error("failed to broadcast tx", "error", err.Error())
+		return false
+	}
+
+	api.logger.Info("Broadcasting tx...", "hash", txHash)
+	return true
+}
+
+// SetGasPrice sets the minimum accepted gas price for the miner.
+func (api *API) SetGasPrice(gasPrice hexutil.Big) bool {
+	api.logger.Info(api.ctx.Viper.ConfigFileUsed())
+	appConf, err := config.ParseConfig(api.ctx.Viper)
+	if err != nil {
+		api.logger.Error("failed to parse file.", "file", api.ctx.Viper.ConfigFileUsed(), "error:", err.Error())
+		return false
+	}
+	// NOTE: To allow values less that 1 aphoton, we need to divide the gasPrice here using some constant
+	// If we want to work the same as go-eth we should just use the gasPrice as an int without converting it
+	coinsValue := gasPrice.ToInt().String()
+	unit := "aphoton"
+	c, err := sdk.ParseDecCoins(coinsValue + unit)
+	if err != nil {
+		api.logger.Error("failed to parse coins", "coins", coinsValue, "error", err.Error())
+		return false
+	}
+	appConf.SetMinGasPrices(c)
+	config.WriteConfigFile(api.ctx.Viper.ConfigFileUsed(), appConf)
+	api.logger.Info("Your configuration file was modified. Please RESTART your node.", "value", coinsValue+unit)
+	return true
+}

ethereum/rpc/namespaces/miner/unsupported.go

@@ -0,0 +1,51 @@
+package miner
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// GetHashrate returns the current hashrate for local CPU miner and remote miner.
+// Unsupported in Ethermint
+func (api *API) GetHashrate() uint64 {
+	api.logger.Debug("miner_getHashrate")
+	api.logger.Info("Unsupported rpc function: miner_getHashrate")
+	return 0
+}
+
+// SetExtra sets the extra data string that is included when this miner mines a block.
+// Unsupported in Ethermint
+func (api *API) SetExtra(extra string) (bool, error) {
+	api.logger.Debug("miner_setExtra")
+	api.logger.Info("Unsupported rpc function: miner_setExtra")
+	return false, errors.New("unsupported rpc function: miner_setExtra")
+}
+
+// SetGasLimit sets the gaslimit to target towards during mining.
+// Unsupported in Ethermint
+func (api *API) SetGasLimit(gasLimit hexutil.Uint64) bool {
+	api.logger.Debug("miner_setGasLimit")
+	api.logger.Info("Unsupported rpc function: miner_setGasLimit")
+	return false
+}
+
+// Start starts the miner with the given number of threads. If threads is nil,
+// the number of workers started is equal to the number of logical CPUs that are
+// usable by this process. If mining is already running, this method adjust the
+// number of threads allowed to use and updates the minimum price required by the
+// transaction pool.
+// Unsupported in Ethermint
+func (api *API) Start(threads *int) error {
+	api.logger.Debug("miner_start")
+	api.logger.Info("Unsupported rpc function: miner_start")
+	return errors.New("unsupported rpc function: miner_start")
+}
+
+// Stop terminates the miner, both at the consensus engine level as well as at
+// the block creation level.
+// Unsupported in Ethermint
+func (api *API) Stop() {
+	api.logger.Debug("miner_stop")
+	api.logger.Info("Unsupported rpc function: miner_stop")
+}

init.sh

@@ -86,4 +86,4 @@ if [[ $1 == "pending" ]]; then
 fi
 
 # Start the node (remove the --pruning=nothing flag if historical queries are not needed)
-ethermintd start --pruning=nothing $TRACE --log_level $LOGLEVEL --minimum-gas-prices=0.0001aphoton --evm-rpc.api eth,txpool,personal,net,debug,web3
+ethermintd start --pruning=nothing $TRACE --log_level $LOGLEVEL --minimum-gas-prices=0.0001aphoton --evm-rpc.api eth,txpool,personal,net,debug,web3,miner