operator

Documentation

Index

• type Operator
  • func NewOperator(walletService interfaces.WalletService, tradeService interfaces.TradeService, ...) (*Operator, error)
  • func (op *Operator) GetShortestQueue() (*TxQueue, int, error)
  • func (op *Operator) GetTxSendOptions() (*bind.TransactOpts, error)
  • func (op *Operator) HandleEvents() error
  • func (op *Operator) HandleTrades(msg *types.OperatorMessage) error
  • func (op *Operator) HandleTxError(m *types.Matches, id int)
  • func (op *Operator) HandleTxSuccess(m *types.Matches, receipt *eth.Receipt)
  • func (op *Operator) PurgeQueues() error
  • func (op *Operator) QueueTrade(m *types.Matches) error
  • func (op *Operator) SubscribeOperatorMessages(fn func(*types.OperatorMessage) error) error
• type OperatorInterface
• type TxQueue
  • func NewTxQueue(n string, tr interfaces.TradeService, p interfaces.EthereumProvider, ...) (*TxQueue, error)
  • func (txq *TxQueue) ExecuteTrade(m *types.Matches, tag uint64) error
  • func (txq *TxQueue) GetChannel() *amqp.Channel
  • func (txq *TxQueue) GetTxCallOptions() *ethereum.CallMsg
  • func (txq *TxQueue) GetTxSendOptions() *bind.TransactOpts
  • func (txq *TxQueue) HandleError(m *types.Matches) error
  • func (txq *TxQueue) HandleTradeInvalid(m *types.Matches) error
  • func (txq *TxQueue) HandleTxError(m *types.Matches) error
  • func (txq *TxQueue) HandleTxSuccess(m *types.Matches) error
  • func (txq *TxQueue) Length() int
  • func (txq *TxQueue) PublishPendingTrades(m *types.Matches) error
  • func (txq *TxQueue) PurgePendingTrades() error
• type TxQueueOrder

Types

type Operator

type Operator struct {
	// AccountService     interfaces.AccountService
	WalletService     interfaces.WalletService
	TradeService      interfaces.TradeService
	OrderService      interfaces.OrderService
	TokenService      interfaces.TokenService
	EthereumProvider  interfaces.EthereumProvider
	Exchange          interfaces.Exchange
	TxQueues          []*TxQueue
	QueueAddressIndex map[common.Address]*TxQueue
	Broker            *rabbitmq.Connection
	// contains filtered or unexported fields
}

Operator manages the transaction queue that will eventually be sent to the exchange contract. The Operator Wallet must be equal to the account that initially deployed the exchange contract or an address with operator rights on the contract

func NewOperator

func NewOperator(
	walletService interfaces.WalletService,
	tradeService interfaces.TradeService,
	orderService interfaces.OrderService,
	provider interfaces.EthereumProvider,
	exchange interfaces.Exchange,
	conn *rabbitmq.Connection,
	accountService interfaces.AccountService,
	tokenService interfaces.TokenService,
) (*Operator, error)

NewOperator creates a new operator struct. It creates an exchange contract instance from the provided address. The error and trade events are received in the ErrorChannel and TradeChannel. Upon receiving errors and trades in their respective channels, event payloads are sent to the associated order maker and taker sockets through the through the event channel on the Order and Trade struct. In addition, an error event cancels the trade in the trading engine and makes the order available again.

func (*Operator) GetShortestQueue

func (op *Operator) GetShortestQueue() (*TxQueue, int, error)

GetShortestQueue

func (*Operator) GetTxSendOptions

func (op *Operator) GetTxSendOptions() (*bind.TransactOpts, error)

func (*Operator) HandleEvents

func (op *Operator) HandleEvents() error

Bug: In certain cases, the trade channel seems to be receiving additional unexpected trades. In the case TestSocketExecuteOrder (in file socket_test.go) is run on its own, everything is working correctly. However, in the case TestSocketExecuteOrder is run among other tests, some tradeLogs do not correspond to an order hash in the ordertrade mapping. I suspect this is because the event listener catches events from previous tests. It might be helpful to see how to listen to events from up to a certain block.

func (*Operator) HandleTrades

func (op *Operator) HandleTrades(msg *types.OperatorMessage) error

func (*Operator) HandleTxError

func (op *Operator) HandleTxError(m *types.Matches, id int)

func (*Operator) HandleTxSuccess

func (op *Operator) HandleTxSuccess(m *types.Matches, receipt *eth.Receipt)

func (*Operator) PurgeQueues

func (op *Operator) PurgeQueues() error

func (*Operator) QueueTrade

func (op *Operator) QueueTrade(m *types.Matches) error

QueueTrade

func (*Operator) SubscribeOperatorMessages

func (op *Operator) SubscribeOperatorMessages(fn func(*types.OperatorMessage) error) error

SubscribeOperatorMessages

type OperatorInterface

type OperatorInterface interface {
	SubscribeOperatorMessages(fn func(*types.OperatorMessage) error) error
	QueueTrade(o *types.Order, t *types.Trade) error
	GetShortestQueue() (*TxQueue, int, error)
}

type TxQueue

type TxQueue struct {
	Name             string
	Wallet           *types.Wallet
	TradeService     interfaces.TradeService
	OrderService     interfaces.OrderService
	EthereumProvider interfaces.EthereumProvider
	Exchange         interfaces.Exchange
	Broker           *rabbitmq.Connection
	AccountService   interfaces.AccountService
	TokenService     interfaces.TokenService
}

func NewTxQueue

func NewTxQueue(
	n string,
	tr interfaces.TradeService,
	p interfaces.EthereumProvider,
	o interfaces.OrderService,
	w *types.Wallet,
	ex interfaces.Exchange,
	rabbitConn *rabbitmq.Connection,
	accountService interfaces.AccountService,
	tokenService interfaces.TokenService,
) (*TxQueue, error)

NewTxQueue

func (*TxQueue) ExecuteTrade

func (txq *TxQueue) ExecuteTrade(m *types.Matches, tag uint64) error

ExecuteTrade send a trade execution order to the smart contract interface. After sending the trade message, the trade is updated on the database and is published to the operator subscribers (order service)

func (*TxQueue) GetChannel

func (txq *TxQueue) GetChannel() *amqp.Channel

func (*TxQueue) GetTxCallOptions

func (txq *TxQueue) GetTxCallOptions() *ethereum.CallMsg

func (*TxQueue) GetTxSendOptions

func (txq *TxQueue) GetTxSendOptions() *bind.TransactOpts

func (*TxQueue) HandleError

func (txq *TxQueue) HandleError(m *types.Matches) error

func (*TxQueue) HandleTradeInvalid

func (txq *TxQueue) HandleTradeInvalid(m *types.Matches) error

func (*TxQueue) HandleTxError

func (txq *TxQueue) HandleTxError(m *types.Matches) error

func (*TxQueue) HandleTxSuccess

func (txq *TxQueue) HandleTxSuccess(m *types.Matches) error

func (*TxQueue) Length

func (txq *TxQueue) Length() int

Length

func (*TxQueue) PublishPendingTrades

func (txq *TxQueue) PublishPendingTrades(m *types.Matches) error

func (*TxQueue) PurgePendingTrades

func (txq *TxQueue) PurgePendingTrades() error

type TxQueueOrder

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