0x-mesh: github.com/0xProject/0x-mesh/rpc Index | Files

package rpc

import "github.com/0xProject/0x-mesh/rpc"

Index

Package Files

client.go server.go service.go types.go

func SetupHeartbeat Uses

func SetupHeartbeat(ctx context.Context) (*ethrpc.Subscription, error)

SetupHeartbeat sets up the heartbeat for a subscription

type AddOrdersOpts Uses

type AddOrdersOpts struct {
    // Pinned determines whether or not the added orders should be pinned. Pinned
    // orders will not be affected by any DDoS prevention or incentive mechanisms
    // and will always stay in storage until they are no longer fillable. Defaults
    // to true.
    Pinned bool `json:"pinned"`
}

AddOrdersOpts is a set of options for the AddOrders RPC method.

type Client Uses

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

Client is a JSON RPC 2.0 client implementation over WebSockets. It can be used to communicate with a 0x Mesh node and add orders.

func NewClient Uses

func NewClient(addr string) (*Client, error)

NewClient creates and returns a new client. addr is the address of the server (i.e. a 0x Mesh node) to dial.

func (*Client) AddOrders Uses

func (c *Client) AddOrders(orders []*zeroex.SignedOrder, opts ...AddOrdersOpts) (*ordervalidator.ValidationResults, error)

AddOrders adds orders to the 0x Mesh node and broadcasts them throughout the 0x Mesh network.

func (*Client) AddPeer Uses

func (c *Client) AddPeer(peerInfo peerstore.PeerInfo) error

AddPeer adds the peer to the node's list of peers. The node will attempt to connect to this new peer and return an error if it cannot.

func (*Client) GetOrders Uses

func (c *Client) GetOrders(page, perPage int, snapshotID string) (*GetOrdersResponse, error)

GetOrders gets all orders stored on the Mesh node at a particular point in time in a paginated fashion

func (*Client) GetStats Uses

func (c *Client) GetStats() (*GetStatsResponse, error)

GetStats retrieves stats about the Mesh node

func (*Client) SubscribeToHeartbeat Uses

func (c *Client) SubscribeToHeartbeat(ctx context.Context, ch chan<- string) (*rpc.ClientSubscription, error)

SubscribeToHeartbeat subscribes a stream of heartbeats in order to have certainty that the WS connection is still alive. Note copied from `go-ethereum` codebase: Slow subscribers will be dropped eventually. Client buffers up to 8000 notifications before considering the subscriber dead. The subscription Err channel will receive ErrSubscriptionQueueOverflow. Use a sufficiently large buffer on the channel or ensure that the channel usually has at least one reader to prevent this issue.

func (*Client) SubscribeToOrders Uses

func (c *Client) SubscribeToOrders(ctx context.Context, ch chan<- []*zeroex.OrderEvent) (*rpc.ClientSubscription, error)

SubscribeToOrders subscribes a stream of order events Note copied from `go-ethereum` codebase: Slow subscribers will be dropped eventually. Client buffers up to 8000 notifications before considering the subscriber dead. The subscription Err channel will receive ErrSubscriptionQueueOverflow. Use a sufficiently large buffer on the channel or ensure that the channel usually has at least one reader to prevent this issue.

type GetOrdersResponse Uses

type GetOrdersResponse struct {
    SnapshotID  string       `json:"snapshotID"`
    OrdersInfos []*OrderInfo `json:"ordersInfos"`
}

GetOrdersResponse is the response returned for an RPC request to mesh_getOrders

type GetStatsResponse Uses

type GetStatsResponse struct {
    Version                           string      `json:"version"`
    PubSubTopic                       string      `json:"pubSubTopic"`
    Rendezvous                        string      `json:"rendervous"`
    PeerID                            string      `json:"peerID"`
    EthereumChainID                   int         `json:"ethereumChainID"`
    LatestBlock                       LatestBlock `json:"latestBlock"`
    NumPeers                          int         `json:"numPeers"`
    NumOrders                         int         `json:"numOrders"`
    NumOrdersIncludingRemoved         int         `json:"numOrdersIncludingRemoved"`
    NumPinnedOrders                   int         `json:"numPinnedOrders"`
    MaxExpirationTime                 string      `json:"maxExpirationTime"`
    StartOfCurrentUTCDay              time.Time   `json:"startOfCurrentUTCDay"`
    EthRPCRequestsSentInCurrentUTCDay int         `json:"ethRPCRequestsSentInCurrentUTCDay"`
    EthRPCRateLimitExpiredRequests    int64       `json:"ethRPCRateLimitExpiredRequests"`
}

GetStatsResponse is the response returned for an RPC request to mesh_getStats

type LatestBlock Uses

type LatestBlock struct {
    Number int         `json:"number"`
    Hash   common.Hash `json:"hash"`
}

LatestBlock is the latest block processed by the Mesh node

type OrderInfo Uses

type OrderInfo struct {
    OrderHash                common.Hash         `json:"orderHash"`
    SignedOrder              *zeroex.SignedOrder `json:"signedOrder"`
    FillableTakerAssetAmount *big.Int            `json:"fillableTakerAssetAmount"`
}

OrderInfo represents an fillable order and how much it could be filled for

func (OrderInfo) MarshalJSON Uses

func (o OrderInfo) MarshalJSON() ([]byte, error)

MarshalJSON is a custom Marshaler for OrderInfo

func (*OrderInfo) UnmarshalJSON Uses

func (o *OrderInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements a custom JSON unmarshaller for the OrderEvent type

type RPCHandler Uses

type RPCHandler interface {
    // AddOrders is called when the client sends an AddOrders request.
    AddOrders(signedOrdersRaw []*json.RawMessage, opts AddOrdersOpts) (*ordervalidator.ValidationResults, error)
    // GetOrders is called when the clients sends a GetOrders request
    GetOrders(page, perPage int, snapshotID string) (*GetOrdersResponse, error)
    // AddPeer is called when the client sends an AddPeer request.
    AddPeer(peerInfo peerstore.PeerInfo) error
    // GetStats is called when the client sends an GetStats request.
    GetStats() (*GetStatsResponse, error)
    // SubscribeToOrders is called when a client sends a Subscribe to `orders` request
    SubscribeToOrders(ctx context.Context) (*rpc.Subscription, error)
}

RPCHandler is used to respond to incoming requests from the client.

type Server Uses

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

Server is a JSON RPC 2.0 server implementation over WebSockets. It accepts requests from a client for adding orders to the 0x Mesh network.

func NewServer Uses

func NewServer(addr string, rpcHandler RPCHandler) (*Server, error)

NewServer creates and returns a new server which will listen for new connections on the given addr and use the rpcHandler to handle incoming requests.

func (*Server) Addr Uses

func (s *Server) Addr() net.Addr

Addr returns the address the server is listening on or nil if it has not yet started listening.

func (*Server) Listen Uses

func (s *Server) Listen(ctx context.Context) error

Listen causes the server to listen for new connections. You can call Close to stop listening. Listen blocks until there is an error or the given context is canceled.

Package rpc imports 19 packages (graph) and is imported by 2 packages. Updated 2019-11-13. Refresh now. Tools for package owners.