path: root/rpc/api/parsing.go

package api

import (
    "bytes"
    "encoding/binary"
    "encoding/hex"
    "encoding/json"
    "math/big"
    "strings"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/rpc/shared"
)

type hexdata struct {
    data  []byte
    isNil bool
}

func (d *hexdata) String() string {
    return "0x" + common.Bytes2Hex(d.data)
}

func (d *hexdata) MarshalJSON() ([]byte, error) {
    if d.isNil {
        return json.Marshal(nil)
    }
    return json.Marshal(d.String())
}

func newHexData(input interface{}) *hexdata {
    d := new(hexdata)

    if input == nil {
        d.isNil = true
        return d
    }
    switch input := input.(type) {
    case []byte:
        d.data = input
    case common.Hash:
        d.data = input.Bytes()
    case *common.Hash:
        if input == nil {
            d.isNil = true
        } else {
            d.data = input.Bytes()
        }
    case common.Address:
        d.data = input.Bytes()
    case *common.Address:
        if input == nil {
            d.isNil = true
        } else {
            d.data = input.Bytes()
        }
    case types.Bloom:
        d.data = input.Bytes()
    case *types.Bloom:
        if input == nil {
            d.isNil = true
        } else {
            d.data = input.Bytes()
        }
    case *big.Int:
        if input == nil {
            d.isNil = true
        } else {
            d.data = input.Bytes()
        }
    case int64:
        d.data = big.NewInt(input).Bytes()
    case uint64:
        buff := make([]byte, 8)
        binary.BigEndian.PutUint64(buff, input)
        d.data = buff
    case int:
        d.data = big.NewInt(int64(input)).Bytes()
    case uint:
        d.data = big.NewInt(int64(input)).Bytes()
    case int8:
        d.data = big.NewInt(int64(input)).Bytes()
    case uint8:
        d.data = big.NewInt(int64(input)).Bytes()
    case int16:
        d.data = big.NewInt(int64(input)).Bytes()
    case uint16:
        buff := make([]byte, 2)
        binary.BigEndian.PutUint16(buff, input)
        d.data = buff
    case int32:
        d.data = big.NewInt(int64(input)).Bytes()
    case uint32:
        buff := make([]byte, 4)
        binary.BigEndian.PutUint32(buff, input)
        d.data = buff
    case string: // hexstring
        // aaargh ffs TODO: avoid back-and-forth hex encodings where unneeded
        bytes, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
        if err != nil {
            d.isNil = true
        } else {
            d.data = bytes
        }
    default:
        d.isNil = true
    }

    return d
}

type hexnum struct {
    data  []byte
    isNil bool
}

func (d *hexnum) String() string {
    // Get hex string from bytes
    out := common.Bytes2Hex(d.data)
    // Trim leading 0s
    out = strings.TrimLeft(out, "0")
    // Output "0x0" when value is 0
    if len(out) == 0 {
        out = "0"
    }
    return "0x" + out
}

func (d *hexnum) MarshalJSON() ([]byte, error) {
    if d.isNil {
        return json.Marshal(nil)
    }
    return json.Marshal(d.String())
}

func newHexNum(input interface{}) *hexnum {
    d := new(hexnum)

    d.data = newHexData(input).data

    return d
}

type BlockRes struct {
    fullTx bool

    BlockNumber     *hexnum           `json:"number"`
    BlockHash       *hexdata          `json:"hash"`
    ParentHash      *hexdata          `json:"parentHash"`
    Nonce           *hexdata          `json:"nonce"`
    Sha3Uncles      *hexdata          `json:"sha3Uncles"`
    LogsBloom       *hexdata          `json:"logsBloom"`
    TransactionRoot *hexdata          `json:"transactionsRoot"`
    StateRoot       *hexdata          `json:"stateRoot"`
    Miner           *hexdata          `json:"miner"`
    Difficulty      *hexnum           `json:"difficulty"`
    TotalDifficulty *hexnum           `json:"totalDifficulty"`
    Size            *hexnum           `json:"size"`
    ExtraData       *hexdata          `json:"extraData"`
    GasLimit        *hexnum           `json:"gasLimit"`
    GasUsed         *hexnum           `json:"gasUsed"`
    UnixTimestamp   *hexnum           `json:"timestamp"`
    Transactions    []*TransactionRes `json:"transactions"`
    Uncles          []*UncleRes       `json:"uncles"`
}

