core

Documentation

Overview

Package core contains everything needed to configure and run a 0x Mesh node.

Index

• type App
  • func New(config Config) (*App, error)
  • func (app *App) AddOrders(ctx context.Context, signedOrdersRaw []*json.RawMessage, pinned bool) (*ordervalidator.ValidationResults, error)
  • func (app *App) AddPeer(peerInfo peerstore.PeerInfo) error
  • func (app *App) GetOrders(page, perPage int, snapshotID string) (*types.GetOrdersResponse, error)
  • func (app *App) GetStats() (*types.Stats, error)
  • func (app *App) HandleMessages(ctx context.Context, messages []*p2p.Message) error
  • func (app *App) IsCaughtUpToLatestBlock(ctx context.Context) bool
  • func (app *App) Start(ctx context.Context) error
  • func (app *App) SubscribeToOrderEvents(sink chan<- []*zeroex.OrderEvent) event.Subscription
• type Config
• type ErrPerPageZero
  • func (e ErrPerPageZero) Error() string
• type ErrSnapshotNotFound
  • func (e ErrSnapshotNotFound) Error() string
• type FilteredPaginationRequestMetadata
• type FilteredPaginationResponseMetadata
• type FilteredPaginationSubProtocol
  • func NewFilteredPaginationSubprotocol(app *App, perPage int) *FilteredPaginationSubProtocol
  • func (p *FilteredPaginationSubProtocol) HandleOrderSyncRequest(ctx context.Context, req *ordersync.Request) (*ordersync.Response, error)
  • func (p *FilteredPaginationSubProtocol) HandleOrderSyncResponse(ctx context.Context, res *ordersync.Response) (*ordersync.Request, error)
  • func (p *FilteredPaginationSubProtocol) Name() string
  • func (p *FilteredPaginationSubProtocol) ParseRequestMetadata(metadata json.RawMessage) (interface{}, error)
  • func (p *FilteredPaginationSubProtocol) ParseResponseMetadata(metadata json.RawMessage) (interface{}, error)

Types

type App

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

func New

func New(config Config) (*App, error)

func (*App) AddOrders

func (app *App) AddOrders(ctx context.Context, signedOrdersRaw []*json.RawMessage, pinned bool) (*ordervalidator.ValidationResults, error)

AddOrders can be used to add orders to Mesh. It validates the given orders and if they are valid, will store and eventually broadcast the orders to peers. If pinned is true, the orders will be marked as pinned, which means they will only be removed if they become unfillable and will not be removed due to having a high expiration time or any incentive mechanisms.

func (*App) AddPeer

func (app *App) AddPeer(peerInfo peerstore.PeerInfo) error

AddPeer can be used to manually connect to a new peer.

func (*App) GetOrders

func (app *App) GetOrders(page, perPage int, snapshotID string) (*types.GetOrdersResponse, error)

GetOrders retrieves paginated orders from the Mesh DB at a specific snapshot in time. Passing an empty string as `snapshotID` creates a new snapshot and returns the first set of results. To fetch all orders, continue to make requests supplying the `snapshotID` returned from the first request. After 1 minute of not received further requests referencing a specific snapshot, the snapshot expires and can no longer be used.

func (*App) GetStats

func (app *App) GetStats() (*types.Stats, error)

GetStats retrieves stats about the Mesh node

func (*App) HandleMessages

func (app *App) HandleMessages(ctx context.Context, messages []*p2p.Message) error

func (*App) IsCaughtUpToLatestBlock

func (app *App) IsCaughtUpToLatestBlock(ctx context.Context) bool

IsCaughtUpToLatestBlock returns whether or not the latest block stored by Mesh corresponds to the latest block retrieved from it's Klaytn RPC endpoint

func (*App) Start

func (app *App) Start(ctx context.Context) error

func (*App) SubscribeToOrderEvents

func (app *App) SubscribeToOrderEvents(sink chan<- []*zeroex.OrderEvent) event.Subscription

SubscribeToOrderEvents let's one subscribe to order events emitted by the OrderWatcher

type Config

