func (c *Client) GetWork() (*soterjson.GetWorkResult, error) {
	return c.GetWorkAsync().Receive()
}
GetWork returns hash data to work on.

See GetWorkSubmit to submit the found solution.
package rpcclient
import (
	"encoding/hex"
	"encoding/json"
	"errors"
	"github.com/soteria-dag/soterd/soterjson"
	"github.com/soteria-dag/soterd/chaincfg/chainhash"
	"github.com/soteria-dag/soterd/soterutil"
)
type FutureGenerateResult chan *response
func (r FutureGenerateResult) Receive() ([]*chainhash.Hash, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var result []string
	err = json.Unmarshal(res, &result)
	if err != nil {
		return nil, err
	}
	convertedResult := make([]*chainhash.Hash, len(result))
	for i, hashString := range result {
		convertedResult[i], err = chainhash.NewHashFromStr(hashString)
		if err != nil {
			return nil, err
		}
	}
	return convertedResult, nil
}
func (c *Client) GenerateAsync(numBlocks uint32) FutureGenerateResult {
	cmd := soterjson.NewGenerateCmd(numBlocks)
	return c.sendCmd(cmd)
}
func (c *Client) Generate(numBlocks uint32) ([]*chainhash.Hash, error) {
	return c.GenerateAsync(numBlocks).Receive()
}
type FutureGetGenerateResult chan *response
func (r FutureGetGenerateResult) Receive() (bool, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return false, err
	}
	var result bool
	err = json.Unmarshal(res, &result)
	if err != nil {
		return false, err
	}
	return result, nil
}
func (c *Client) GetGenerateAsync() FutureGetGenerateResult {
	cmd := soterjson.NewGetGenerateCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetGenerate() (bool, error) {
	return c.GetGenerateAsync().Receive()
}
type FutureSetGenerateResult chan *response
func (r FutureSetGenerateResult) Receive() error {
	_, err := receiveFuture(r)
	return err
}
func (c *Client) SetGenerateAsync(enable bool, numCPUs int) FutureSetGenerateResult {
	cmd := soterjson.NewSetGenerateCmd(enable, &numCPUs)
	return c.sendCmd(cmd)
}
func (c *Client) SetGenerate(enable bool, numCPUs int) error {
	return c.SetGenerateAsync(enable, numCPUs).Receive()
}
type FutureGetHashesPerSecResult chan *response
func (r FutureGetHashesPerSecResult) Receive() (int64, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return -1, err
	}
	var result int64
	err = json.Unmarshal(res, &result)
	if err != nil {
		return 0, err
	}
	return result, nil
}
func (c *Client) GetHashesPerSecAsync() FutureGetHashesPerSecResult {
	cmd := soterjson.NewGetHashesPerSecCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetHashesPerSec() (int64, error) {
	return c.GetHashesPerSecAsync().Receive()
}
type FutureGetBlockMetricsResult chan *response
func (r FutureGetBlockMetricsResult) Receive() (*soterjson.GetBlockMetricsResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var blkTimes soterjson.GetBlockMetricsResult
	if err := json.Unmarshal(res, &blkTimes); err != nil {
		return nil, err
	}
	return &blkTimes, nil
}
func (c *Client) GetBlockMetricsAsync() FutureGetBlockMetricsResult {
	cmd := soterjson.NewGetBlockMetricsCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetBlockMetrics() (*soterjson.GetBlockMetricsResult, error) {
	return c.GetBlockMetricsAsync().Receive()
}
type FutureGetMiningInfoResult chan *response
func (r FutureGetMiningInfoResult) Receive() (*soterjson.GetMiningInfoResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var infoResult soterjson.GetMiningInfoResult
	err = json.Unmarshal(res, &infoResult)
	if err != nil {
		return nil, err
	}
	return &infoResult, nil
}
func (c *Client) GetMiningInfoAsync() FutureGetMiningInfoResult {
	cmd := soterjson.NewGetMiningInfoCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetMiningInfo() (*soterjson.GetMiningInfoResult, error) {
	return c.GetMiningInfoAsync().Receive()
}
type FutureGetNetworkHashPS chan *response
func (r FutureGetNetworkHashPS) Receive() (int64, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return -1, err
	}
	var result int64
	err = json.Unmarshal(res, &result)
	if err != nil {
		return 0, err
	}
	return result, nil
}
func (c *Client) GetNetworkHashPSAsync() FutureGetNetworkHashPS {
	cmd := soterjson.NewGetNetworkHashPSCmd(nil, nil)
	return c.sendCmd(cmd)
}
func (c *Client) GetNetworkHashPS() (int64, error) {
	return c.GetNetworkHashPSAsync().Receive()
}
func (c *Client) GetNetworkHashPS2Async(blocks int) FutureGetNetworkHashPS {
	cmd := soterjson.NewGetNetworkHashPSCmd(&blocks, nil)
	return c.sendCmd(cmd)
}
func (c *Client) GetNetworkHashPS2(blocks int) (int64, error) {
	return c.GetNetworkHashPS2Async(blocks).Receive()
}
func (c *Client) GetNetworkHashPS3Async(blocks, height int) FutureGetNetworkHashPS {
	cmd := soterjson.NewGetNetworkHashPSCmd(&blocks, &height)
	return c.sendCmd(cmd)
}
func (c *Client) GetNetworkHashPS3(blocks, height int) (int64, error) {
	return c.GetNetworkHashPS3Async(blocks, height).Receive()
}
type FutureGetWork chan *response
func (r FutureGetWork) Receive() (*soterjson.GetWorkResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var result soterjson.GetWorkResult
	err = json.Unmarshal(res, &result)
	if err != nil {
		return nil, err
	}
	return &result, nil
}
func (c *Client) GetWorkAsync() FutureGetWork {
	cmd := soterjson.NewGetWorkCmd(nil)
	return c.sendCmd(cmd)
}