28aaba0695
* Set up framework for sending transaction with correct args and nonce mutex locking * Set up printing ethereum address through emintkeys and getting chainid from flags * Implemented defaults for eth_sendTransaction * Fix bug with no data provided * Updated comments and error, as well as RLP encoded tx bytes for return instead of amino encoded
367 lines
12 KiB
Go
367 lines
12 KiB
Go
package rpc
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client/context"
|
|
authutils "github.com/cosmos/cosmos-sdk/x/auth/client/utils"
|
|
emintcrypto "github.com/cosmos/ethermint/crypto"
|
|
emintkeys "github.com/cosmos/ethermint/keys"
|
|
"github.com/cosmos/ethermint/rpc/args"
|
|
"github.com/cosmos/ethermint/version"
|
|
"github.com/cosmos/ethermint/x/evm/types"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client/flags"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
// PublicEthAPI is the eth_ prefixed set of APIs in the Web3 JSON-RPC spec.
|
|
type PublicEthAPI struct {
|
|
cliCtx context.CLIContext
|
|
key emintcrypto.PrivKeySecp256k1
|
|
nonceLock *AddrLocker
|
|
}
|
|
|
|
// NewPublicEthAPI creates an instance of the public ETH Web3 API.
|
|
func NewPublicEthAPI(cliCtx context.CLIContext, nonceLock *AddrLocker,
|
|
key emintcrypto.PrivKeySecp256k1) *PublicEthAPI {
|
|
|
|
return &PublicEthAPI{
|
|
cliCtx: cliCtx,
|
|
key: key,
|
|
nonceLock: nonceLock,
|
|
}
|
|
}
|
|
|
|
// ProtocolVersion returns the supported Ethereum protocol version.
|
|
func (e *PublicEthAPI) ProtocolVersion() string {
|
|
return version.ProtocolVersion
|
|
}
|
|
|
|
// 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 *PublicEthAPI) Syncing() interface{} {
|
|
return false
|
|
}
|
|
|
|
// Coinbase returns this node's coinbase address. Not used in Ethermint.
|
|
func (e *PublicEthAPI) Coinbase() (addr common.Address) {
|
|
return
|
|
}
|
|
|
|
// Mining returns whether or not this node is currently mining. Always false.
|
|
func (e *PublicEthAPI) Mining() bool {
|
|
return false
|
|
}
|
|
|
|
// Hashrate returns the current node's hashrate. Always 0.
|
|
func (e *PublicEthAPI) Hashrate() hexutil.Uint64 {
|
|
return 0
|
|
}
|
|
|
|
// GasPrice returns the current gas price based on Ethermint's gas price oracle.
|
|
func (e *PublicEthAPI) GasPrice() *hexutil.Big {
|
|
out := big.NewInt(0)
|
|
return (*hexutil.Big)(out)
|
|
}
|
|
|
|
// Accounts returns the list of accounts available to this node.
|
|
func (e *PublicEthAPI) Accounts() ([]common.Address, error) {
|
|
addresses := make([]common.Address, 0) // return [] instead of nil if empty
|
|
keybase, err := emintkeys.NewKeyBaseFromHomeFlag()
|
|
if err != nil {
|
|
return addresses, err
|
|
}
|
|
|
|
infos, err := keybase.List()
|
|
if err != nil {
|
|
return addresses, err
|
|
}
|
|
|
|
for _, info := range infos {
|
|
addressBytes := info.GetPubKey().Address().Bytes()
|
|
addresses = append(addresses, common.BytesToAddress(addressBytes))
|
|
}
|
|
|
|
return addresses, nil
|
|
}
|
|
|
|
// BlockNumber returns the current block number.
|
|
func (e *PublicEthAPI) BlockNumber() *big.Int {
|
|
res, _, err := e.cliCtx.QueryWithData(fmt.Sprintf("custom/%s/blockNumber", types.ModuleName), nil)
|
|
if err != nil {
|
|
fmt.Printf("could not resolve: %s\n", err)
|
|
return nil
|
|
}
|
|
|
|
var out types.QueryResBlockNumber
|
|
e.cliCtx.Codec.MustUnmarshalJSON(res, &out)
|
|
return out.Number
|
|
}
|
|
|
|
// GetBalance returns the provided account's balance up to the provided block number.
|
|
func (e *PublicEthAPI) GetBalance(address common.Address, blockNum rpc.BlockNumber) (*hexutil.Big, error) {
|
|
ctx := e.cliCtx.WithHeight(blockNum.Int64())
|
|
res, _, err := ctx.QueryWithData(fmt.Sprintf("custom/%s/balance/%s", types.ModuleName, address), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var out types.QueryResBalance
|
|
e.cliCtx.Codec.MustUnmarshalJSON(res, &out)
|
|
return (*hexutil.Big)(out.Balance), nil
|
|
}
|
|
|
|
// GetStorageAt returns the contract storage at the given address, block number, and key.
|
|
func (e *PublicEthAPI) GetStorageAt(address common.Address, key string, blockNum rpc.BlockNumber) (hexutil.Bytes, error) {
|
|
ctx := e.cliCtx.WithHeight(blockNum.Int64())
|
|
res, _, err := ctx.QueryWithData(fmt.Sprintf("custom/%s/storage/%s/%s", types.ModuleName, address, key), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var out types.QueryResStorage
|
|
e.cliCtx.Codec.MustUnmarshalJSON(res, &out)
|
|
return out.Value[:], nil
|
|
}
|
|
|
|
// GetTransactionCount returns the number of transactions at the given address up to the given block number.
|
|
func (e *PublicEthAPI) GetTransactionCount(address common.Address, blockNum rpc.BlockNumber) (hexutil.Uint64, error) {
|
|
ctx := e.cliCtx.WithHeight(blockNum.Int64())
|
|
res, _, err := ctx.QueryWithData(fmt.Sprintf("custom/%s/nonce/%s", types.ModuleName, address), nil)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
var out types.QueryResNonce
|
|
e.cliCtx.Codec.MustUnmarshalJSON(res, &out)
|
|
return hexutil.Uint64(out.Nonce), nil
|
|
}
|
|
|
|
// GetBlockTransactionCountByHash returns the number of transactions in the block identified by hash.
|
|
func (e *PublicEthAPI) GetBlockTransactionCountByHash(hash common.Hash) hexutil.Uint {
|
|
return 0
|
|
}
|
|
|
|
// GetBlockTransactionCountByNumber returns the number of transactions in the block identified by number.
|
|
func (e *PublicEthAPI) GetBlockTransactionCountByNumber(blockNum rpc.BlockNumber) (hexutil.Uint, error) {
|
|
node, err := e.cliCtx.GetNode()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
height := blockNum.Int64()
|
|
block, err := node.Block(&height)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return hexutil.Uint(block.Block.NumTxs), nil
|
|
}
|
|
|
|
// GetUncleCountByBlockHash returns the number of uncles in the block idenfied by hash. Always zero.
|
|
func (e *PublicEthAPI) GetUncleCountByBlockHash(hash common.Hash) hexutil.Uint {
|
|
return 0
|
|
}
|
|
|
|
// GetUncleCountByBlockNumber returns the number of uncles in the block idenfied by number. Always zero.
|
|
func (e *PublicEthAPI) GetUncleCountByBlockNumber(blockNum rpc.BlockNumber) hexutil.Uint {
|
|
return 0
|
|
}
|
|
|
|
// GetCode returns the contract code at the given address and block number.
|
|
func (e *PublicEthAPI) GetCode(address common.Address, blockNumber rpc.BlockNumber) (hexutil.Bytes, error) {
|
|
ctx := e.cliCtx.WithHeight(blockNumber.Int64())
|
|
res, _, err := ctx.QueryWithData(fmt.Sprintf("custom/%s/code/%s", types.ModuleName, address), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var out types.QueryResCode
|
|
e.cliCtx.Codec.MustUnmarshalJSON(res, &out)
|
|
return out.Code, nil
|
|
}
|
|
|
|
// Sign signs the provided data using the private key of address via Geth's signature standard.
|
|
func (e *PublicEthAPI) Sign(address common.Address, data hexutil.Bytes) (hexutil.Bytes, error) {
|
|
// TODO: Change this functionality to find an unlocked account by address
|
|
if e.key == nil || !bytes.Equal(e.key.PubKey().Address().Bytes(), address.Bytes()) {
|
|
return nil, keystore.ErrLocked
|
|
}
|
|
|
|
// Sign the requested hash with the wallet
|
|
signature, err := e.key.Sign(data)
|
|
if err == nil {
|
|
signature[64] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper
|
|
}
|
|
|
|
return signature, err
|
|
}
|
|
|
|
// SendTransaction sends an Ethereum transaction.
|
|
func (e *PublicEthAPI) SendTransaction(args args.SendTxArgs) (common.Hash, error) {
|
|
// TODO: Change this functionality to find an unlocked account by address
|
|
if e.key == nil || !bytes.Equal(e.key.PubKey().Address().Bytes(), args.From.Bytes()) {
|
|
return common.Hash{}, keystore.ErrLocked
|
|
}
|
|
|
|
// Mutex lock the address' nonce to avoid assigning it to multiple requests
|
|
if args.Nonce == nil {
|
|
e.nonceLock.LockAddr(args.From)
|
|
defer e.nonceLock.UnlockAddr(args.From)
|
|
}
|
|
|
|
// Assemble transaction from fields
|
|
tx, err := types.GenerateFromArgs(args, e.cliCtx)
|
|
if err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
|
|
// ChainID must be set as flag to send transaction
|
|
chainID := viper.GetString(flags.FlagChainID)
|
|
// parse the chainID from a string to a base-10 integer
|
|
intChainID, ok := new(big.Int).SetString(chainID, 10)
|
|
if !ok {
|
|
return common.Hash{}, fmt.Errorf(
|
|
fmt.Sprintf("Invalid chainID: %s, must be integer format", chainID))
|
|
}
|
|
|
|
// Sign transaction
|
|
tx.Sign(intChainID, e.key.ToECDSA())
|
|
|
|
// Encode transaction by default Tx encoder
|
|
txEncoder := authutils.GetTxEncoder(e.cliCtx.Codec)
|
|
txBytes, err := txEncoder(tx)
|
|
if err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
|
|
// Broadcast transaction
|
|
res, err := e.cliCtx.BroadcastTx(txBytes)
|
|
// If error is encountered on the node, the broadcast will not return an error
|
|
// TODO: Remove res log
|
|
fmt.Println(res.RawLog)
|
|
if err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
|
|
// Return RLP encoded bytes
|
|
return tx.Hash(), nil
|
|
}
|
|
|
|
// SendRawTransaction send a raw Ethereum transaction.
|
|
func (e *PublicEthAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) {
|
|
tx := new(types.EthereumTxMsg)
|
|
|
|
// RLP decode raw transaction bytes
|
|
if err := rlp.DecodeBytes(data, tx); err != nil {
|
|
// Return nil is for when gasLimit overflows uint64
|
|
return common.Hash{}, nil
|
|
}
|
|
|
|
// Encode transaction by default Tx encoder
|
|
txEncoder := authutils.GetTxEncoder(e.cliCtx.Codec)
|
|
txBytes, err := txEncoder(tx)
|
|
if err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
|
|
// TODO: Possibly log the contract creation address (if recipient address is nil) or tx data
|
|
res, err := e.cliCtx.BroadcastTx(txBytes)
|
|
// If error is encountered on the node, the broadcast will not return an error
|
|
// TODO: Remove res log
|
|
fmt.Println(res.RawLog)
|
|
if err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
|
|
// Return RLP encoded bytes
|
|
return tx.Hash(), nil
|
|
}
|
|
|
|
// CallArgs represents arguments to a smart contract call as provided by RPC clients.
|
|
type CallArgs struct {
|
|
From common.Address `json:"from"`
|
|
To common.Address `json:"to"`
|
|
Gas hexutil.Uint64 `json:"gas"`
|
|
GasPrice hexutil.Big `json:"gasPrice"`
|
|
Value hexutil.Big `json:"value"`
|
|
Data hexutil.Bytes `json:"data"`
|
|
}
|
|
|
|
// Call performs a raw contract call.
|
|
func (e *PublicEthAPI) Call(args CallArgs, blockNum rpc.BlockNumber) hexutil.Bytes {
|
|
return nil
|
|
}
|
|
|
|
// EstimateGas estimates gas usage for the given smart contract call.
|
|
func (e *PublicEthAPI) EstimateGas(args CallArgs, blockNum rpc.BlockNumber) hexutil.Uint64 {
|
|
return 0
|
|
}
|
|
|
|
// GetBlockByHash returns the block identified by hash.
|
|
func (e *PublicEthAPI) GetBlockByHash(hash common.Hash, fullTx bool) map[string]interface{} {
|
|
return nil
|
|
}
|
|
|
|
// GetBlockByNumber returns the block identified by number.
|
|
func (e *PublicEthAPI) GetBlockByNumber(blockNum rpc.BlockNumber, fullTx bool) map[string]interface{} {
|
|
return nil
|
|
}
|
|
|
|
// Transaction represents a transaction returned to RPC clients.
|
|
type Transaction struct {
|
|
BlockHash common.Hash `json:"blockHash"`
|
|
BlockNumber *hexutil.Big `json:"blockNumber"`
|
|
From common.Address `json:"from"`
|
|
Gas hexutil.Uint64 `json:"gas"`
|
|
GasPrice *hexutil.Big `json:"gasPrice"`
|
|
Hash common.Hash `json:"hash"`
|
|
Input hexutil.Bytes `json:"input"`
|
|
Nonce hexutil.Uint64 `json:"nonce"`
|
|
To *common.Address `json:"to"`
|
|
TransactionIndex hexutil.Uint `json:"transactionIndex"`
|
|
Value *hexutil.Big `json:"value"`
|
|
V *hexutil.Big `json:"v"`
|
|
R *hexutil.Big `json:"r"`
|
|
S *hexutil.Big `json:"s"`
|
|
}
|
|
|
|
// GetTransactionByHash returns the transaction identified by hash.
|
|
func (e *PublicEthAPI) GetTransactionByHash(hash common.Hash) *Transaction {
|
|
return nil
|
|
}
|
|
|
|
// GetTransactionByBlockHashAndIndex returns the transaction identified by hash and index.
|
|
func (e *PublicEthAPI) GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) *Transaction {
|
|
return nil
|
|
}
|
|
|
|
// GetTransactionByBlockNumberAndIndex returns the transaction identified by number and index.
|
|
func (e *PublicEthAPI) GetTransactionByBlockNumberAndIndex(blockNumber rpc.BlockNumber, idx hexutil.Uint) *Transaction {
|
|
return nil
|
|
}
|
|
|
|
// GetTransactionReceipt returns the transaction receipt identified by hash.
|
|
func (e *PublicEthAPI) GetTransactionReceipt(hash common.Hash) map[string]interface{} {
|
|
return nil
|
|
}
|
|
|
|
// GetUncleByBlockHashAndIndex returns the uncle identified by hash and index. Always returns nil.
|
|
func (e *PublicEthAPI) GetUncleByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) map[string]interface{} {
|
|
return nil
|
|
}
|
|
|
|
// GetUncleByBlockNumberAndIndex returns the uncle identified by number and index. Always returns nil.
|
|
func (e *PublicEthAPI) GetUncleByBlockNumberAndIndex(number hexutil.Uint, idx hexutil.Uint) map[string]interface{} {
|
|
return nil
|
|
}
|