type Config struct {
	// Verbosity is the logging verbosity: 0=panic, 1=fatal, 2=error, 3=warn, 4=info, 5=debug 6=trace
	Verbosity int `envvar:"VERBOSITY" default:"2"`
	// DataDir is the directory to use for persisting all data, including the
	// database and private key files.
	DataDir string `envvar:"DATA_DIR" default:"0x_mesh"`
	// P2PTCPPort is the port on which to listen for new TCP connections from
	// peers in the network. Set to 60558 by default.
	P2PTCPPort int `envvar:"P2P_TCP_PORT" default:"60558"`
	// P2PWebSocketsPort is the port on which to listen for new WebSockets
	// connections from peers in the network. Set to 60559 by default.
	P2PWebSocketsPort int `envvar:"P2P_WEBSOCKETS_PORT" default:"60559"`
	// KlayRPCURL is the URL of an Klaytn node which supports the JSON RPC
	// API.
	KlayRPCURL string `envvar:"KLAYTN_RPC_URL" json:"-"`
	// KlaytnChainID is the chain ID specifying which Klaytn chain you wish to
	// run your Mesh node for
	KlaytnChainID int `envvar:"KLAYTN_CHAIN_ID"`
	// UseBootstrapList is whether to bootstrap the DHT by connecting to a
	// specific set of peers.
	UseBootstrapList bool `envvar:"USE_BOOTSTRAP_LIST" default:"true"`
	// BootstrapList is a comma-separated list of multiaddresses to use for
	// bootstrapping the DHT (e.g.,
	// "/ip4/3.214.190.67/tcp/60558/ipfs/16Uiu2HAmGx8Z6gdq5T5AQE54GMtqDhDFhizywTy1o28NJbAMMumF").
	// If empty, the default bootstrap list will be used.
	BootstrapList string `envvar:"BOOTSTRAP_LIST" default:""`
	// BlockPollingInterval is the polling interval to wait before checking for a new Klaytn block
	// that might contain transactions that impact the fillability of orders stored by Mesh. Different
	// chains have different block producing intervals: POW chains are typically slower (e.g., Mainnet)
	// and POA chains faster (e.g., Kovan) so one should adjust the polling interval accordingly.
	BlockPollingInterval time.Duration `envvar:"BLOCK_POLLING_INTERVAL" default:"1s"`
	// KlayRPCMaxContentLength is the maximum request Content-Length accepted by the backing Klaytn RPC
	// endpoint used by Mesh. When batch validating 0x orders, we will fit as many orders into a
	// request without crossing the max content length.
	KlayRPCMaxContentLength int `envvar:"KLAYTN_RPC_MAX_CONTENT_LENGTH" default:"524288"`
	// EnableKlayRPCRateLimiting determines whether or not Mesh should limit
	// the number of Klaytn RPC requests it sends. It defaults to true.
	// Disabling Klaytn RPC rate limiting can reduce latency for receiving order
	// events in some network conditions, but can also potentially lead to higher
	// costs or other rate limiting issues outside of Mesh, depending on your
	// Klaytn RPC provider. If set to false, klayRPCMaxRequestsPer24HrUTC
	// and klayRPCMaxRequestsPerSecond will have no effect.
	EnableKlayRPCRateLimiting bool `envvar:"ENABLE_KLAYTN_RPC_RATE_LIMITING" default:"true"`
	// KlayRPCMaxRequestsPer24HrUTC caps the number of Klaytn JSON-RPC requests a Mesh node will make
	// per 24hr UTC time window (time window starts and ends at midnight UTC). It defaults to 200k but
	// can be increased well beyond this limit depending on your infrastructure or Klaytn RPC provider.
	KlayRPCMaxRequestsPer24HrUTC int `envvar:"KLAYTN_RPC_MAX_REQUESTS_PER_24_HR_UTC" default:"200000"`
	// KlayRPCMaxRequestsPerSecond caps the number of Klaytn JSON-RPC requests a Mesh node will make per
	// second. This limits the concurrency of these requests and prevents the Mesh node from getting rate-limited.
	// It defaults to the recommended 30 rps for Infura's free tier, and can be increased to 100 rpc for pro users,
	// and potentially higher on alternative infrastructure.
	KlayRPCMaxRequestsPerSecond float64 `envvar:"KLAYTN_RPC_MAX_REQUESTS_PER_SECOND" default:"30"`
	// CustomContractAddresses is a JSON-encoded string representing a set of
	// custom addresses to use for the configured chain ID. The contract
	// addresses for most common chains/networks are already included by default, so this
	// is typically only needed for testing on custom chains/networks. The given
	// addresses are added to the default list of addresses for known chains/networks and
	// overriding any contract addresses for known chains/networks is not allowed. The
	// addresses for exchange, devUtils, erc20Proxy, erc721Proxy and erc1155Proxy are required
	// for each chain/network. For example:
	//
	//    {
	//        "exchange":"0x48bacb9266a570d521063ef5dd96e61686dbe788",
	//        "devUtils": "0x38ef19fdf8e8415f18c307ed71967e19aac28ba1",
	//        "erc20Proxy": "0x1dc4c1cefef38a777b15aa20260a54e584b16c48",
	//        "erc721Proxy": "0x1d7022f5b17d2f8b695918fb48fa1089c9f85401",
	//        "erc1155Proxy": "0x64517fa2b480ba3678a2a3c0cf08ef7fd4fad36f"
	//    }
	//
	CustomContractAddresses string `envvar:"CUSTOM_CONTRACT_ADDRESSES" default:""`
	// MaxOrdersInStorage is the maximum number of orders that Mesh will keep in
	// storage. As the number of orders in storage grows, Mesh will begin
	// enforcing a limit on maximum expiration time for incoming orders and remove
	// any orders with an expiration time too far in the future.
	MaxOrdersInStorage int `envvar:"MAX_ORDERS_IN_STORAGE" default:"100000"`
	// CustomOrderFilter is a stringified JSON Schema which will be used for
	// validating incoming orders. If provided, Mesh will only receive orders from
	// other peers in the network with the same filter.
	//
	// Here is an example filter which will only allow orders with a specific
	// makerAssetData:
	//
	//    {
	//        "properties": {
	//            "makerAssetData": {
	//                "const": "0xf47261b0000000000000000000000000871dd7c2b4b25e1aa18728e9d5f2af4c4e431f5c"
	//            }
	//        }
	//    }
	//
	// Note that you only need to include the requirements for your specific
	// application in the filter. The default requirements for a valid order (e.g.
	// all the required fields) are automatically included. For more information
	// on JSON Schemas, see https://json-schema.org/
	CustomOrderFilter string `envvar:"CUSTOM_ORDER_FILTER" default:"{}"`
	// KlayRPCClient is the client to use for all Klaytn RPC requests. It is only
	// settable in browsers and cannot be set via environment variable. If
	// provided, KlayRPCURL will be ignored.
	KlayRPCClient *rpc.Client `envvar:"-"`
}

