交易所撮合引擎原理及實現程式碼
交易撮合引擎（Matching/Trading Engine），顧名思義是用來撮合交易的軟體，廣泛地應用在金融、證券、加密貨幣交易等領域。交易引擎負責管理加密資產市場中所有的開口訂單（Open Orders），並在發現匹配的訂單對（Trading Pair）時自動執行交易。本文將首先介紹有關加密資產交易撮合引擎的基本概念，例如委託單、交易委託賬本等，然後使用Golang實現一個原理性的撮合引擎。如果你正在考慮實現類似交易所（Exchange）這樣的產品，相信本文會對你有很大的幫助。
可以這樣先思考一下：如果你要實現一個供人們將以太幣兌換為比特幣的市場，那麼你就需要跟蹤一些資訊，例如以太幣的買/賣價格（以比特幣計算）、哪些買單或賣單還沒有執行等等，同時還要處理新進來的委託單。將這一思路擴充套件到多個交易對，然後再整合錢包功能，你就實現了一個完整的交易引擎，就像幣安一樣。
本文的完整原始碼下載地址：https://github.com/ezpod/crypto-exchange-engine
1、基本概念與術語
在開始打造交易撮合引擎之前，讓我們首先熟悉相關的基本概念與術語。
撮合/交易引擎
正如前面所述，交易撮合引擎是用來撮合交易的軟體，可以先把交易撮合引擎看作一個黑盒子，它有一些輸入和輸出。
例如，可能的輸入包括：
- 建立新的委託單（NewOrder）：一個新的委託單可以作為交易撮合引擎的輸入，引擎會嘗試將其與已有的 委託單進行撮合。
- 取消已有的委託單（CancelOrder）：使用者也可以取消一個之前輸入的委託單，如果它還沒有執行的話，即開口訂單。
當然你可以定義其他的輸入，出於簡化考慮，我們現在只定義上述兩個輸入。
交易撮合引擎的輸出是一些事件，以便及時通知其他應用處理。例如，當引擎撮合了一筆交易後，就會觸發一個TradesGenerated事件；而當取消了一個已有的委託單後，引擎就會觸發rderCancelled。同樣，你可以根據自己的需求來定義引擎的輸出，這裡我們還是簡單點，只定義這兩個輸出事件。
交易委託賬本
交易委託賬本（Order Book）就是一個買方委託單或買方委託單的列表，通常按照價格和時間排序。
當一個新的買方（買方）委託單進入引擎後，引擎就會將嘗試其與現有的賣方（買方）委託賬本 進行匹配，看是否存在執行交易的可能。如果找到了匹配的對手單，引擎就可以執行這兩個委託單了，也就是撮合成功了。
委託單
在任何交易引擎中，都可能有多種型別的委託單供使用者選擇。其中常見的型別包括：
- 限價委託單
限價委託單是在當前的加密貨幣交易環境中最常用的委託型別。這種委託單允許使用者指定一個價格，只有當撮合引擎找到同樣價格甚至更好價格的對手單時才執行交易。
對於一個買方委託單而言，這意味著如果你的委託價格是￥100，那麼該委託單將會在任何不高於￥100的價格成交 —— 買到指定的價格或者更便宜的價格；而對於一個賣方委託單而言，同樣的委託價格意味著該委託單將在任何不低於￥100的價格成交—— 賣出指定的價格或者更高的價格。
- 市價委託單
市價委託單的撮合會完全忽略價格因素，而致力於有限完成指定數量的成交。市價委託單在交易委託賬本中有較高的優先順序，在流動性充足的市場中市價單可以保證成交。
例如，當用戶委託購買2個以太幣時，該委託單可以在￥900、￥1000、￥2000或任何其他價位成交，這依賴於市場中當前的敞口委託單的情況。
- 止損委託單
止損委託單盡在市場價格到達指定價位時才被啟用，因此它的執行方式與市價委託單相反。一旦止損委託單啟用，它們可以自動轉化為市價委託單或限價委託單。
如果你希望打造一個高階的交易所，那麼還有其他一些需要了解的概念，例如流動性、多/空交易、FIX/FAST協議等等，但是同樣出於簡化考慮，我們將這些內容留給你自己去發現。
2、系統架構
現在，對於交易撮合引擎的構成我們已經有了一些瞭解，那麼讓我們看一下整個系統的架構，以及我們將要使用的技術：
正如你上面看到的，我們的系統將包含引擎的多個客戶端，這些客戶端可以是交易所繫統中的其他元件，例如接收終端使用者委託請求的App等等。
在客戶端和引擎之間的通訊是使用Apache Kafka作為訊息匯流排來實現的，每個交易對都對應Kafka的一個主題，這樣我們可以確保當訊息佇列接收到使用者委託單時，引擎將以同樣的先後順序處理委託單。這保證了即使引擎崩潰重啟我們也可以重建交易委託賬本。
引擎將監聽Kafka主題，執行委託賬本命令並將引擎的輸出事件釋出到訊息佇列中。當然如果能夠監測委託單的處理速度以及交易的執行情況會更酷。我們可以使用Prometheus來採集效能指標，使用grafana來實現一個監視儀表盤。
3、開發語言選擇
可以選擇你熟悉的開發語言，不過由於交易撮合引擎計算量巨大，通常我們應當選擇底層系列的語言，例如：C/C++、GoLang、Rust、Java等等。在這個教程中，我們使用Golang，因為它很快、容易理解、併發實現簡單，而且我也有好久沒有用C++了。
4、開發交易撮合引擎
我們將按照以下的步驟來開發交易撮合引擎：
- 基礎型別定義
- Consumer實現
- Order Book實現
- Producer實現
- Monitoring實現
4.1 基礎型別定義
我們需要首先定義一些基礎型別，這包括Order、OrderBook和Trade，分別表示委託單、交易委託賬本和交易：
下面是engine/order.go檔案的內容：
package engine
import "encoding/json"
type Order struct {
Amount uint64 `json:"amount"`
Price uint64 `json:"price"`
ID string `json:"id"`
Side int8 `json:"side"`
}
func (order *Order) FromJSON(msg []byte) error {
return json.Unmarshal(msg, order)
}
func (order *Order) ToJSON() []byte {
str, _ := json.Marshal(order)
return str
}
這裡我們就是簡單地建立了一個結構用來記錄訂單的主要資訊，然後添加了一個方法用於快速的JSON轉換。
類似地engine/trade.go檔案的內容：
package engine
import "encoding/json"
type Trade struct {
TakerOrderID string `json:"taker_order_id"`
MakerOrderID string `json:"maker_order_id"`
Amount uint64 `json:"amount"`
Price uint64 `json:"price"`
}
func (trade *Trade) FromJSON(msg []byte) error {
return json.Unmarshal(msg, trade)
}
func (trade *Trade) ToJSON() []byte {
str, _ := json.Marshal(trade)
return str
}
現在我們已經定義了基本的輸入和輸出型別，現在看看交易委託賬本engine/order_book.go檔案的內容：
package engine
// OrderBook type
type OrderBook struct {
BuyOrders []Order
SellOrders []Order
}
// Add a buy order to the order book
func (book *OrderBook) addBuyOrder(order Order) {
n := len(book.BuyOrders)
var i int
for i := n - 1; i >= 0; i-- {
buyOrder := book.BuyOrders[i]
if buyOrder.Price < order.Price {
break
}
}
if i == n-1 {
book.BuyOrders = append(book.BuyOrders, order)
} else {
copy(book.BuyOrders[i+1:], book.BuyOrders[i:])
book.BuyOrders[i] = order
}
}
// Add a sell order to the order book
func (book *OrderBook) addSellOrder(order Order) {
n := len(book.SellOrders)
var i int
for i := n - 1; i >= 0; i-- {
sellOrder := book.SellOrders[i]
if sellOrder.Price > order.Price {
break
}
}
if i == n-1 {
book.SellOrders = append(book.SellOrders, order)
} else {
copy(book.SellOrders[i+1:], book.SellOrders[i:])
book.SellOrders[i] = order
}
}
// Remove a buy order from the order book at a given index
func (book *OrderBook) removeBuyOrder(index int) {
book.BuyOrders = append(book.BuyOrders[:index], book.BuyOrders[index+1:]...)
}
// Remove a sell order from the order book at a given index
func (book *OrderBook) removeSellOrder(index int) {
book.SellOrders = append(book.SellOrders[:index], book.SellOrders[index+1:]...)
}
在交易委託賬本中，除了建立儲存買/賣方委託單的列表外，我們還需要定義新增新委託單的方法。
委託單列表應當根據其型別按升序或降序排列：賣方委託單是按降序排列的，這樣在列表中序號最大的委託單價格最低；買方委託單是按升序排列的，因此在其列表中最後的委託單價格最高。
由於絕大多數交易會在市場價格附近成交，我們可以輕鬆地從這些陣列中插入或移除成員。
4.2 委託單處理
現在讓我們來處理委託單。
在下面的程式碼中我們添加了一個命令來實現對限價委託單的處理。
檔案engine/order_book_limit_order.go的內容：
package engine
// Process an order and return the trades generated before adding the remaining amount to the market
func (book *OrderBook) Process(order Order) []Trade {
if order.Side == 1 {
return book.processLimitBuy(order)
}
return book.processLimitSell(order)
}
// Process a limit buy order
func (book *OrderBook) processLimitBuy(order Order) []Trade {
trades := make([]Trade, 0, 1)
n := len(book.SellOrders)
// check if we have at least one matching order
if n != 0 || book.SellOrders[n-1].Price <= order.Price {
// traverse all orders that match
for i := n - 1; i >= 0; i-- {
sellOrder := book.SellOrders[i]
if sellOrder.Price > order.Price {
break
}
// fill the entire order
if sellOrder.Amount >= order.Amount {
trades = append(trades, Trade{order.ID, sellOrder.ID, order.Amount, sellOrder.Price})
sellOrder.Amount -= order.Amount
if sellOrder.Amount == 0 {
book.removeSellOrder(i)
}
return trades
}
// fill a partial order and continue
if sellOrder.Amount < order.Amount {
trades = append(trades, Trade{order.ID, sellOrder.ID, sellOrder.Amount, sellOrder.Price})
order.Amount -= sellOrder.Amount
book.removeSellOrder(i)
continue
}
}
}
// finally add the remaining order to the list
book.addBuyOrder(order)
return trades
}
// Process a limit sell order
func (book *OrderBook) processLimitSell(order Order) []Trade {
trades := make([]Trade, 0, 1)
n := len(book.BuyOrders)
// check if we have at least one matching order
if n != 0 || book.BuyOrders[n-1].Price >= order.Price {
// traverse all orders that match
for i := n - 1; i >= 0; i-- {
buyOrder := book.BuyOrders[i]
if buyOrder.Price < order.Price {
break
}
// fill the entire order
if buyOrder.Amount >= order.Amount {
trades = append(trades, Trade{order.ID, buyOrder.ID, order.Amount, buyOrder.Price})
buyOrder.Amount -= order.Amount
if buyOrder.Amount == 0 {
book.removeBuyOrder(i)
}
return trades
}
// fill a partial order and continue
if buyOrder.Amount < order.Amount {
trades = append(trades, Trade{order.ID, buyOrder.ID, buyOrder.Amount, buyOrder.Price})
order.Amount -= buyOrder.Amount
book.removeBuyOrder(i)
continue
}
}
}
// finally add the remaining order to the list
book.addSellOrder(order)
return trades
}
看起來我們將一個方法變成了兩個，分別處理買方委託單和賣方委託單。這兩個方法在每個方面 都很相似，除了處理的市場側不同。
演算法非常簡單。我們將一個買方委託單與所有的賣方委託單進行匹配，找出任何與買方委託價格 一致甚至更低的賣方委託單。當這一條件不能滿足時，或者該買方委託單完成後，我們返會撮合 的交易。
4.3 接入Kafka
現在就快完成我們的交易引擎了，還需要接入Apache Kafka伺服器，然後開始監聽委託單。
main.go檔案的內容：
package main
import (
"engine/engine"
"log"
"github.com/Shopify/sarama"
cluster "github.com/bsm/sarama-cluster"
)
func main() {
// create the consumer and listen for new order messages
consumer := createConsumer()
// create the producer of trade messages
producer := createProducer()
// create the order book
book := engine.OrderBook{
BuyOrders: make([]engine.Order, 0, 100),
SellOrders: make([]engine.Order, 0, 100),
}
// create a signal channel to know when we are done
done := make(chan bool)
// start processing orders
go func() {
for msg := range consumer.Messages() {
var order engine.Order
// decode the message
order.FromJSON(msg.Value)
// process the order
trades := book.Process(order)
// send trades to message queue
for _, trade := range trades {
rawTrade := trade.ToJSON()
producer.Input() <- &sarama.ProducerMessage{
Topic: "trades",
Value: sarama.ByteEncoder(rawTrade),
}
}
// mark the message as processed
consumer.MarkOffset(msg, "")
}
done <- true
}()
// wait until we are done
<-done
}
//
// Create the consumer
//
func createConsumer() *cluster.Consumer {
// define our configuration to the cluster
config := cluster.NewConfig()
config.Consumer.Return.Errors = false
config.Group.Return.Notifications = false
config.Consumer.Offsets.Initial = sarama.OffsetOldest
// create the consumer
consumer, err := cluster.NewConsumer([]string{"127.0.0.1:9092"}, "myconsumer", []string{"orders"}, config)
if err != nil {
log.Fatal("Unable to connect consumer to kafka cluster")
}
go handleErrors(consumer)
go handleNotifications(consumer)
return consumer
}
func handleErrors(consumer *cluster.Consumer) {
for err := range consumer.Errors() {
log.Printf("Error: %s\n", err.Error())
}
}
func handleNotifications(consumer *cluster.Consumer) {
for ntf := range consumer.Notifications() {
log.Printf("Rebalanced: %+v\n", ntf)
}
}
//
// Create the producer
//
func createProducer() sarama.AsyncProducer {
config := sarama.NewConfig()
config.Producer.Return.Successes = false
config.Producer.Return.Errors = true
config.Producer.RequiredAcks = sarama.WaitForAll
producer, err := sarama.NewAsyncProducer([]string{"127.0.0.1:9092"}, config)
if err != nil {
log.Fatal("Unable to connect producer to kafka server")
}
return producer
}
利用Golang的Sarama Kafka客戶端開發庫，我們可以分別建立一個接入Kafka的消費者和生產者。
消費者將在指定的Kafka主題上等待新的委託單，然後進行撮合處理。生成的交易接下來使用生產者傳送到指定的交易主題。
Kafka訊息採用位元組陣列編碼，因此我們需要將其解碼。反之，將交易傳入訊息佇列時，我們還需要進行必要的編碼。
5、結語
現在你有了一個可伸縮的交易引擎！完整的程式碼可以在GITHUB下載：crypto-exchange-engine。
不過這個引擎的目的是教學，另外程式碼還支援很多進一步的優化，例如：
- 使用一種更高效的匹配演算法
- 新增取消訂單的功能
- 增強通訊能力
- 委託賬本的備份與恢復
- 新增監視功能
如果你想學習區塊鏈並在Blockchain Technologies建立職業生涯，那麼請檢視我們分享的一些以太坊、比特幣、EOS、Fabric等區塊鏈相關的互動式線上程式設計實戰教程：
- java以太坊開發教程，主要是針對java和android程式設計師進行區塊鏈以太坊開發的web3j詳解。
- python以太坊，主要是針對python工程師使用web3.py進行區塊鏈以太坊開發的詳解。
- php以太坊，主要是介紹使用php進行智慧合約開發互動，進行賬號建立、交易、轉賬、代幣開發以及過濾器和交易等內容。
- 以太坊入門教程，主要介紹智慧合約與dapp應用開發，適合入門。
- 以太坊開發進階教程，主要是介紹使用node.js、mongodb、區塊鏈、ipfs實現去中心化電商DApp實戰，適合進階。
- ERC721以太坊通證實戰，課程以一個數字藝術品創作與分享DApp的實戰開發為主線，深入講解以太坊非同質化通證的概念、標準與開發方案。內容包含ERC-721標準的自主實現，講解OpenZeppelin合約程式碼庫二次開發，實戰專案採用Truffle，IPFS，實現了通證以及去中心化的通證交易所。
- C#以太坊，主要講解如何使用C#開發基於.Net的以太坊應用，包括賬戶管理、狀態與交易、智慧合約開發與互動、過濾器和交易等。
- java比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈儲存、去中心化共識機制、金鑰與指令碼、交易與UTXO等，同時也詳細講解如何在Java程式碼中整合比特幣支援功能，例如建立地址、管理錢包、構造裸交易等，是Java工程師不可多得的比特幣開發學習課程。
- php比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈儲存、去中心化共識機制、金鑰與指令碼、交易與UTXO等，同時也詳細講解如何在Php程式碼中整合比特幣支援功能，例如建立地址、管理錢包、構造裸交易等，是Php工程師不可多得的比特幣開發學習課程。
- c#比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈儲存、去中心化共識機制、金鑰與指令碼、交易與UTXO等，同時也詳細講解如何在C#程式碼中整合比特幣支援功能，例如建立地址、管理錢包、構造裸交易等，是C#工程師不可多得的比特幣開發學習課程。
- EOS入門教程，本課程幫助你快速入門EOS區塊鏈去中心化應用的開發，內容涵蓋EOS工具鏈、賬戶與錢包、發行代幣、智慧合約開發與部署、使用程式碼與智慧合約互動等核心知識點，最後綜合運用各知識點完成一個便籤DApp的開發。
- 深入淺出玩轉EOS錢包開發，本課程以手機EOS錢包的完整開發過程為主線，深入學習EOS區塊鏈應用開發，課程內容即涵蓋賬戶、計算資源、智慧合約、動作與交易等EOS區塊鏈的核心概念，同時也講解如何使用eosjs和eosjs-ecc開發包訪問EOS區塊鏈，以及如何在React前端應用中整合對EOS區塊鏈的支援。課程內容深入淺出，非常適合前端工程師深入學習EOS區塊鏈應用開發。
- Hyperledger Fabric 區塊鏈開發詳解，本課程面向初學者，內容即包含Hyperledger Fabric的身份證書與MSP服務、許可權策略、通道配置與啟動、鏈碼通訊介面等核心概念，也包含Fabric網路設計、nodejs鏈碼與應用開發的操作實踐，是Nodejs工程師學習Fabric區塊鏈開發的最佳選擇。
- Hyperledger Fabric java 區塊鏈開發詳解，課程面向初學者，內容即包含Hyperledger Fabric的身份證書與MSP服務、許可權策略、通道配置與啟動、鏈碼通訊介面等核心概念，也包含Fabric網路設計、java鏈碼與應用開發的操作實踐，是java工程師學習Fabric區塊鏈開發的最佳選擇。
- tendermint區塊鏈開發詳解，本課程適合希望使用tendermint進行區塊鏈開發的工程師，課程內容即包括tendermint應用開發模型中的核心概念，例如ABCI介面、默克爾樹、多版本狀態庫等，也包括代幣發行等豐富的實操程式碼，是go語言工程師快速入門區塊鏈開發的最佳選擇。
原文連結：交易撮合引擎原理與實