163 lines
3.4 KiB
Go
163 lines
3.4 KiB
Go
package common
|
|
|
|
import (
|
|
"errors"
|
|
|
|
gethcommon "github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
)
|
|
|
|
// RPCCall represents a unit of a rpc request which is to be executed.
|
|
type RPCCall struct {
|
|
ID int64
|
|
Method string
|
|
Params []interface{}
|
|
}
|
|
|
|
// contains series of errors for parsing operations.
|
|
var (
|
|
ErrInvalidFromAddress = errors.New("Failed to parse From Address")
|
|
ErrInvalidToAddress = errors.New("Failed to parse To Address")
|
|
)
|
|
|
|
// ParseFromAddress returns the address associated with the RPCCall.
|
|
func (r RPCCall) ParseFromAddress() (gethcommon.Address, error) {
|
|
params, ok := r.Params[0].(map[string]interface{})
|
|
if !ok {
|
|
return gethcommon.HexToAddress("0x"), ErrInvalidFromAddress
|
|
}
|
|
|
|
from, ok := params["from"].(string)
|
|
if !ok {
|
|
return gethcommon.HexToAddress("0x"), ErrInvalidFromAddress
|
|
}
|
|
|
|
return gethcommon.HexToAddress(from), nil
|
|
}
|
|
|
|
// ParseToAddress returns the gethcommon.Address associated with the call.
|
|
func (r RPCCall) ParseToAddress() (gethcommon.Address, error) {
|
|
params, ok := r.Params[0].(map[string]interface{})
|
|
if !ok {
|
|
return gethcommon.HexToAddress("0x"), ErrInvalidToAddress
|
|
}
|
|
|
|
to, ok := params["to"].(string)
|
|
if !ok {
|
|
return gethcommon.HexToAddress("0x"), ErrInvalidToAddress
|
|
}
|
|
|
|
return gethcommon.HexToAddress(to), nil
|
|
}
|
|
|
|
// ParseData returns the bytes associated with the call.
|
|
func (r RPCCall) ParseData() hexutil.Bytes {
|
|
params, ok := r.Params[0].(map[string]interface{})
|
|
if !ok {
|
|
return hexutil.Bytes("0x")
|
|
}
|
|
|
|
data, ok := params["data"].(string)
|
|
if !ok {
|
|
data = "0x"
|
|
}
|
|
|
|
byteCode, err := hexutil.Decode(data)
|
|
if err != nil {
|
|
byteCode = hexutil.Bytes(data)
|
|
}
|
|
|
|
return byteCode
|
|
}
|
|
|
|
// ParseValue returns the hex big associated with the call.
|
|
// nolint: dupl
|
|
func (r RPCCall) ParseValue() *hexutil.Big {
|
|
params, ok := r.Params[0].(map[string]interface{})
|
|
if !ok {
|
|
return nil
|
|
//return (*hexutil.Big)(big.NewInt("0x0"))
|
|
}
|
|
|
|
inputValue, ok := params["value"].(string)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
parsedValue, err := hexutil.DecodeBig(inputValue)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
return (*hexutil.Big)(parsedValue)
|
|
}
|
|
|
|
// ParseGas returns the hex big associated with the call.
|
|
// nolint: dupl
|
|
func (r RPCCall) ParseGas() *hexutil.Uint64 {
|
|
params, ok := r.Params[0].(map[string]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
inputValue, ok := params["gas"].(string)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
parsedValue, err := hexutil.DecodeUint64(inputValue)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
v := hexutil.Uint64(parsedValue)
|
|
return &v
|
|
}
|
|
|
|
// ParseGasPrice returns the hex big associated with the call.
|
|
// nolint: dupl
|
|
func (r RPCCall) ParseGasPrice() *hexutil.Big {
|
|
params, ok := r.Params[0].(map[string]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
inputValue, ok := params["gasPrice"].(string)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
parsedValue, err := hexutil.DecodeBig(inputValue)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
return (*hexutil.Big)(parsedValue)
|
|
}
|
|
|
|
// ToSendTxArgs converts RPCCall to SendTxArgs.
|
|
func (r RPCCall) ToSendTxArgs() SendTxArgs {
|
|
var err error
|
|
var fromAddr, toAddr gethcommon.Address
|
|
|
|
fromAddr, err = r.ParseFromAddress()
|
|
if err != nil {
|
|
fromAddr = gethcommon.HexToAddress("0x0")
|
|
}
|
|
|
|
toAddr, err = r.ParseToAddress()
|
|
if err != nil {
|
|
toAddr = gethcommon.HexToAddress("0x0")
|
|
}
|
|
|
|
input := r.ParseData()
|
|
return SendTxArgs{
|
|
To: &toAddr,
|
|
From: fromAddr,
|
|
Value: r.ParseValue(),
|
|
Input: input,
|
|
Gas: r.ParseGas(),
|
|
GasPrice: r.ParseGasPrice(),
|
|
}
|
|
}
|