github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/rpc/rpcinfo/infoclient/client.go (about)

     1  // Copyright Monax Industries Limited
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package infoclient
     5  
     6  import (
     7  	"errors"
     8  	"fmt"
     9  
    10  	"github.com/hyperledger/burrow/acm"
    11  	"github.com/hyperledger/burrow/crypto"
    12  	"github.com/hyperledger/burrow/execution/names"
    13  	"github.com/hyperledger/burrow/rpc"
    14  	"github.com/hyperledger/burrow/rpc/rpcinfo"
    15  )
    16  
    17  func Status(client rpc.Client) (*rpc.ResultStatus, error) {
    18  	res := new(rpc.ResultStatus)
    19  	err := client.Call(rpcinfo.Status, pmap(), res)
    20  	if err != nil {
    21  		return nil, err
    22  	}
    23  	return res, nil
    24  }
    25  
    26  func ChainId(client rpc.Client) (*rpc.ResultChainId, error) {
    27  	res := new(rpc.ResultChainId)
    28  	err := client.Call(rpcinfo.ChainID, pmap(), &res)
    29  	if err != nil {
    30  		return nil, err
    31  	}
    32  	return res, nil
    33  }
    34  
    35  func Account(client rpc.Client, address crypto.Address) (*acm.Account, error) {
    36  	res := new(rpc.ResultAccount)
    37  	err := client.Call(rpcinfo.Account, pmap("address", address), res)
    38  	if err != nil {
    39  		return nil, err
    40  	}
    41  	return res.Account, nil
    42  }
    43  
    44  func DumpStorage(client rpc.Client, address crypto.Address) (*rpc.ResultDumpStorage, error) {
    45  	res := new(rpc.ResultDumpStorage)
    46  	err := client.Call(rpcinfo.DumpStorage, pmap("address", address), res)
    47  	if err != nil {
    48  		return nil, err
    49  	}
    50  	return res, nil
    51  }
    52  
    53  func Storage(client rpc.Client, address crypto.Address, key []byte) ([]byte, error) {
    54  	res := new(rpc.ResultStorage)
    55  	err := client.Call(rpcinfo.Storage, pmap("address", address, "key", key), res)
    56  	if err != nil {
    57  		return nil, err
    58  	}
    59  	return res.Value, nil
    60  }
    61  
    62  func Name(client rpc.Client, name string) (*names.Entry, error) {
    63  	res := new(rpc.ResultName)
    64  	err := client.Call(rpcinfo.Name, pmap("name", name), res)
    65  	if err != nil {
    66  		return nil, err
    67  	}
    68  	return res.Entry, nil
    69  }
    70  
    71  func Names(client rpc.Client, regex string) ([]*names.Entry, error) {
    72  	res := new(rpc.ResultNames)
    73  	err := client.Call(rpcinfo.Names, pmap("regex", regex), res)
    74  	if err != nil {
    75  		return nil, err
    76  	}
    77  	return res.Names, nil
    78  }
    79  
    80  func Blocks(client rpc.Client, minHeight, maxHeight int) (*rpc.ResultBlocks, error) {
    81  	res := new(rpc.ResultBlocks)
    82  	err := client.Call(rpcinfo.Blocks, pmap("minHeight", minHeight, "maxHeight", maxHeight), res)
    83  	if err != nil {
    84  		return nil, err
    85  	}
    86  	return res, nil
    87  }
    88  
    89  func Block(client rpc.Client, height int) (*rpc.ResultBlock, error) {
    90  	res := new(rpc.ResultBlock)
    91  	err := client.Call(rpcinfo.Block, pmap("height", height), res)
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  	return res, nil
    96  }
    97  
    98  func UnconfirmedTxs(client rpc.Client, maxTxs int) (*rpc.ResultUnconfirmedTxs, error) {
    99  	res := new(rpc.ResultUnconfirmedTxs)
   100  	err := client.Call(rpcinfo.UnconfirmedTxs, pmap("maxTxs", maxTxs), res)
   101  	if err != nil {
   102  		return nil, err
   103  	}
   104  	resCon := res
   105  	return resCon, nil
   106  }
   107  
   108  func Validators(client rpc.Client) (*rpc.ResultValidators, error) {
   109  	res := new(rpc.ResultValidators)
   110  	err := client.Call(rpcinfo.Validators, pmap(), res)
   111  	if err != nil {
   112  		return nil, err
   113  	}
   114  	return res, nil
   115  }
   116  
   117  func Consensus(client rpc.Client) (*rpc.ResultConsensusState, error) {
   118  	res := new(rpc.ResultConsensusState)
   119  	err := client.Call(rpcinfo.Consensus, pmap(), res)
   120  	if err != nil {
   121  		return nil, err
   122  	}
   123  	return res, nil
   124  }
   125  
   126  func pmap(keyvals ...interface{}) map[string]interface{} {
   127  	pm, err := ParamsToMap(keyvals...)
   128  	if err != nil {
   129  		panic(err)
   130  	}
   131  	return pm
   132  }
   133  
   134  func ParamsToMap(orderedKeyVals ...interface{}) (map[string]interface{}, error) {
   135  	if len(orderedKeyVals)%2 != 0 {
   136  		return nil, fmt.Errorf("mapAndValues requires a even length list of"+
   137  			" keys and values but got: %v (length %v)",
   138  			orderedKeyVals, len(orderedKeyVals))
   139  	}
   140  	paramsMap := make(map[string]interface{})
   141  	for i := 0; i < len(orderedKeyVals); i += 2 {
   142  		key, ok := orderedKeyVals[i].(string)
   143  		if !ok {
   144  			return nil, errors.New("mapAndValues requires every even element" +
   145  				" of orderedKeyVals to be a string key")
   146  		}
   147  		val := orderedKeyVals[i+1]
   148  		paramsMap[key] = val
   149  	}
   150  	return paramsMap, nil
   151  }