match

Documentation

Index

• Variables
• func CalcReceivedAmount(orders []*common.Order) ([]*bc.AssetAmount, []*bc.AssetAmount)
• func CalcRequestAmount(fromAmount uint64, ratioNumerator, ratioDenominator int64) uint64
• func IsMatched(orders []*common.Order) bool
• type AllocatedAssets
• type DefaultFeeStrategy
  • func NewDefaultFeeStrategy() *DefaultFeeStrategy
  • func (d *DefaultFeeStrategy) Allocate(receiveAmounts, priceDiffs []*bc.AssetAmount) *AllocatedAssets
  • func (d *DefaultFeeStrategy) Validate(receiveAmounts []*bc.AssetAmount, feeAmounts map[bc.AssetID]uint64) error
• type Engine
  • func NewEngine(orderBook *OrderBook, feeStrategy FeeStrategy, rewardProgram []byte) *Engine
  • func (e *Engine) HasMatchedTx(tradePairs ...*common.TradePair) bool
  • func (e *Engine) NextMatchedTx(tradePairs ...*common.TradePair) (*types.Tx, error)
• type FeeStrategy
• type OrderBook
  • func NewOrderBook(movStore database.MovStore, arrivalAddOrders, arrivalDelOrders []*common.Order) *OrderBook
  • func (o *OrderBook) AddOrder(order *common.Order)
  • func (o *OrderBook) DelOrder(order *common.Order)
  • func (o *OrderBook) PeekOrder(tradePair *common.TradePair) *common.Order
  • func (o *OrderBook) PeekOrders(tradePairs []*common.TradePair) []*common.Order
  • func (o *OrderBook) PopOrder(tradePair *common.TradePair)
  • func (o *OrderBook) PopOrders(tradePairs []*common.TradePair) []*common.Order

Variables

var (
	// ErrAmountOfFeeOutOfRange represent The fee charged is out of range
	ErrAmountOfFeeOutOfRange = errors.New("amount of fee is out of range")
)

Functions

func CalcReceivedAmount

func CalcReceivedAmount(orders []*common.Order) ([]*bc.AssetAmount, []*bc.AssetAmount)

CalcReceivedAmount return amount of assets received by each participant in the matching transaction and the price difference

func CalcRequestAmount

func CalcRequestAmount(fromAmount uint64, ratioNumerator, ratioDenominator int64) uint64

CalcRequestAmount is from amount * numerator / ratioDenominator

func IsMatched

func IsMatched(orders []*common.Order) bool

IsMatched check does the orders can be exchange

Types

type AllocatedAssets

type AllocatedAssets struct {
	Receives []*bc.AssetAmount
	Fees     []*bc.AssetAmount
}

AllocatedAssets represent reallocated assets after calculating fees

type DefaultFeeStrategy

type DefaultFeeStrategy struct{}

DefaultFeeStrategy represent the default fee charge strategy

func NewDefaultFeeStrategy

func NewDefaultFeeStrategy() *DefaultFeeStrategy

NewDefaultFeeStrategy return a new instance of DefaultFeeStrategy

func (*DefaultFeeStrategy) Allocate

func (d *DefaultFeeStrategy) Allocate(receiveAmounts, priceDiffs []*bc.AssetAmount) *AllocatedAssets

Allocate will allocate the price differential in matching transaction to the participants and the fee

func (*DefaultFeeStrategy) Validate

func (d *DefaultFeeStrategy) Validate(receiveAmounts []*bc.AssetAmount, feeAmounts map[bc.AssetID]uint64) error

Validate verify that the fee charged for a matching transaction is correct

type Engine

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

Engine is used to generate math transactions

func NewEngine

func NewEngine(orderBook *OrderBook, feeStrategy FeeStrategy, rewardProgram []byte) *Engine

NewEngine return a new Engine

func (*Engine) HasMatchedTx

func (e *Engine) HasMatchedTx(tradePairs ...*common.TradePair) bool

HasMatchedTx check does the input trade pair can generate a match deal

func (*Engine) NextMatchedTx

func (e *Engine) NextMatchedTx(tradePairs ...*common.TradePair) (*types.Tx, error)

NextMatchedTx return the next matchable transaction by the specified trade pairs the size of trade pairs at least 2, and the sequence of trade pairs can form a loop for example, [assetA -> assetB, assetB -> assetC, assetC -> assetA]

type FeeStrategy

type FeeStrategy interface {
	// Allocate will allocate the price differential in matching transaction to the participants and the fee
	// @param receiveAmounts the amount of assets that the participants in the matching transaction can received when no fee is considered
	// @param priceDiffs price differential of matching transaction
	// @return reallocated assets after calculating fees
	Allocate(receiveAmounts, priceDiffs []*bc.AssetAmount) *AllocatedAssets

	// Validate verify that the fee charged for a matching transaction is correct
	Validate(receiveAmounts []*bc.AssetAmount, feeAmounts map[bc.AssetID]uint64) error
}

FeeStrategy used to indicate how to charge a matching fee

type OrderBook

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

OrderBook is used to handle the mov orders in memory like stack

func NewOrderBook

func NewOrderBook(movStore database.MovStore, arrivalAddOrders, arrivalDelOrders []*common.Order) *OrderBook

NewOrderBook create a new OrderBook object

func (*OrderBook) AddOrder

func (o *OrderBook) AddOrder(order *common.Order)

AddOrder add the in memory temp order to order table, because temp order is what left for the partial trade order, so the price should be lowest.

func (*OrderBook) DelOrder

func (o *OrderBook) DelOrder(order *common.Order)

DelOrder mark the order has been deleted in order book

func (*OrderBook) PeekOrder

func (o *OrderBook) PeekOrder(tradePair *common.TradePair) *common.Order

PeekOrder return the next lowest order of given trade pair

func (*OrderBook) PeekOrders

func (o *OrderBook) PeekOrders(tradePairs []*common.TradePair) []*common.Order

PeekOrders return the next lowest orders by given array of trade pairs

func (*OrderBook) PopOrder

func (o *OrderBook) PopOrder(tradePair *common.TradePair)

PopOrder delete the next lowest order of given trade pair

func (*OrderBook) PopOrders

func (o *OrderBook) PopOrders(tradePairs []*common.TradePair) []*common.Order

PopOrders delete the next lowest orders by given trade pairs