Config is a set of configuration options for 0x Mesh.

type ErrPerPageZero

type ErrPerPageZero struct{}

ErrPerPageZero is the error returned when a GetOrders request specifies perPage to 0

func (ErrPerPageZero) Error

func (e ErrPerPageZero) Error() string

type ErrSnapshotNotFound

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

ErrSnapshotNotFound is the error returned when a snapshot not found with a particular id

func (ErrSnapshotNotFound) Error

func (e ErrSnapshotNotFound) Error() string

type FilteredPaginationRequestMetadata

type FilteredPaginationRequestMetadata struct {
	Page       int    `json:"page"`
	SnapshotID string `json:"snapshotID"`
}

FilteredPaginationRequestMetadata is the request metadata for the FilteredPaginationSubProtocol. It keeps track of the current page and SnapshotID, which is expected to be an empty string on the first request.

type FilteredPaginationResponseMetadata

type FilteredPaginationResponseMetadata struct {
	Page       int    `json:"page"`
	SnapshotID string `json:"snapshotID"`
}

FilteredPaginationResponseMetadata is the response metadata for the FilteredPaginationSubProtocol. It keeps track of the current page and SnapshotID.

type FilteredPaginationSubProtocol

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

FilteredPaginationSubProtocol is an ordersync subprotocol which returns all orders by paginating through them. It involves sending multiple requests until pagination is finished and all orders have been returned.

func NewFilteredPaginationSubprotocol

func NewFilteredPaginationSubprotocol(app *App, perPage int) *FilteredPaginationSubProtocol

NewFilteredPaginationSubprotocol creates and returns a new FilteredPaginationSubprotocol which will respond with perPage orders for each individual request/response.

func (*FilteredPaginationSubProtocol) HandleOrderSyncRequest

func (p *FilteredPaginationSubProtocol) HandleOrderSyncRequest(ctx context.Context, req *ordersync.Request) (*ordersync.Response, error)

HandleOrderSyncRequest returns the orders for one page, based on the page number and snapshotID corresponding to the given request. This is the implementation for the "provider" side of the subprotocol.

func (*FilteredPaginationSubProtocol) HandleOrderSyncResponse

func (p *FilteredPaginationSubProtocol) HandleOrderSyncResponse(ctx context.Context, res *ordersync.Response) (*ordersync.Request, error)

HandleOrderSyncResponse handles the orders for one page by validating them, storing them in the database, and firing the appropriate events. It also returns the next request to be sent. This is the implementation for the "requester" side of the subprotocol.

func (*FilteredPaginationSubProtocol) Name

func (p *FilteredPaginationSubProtocol) Name() string

Name returns the name of the FilteredPaginationSubProtocol

func (*FilteredPaginationSubProtocol) ParseRequestMetadata

func (p *FilteredPaginationSubProtocol) ParseRequestMetadata(metadata json.RawMessage) (interface{}, error)

func (*FilteredPaginationSubProtocol) ParseResponseMetadata

func (p *FilteredPaginationSubProtocol) ParseResponseMetadata(metadata json.RawMessage) (interface{}, error)