Example:eth_getBlockByHash rpc call return null, if block was not found, which might happen when node is de-synchronised. In this case EthGetBlockByHash api method will return nil error, and empty response. Expected behaviour in this case would be return nil in response.

Summary

I love your tool. It is very convenient and easy to use. Can you give me an example of EthCall. I got error like the following. The below ethcall is for getting ERC20 token name with the contract address.

Steps to Reproduce

1. run EthCall()

• test.go

var client *ethrpc.EthRPC

func EthCall() string {
	result, err := client.EthCall(ethrpc.T{To: "0x41e5560054824ea6b0732e656e3ad64e20e94e45", Data: "0x06fdde03"}, "latest")
	if err != nil {
		panic(err)
	}
	return result
}

Expected Results

Return the result same as normal JSON RPC

$ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{"to":"0x41e5560054824ea6b0732e656e3ad64e20e94e45","data":"0x06fdde03"}, "latest"],"id":83}' http://localhost:xxxx

{"jsonrpc":"2.0","id":83,"result":"0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000054369766963000000000000000000000000000000000000000000000000000000"}

Actual Results

Error occurred.

panic: Error -32602 (invalid argument 0: hex string has length 0, want 40 for common.Address)

In eth_call the from field is optional (unlike for instance in eth_sendTransaction).

However, the current code always fills in the from field with an empty string if no actual value is provided, which results in the following error:

invalid argument 0: hex string has length 0, want 40 for common.Address

when using eth_call with no from field provided.

This fix makes the from field optional so that the rpc json request gets correctly serialized.

The EthGetBlockByNumber method has the first parameter of type INT. The first parameter takes a block number. In the future, this type will create problems with large numbers of blocks that are constantly increasing. My advice is to use UINT64 or implement your own bigInt type.

Parity returns status: null for transactions before Byzantium. Current code doesn't handle this and will throw calling strconv.ParseInt with null. Maybe we should change this field into *int.

Parity ref: https://wiki.parity.io/JSONRPC-eth-module#eth_gettransactionreceipt Sample data:

{
	"jsonrpc": "2.0",
	"result": {
		"blockHash": "0xd99ad9a1142e57fbd0aea432bd76ef46c0af1ef71d80b6986b945fce95ce9d34",
		"blockNumber": "0x1e8485",
		"contractAddress": null,
		"cumulativeGasUsed": "0x16d15",
		"gasUsed": "0xc905",
		"logs": [
			{
				"address": "0xe0b7927c4af23765cb51314a0e0521a9645f0e2a",
				"blockHash": "0xd99ad9a1142e57fbd0aea432bd76ef46c0af1ef71d80b6986b945fce95ce9d34",
				"blockNumber": "0x1e8485",
				"data": "0x0000000000000000000000000000000000000000000000000000002e90edd000",
				"logIndex": "0x0",
				"topics": [
					"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
					"0x000000000000000000000000147af46ae9ccd18bb35ca01b353b51990e49dce1",
					"0x00000000000000000000000045d01cc478a3dcfd66607726dc50780f3eb4d7bc"
				],
				"transactionHash": "0x6994e58ca3816889184186ad8883e20277883959084c72a9fe12b92bea6422e2",
				"transactionIndex": "0x2",
				"transactionLogIndex": "0x0",
				"type": "mined"
			}
		],
		"logsBloom": "0x00000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000040000000008000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000400010000000000000000000000000000000000000000000000000000000000004000000000000000000800000000000000000000000000000000000000000000000000000000004000002000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000",
		"root": "0x5b694615e7e1ff4857d3c0714a4b70133ec2c161e1808029828ef979e5551347",
		"status": null,
		"transactionHash": "0x6994e58ca3816889184186ad8883e20277883959084c72a9fe12b92bea6422e2",
		"transactionIndex": "0x2"
	},
	"id": 1
}

Disclaimer - I'm not super familiar with the Ethereum network

Trying to send a transaction on a private network with EthSendTransaction but getting the following error

Error -32000 (authentication needed: password or unlock)

Is there another function that I should be using that takes a password?

In most cases, using http.Client is not a problem. However, you need to explicitly specify http.Client in certain cases (for example, when running on the Google App Engine). With this change, you can use any http.Client.

Trying to use the EthSendTransaction() function and having some trouble with the inputs used in the transaction{} object.

It would help alot if you could add an example to the README demonstrating the values used in the transaction{} object and what they represent.

TCP will not be released immediately after the end of the access, so when the client opens multiple threads to access at the same time, there will be an error of "onnectex: only one usage of each socket address (protocol/network address/port) is normally allowed." Can we adjust "TIME-WAIT"?

when I try use

client.EthCall(ethrpc.T{
            To:   contractAddress,
            Data: data,
        }, "latest")

to query balance of erc20 token

type T struct {
	From     string
	To       string
	Gas      int
	GasPrice *big.Int
	Value    *big.Int
	Data     string
	Nonce    int
}

func (t T) MarshalJSON() ([]byte, error) {
	params := map[string]interface{}{
		"from": t.From,
	}
	if t.To != "" {
		params["to"] = t.To
	}
	if t.Gas > 0 {
		params["gas"] = IntToHex(t.Gas)
	}
	if t.GasPrice != nil {
		params["gasPrice"] = BigToHex(*t.GasPrice)
	}
	if t.Value != nil {
		params["value"] = BigToHex(*t.Value)
	}
	if t.Data != "" {
		params["data"] = t.Data
	}
	if t.Nonce > 0 {
		params["nonce"] = IntToHex(t.Nonce)
	}

	return json.Marshal(params)
}

this let t.From = "" and get this json string {"id":1,"jsonrpc":"2.0","method":"eth_call","params":[{"data":"0x70a08231000000000000000000000000fe2e424e2ef9b929157dd525c414f4b128ee1bfb","from":"","to":"0xf4c90e18727c5c76499ea6369c856a6d61d3e92e"},"latest"]} after marshal

finnal error appear

invalid argument 0: hex string has length 0, want 40 for common.Address

client := ethrpc.New("https://ropsten.infura.io") hash := "0x931084475948fa771429ea3a5c39650e83a95059eff624d2089cc64c21e62915" bl ,err :=client.EthGetBlockByHash(hash,true) if err != nil{ log.Print("err", err) } fmt.Print("bl---",bl)

As far as I understand nonce might be zero, but current version of library doesn't allow it, and just do not place "nonce" in json request, which later interpreted by daemon that nonce specified at all, and request is not valid.

Not sure for 100% but that seems like this bug caused our transaction stuck on queue pool of ethereum daemon.