func (rpc *EthRPC) EthGetFilterChanges(filterID string) ([]Log, error) {
	var logs = []Log{}
	err := rpc.call("eth_getFilterChanges", &logs, filterID)
	return logs, err
}
EthGetFilterChanges polling method for a filter, which returns an array of logs which occurred since last poll.
package web3
import (
	"auctionBidder/utils"
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"math/big"
	"net/http"
	"os"
)
type EthError struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
}
func (err EthError) Error() string {
	return fmt.Sprintf("Error %d (%s)", err.Code, err.Message)
}
type ethResponse struct {
	ID      int             `json:"id"`
	JSONRPC string          `json:"jsonrpc"`
	Result  json.RawMessage `json:"result"`
	Error   *EthError       `json:"error"`
}
type ethRequest struct {
	ID      int           `json:"id"`
	JSONRPC string        `json:"jsonrpc"`
	Method  string        `json:"method"`
	Params  []interface{} `json:"params"`
}
type EthRPC struct {
	url    string
	client httpClient
	log    logger
	Debug  bool
}
func New(url string, options ...func(rpc *EthRPC)) *EthRPC {
	rpc := &EthRPC{
		url:    url,
		client: http.DefaultClient,
		log:    log.New(os.Stderr, "", log.LstdFlags),
	}
	for _, option := range options {
		option(rpc)
	}
	return rpc
}
func NewEthRPC(url string, options ...func(rpc *EthRPC)) *EthRPC {
	return New(url, options...)
}
func (rpc *EthRPC) call(method string, target interface{}, params ...interface{}) error {
	result, err := rpc.Call(method, params...)
	if err != nil {
		return err
	}
	if target == nil {
		return nil
	}
	return json.Unmarshal(result, target)
}
func (rpc *EthRPC) URL() string {
	return rpc.url
}
func (rpc *EthRPC) Call(method string, params ...interface{}) (json.RawMessage, error) {
	request := ethRequest{
		ID:      1,
		JSONRPC: "2.0",
		Method:  method,
		Params:  params,
	}
	body, err := json.Marshal(request)
	if err != nil {
		return nil, err
	}
	response, err := rpc.client.Post(rpc.url, "application/json", bytes.NewBuffer(body))
	if response != nil {
		defer response.Body.Close()
	}
	if err != nil {
		return nil, err
	}
	data, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}
	if rpc.Debug {
		rpc.log.Println(fmt.Sprintf("%s\nRequest: %s\nResponse: %s\n", method, body, data))
	}
	resp := new(ethResponse)
	if err := json.Unmarshal(data, resp); err != nil {
		return nil, err
	}
	if resp.Error != nil {
		return nil, *resp.Error
	}
	return resp.Result, nil
}
func (rpc *EthRPC) RawCall(method string, params ...interface{}) (json.RawMessage, error) {
	return rpc.Call(method, params...)
}
func (rpc *EthRPC) Web3ClientVersion() (string, error) {
	var clientVersion string
	err := rpc.call("web3_clientVersion", &clientVersion)
	return clientVersion, err
}
func (rpc *EthRPC) Web3Sha3(data []byte) (string, error) {
	var hash string
	err := rpc.call("web3_sha3", &hash, fmt.Sprintf("0x%x", data))
	return hash, err
}
func (rpc *EthRPC) NetVersion() (string, error) {
	var version string
	err := rpc.call("net_version", &version)
	return version, err
}
func (rpc *EthRPC) NetListening() (bool, error) {
	var listening bool
	err := rpc.call("net_listening", &listening)
	return listening, err
}
func (rpc *EthRPC) NetPeerCount() (int, error) {
	var response string
	if err := rpc.call("net_peerCount", &response); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthProtocolVersion() (string, error) {
	var protocolVersion string
	err := rpc.call("eth_protocolVersion", &protocolVersion)
	return protocolVersion, err
}
func (rpc *EthRPC) EthSyncing() (*Syncing, error) {
	result, err := rpc.RawCall("eth_syncing")
	if err != nil {
		return nil, err
	}
	syncing := new(Syncing)
	if bytes.Equal(result, []byte("false")) {
		return syncing, nil
	}
	err = json.Unmarshal(result, syncing)
	return syncing, err
}
func (rpc *EthRPC) EthCoinbase() (string, error) {
	var address string
	err := rpc.call("eth_coinbase", &address)
	return address, err
}
func (rpc *EthRPC) EthMining() (bool, error) {
	var mining bool
	err := rpc.call("eth_mining", &mining)
	return mining, err
}
func (rpc *EthRPC) EthHashrate() (int, error) {
	var response string
	if err := rpc.call("eth_hashrate", &response); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGasPrice() (big.Int, error) {
	var response string
	if err := rpc.call("eth_gasPrice", &response); err != nil {
		return big.Int{}, err
	}
	return utils.HexString2BigInt(response)
}
func (rpc *EthRPC) EthAccounts() ([]string, error) {
	accounts := []string{}
	err := rpc.call("eth_accounts", &accounts)
	return accounts, err
}
func (rpc *EthRPC) EthBlockNumber() (int, error) {
	var response string
	if err := rpc.call("eth_blockNumber", &response); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGetBalance(address, block string) (big.Int, error) {
	var response string
	if err := rpc.call("eth_getBalance", &response, address, block); err != nil {
		return big.Int{}, err
	}
	return utils.HexString2BigInt(response)
}
func (rpc *EthRPC) EthGetStorageAt(data string, position int, tag string) (string, error) {
	var result string
	err := rpc.call("eth_getStorageAt", &result, data, utils.Int2HexString(position), tag)
	return result, err
}
func (rpc *EthRPC) EthGetTransactionCount(address, block string) (int, error) {
	var response string
	if err := rpc.call("eth_getTransactionCount", &response, address, block); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGetBlockTransactionCountByHash(hash string) (int, error) {
	var response string
	if err := rpc.call("eth_getBlockTransactionCountByHash", &response, hash); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGetBlockTransactionCountByNumber(number int) (int, error) {
	var response string
	if err := rpc.call("eth_getBlockTransactionCountByNumber", &response, utils.Int2HexString(number)); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGetUncleCountByBlockHash(hash string) (int, error) {
	var response string
	if err := rpc.call("eth_getUncleCountByBlockHash", &response, hash); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGetUncleCountByBlockNumber(number int) (int, error) {
	var response string
	if err := rpc.call("eth_getUncleCountByBlockNumber", &response, utils.Int2HexString(number)); err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) EthGetCode(address, block string) (string, error) {
	var code string
	err := rpc.call("eth_getCode", &code, address, block)
	return code, err
}
func (rpc *EthRPC) EthSign(address, data string) (string, error) {
	var signature string
	err := rpc.call("eth_sign", &signature, address, data)
	return signature, err
}
func (rpc *EthRPC) EthSendTransaction(transaction T) (string, error) {
	var hash string
	err := rpc.call("eth_sendTransaction", &hash, transaction)
	return hash, err
}
func (rpc *EthRPC) EthSendRawTransaction(data string) (string, error) {
	var hash string
	err := rpc.call("eth_sendRawTransaction", &hash, data)
	return hash, err
}
func (rpc *EthRPC) EthCall(transaction T, tag string) (string, error) {
	var data string
	err := rpc.call("eth_call", &data, transaction, tag)
	return data, err
}
func (rpc *EthRPC) EthEstimateGas(transaction T) (int, error) {
	var response string
	err := rpc.call("eth_estimateGas", &response, transaction)
	if err != nil {
		return 0, err
	}
	return utils.HexString2Int(response)
}
func (rpc *EthRPC) getBlock(method string, withTransactions bool, params ...interface{}) (*Block, error) {
	result, err := rpc.RawCall(method, params...)
	if err != nil {
		return nil, err
	}
	if bytes.Equal(result, []byte("null")) {
		return nil, nil
	}
	var response proxyBlock
	if withTransactions {
		response = new(proxyBlockWithTransactions)
	} else {
		response = new(proxyBlockWithoutTransactions)
	}
	err = json.Unmarshal(result, response)
	if err != nil {
		return nil, err
	}
	block := response.toBlock()
	return &block, nil
}
func (rpc *EthRPC) EthGetBlockByHash(hash string, withTransactions bool) (*Block, error) {
	return rpc.getBlock("eth_getBlockByHash", withTransactions, hash, withTransactions)
}
func (rpc *EthRPC) EthGetBlockByNumber(number int, withTransactions bool) (*Block, error) {
	return rpc.getBlock("eth_getBlockByNumber", withTransactions, utils.Int2HexString(number), withTransactions)
}
func (rpc *EthRPC) getTransaction(method string, params ...interface{}) (*Transaction, error) {
	transaction := new(Transaction)
	err := rpc.call(method, transaction, params...)
	return transaction, err
}
func (rpc *EthRPC) EthGetTransactionByHash(hash string) (*Transaction, error) {
	return rpc.getTransaction("eth_getTransactionByHash", hash)
}
func (rpc *EthRPC) EthGetTransactionByBlockHashAndIndex(blockHash string, transactionIndex int) (*Transaction, error) {
	return rpc.getTransaction("eth_getTransactionByBlockHashAndIndex", blockHash, utils.Int2HexString(transactionIndex))
}
func (rpc *EthRPC) EthGetTransactionByBlockNumberAndIndex(blockNumber, transactionIndex int) (*Transaction, error) {
	return rpc.getTransaction("eth_getTransactionByBlockNumberAndIndex", utils.Int2HexString(blockNumber), utils.Int2HexString(transactionIndex))
}
func (rpc *EthRPC) EthGetTransactionReceipt(hash string) (*TransactionReceipt, error) {
	transactionReceipt := new(TransactionReceipt)
	err := rpc.call("eth_getTransactionReceipt", transactionReceipt, hash)
	if err != nil {
		return nil, err
	}
	return transactionReceipt, nil
}
func (rpc *EthRPC) EthGetCompilers() ([]string, error) {
	compilers := []string{}
	err := rpc.call("eth_getCompilers", &compilers)
	return compilers, err
}
func (rpc *EthRPC) EthNewFilter(params FilterParams) (string, error) {
	var filterID string
	err := rpc.call("eth_newFilter", &filterID, params)
	return filterID, err
}
func (rpc *EthRPC) EthNewBlockFilter() (string, error) {
	var filterID string
	err := rpc.call("eth_newBlockFilter", &filterID)
	return filterID, err
}
func (rpc *EthRPC) EthNewPendingTransactionFilter() (string, error) {
	var filterID string
	err := rpc.call("eth_newPendingTransactionFilter", &filterID)
	return filterID, err
}
func (rpc *EthRPC) EthUninstallFilter(filterID string) (bool, error) {
	var res bool
	err := rpc.call("eth_uninstallFilter", &res, filterID)
	return res, err
}