func (b *BlockRes) MarshalJSON() ([]byte, error) {
    if b.fullTx {
        var ext struct {
            BlockNumber     *hexnum           `json:"number"`
            BlockHash       *hexdata          `json:"hash"`
            ParentHash      *hexdata          `json:"parentHash"`
            Nonce           *hexdata          `json:"nonce"`
            Sha3Uncles      *hexdata          `json:"sha3Uncles"`
            LogsBloom       *hexdata          `json:"logsBloom"`
            TransactionRoot *hexdata          `json:"transactionsRoot"`
            StateRoot       *hexdata          `json:"stateRoot"`
            Miner           *hexdata          `json:"miner"`
            Difficulty      *hexnum           `json:"difficulty"`
            TotalDifficulty *hexnum           `json:"totalDifficulty"`
            Size            *hexnum           `json:"size"`
            ExtraData       *hexdata          `json:"extraData"`
            GasLimit        *hexnum           `json:"gasLimit"`
            GasUsed         *hexnum           `json:"gasUsed"`
            UnixTimestamp   *hexnum           `json:"timestamp"`
            Transactions    []*TransactionRes `json:"transactions"`
            Uncles          []*hexdata        `json:"uncles"`
        }

        ext.BlockNumber = b.BlockNumber
        ext.BlockHash = b.BlockHash
        ext.ParentHash = b.ParentHash
        ext.Nonce = b.Nonce
        ext.Sha3Uncles = b.Sha3Uncles
        ext.LogsBloom = b.LogsBloom
        ext.TransactionRoot = b.TransactionRoot
        ext.StateRoot = b.StateRoot
        ext.Miner = b.Miner
        ext.Difficulty = b.Difficulty
        ext.TotalDifficulty = b.TotalDifficulty
        ext.Size = b.Size
        ext.ExtraData = b.ExtraData
        ext.GasLimit = b.GasLimit
        ext.GasUsed = b.GasUsed
        ext.UnixTimestamp = b.UnixTimestamp
        ext.Transactions = b.Transactions
        ext.Uncles = make([]*hexdata, len(b.Uncles))
        for i, u := range b.Uncles {
            ext.Uncles[i] = u.BlockHash
        }
        return json.Marshal(ext)
    } else {
        var ext struct {
            BlockNumber     *hexnum    `json:"number"`
            BlockHash       *hexdata   `json:"hash"`
            ParentHash      *hexdata   `json:"parentHash"`
            Nonce           *hexdata   `json:"nonce"`
            Sha3Uncles      *hexdata   `json:"sha3Uncles"`
            LogsBloom       *hexdata   `json:"logsBloom"`
            TransactionRoot *hexdata   `json:"transactionsRoot"`
            StateRoot       *hexdata   `json:"stateRoot"`
            Miner           *hexdata   `json:"miner"`
            Difficulty      *hexnum    `json:"difficulty"`
            TotalDifficulty *hexnum    `json:"totalDifficulty"`
            Size            *hexnum    `json:"size"`
            ExtraData       *hexdata   `json:"extraData"`
            GasLimit        *hexnum    `json:"gasLimit"`
            GasUsed         *hexnum    `json:"gasUsed"`
            UnixTimestamp   *hexnum    `json:"timestamp"`
            Transactions    []*hexdata `json:"transactions"`
            Uncles          []*hexdata `json:"uncles"`
        }

        ext.BlockNumber = b.BlockNumber
        ext.BlockHash = b.BlockHash
        ext.ParentHash = b.ParentHash
        ext.Nonce = b.Nonce
        ext.Sha3Uncles = b.Sha3Uncles
        ext.LogsBloom = b.LogsBloom
        ext.TransactionRoot = b.TransactionRoot
        ext.StateRoot = b.StateRoot
        ext.Miner = b.Miner
        ext.Difficulty = b.Difficulty
        ext.TotalDifficulty = b.TotalDifficulty
        ext.Size = b.Size
        ext.ExtraData = b.ExtraData
        ext.GasLimit = b.GasLimit
        ext.GasUsed = b.GasUsed
        ext.UnixTimestamp = b.UnixTimestamp
        ext.Transactions = make([]*hexdata, len(b.Transactions))
        for i, tx := range b.Transactions {
            ext.Transactions[i] = tx.Hash
        }
        ext.Uncles = make([]*hexdata, len(b.Uncles))
        for i, u := range b.Uncles {
            ext.Uncles[i] = u.BlockHash
        }
        return json.Marshal(ext)
    }
}

