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

package ordersync

import "github.com/0xProject/0x-mesh/core/ordersync"

Package ordersync contains the ordersync protocol, which is used for sharing existing orders between two peers, typically during initialization. The protocol consists of a requester (the peer requesting orders) and a provider (the peer providing them).

Index

Package Files

ordersync.go peer_score.go

Constants

const (
    // TypeRequest is used to identify a JSON message as an ordersync request.
    TypeRequest = "Request"
    // TypeResponse is used to identify a JSON message as an ordersync response.
    TypeResponse = "Response"
)
const (
    // ID is the ID for the ordersync protocol.
    ID = protocol.ID("/0x-mesh/order-sync/version/0")
)

Variables

var (
    // ErrNoOrders is returned whenever the orders we are looking for cannot be
    // found anywhere on the network. This can mean that we aren't connected to any
    // peers on the same topic, that there are no orders for the topic throughout
    // the entire network, or that there are peers that have the orders we're
    // looking for, but they are refusing to give them to us.
    ErrNoOrders = errors.New("no orders where received from any known peers")
    // ErrNoOrderFromPeer is returned when a peer returns no orders during ordersync.
    ErrNoOrdersFromPeer = errors.New("no orders received from peer")
)

type FirstRequestsForSubprotocols Uses

type FirstRequestsForSubprotocols struct {
    MetadataForSubprotocol []json.RawMessage `json:"metadata"`
}

type NoMatchingSubprotocolsError Uses

type NoMatchingSubprotocolsError struct {
    Requested []string
    Supported []string
}

NoMatchingSubprotocolsError is returned whenever two peers attempting to use the ordersync protocol cannot agree on a subprotocol to use.

func (NoMatchingSubprotocolsError) Error Uses

func (e NoMatchingSubprotocolsError) Error() string

type Request Uses

type Request struct {
    RequesterID peer.ID     `json:"requesterID"`
    Metadata    interface{} `json:"metadata"`
}

Request represents a high-level ordersync request. It abstracts away some of the details of subprotocol negotiation and encoding/decoding.

type Response Uses

type Response struct {
    ProviderID peer.ID               `json:"providerID"`
    Orders     []*zeroex.SignedOrder `json:"orders"`
    Complete   bool                  `json:"complete"`
    Metadata   interface{}           `json:"metadata"`
}

Response represents a high-level ordersync response. It abstracts away some of the details of subprotocol negotiation and encoding/decoding.

type Service Uses

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

Service is the main entrypoint for running the ordersync protocol. It handles responding to and sending ordersync requests.

func New Uses

func New(ctx context.Context, node *p2p.Node, subprotocols []Subprotocol) *Service

New creates and returns a new ordersync service, which is used for both requesting orders from other peers and providing orders to peers who request them. New expects an array of subprotocols which the service will support, in the order of preference. The service will automatically pick the most preferred protocol that is supported by both peers for each request/response.

func (*Service) GetMatchingSubprotocol Uses

func (s *Service) GetMatchingSubprotocol(rawReq *rawRequest) (Subprotocol, int, error)

GetMatchingSubprotocol returns the most preferred subprotocol to use based on the given request.

func (*Service) GetOrders Uses

func (s *Service) GetOrders(ctx context.Context, minPeers int) error

GetOrders iterates through every peer the node is currently connected to and attempts to perform the ordersync protocol. It keeps trying until ordersync has been completed with minPeers, using an exponential backoff strategy between retries.

func (*Service) HandleStream Uses

func (s *Service) HandleStream(stream network.Stream)

HandleStream is a stream handler that is used to handle incoming ordersync requests.

func (*Service) PeriodicallyGetOrders Uses

func (s *Service) PeriodicallyGetOrders(ctx context.Context, minPeers int, approxDelay time.Duration) error

PeriodicallyGetOrders periodically calls GetOrders. It waits a minimum of approxDelay (with some random jitter) between each call. It will block until there is a critical error or the given context is canceled.

type Subprotocol Uses

type Subprotocol interface {
    // Name is the name of the subprotocol. Must be unique.
    Name() string
    // HandleOrderSyncRequest returns a Response based on the given Request. It is the
    // implementation for the "provider" side of the subprotocol.
    HandleOrderSyncRequest(context.Context, *Request) (*Response, error)
    // HandleOrderSyncResponse handles a response (e.g. typically by saving orders to
    // the database), returns the number of valid orders that were received,
    // and, if needed, creates and returns the next request that should be sent.
    // If nextRequest is nil, the ordersync protocol is considered finished.
    // HandleOrderSyncResponse is the implementation for the "requester" side
    // of the subprotocol.
    HandleOrderSyncResponse(context.Context, *Response) (nextRequest *Request, numValidOrders int, err error)
    // ParseRequestMetadata converts raw request metadata into a concrete type
    // that the subprotocol expects.
    ParseRequestMetadata(metadata json.RawMessage) (interface{}, error)
    // ParseResponseMetadata converts raw response metadata into a concrete type
    // that the subprotocol expects.
    ParseResponseMetadata(metadata json.RawMessage) (interface{}, error)
    // GenerateFirstRequestMetadata generates the metadata for the first request
    // that should be made with this subprotocol.
    GenerateFirstRequestMetadata() (json.RawMessage, error)
}

Subprotocol is a lower-level protocol which defines the details for the request/response metadata. While the ordersync protocol supports sending requests and responses in order to synchronize orders between two peers in general, a subprotocol defines exactly what those requests and responses should look like and how each peer is expected to respond to them.

Package ordersync imports 16 packages (graph) and is imported by 1 packages. Updated 2020-09-24. Refresh now. Tools for package owners.