rpcbackend

Documentation

Index

• type Backend
  • func NewRPCClient(client *resty.Client) Backend
  • func NewRPCClientWithOption(client *resty.Client, options RPCClientOptions) Backend
• type RPC
• type RPCClient
  • func (rc *RPCClient) CallRPC(ctx context.Context, result interface{}, method string, params ...interface{}) *RPCError
  • func (rc *RPCClient) SyncRequest(ctx context.Context, rpcReq *RPCRequest) (rpcRes *RPCResponse, err error)
• type RPCClientOptions
• type RPCCode
• type RPCError
  • func NewRPCError(ctx context.Context, code RPCCode, msg i18n.ErrorMessageKey, ...) *RPCError
  • func (e *RPCError) Error() error
  • func (e *RPCError) String() string
• type RPCRequest
• type RPCResponse
  • func RPCErrorResponse(err error, id *fftypes.JSONAny, code RPCCode) *RPCResponse
  • func (r *RPCResponse) Message() string
• type RPCSubscriptionNotification
• type Subscription
• type WebSocketRPCClient
  • func NewWSRPCClient(wsConf *wsclient.WSConfig) WebSocketRPCClient

Types

type Backend

type Backend interface {
	RPC
	SyncRequest(ctx context.Context, rpcReq *RPCRequest) (rpcRes *RPCResponse, err error)
}

Backend performs communication with a backend

func NewRPCClient

func NewRPCClient(client *resty.Client) Backend

NewRPCClient Constructor

func NewRPCClientWithOption

func NewRPCClientWithOption(client *resty.Client, options RPCClientOptions) Backend

NewRPCClientWithOption Constructor

type RPC

type RPC interface {
	CallRPC(ctx context.Context, result interface{}, method string, params ...interface{}) *RPCError
}

type RPCClient

type RPCClient struct {
	// contains filtered or unexported fields
}

func (*RPCClient) CallRPC

func (rc *RPCClient) CallRPC(ctx context.Context, result interface{}, method string, params ...interface{}) *RPCError

func (*RPCClient) SyncRequest

func (rc *RPCClient) SyncRequest(ctx context.Context, rpcReq *RPCRequest) (rpcRes *RPCResponse, err error)

SyncRequest sends an individual RPC request to the backend (always over HTTP currently), and waits synchronously for the response, or an error.

In all return paths *including error paths* the RPCResponse is populated so the caller has an RPC structure to send back to the front-end caller.

type RPCClientOptions

type RPCClientOptions struct {
	MaxConcurrentRequest int64
}

type RPCCode

type RPCCode int64

const (
	RPCCodeParseError     RPCCode = -32700
	RPCCodeInvalidRequest RPCCode = -32600
	RPCCodeInternalError  RPCCode = -32603
)

type RPCError

type RPCError struct {
	Code    int64           `json:"code"`
	Message string          `json:"message"`
	Data    fftypes.JSONAny `json:"data,omitempty"`
}

func NewRPCError

func NewRPCError(ctx context.Context, code RPCCode, msg i18n.ErrorMessageKey, inserts ...interface{}) *RPCError

func (*RPCError) Error

func (e *RPCError) Error() error

func (*RPCError) String

func (e *RPCError) String() string

type RPCRequest

type RPCRequest struct {
	JSONRpc string             `json:"jsonrpc"`
	ID      *fftypes.JSONAny   `json:"id"`
	Method  string             `json:"method"`
	Params  []*fftypes.JSONAny `json:"params,omitempty"`
}

type RPCResponse

type RPCResponse struct {
	JSONRpc string           `json:"jsonrpc"`
	ID      *fftypes.JSONAny `json:"id"`
	Result  *fftypes.JSONAny `json:"result,omitempty"`
	Error   *RPCError        `json:"error,omitempty"`
	// Only for subscription notifications
	Method string           `json:"method,omitempty"`
	Params *fftypes.JSONAny `json:"params,omitempty"`
}

func RPCErrorResponse

func RPCErrorResponse(err error, id *fftypes.JSONAny, code RPCCode) *RPCResponse

func (*RPCResponse) Message

func (r *RPCResponse) Message() string

type RPCSubscriptionNotification

type RPCSubscriptionNotification struct {
	CurrentSubID string // will change on each reconnect
	Result       *fftypes.JSONAny
}

type Subscription

type Subscription interface {
	LocalID() *fftypes.UUID // does not change through reconnects
	Notifications() chan *RPCSubscriptionNotification
	Unsubscribe(ctx context.Context) *RPCError
}

type WebSocketRPCClient

type WebSocketRPCClient interface {
	RPC
	Subscribe(ctx context.Context, params ...interface{}) (sub Subscription, error *RPCError)
	Subscriptions() []Subscription
	UnsubscribeAll(ctx context.Context) (error *RPCError)
	Connect(ctx context.Context) error
	Close()
}

WebSocketRPCClient performs communication over a websocket with an Ethereum JSON/RPC endpoint

- Manages websocket connect/reconnect with keepalive etc. - Manages subscriptions with a local ID, so they re-established automatically after reconnect - Allows synchronous exchange over the WebSocket so you don't have to maintain a separate HTTP connection too

func NewWSRPCClient

func NewWSRPCClient(wsConf *wsclient.WSConfig) WebSocketRPCClient

NewRPCClient Constructor