func NewBlockRes(block *types.Block, fullTx bool) *BlockRes {
    if block == nil {
        return nil
    }

    res := new(BlockRes)
    res.fullTx = fullTx
    res.BlockNumber = newHexNum(block.Number())
    res.BlockHash = newHexData(block.Hash())
    res.ParentHash = newHexData(block.ParentHash())
    res.Nonce = newHexData(block.Nonce())
    res.Sha3Uncles = newHexData(block.UncleHash())
    res.LogsBloom = newHexData(block.Bloom())
    res.TransactionRoot = newHexData(block.TxHash())
    res.StateRoot = newHexData(block.Root())
    res.Miner = newHexData(block.Coinbase())
    res.Difficulty = newHexNum(block.Difficulty())
    res.TotalDifficulty = newHexNum(block.Td)
    res.Size = newHexNum(block.Size().Int64())
    res.ExtraData = newHexData(block.Extra())
    res.GasLimit = newHexNum(block.GasLimit())
    res.GasUsed = newHexNum(block.GasUsed())
    res.UnixTimestamp = newHexNum(block.Time())

    txs := block.Transactions()
    res.Transactions = make([]*TransactionRes, len(txs))
    for i, tx := range txs {
        res.Transactions[i] = NewTransactionRes(tx)
        res.Transactions[i].BlockHash = res.BlockHash
        res.Transactions[i].BlockNumber = res.BlockNumber
        res.Transactions[i].TxIndex = newHexNum(i)
    }

    uncles := block.Uncles()
    res.Uncles = make([]*UncleRes, len(uncles))
    for i, uncle := range uncles {
        res.Uncles[i] = NewUncleRes(uncle)
    }

    return res
}

type TransactionRes struct {
    Hash        *hexdata `json:"hash"`
    Nonce       *hexnum  `json:"nonce"`
    BlockHash   *hexdata `json:"blockHash"`
    BlockNumber *hexnum  `json:"blockNumber"`
    TxIndex     *hexnum  `json:"transactionIndex"`
    From        *hexdata `json:"from"`
    To          *hexdata `json:"to"`
    Value       *hexnum  `json:"value"`
    Gas         *hexnum  `json:"gas"`
    GasPrice    *hexnum  `json:"gasPrice"`
    Input       *hexdata `json:"input"`
}

func NewTransactionRes(tx *types.Transaction) *TransactionRes {
    if tx == nil {
        return nil
    }

    var v = new(TransactionRes)
    v.Hash = newHexData(tx.Hash())
    v.Nonce = newHexNum(tx.Nonce())
    // v.BlockHash =
    // v.BlockNumber =
    // v.TxIndex =
    from, _ := tx.From()
    v.From = newHexData(from)
    v.To = newHexData(tx.To())
    v.Value = newHexNum(tx.Value())
    v.Gas = newHexNum(tx.Gas())
    v.GasPrice = newHexNum(tx.GasPrice())
    v.Input = newHexData(tx.Data())
    return v
}

type UncleRes struct {
    BlockNumber     *hexnum  `json:"number"`
    BlockHash       *hexdata `json:"hash"`
    ParentHash      *hexdata `json:"parentHash"`
    Nonce           *hexdata `json:"nonce"`
    Sha3Uncles      *hexdata `json:"sha3Uncles"`
    ReceiptHash     *hexdata `json:"receiptHash"`
    LogsBloom       *hexdata `json:"logsBloom"`
    TransactionRoot *hexdata `json:"transactionsRoot"`
    StateRoot       *hexdata `json:"stateRoot"`
    Miner           *hexdata `json:"miner"`
    Difficulty      *hexnum  `json:"difficulty"`
    ExtraData       *hexdata `json:"extraData"`
    GasLimit        *hexnum  `json:"gasLimit"`
    GasUsed         *hexnum  `json:"gasUsed"`
    UnixTimestamp   *hexnum  `json:"timestamp"`
}

