rpc/client: take context as first param (#5347)

Closes #5145

also applies to light/client

rpc/client/http/http.go

@@ -183,8 +183,8 @@ func (c *HTTP) NewBatch() *BatchHTTP {
 // compilation of the batched requests and send them off using the client as a
 // single request. On success, this returns a list of the deserialized results
 // from each request in the sent batch.
-func (b *BatchHTTP) Send() ([]interface{}, error) {
-	return b.rpcBatch.Send()
+func (b *BatchHTTP) Send(ctx context.Context) ([]interface{}, error) {
+	return b.rpcBatch.Send(ctx)
 }
 
 // Clear will empty out this batch of requests and return the number of requests
@@ -201,9 +201,9 @@ func (b *BatchHTTP) Count() int {
 //-----------------------------------------------------------------------------
 // baseRPCClient
 
-func (c *baseRPCClient) Status() (*ctypes.ResultStatus, error) {
+func (c *baseRPCClient) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
 	result := new(ctypes.ResultStatus)
-	_, err := c.caller.Call("status", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "status", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
@@ -211,9 +211,9 @@ func (c *baseRPCClient) Status() (*ctypes.ResultStatus, error) {
 	return result, nil
 }
 
-func (c *baseRPCClient) ABCIInfo() (*ctypes.ResultABCIInfo, error) {
+func (c *baseRPCClient) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) {
 	result := new(ctypes.ResultABCIInfo)
-	_, err := c.caller.Call("abci_info", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "abci_info", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
@@ -221,16 +221,21 @@ func (c *baseRPCClient) ABCIInfo() (*ctypes.ResultABCIInfo, error) {
 	return result, nil
 }
 
-func (c *baseRPCClient) ABCIQuery(path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) {
-	return c.ABCIQueryWithOptions(path, data, rpcclient.DefaultABCIQueryOptions)
+func (c *baseRPCClient) ABCIQuery(
+	ctx context.Context,
+	path string,
+	data bytes.HexBytes,
+) (*ctypes.ResultABCIQuery, error) {
+	return c.ABCIQueryWithOptions(ctx, path, data, rpcclient.DefaultABCIQueryOptions)
 }
 
 func (c *baseRPCClient) ABCIQueryWithOptions(
+	ctx context.Context,
 	path string,
 	data bytes.HexBytes,
 	opts rpcclient.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) {
 	result := new(ctypes.ResultABCIQuery)
-	_, err := c.caller.Call("abci_query",
+	_, err := c.caller.Call(ctx, "abci_query",
 		map[string]interface{}{"path": path, "data": data, "height": opts.Height, "prove": opts.Prove},
 		result)
 	if err != nil {
@@ -240,115 +245,138 @@ func (c *baseRPCClient) ABCIQueryWithOptions(
 	return result, nil
 }
 
-func (c *baseRPCClient) BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
+func (c *baseRPCClient) BroadcastTxCommit(
+	ctx context.Context,
+	tx types.Tx,
+) (*ctypes.ResultBroadcastTxCommit, error) {
 	result := new(ctypes.ResultBroadcastTxCommit)
-	_, err := c.caller.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, result)
+	_, err := c.caller.Call(ctx, "broadcast_tx_commit", map[string]interface{}{"tx": tx}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) BroadcastTxAsync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
-	return c.broadcastTX("broadcast_tx_async", tx)
+func (c *baseRPCClient) BroadcastTxAsync(
+	ctx context.Context,
+	tx types.Tx,
+) (*ctypes.ResultBroadcastTx, error) {
+	return c.broadcastTX(ctx, "broadcast_tx_async", tx)
 }
 
-func (c *baseRPCClient) BroadcastTxSync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
-	return c.broadcastTX("broadcast_tx_sync", tx)
+func (c *baseRPCClient) BroadcastTxSync(
+	ctx context.Context,
+	tx types.Tx,
+) (*ctypes.ResultBroadcastTx, error) {
+	return c.broadcastTX(ctx, "broadcast_tx_sync", tx)
 }
 
-func (c *baseRPCClient) broadcastTX(route string, tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
+func (c *baseRPCClient) broadcastTX(
+	ctx context.Context,
+	route string,
+	tx types.Tx,
+) (*ctypes.ResultBroadcastTx, error) {
 	result := new(ctypes.ResultBroadcastTx)
-	_, err := c.caller.Call(route, map[string]interface{}{"tx": tx}, result)
+	_, err := c.caller.Call(ctx, route, map[string]interface{}{"tx": tx}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) UnconfirmedTxs(limit *int) (*ctypes.ResultUnconfirmedTxs, error) {
+func (c *baseRPCClient) UnconfirmedTxs(
+	ctx context.Context,
+	limit *int,
+) (*ctypes.ResultUnconfirmedTxs, error) {
 	result := new(ctypes.ResultUnconfirmedTxs)
 	params := make(map[string]interface{})
 	if limit != nil {
 		params["limit"] = limit
 	}
-	_, err := c.caller.Call("unconfirmed_txs", params, result)
+	_, err := c.caller.Call(ctx, "unconfirmed_txs", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) NumUnconfirmedTxs() (*ctypes.ResultUnconfirmedTxs, error) {
+func (c *baseRPCClient) NumUnconfirmedTxs(ctx context.Context) (*ctypes.ResultUnconfirmedTxs, error) {
 	result := new(ctypes.ResultUnconfirmedTxs)
-	_, err := c.caller.Call("num_unconfirmed_txs", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "num_unconfirmed_txs", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) CheckTx(tx types.Tx) (*ctypes.ResultCheckTx, error) {
+func (c *baseRPCClient) CheckTx(ctx context.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) {
 	result := new(ctypes.ResultCheckTx)
-	_, err := c.caller.Call("check_tx", map[string]interface{}{"tx": tx}, result)
+	_, err := c.caller.Call(ctx, "check_tx", map[string]interface{}{"tx": tx}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) NetInfo() (*ctypes.ResultNetInfo, error) {
+func (c *baseRPCClient) NetInfo(ctx context.Context) (*ctypes.ResultNetInfo, error) {
 	result := new(ctypes.ResultNetInfo)
-	_, err := c.caller.Call("net_info", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "net_info", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) {
+func (c *baseRPCClient) DumpConsensusState(ctx context.Context) (*ctypes.ResultDumpConsensusState, error) {
 	result := new(ctypes.ResultDumpConsensusState)
-	_, err := c.caller.Call("dump_consensus_state", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "dump_consensus_state", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) ConsensusState() (*ctypes.ResultConsensusState, error) {
+func (c *baseRPCClient) ConsensusState(ctx context.Context) (*ctypes.ResultConsensusState, error) {
 	result := new(ctypes.ResultConsensusState)
-	_, err := c.caller.Call("consensus_state", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "consensus_state", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) ConsensusParams(height *int64) (*ctypes.ResultConsensusParams, error) {
+func (c *baseRPCClient) ConsensusParams(
+	ctx context.Context,
+	height *int64,
+) (*ctypes.ResultConsensusParams, error) {
 	result := new(ctypes.ResultConsensusParams)
 	params := make(map[string]interface{})
 	if height != nil {
 		params["height"] = height
 	}
-	_, err := c.caller.Call("consensus_params", params, result)
+	_, err := c.caller.Call(ctx, "consensus_params", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) Health() (*ctypes.ResultHealth, error) {
+func (c *baseRPCClient) Health(ctx context.Context) (*ctypes.ResultHealth, error) {
 	result := new(ctypes.ResultHealth)
-	_, err := c.caller.Call("health", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "health", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) BlockchainInfo(minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) {
+func (c *baseRPCClient) BlockchainInfo(
+	ctx context.Context,
+	minHeight,
+	maxHeight int64,
+) (*ctypes.ResultBlockchainInfo, error) {
 	result := new(ctypes.ResultBlockchainInfo)
-	_, err := c.caller.Call("blockchain",
+	_, err := c.caller.Call(ctx, "blockchain",
 		map[string]interface{}{"minHeight": minHeight, "maxHeight": maxHeight},
 		result)
 	if err != nil {
@@ -357,80 +385,90 @@ func (c *baseRPCClient) BlockchainInfo(minHeight, maxHeight int64) (*ctypes.Resu
 	return result, nil
 }
 
-func (c *baseRPCClient) Genesis() (*ctypes.ResultGenesis, error) {
+func (c *baseRPCClient) Genesis(ctx context.Context) (*ctypes.ResultGenesis, error) {
 	result := new(ctypes.ResultGenesis)
-	_, err := c.caller.Call("genesis", map[string]interface{}{}, result)
+	_, err := c.caller.Call(ctx, "genesis", map[string]interface{}{}, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) Block(height *int64) (*ctypes.ResultBlock, error) {
+func (c *baseRPCClient) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) {
 	result := new(ctypes.ResultBlock)
 	params := make(map[string]interface{})
 	if height != nil {
 		params["height"] = height
 	}
-	_, err := c.caller.Call("block", params, result)
+	_, err := c.caller.Call(ctx, "block", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) BlockByHash(hash []byte) (*ctypes.ResultBlock, error) {
+func (c *baseRPCClient) BlockByHash(ctx context.Context, hash []byte) (*ctypes.ResultBlock, error) {
 	result := new(ctypes.ResultBlock)
 	params := map[string]interface{}{
 		"hash": hash,
 	}
-	_, err := c.caller.Call("block_by_hash", params, result)
+	_, err := c.caller.Call(ctx, "block_by_hash", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) BlockResults(height *int64) (*ctypes.ResultBlockResults, error) {
+func (c *baseRPCClient) BlockResults(
+	ctx context.Context,
+	height *int64,
+) (*ctypes.ResultBlockResults, error) {
 	result := new(ctypes.ResultBlockResults)
 	params := make(map[string]interface{})
 	if height != nil {
 		params["height"] = height
 	}
-	_, err := c.caller.Call("block_results", params, result)
+	_, err := c.caller.Call(ctx, "block_results", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) Commit(height *int64) (*ctypes.ResultCommit, error) {
+func (c *baseRPCClient) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) {
 	result := new(ctypes.ResultCommit)
 	params := make(map[string]interface{})
 	if height != nil {
 		params["height"] = height
 	}
-	_, err := c.caller.Call("commit", params, result)
+	_, err := c.caller.Call(ctx, "commit", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) Tx(hash []byte, prove bool) (*ctypes.ResultTx, error) {
+func (c *baseRPCClient) Tx(ctx context.Context, hash []byte, prove bool) (*ctypes.ResultTx, error) {
 	result := new(ctypes.ResultTx)
 	params := map[string]interface{}{
 		"hash":  hash,
 		"prove": prove,
 	}
-	_, err := c.caller.Call("tx", params, result)
+	_, err := c.caller.Call(ctx, "tx", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) TxSearch(query string, prove bool, page, perPage *int, orderBy string) (
+func (c *baseRPCClient) TxSearch(
+	ctx context.Context,
+	query string,
+	prove bool,
+	page,
+	perPage *int,
+	orderBy string,
+) (
 	*ctypes.ResultTxSearch, error) {
 	result := new(ctypes.ResultTxSearch)
 	params := map[string]interface{}{
@@ -444,14 +482,19 @@ func (c *baseRPCClient) TxSearch(query string, prove bool, page, perPage *int, o
 	if perPage != nil {
 		params["per_page"] = perPage
 	}
-	_, err := c.caller.Call("tx_search", params, result)
+	_, err := c.caller.Call(ctx, "tx_search", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) Validators(height *int64, page, perPage *int) (*ctypes.ResultValidators, error) {
+func (c *baseRPCClient) Validators(
+	ctx context.Context,
+	height *int64,
+	page,
+	perPage *int,
+) (*ctypes.ResultValidators, error) {
 	result := new(ctypes.ResultValidators)
 	params := make(map[string]interface{})
 	if page != nil {
@@ -463,16 +506,19 @@ func (c *baseRPCClient) Validators(height *int64, page, perPage *int) (*ctypes.R
 	if height != nil {
 		params["height"] = height
 	}
-	_, err := c.caller.Call("validators", params, result)
+	_, err := c.caller.Call(ctx, "validators", params, result)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func (c *baseRPCClient) BroadcastEvidence(ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) {
+func (c *baseRPCClient) BroadcastEvidence(
+	ctx context.Context,
+	ev types.Evidence,
+) (*ctypes.ResultBroadcastEvidence, error) {
 	result := new(ctypes.ResultBroadcastEvidence)
-	_, err := c.caller.Call("broadcast_evidence", map[string]interface{}{"evidence": ev}, result)
+	_, err := c.caller.Call(ctx, "broadcast_evidence", map[string]interface{}{"evidence": ev}, result)
 	if err != nil {
 		return nil, err
 	}