Documentation

Index

Constants

View Source
const (
	RPCErrorUnspecified        = iota // 0
	RPCParseError                     // 1
	RPCUnknownRoute                   // 2
	RPCInternal                       // 3
	RPCQuarantineClient               // 4
	RPCVersionUnsupported             // 5
	RPCUnknownMatch                   // 6
	RPCInternalError                  // 7
	RPCInitError                      // 8
	RPCLoginError                     // 9
	RPCLogoutError                    // 10
	RPCCreateWalletError              // 11
	RPCOpenWalletError                // 12
	RPCWalletExistsError              // 13
	RPCCloseWalletError               // 14
	RPCGetFeeError                    // 15
	RPCRegisterError                  // 16
	RPCArgumentsError                 // 17
	RPCTradeError                     // 18
	RPCCancelError                    // 19
	RPCWithdrawError                  // 20
	RPCOrderBookError                 // 21
	SignatureError                    // 22
	SerializationError                // 23
	TransactionUndiscovered           // 24
	ContractError                     // 25
	SettlementSequenceError           // 26
	ResultLengthError                 // 27
	IDMismatchError                   // 28
	RedemptionError                   // 29
	IDTypeError                       // 30
	AckCountError                     // 31
	UnknownResponseID                 // 32
	OrderParameterError               // 33
	UnknownMarketError                // 34
	ClockRangeError                   // 35
	FundingError                      // 36
	CoinAuthError                     // 37
	UnknownMarket                     // 38
	NotSubscribedError                // 39
	UnauthorizedConnection            // 40
	AuthenticationError               // 41
	PubKeyParseError                  // 42
	FeeError                          // 43
	InvalidPreimage                   // 44
	PreimageCommitmentMismatch        // 45
	UnknownMessageType                // 46
	AccountClosedError                // 47
	MarketNotRunningError             // 48
	TryAgainLaterError                // 49
	AccountNotFoundError              // 50
	UnpaidAccountError                // 51
	InvalidRequestError               // 52
	OrderQuantityTooHigh              // 53
)

    Error codes

    View Source
    const (
    	// MatchRoute is the route of a DEX-originating request-type message notifying
    	// the client of a match and initiating swap negotiation.
    	MatchRoute = "match"
    	// NoMatchRoute is the route of a DEX-originating notification-type message
    	// notifying the client that an order did not match during its match cycle.
    	NoMatchRoute = "nomatch"
    	// MatchStatusRoute is the route of a client-originating request-type
    	// message to retrieve match data from the DEX.
    	MatchStatusRoute = "match_status"
    	// OrderStatusRoute is the route of a client-originating request-type
    	// message to retrieve order data from the DEX.
    	OrderStatusRoute = "order_status"
    	// InitRoute is the route of a client-originating request-type message
    	// notifying the DEX, and subsequently the match counter-party, of the details
    	// of a swap contract.
    	InitRoute = "init"
    	// AuditRoute is the route of a DEX-originating request-type message relaying
    	// swap contract details (from InitRoute) from one client to the other.
    	AuditRoute = "audit"
    	// RedeemRoute is the route of a client-originating request-type message
    	// notifying the DEX, and subsequently the match counter-party, of the details
    	// of a redemption transaction.
    	RedeemRoute = "redeem"
    	// RedemptionRoute is the route of a DEX-originating request-type message
    	// relaying redemption transaction (from RedeemRoute) details from one client
    	// to the other.
    	RedemptionRoute = "redemption"
    	// RevokeMatchRoute is a DEX-originating notification-type message informing
    	// a client that a match has been revoked.
    	RevokeMatchRoute = "revoke_match"
    	// RevokeOrderRoute is a DEX-originating notification-type message informing
    	// a client that an order has been revoked.
    	RevokeOrderRoute = "revoke_order"
    	// LimitRoute is the client-originating request-type message placing a limit
    	// order.
    	LimitRoute = "limit"
    	// MarketRoute is the client-originating request-type message placing a market
    	// order.
    	MarketRoute = "market"
    	// CancelRoute is the client-originating request-type message placing a cancel
    	// order.
    	CancelRoute = "cancel"
    	// OrderBookRoute is the client-originating request-type message subscribing
    	// to an order book update notification feed.
    	OrderBookRoute = "orderbook"
    	// UnsubOrderBookRoute is client-originating request-type message cancelling
    	// an order book subscription.
    	UnsubOrderBookRoute = "unsub_orderbook"
    	// BookOrderRoute is the DEX-originating notification-type message informing
    	// the client to add the order to the order book.
    	BookOrderRoute = "book_order"
    	// UnbookOrderRoute is the DEX-originating notification-type message informing
    	// the client to remove an order from the order book.
    	UnbookOrderRoute = "unbook_order"
    	// EpochOrderRoute is the DEX-originating notification-type message informing
    	// the client about an order added to the epoch queue.
    	EpochOrderRoute = "epoch_order"
    	// UpdateRemainingRoute is the DEX-originating notification-type message that
    	// updates the remaining amount of unfilled quantity on a standing limit order.
    	UpdateRemainingRoute = "update_remaining"
    	// ConnectRoute is a client-originating request-type message seeking
    	// authentication so that the connection can be used for trading.
    	ConnectRoute = "connect"
    	// RegisterRoute is the client-originating request-type message initiating a
    	// new client registration.
    	RegisterRoute = "register"
    	// NotifyFeeRoute is the client-originating request-type message informing the
    	// DEX that the fee has been paid and has the requisite number of
    	// confirmations.
    	NotifyFeeRoute = "notifyfee"
    	// ConfigRoute is the client-originating request-type message requesting the
    	// DEX configuration information.
    	ConfigRoute = "config"
    	// MatchProofRoute is the DEX-originating notification-type message
    	// delivering match cycle results to the client.
    	MatchProofRoute = "match_proof"
    	// PreimageRoute is the DEX-originating request-type message requesting the
    	// preimages for the client's epoch orders.
    	PreimageRoute = "preimage"
    	// SuspensionRoute is the DEX-originating request-type message informing the
    	// client of an upcoming trade suspension. This is part of the
    	// subscription-based orderbook notification feed.
    	SuspensionRoute = "suspension"
    	// ResumptionRoute is the DEX-originating request-type message informing the
    	// client of an upcoming trade resumption. This is part of the
    	// subscription-based orderbook notification feed.
    	ResumptionRoute = "resumption"
    	// NotifyRoute is the DEX-originating notification-type message
    	// delivering text messages from the operator.
    	NotifyRoute = "notify"
    	// PenaltyRoute is the DEX-originating notification-type message
    	// informing of a broken rule and the resulting penalty.
    	PenaltyRoute = "penalty"
    )

      Routes are destinations for a "payload" of data. The type of data being delivered, and what kind of action is expected from the receiving party, is completely dependent on the route. The route designation is a string sent as the "route" parameter of a JSON-encoded Message.

      View Source
      const (
      	BuyOrderNum       = 1
      	SellOrderNum      = 2
      	StandingOrderNum  = 1
      	ImmediateOrderNum = 2
      	LimitOrderNum     = 1
      	MarketOrderNum    = 2
      	CancelOrderNum    = 3
      )

      Variables

      This section is empty.

      Functions

      This section is empty.

      Types

      type Acknowledgement

      type Acknowledgement struct {
      	MatchID Bytes `json:"matchid"`
      	Sig     Bytes `json:"sig"`
      }

        Acknowledgement is the 'result' field in a response to a request that requires an acknowledgement. It is typically a signature of some serialized data associated with the request.

        type Asset

        type Asset struct {
        	Symbol       string `json:"symbol"`
        	ID           uint32 `json:"id"`
        	LotSize      uint64 `json:"lotsize"`
        	RateStep     uint64 `json:"ratestep"`
        	MaxFeeRate   uint64 `json:"maxfeerate"`
        	SwapSize     uint64 `json:"swapsize"`
        	SwapSizeBase uint64 `json:"swapsizebase"`
        	SwapConf     uint16 `json:"swapconf"`
        }

          Asset describes an asset and its variables, and is returned as part of a ConfigResult.

          type Audit

          type Audit struct {
          	Signature
          	OrderID  Bytes  `json:"orderid"`
          	MatchID  Bytes  `json:"matchid"`
          	Time     uint64 `json:"timestamp"`
          	CoinID   Bytes  `json:"coinid"`
          	Contract Bytes  `json:"contract"`
          }

            Audit is the payload for a DEX-originating AuditRoute request.

            func (*Audit) Serialize

            func (audit *Audit) Serialize() []byte

              Serialize serializes the Audit data.

              type BookOrderNote

              type BookOrderNote struct {
              	OrderNote
              	TradeNote
              }

                BookOrderNote is the payload for a DEX-originating notification-type message informing the client to add the order to the order book.

                type Bytes

                type Bytes = dex.Bytes

                type CancelOrder

                type CancelOrder struct {
                	Prefix
                	TargetID Bytes `json:"targetid"`
                }

                  CancelOrder is the payload for the CancelRoute, which places a cancel order.

                  func (*CancelOrder) Serialize

                  func (c *CancelOrder) Serialize() []byte

                    Serialize serializes the CancelOrder data.

                    type Coin

                    type Coin struct {
                    	ID      Bytes   `json:"coinid"`
                    	PubKeys []Bytes `json:"pubkeys"`
                    	Sigs    []Bytes `json:"sigs"`
                    	Redeem  Bytes   `json:"redeem"`
                    }

                      Coin is information for validating funding coins. Some number of Coins must be included with both Limit and Market payloads.

                      type ConfigResult

                      type ConfigResult struct {
                      	CancelMax        float64   `json:"cancelmax"`
                      	BroadcastTimeout uint64    `json:"btimeout"`
                      	RegFeeConfirms   uint16    `json:"regfeeconfirms"`
                      	Assets           []*Asset  `json:"assets"`
                      	Markets          []*Market `json:"markets"`
                      	Fee              uint64    `json:"fee"`
                      }

                        ConfigResult is the successful result for the ConfigRoute.

                        type Connect

                        type Connect struct {
                        	Signature
                        	AccountID  Bytes  `json:"accountid"`
                        	APIVersion uint16 `json:"apiver"`
                        	Time       uint64 `json:"timestamp"`
                        }

                          Connect is the payload for a client-originating ConnectRoute request.

                          func (*Connect) Serialize

                          func (c *Connect) Serialize() []byte

                            Serialize serializes the Connect data.

                            type ConnectResult

                            type ConnectResult struct {
                            	Sig                 Bytes          `json:"sig"`
                            	ActiveOrderStatuses []*OrderStatus `json:"activeorderstatuses"`
                            	ActiveMatches       []*Match       `json:"activematches"`
                            	Score               int32          `json:"score"`
                            }

                              ConnectResult is the result for the ConnectRoute request.

                              TODO: Include penalty data as specified in the spec.

                              type EpochOrderNote

                              type EpochOrderNote struct {
                              	BookOrderNote
                              	Commit    Bytes  `json:"com"`
                              	OrderType uint8  `json:"otype"`
                              	Epoch     uint64 `json:"epoch"`
                              	TargetID  Bytes  `json:"target,omitempty"` // omit for cancel orders
                              }

                                EpochOrderRoute is the DEX-originating notification-type message informing the client about an order added to the epoch queue.

                                type Error

                                type Error struct {
                                	Code    int    `json:"code"`
                                	Message string `json:"message"`
                                }

                                  Error is returned as part of the Response to indicate that an error occurred during method execution.

                                  func NewError

                                  func NewError(code int, format string, a ...interface{}) *Error

                                    NewError is a constructor for an Error.

                                    func (*Error) Error

                                    func (e *Error) Error() string

                                      Error returns the error message. Satisfies the error interface.

                                      func (Error) String

                                      func (e Error) String() string

                                        String satisfies the Stringer interface for pretty printing.

                                        type Init

                                        type Init struct {
                                        	Signature
                                        	OrderID  Bytes `json:"orderid"`
                                        	MatchID  Bytes `json:"matchid"`
                                        	CoinID   Bytes `json:"coinid"`
                                        	Contract Bytes `json:"contract"`
                                        }

                                          Init is the payload for a client-originating InitRoute request.

                                          func (*Init) Serialize

                                          func (init *Init) Serialize() []byte

                                            Serialize serializes the Init data.

                                            type LimitOrder

                                            type LimitOrder struct {
                                            	Prefix
                                            	Trade
                                            	Rate uint64 `json:"rate"`
                                            	TiF  uint8  `json:"timeinforce"`
                                            }

                                              LimitOrder is the payload for the LimitRoute, which places a limit order.

                                              func (*LimitOrder) Serialize

                                              func (l *LimitOrder) Serialize() []byte

                                                Serialize serializes the Limit data.

                                                type Market

                                                type Market struct {
                                                	Name            string  `json:"name"`
                                                	Base            uint32  `json:"base"`
                                                	Quote           uint32  `json:"quote"`
                                                	EpochLen        uint64  `json:"epochlen"`
                                                	MarketBuyBuffer float64 `json:"buybuffer"`
                                                	MarketStatus    `json:"status"`
                                                }

                                                  Market describes a market and its variables, and is returned as part of a ConfigResult. The market's status (running, start epoch, and any planned final epoch before suspend) are also provided.

                                                  func (*Market) Running

                                                  func (m *Market) Running() bool

                                                    Running indicates if the market should be running given the known StartEpoch, EpochLen, and FinalEpoch (if set).

                                                    type MarketOrder

                                                    type MarketOrder struct {
                                                    	Prefix
                                                    	Trade
                                                    }

                                                      MarketOrder is the payload for the MarketRoute, which places a market order.

                                                      func (*MarketOrder) Serialize

                                                      func (m *MarketOrder) Serialize() []byte

                                                        Serialize serializes the MarketOrder data.

                                                        type MarketStatus

                                                        type MarketStatus struct {
                                                        	StartEpoch uint64 `json:"startepoch"`
                                                        	FinalEpoch uint64 `json:"finalepoch,omitempty"`
                                                        	Persist    *bool  `json:"persistbook,omitempty"` // nil and omitted when finalepoch is omitted
                                                        }

                                                          MarketStatus describes the status of the market, where StartEpoch is when the market started or will start. FinalEpoch is a when the market will suspend if it is running, or when the market suspended if it is presently stopped.

                                                          type Match

                                                          type Match struct {
                                                          	Signature
                                                          	OrderID      Bytes  `json:"orderid"`
                                                          	MatchID      Bytes  `json:"matchid"`
                                                          	Quantity     uint64 `json:"qty"`
                                                          	Rate         uint64 `json:"rate"`
                                                          	ServerTime   uint64 `json:"tserver"`
                                                          	Address      string `json:"address"`
                                                          	FeeRateBase  uint64 `json:"feeratebase"`
                                                          	FeeRateQuote uint64 `json:"feeratequote"`
                                                          	// Status and Side are provided for convenience and are not part of the
                                                          	// match serialization.
                                                          	Status uint8 `json:"status"`
                                                          	Side   uint8 `json:"side"`
                                                          }

                                                            Match is the params for a DEX-originating MatchRoute request.

                                                            func (*Match) Serialize

                                                            func (m *Match) Serialize() []byte

                                                              Serialize serializes the Match data.

                                                              type MatchProofNote

                                                              type MatchProofNote struct {
                                                              	MarketID  string  `json:"marketid"`
                                                              	Epoch     uint64  `json:"epoch"`
                                                              	Preimages []Bytes `json:"preimages"`
                                                              	Misses    []Bytes `json:"misses"`
                                                              	CSum      Bytes   `json:"csum"`
                                                              	Seed      Bytes   `json:"seed"`
                                                              }

                                                                MatchProofNote is the match_proof notification payload.

                                                                type MatchRequest

                                                                type MatchRequest struct {
                                                                	Base    uint32 `json:"base"`
                                                                	Quote   uint32 `json:"quote"`
                                                                	MatchID Bytes  `json:"matchid"`
                                                                }

                                                                  MatchRequest details a match for the MatchStatusRoute request. The actual payload is a []MatchRequest.

                                                                  type MatchStatusResult

                                                                  type MatchStatusResult struct {
                                                                  	MatchID       Bytes `json:"matchid"`
                                                                  	Status        uint8 `json:"status"`
                                                                  	MakerContract Bytes `json:"makercontract,omitempty"`
                                                                  	TakerContract Bytes `json:"takercontract,omitempty"`
                                                                  	MakerSwap     Bytes `json:"makerswap,omitempty"`
                                                                  	TakerSwap     Bytes `json:"takerswap,omitempty"`
                                                                  	MakerRedeem   Bytes `json:"makerredeem,omitempty"`
                                                                  	TakerRedeem   Bytes `json:"takerredeem,omitempty"`
                                                                  	Secret        Bytes `json:"secret,omitempty"`
                                                                  	Active        bool  `json:"active"`
                                                                  }

                                                                    MatchStatus is the successful result for the MatchStatusRoute request.

                                                                    type Message

                                                                    type Message struct {
                                                                    	// Type is the message type.
                                                                    	Type MessageType `json:"type"`
                                                                    	// Route is used for requests and notifications, and specifies a handler for
                                                                    	// the message.
                                                                    	Route string `json:"route,omitempty"`
                                                                    	// ID is a unique number that is used to link a response to a request.
                                                                    	ID uint64 `json:"id,omitempty"`
                                                                    	// Payload is any data attached to the message. How Payload is decoded
                                                                    	// depends on the Route.
                                                                    	Payload json.RawMessage `json:"payload,omitempty"`
                                                                    }

                                                                      Message is the primary messaging type for websocket communications.

                                                                      func DecodeMessage

                                                                      func DecodeMessage(b []byte) (*Message, error)

                                                                        DecodeMessage decodes a *Message from JSON-formatted bytes.

                                                                        func NewNotification

                                                                        func NewNotification(route string, payload interface{}) (*Message, error)

                                                                          NewNotification encodes the payload and creates a Notification-type *Message.

                                                                          func NewRequest

                                                                          func NewRequest(id uint64, route string, payload interface{}) (*Message, error)

                                                                            NewRequest is the constructor for a Request-type *Message.

                                                                            func NewResponse

                                                                            func NewResponse(id uint64, result interface{}, rpcErr *Error) (*Message, error)

                                                                              NewResponse encodes the result and creates a Response-type *Message.

                                                                              func (*Message) Response

                                                                              func (msg *Message) Response() (*ResponsePayload, error)

                                                                                Response attempts to decode the payload to a *ResponsePayload. Response will return an error if the Type is not Response.

                                                                                func (*Message) String

                                                                                func (msg *Message) String() string

                                                                                  String prints the message as a JSON-encoded string.

                                                                                  func (*Message) Unmarshal

                                                                                  func (msg *Message) Unmarshal(payload interface{}) error

                                                                                    Unmarshal unmarshals the Payload field into the provided interface.

                                                                                    func (*Message) UnmarshalResult

                                                                                    func (msg *Message) UnmarshalResult(result interface{}) error

                                                                                      UnmarshalResult is a convenience method for decoding the Result field of a ResponsePayload.

                                                                                      type MessageType

                                                                                      type MessageType uint8

                                                                                        MessageType indicates the type of message. MessageType is typically the first switch checked when examining a message, and how the rest of the message is decoded depends on its MessageType.

                                                                                        const (
                                                                                        	InvalidMessageType MessageType = iota // 0
                                                                                        	Request                               // 1
                                                                                        	Response                              // 2
                                                                                        	Notification                          // 3
                                                                                        )

                                                                                        func (MessageType) String

                                                                                        func (mt MessageType) String() string

                                                                                          String satisfies the Stringer interface for translating the MessageType code into a description, primarily for logging.

                                                                                          type NoMatch

                                                                                          type NoMatch struct {
                                                                                          	OrderID Bytes `json:"orderid"`
                                                                                          }

                                                                                            Nomatch is the payload for a server-originating NoMatchRoute notification.

                                                                                            type NotifyFee

                                                                                            type NotifyFee struct {
                                                                                            	Signature
                                                                                            	AccountID Bytes  `json:"accountid"`
                                                                                            	CoinID    Bytes  `json:"coinid"`
                                                                                            	Time      uint64 `json:"timestamp"`
                                                                                            }

                                                                                              NotifyFee is the payload for a client-originating NotifyFeeRoute request.

                                                                                              func (*NotifyFee) Serialize

                                                                                              func (n *NotifyFee) Serialize() []byte

                                                                                                Serialize serializes the NotifyFee data.

                                                                                                func (*NotifyFee) Stamp

                                                                                                func (n *NotifyFee) Stamp(t uint64)

                                                                                                  Stamp satisfies the Stampable interface.

                                                                                                  type NotifyFeeResult

                                                                                                  type NotifyFeeResult struct {
                                                                                                  	Signature
                                                                                                  }

                                                                                                    NotifyFeeResult is the result for the response to NotifyFee. Though it embeds Signature, it does not satisfy the Signable interface, as it has no need for serialization.

                                                                                                    type OrderBook

                                                                                                    type OrderBook struct {
                                                                                                    	MarketID string `json:"marketid"`
                                                                                                    	Seq      uint64 `json:"seq"`
                                                                                                    	Epoch    uint64 `json:"epoch"`
                                                                                                    	// MarketStatus `json:"status"`// maybe
                                                                                                    	// DRAFT NOTE: We might want to use a different structure for bulk updates.
                                                                                                    	// Sending a struct of arrays rather than an array of structs could
                                                                                                    	// potentially cut the encoding effort and encoded size substantially.
                                                                                                    	Orders []*BookOrderNote `json:"orders"`
                                                                                                    }

                                                                                                      OrderBook is the response to a successful OrderBookSubscription.

                                                                                                      type OrderBookSubscription

                                                                                                      type OrderBookSubscription struct {
                                                                                                      	Base  uint32 `json:"base"`
                                                                                                      	Quote uint32 `json:"quote"`
                                                                                                      }

                                                                                                        OrderBookSubscription is the payload for a client-originating request to the OrderBookRoute, intializing an order book feed.

                                                                                                        type OrderNote

                                                                                                        type OrderNote struct {
                                                                                                        	Seq      uint64 `json:"seq,omitempty"`      // May be empty when part of an OrderBook.
                                                                                                        	MarketID string `json:"marketid,omitempty"` // May be empty when part of an OrderBook.
                                                                                                        	OrderID  Bytes  `json:"oid"`
                                                                                                        }

                                                                                                          OrderNote is part of a notification about any type of order.

                                                                                                          type OrderResult

                                                                                                          type OrderResult struct {
                                                                                                          	Sig        Bytes  `json:"sig"`
                                                                                                          	OrderID    Bytes  `json:"orderid"`
                                                                                                          	ServerTime uint64 `json:"tserver"`
                                                                                                          }

                                                                                                            OrderResult is returned from the order-placing routes.

                                                                                                            type OrderStatus

                                                                                                            type OrderStatus struct {
                                                                                                            	ID     Bytes  `json:"id"`
                                                                                                            	Status uint16 `json:"status"`
                                                                                                            }

                                                                                                              OrderStatus is the current status of an order.

                                                                                                              type OrderStatusRequest

                                                                                                              type OrderStatusRequest struct {
                                                                                                              	Base    uint32 `json:"base"`
                                                                                                              	Quote   uint32 `json:"quote"`
                                                                                                              	OrderID Bytes  `json:"orderid"`
                                                                                                              }

                                                                                                                OrderStatusRequest details an order for the OrderStatusRoute request. The actual payload is a []OrderStatusRequest.

                                                                                                                type Penalty

                                                                                                                type Penalty struct {
                                                                                                                	Rule     account.Rule `json:"rule"`
                                                                                                                	Time     uint64       `json:"timestamp"`
                                                                                                                	Duration uint64       `json:"duration"`
                                                                                                                	Details  string       `json:"details"`
                                                                                                                }

                                                                                                                  Penalty is part of the payload for a dex-originating Penalty notification and part of the connect response.

                                                                                                                  type PenaltyNote

                                                                                                                  type PenaltyNote struct {
                                                                                                                  	Signature
                                                                                                                  	Penalty *Penalty `json:"penalty"`
                                                                                                                  }

                                                                                                                    PenaltyNote is the payload of a Penalty notification.

                                                                                                                    func (*PenaltyNote) Serialize

                                                                                                                    func (n *PenaltyNote) Serialize() []byte

                                                                                                                      Serialize serializes the PenaltyNote data.

                                                                                                                      type Prefix

                                                                                                                      type Prefix struct {
                                                                                                                      	Signature
                                                                                                                      	AccountID  Bytes  `json:"accountid"`
                                                                                                                      	Base       uint32 `json:"base"`
                                                                                                                      	Quote      uint32 `json:"quote"`
                                                                                                                      	OrderType  uint8  `json:"ordertype"`
                                                                                                                      	ClientTime uint64 `json:"tclient"`
                                                                                                                      	ServerTime uint64 `json:"tserver"`
                                                                                                                      	Commit     Bytes  `json:"com"`
                                                                                                                      }

                                                                                                                        Prefix is a common structure shared among order type payloads.

                                                                                                                        func (*Prefix) Serialize

                                                                                                                        func (p *Prefix) Serialize() []byte

                                                                                                                          Serialize serializes the Prefix data.

                                                                                                                          func (*Prefix) Stamp

                                                                                                                          func (p *Prefix) Stamp(t uint64)

                                                                                                                            Stamp sets the server timestamp and epoch ID. Partially satisfies the Stampable interface.

                                                                                                                            type PreimageRequest

                                                                                                                            type PreimageRequest struct {
                                                                                                                            	OrderID        Bytes `json:"orderid"`
                                                                                                                            	CommitChecksum Bytes `json:"csum"`
                                                                                                                            }

                                                                                                                              PreimageRequest is the server-originating preimage request payload.

                                                                                                                              type PreimageResponse

                                                                                                                              type PreimageResponse struct {
                                                                                                                              	Preimage Bytes `json:"pimg"`
                                                                                                                              }

                                                                                                                                PreimageResponse is the client-originating preimage response payload.

                                                                                                                                type Redeem

                                                                                                                                type Redeem struct {
                                                                                                                                	Signature
                                                                                                                                	OrderID Bytes `json:"orderid"`
                                                                                                                                	MatchID Bytes `json:"matchid"`
                                                                                                                                	CoinID  Bytes `json:"coinid"`
                                                                                                                                	Secret  Bytes `json:"secret"`
                                                                                                                                }

                                                                                                                                  Redeem are the params for a client-originating RedeemRoute request.

                                                                                                                                  func (*Redeem) Serialize

                                                                                                                                  func (redeem *Redeem) Serialize() []byte

                                                                                                                                    Serialize serializes the Redeem data.

                                                                                                                                    type Redemption

                                                                                                                                    type Redemption struct {
                                                                                                                                    	Redeem
                                                                                                                                    	Time uint64 `json:"timestamp"`
                                                                                                                                    }

                                                                                                                                      Redemption is the payload for a DEX-originating RedemptionRoute request.

                                                                                                                                      func (*Redemption) Serialize

                                                                                                                                      func (r *Redemption) Serialize() []byte

                                                                                                                                        Serialize serializes the Redemption data.

                                                                                                                                        type Register

                                                                                                                                        type Register struct {
                                                                                                                                        	Signature
                                                                                                                                        	PubKey Bytes  `json:"pubkey"`
                                                                                                                                        	Time   uint64 `json:"timestamp"`
                                                                                                                                        }

                                                                                                                                          Register is the payload for the RegisterRoute request.

                                                                                                                                          func (*Register) Serialize

                                                                                                                                          func (r *Register) Serialize() []byte

                                                                                                                                            Serialize serializes the Register data.

                                                                                                                                            type RegisterResult

                                                                                                                                            type RegisterResult struct {
                                                                                                                                            	Signature
                                                                                                                                            	DEXPubKey    Bytes  `json:"pubkey"`
                                                                                                                                            	ClientPubKey Bytes  `json:"-"`
                                                                                                                                            	Address      string `json:"address"`
                                                                                                                                            	Fee          uint64 `json:"fee"`
                                                                                                                                            	Time         uint64 `json:"timestamp"`
                                                                                                                                            }

                                                                                                                                              RegisterResult is the result for the response to Register.

                                                                                                                                              func (*RegisterResult) Serialize

                                                                                                                                              func (r *RegisterResult) Serialize() []byte

                                                                                                                                                Serialize serializes the RegisterResult data.

                                                                                                                                                type ResponsePayload

                                                                                                                                                type ResponsePayload struct {
                                                                                                                                                	// Result is the payload, if successful, else nil.
                                                                                                                                                	Result json.RawMessage `json:"result,omitempty"`
                                                                                                                                                	// Error is the error, or nil if none was encountered.
                                                                                                                                                	Error *Error `json:"error,omitempty"`
                                                                                                                                                }

                                                                                                                                                  ResponsePayload is the payload for a Response-type Message.

                                                                                                                                                  type RevokeMatch

                                                                                                                                                  type RevokeMatch struct {
                                                                                                                                                  	Signature
                                                                                                                                                  	OrderID Bytes `json:"orderid"`
                                                                                                                                                  	MatchID Bytes `json:"matchid"`
                                                                                                                                                  }

                                                                                                                                                    RevokeMatch are the params for a DEX-originating RevokeMatchRoute request.

                                                                                                                                                    func (*RevokeMatch) Serialize

                                                                                                                                                    func (rev *RevokeMatch) Serialize() []byte

                                                                                                                                                      Serialize serializes the RevokeMatch data.

                                                                                                                                                      type RevokeOrder

                                                                                                                                                      type RevokeOrder struct {
                                                                                                                                                      	Signature
                                                                                                                                                      	OrderID Bytes `json:"orderid"`
                                                                                                                                                      }

                                                                                                                                                        RevokeOrder are the params for a DEX-originating RevokeOrderRoute notification.

                                                                                                                                                        func (*RevokeOrder) Serialize

                                                                                                                                                        func (rev *RevokeOrder) Serialize() []byte

                                                                                                                                                          Serialize serializes the RevokeOrder data.

                                                                                                                                                          type Signable

                                                                                                                                                          type Signable interface {
                                                                                                                                                          	Serialize() []byte
                                                                                                                                                          	SetSig([]byte)
                                                                                                                                                          	SigBytes() []byte
                                                                                                                                                          }

                                                                                                                                                            Signable allows for serialization and signing.

                                                                                                                                                            type Signature

                                                                                                                                                            type Signature struct {
                                                                                                                                                            	Sig Bytes `json:"sig"`
                                                                                                                                                            }

                                                                                                                                                              Signature partially implements Signable, and can be embedded by types intended to satisfy Signable, which must themselves implement the Serialize method.

                                                                                                                                                              func (*Signature) SetSig

                                                                                                                                                              func (s *Signature) SetSig(b []byte)

                                                                                                                                                                SetSig sets the Sig field.

                                                                                                                                                                func (*Signature) SigBytes

                                                                                                                                                                func (s *Signature) SigBytes() []byte

                                                                                                                                                                  SigBytes returns the signature as a []byte.

                                                                                                                                                                  type Stampable

                                                                                                                                                                  type Stampable interface {
                                                                                                                                                                  	Signable
                                                                                                                                                                  	Stamp(serverTime uint64)
                                                                                                                                                                  }

                                                                                                                                                                    Stampable is an interface that supports timestamping and signing.

                                                                                                                                                                    type Trade

                                                                                                                                                                    type Trade struct {
                                                                                                                                                                    	Side     uint8   `json:"side"`
                                                                                                                                                                    	Quantity uint64  `json:"ordersize"`
                                                                                                                                                                    	Coins    []*Coin `json:"coins"`
                                                                                                                                                                    	Address  string  `json:"address"`
                                                                                                                                                                    }

                                                                                                                                                                      Trade is common to Limit and Market Payloads.

                                                                                                                                                                      func (*Trade) Serialize

                                                                                                                                                                      func (t *Trade) Serialize() []byte

                                                                                                                                                                        Serialize serializes the Trade data.

                                                                                                                                                                        type TradeNote

                                                                                                                                                                        type TradeNote struct {
                                                                                                                                                                        	Side     uint8  `json:"side,omitempty"`
                                                                                                                                                                        	Quantity uint64 `json:"qty,omitempty"`
                                                                                                                                                                        	Rate     uint64 `json:"rate,omitempty"`
                                                                                                                                                                        	TiF      uint8  `json:"tif,omitempty"`
                                                                                                                                                                        	Time     uint64 `json:"time,omitempty"`
                                                                                                                                                                        }

                                                                                                                                                                          TradeNote is part of a notification that includes information about a limit or market order.

                                                                                                                                                                          type TradeResumption

                                                                                                                                                                          type TradeResumption struct {
                                                                                                                                                                          	MarketID   string `json:"marketid"`
                                                                                                                                                                          	ResumeTime uint64 `json:"resumetime,omitempty"` // only set in advance of resume
                                                                                                                                                                          	StartEpoch uint64 `json:"startepoch"`
                                                                                                                                                                          }

                                                                                                                                                                            TradeResumption is the ResumptionRoute notification payload. It is part of the orderbook subscription.

                                                                                                                                                                            type TradeSuspension

                                                                                                                                                                            type TradeSuspension struct {
                                                                                                                                                                            	MarketID    string `json:"marketid"`
                                                                                                                                                                            	Seq         uint64 `json:"seq,omitempty"`         // only set at suspend time and if Persist==false
                                                                                                                                                                            	SuspendTime uint64 `json:"suspendtime,omitempty"` // only set in advance of suspend
                                                                                                                                                                            	FinalEpoch  uint64 `json:"finalepoch"`
                                                                                                                                                                            	Persist     bool   `json:"persistbook"`
                                                                                                                                                                            }

                                                                                                                                                                              TradeSuspension is the SuspensionRoute notification payload. It is part of the orderbook subscription.

                                                                                                                                                                              type UnbookOrderNote

                                                                                                                                                                              type UnbookOrderNote OrderNote

                                                                                                                                                                                UnbookOrderRoute is the DEX-originating notification-type message informing the client to remove an order from the order book.

                                                                                                                                                                                type UnsubOrderBook

                                                                                                                                                                                type UnsubOrderBook struct {
                                                                                                                                                                                	MarketID string `json:"marketid"`
                                                                                                                                                                                }

                                                                                                                                                                                  UnsubOrderBook is the payload for a client-originating request to the UnsubOrderBookRoute, terminating an order book subscription.

                                                                                                                                                                                  type UpdateRemainingNote

                                                                                                                                                                                  type UpdateRemainingNote struct {
                                                                                                                                                                                  	OrderNote
                                                                                                                                                                                  	Remaining uint64 `json:"remaining"`
                                                                                                                                                                                  }

                                                                                                                                                                                    UpdateRemainingNote is the DEX-originating notification-type message informing the client about an update to a booked order's remaining quantity.

                                                                                                                                                                                    Source Files