func NewUncleRes(h *types.Header) *UncleRes {
    if h == nil {
        return nil
    }

    var v = new(UncleRes)
    v.BlockNumber = newHexNum(h.Number)
    v.BlockHash = newHexData(h.Hash())
    v.ParentHash = newHexData(h.ParentHash)
    v.Sha3Uncles = newHexData(h.UncleHash)
    v.Nonce = newHexData(h.Nonce[:])
    v.LogsBloom = newHexData(h.Bloom)
    v.TransactionRoot = newHexData(h.TxHash)
    v.StateRoot = newHexData(h.Root)
    v.Miner = newHexData(h.Coinbase)
    v.Difficulty = newHexNum(h.Difficulty)
    v.ExtraData = newHexData(h.Extra)
    v.GasLimit = newHexNum(h.GasLimit)
    v.GasUsed = newHexNum(h.GasUsed)
    v.UnixTimestamp = newHexNum(h.Time)
    v.ReceiptHash = newHexData(h.ReceiptHash)

    return v
}

// type FilterLogRes struct {
//  Hash             string `json:"hash"`
//  Address          string `json:"address"`
//  Data             string `json:"data"`
//  BlockNumber      string `json:"blockNumber"`
//  TransactionHash  string `json:"transactionHash"`
//  BlockHash        string `json:"blockHash"`
//  TransactionIndex string `json:"transactionIndex"`
//  LogIndex         string `json:"logIndex"`
// }

// type FilterWhisperRes struct {
//  Hash       string `json:"hash"`
//  From       string `json:"from"`
//  To         string `json:"to"`
//  Expiry     string `json:"expiry"`
//  Sent       string `json:"sent"`
//  Ttl        string `json:"ttl"`
//  Topics     string `json:"topics"`
//  Payload    string `json:"payload"`
//  WorkProved string `json:"workProved"`
// }

type ReceiptRes struct {
    TransactionHash   *hexdata       `json:transactionHash`
    TransactionIndex  *hexnum        `json:transactionIndex`
    BlockNumber       *hexnum        `json:blockNumber`
    BlockHash         *hexdata       `json:blockHash`
    CumulativeGasUsed *hexnum        `json:cumulativeGasUsed`
    GasUsed           *hexnum        `json:gasUsed`
    ContractAddress   *hexdata       `json:contractAddress`
    Logs              *[]interface{} `json:logs`
}

func NewReceiptRes(rec *types.Receipt) *ReceiptRes {
    if rec == nil {
        return nil
    }

    var v = new(ReceiptRes)
    v.TransactionHash = newHexData(rec.TxHash)
    // v.TransactionIndex = newHexNum(input)
    // v.BlockNumber = newHexNum(input)
    // v.BlockHash = newHexData(input)
    v.CumulativeGasUsed = newHexNum(rec.CumulativeGasUsed)
    // v.GasUsed = newHexNum(input)
    // If the ContractAddress is 20 0x0 bytes, assume it is not a contract creation
    if bytes.Compare(rec.ContractAddress.Bytes(), bytes.Repeat([]byte{0}, 20)) != 0 {
        v.ContractAddress = newHexData(rec.ContractAddress)
    }
    // v.Logs = rec.Logs()

    return v
}

func numString(raw interface{}) (*big.Int, error) {
    var number *big.Int
    // Parse as integer
    num, ok := raw.(float64)
    if ok {
        number = big.NewInt(int64(num))
        return number, nil
    }

    // Parse as string/hexstring
    str, ok := raw.(string)
    if ok {
        number = common.String2Big(str)
        return number, nil
    }

    return nil, shared.NewInvalidTypeError("", "not a number or string")
}

func blockHeight(raw interface{}, number *int64) error {
    // Parse as integer
    num, ok := raw.(float64)
    if ok {
        *number = int64(num)
        return nil
    }

    // Parse as string/hexstring
    str, ok := raw.(string)
    if !ok {
        return shared.NewInvalidTypeError("", "not a number or string")
    }

    switch str {
    case "earliest":
        *number = 0
    case "latest":
        *number = -1
    case "pending":
        *number = -2
    default:
        if common.HasHexPrefix(str) {
            *number = common.String2Big(str).Int64()
        } else {
            return shared.NewInvalidTypeError("blockNumber", "is not a valid string")
        }
    }

    return nil
}

func blockHeightFromJson(msg json.RawMessage, number *int64) error {
    var raw interface{}
    if err := json.Unmarshal(msg, &raw); err != nil {
        return shared.NewDecodeParamError(err.Error())
    }
    return blockHeight(raw, number)
}