Example orderbook subscribe sol.

examples/CMakeLists.txt

@@ -5,9 +5,11 @@ add_executable(example-get-account-info getAccountInfo.cpp)
 add_executable(example-account-subscribe accountSubscribe.cpp)
 add_executable(example-send-transaction sendTransaction.cpp)
 add_executable(example-place-order placeOrder.cpp)
+add_executable(example-orderbook-subscribe orderbookSubscribe.cpp)
 
 # link
 target_link_libraries(example-get-account-info ${CONAN_LIBS} sol)
 target_link_libraries(example-account-subscribe ${CONAN_LIBS} sol)
 target_link_libraries(example-send-transaction ${CONAN_LIBS} sol)
-target_link_libraries(example-place-order ${CONAN_LIBS} sol)
+target_link_libraries(example-place-order ${CONAN_LIBS} sol)
+target_link_libraries(example-orderbook-subscribe ${CONAN_LIBS} sol)

examples/orderbookSubscribe.cpp

@@ -0,0 +1,84 @@
+#include <cpr/cpr.h>
+#include <spdlog/spdlog.h>
+
+#include <chrono>
+#include <mutex>
+#include <websocketpp/client.hpp>
+#include <websocketpp/config/asio_client.hpp>
+
+#include "mango_v3.hpp"
+#include "orderbook/levelOne.hpp"
+#include "orderbook/orderbook.hpp"
+#include "solana.hpp"
+#include "subscriptions/bookSide.hpp"
+#include "subscriptions/trades.hpp"
+
+class updateLogger {
+ public:
+  updateLogger(mango_v3::orderbook::book& orderbook,
+               mango_v3::subscription::trades& trades)
+      : orderbook(orderbook), trades(trades) {
+    orderbook.registerUpdateCallback(std::bind(&updateLogger::logUpdate, this));
+    trades.registerUpdateCallback(std::bind(&updateLogger::logUpdate, this));
+  }
+
+  void start() {
+    orderbook.subscribe();
+    trades.subscribe();
+  }
+
+  void logUpdate() {
+    const std::scoped_lock lock(updateMtx);
+    auto level1Snapshot = orderbook.getLevel1();
+    if (level1Snapshot.valid()) {
+      spdlog::info("============Update============");
+      spdlog::info("Latest trade: {}", trades.getLastTrade()
+                                           ? to_string(trades.getLastTrade())
+                                           : "not received yet");
+      spdlog::info("Bid-Ask {}-{}", level1Snapshot.highestBid,
+                   level1Snapshot.lowestAsk);
+      spdlog::info("MidPrice: {}", level1Snapshot.midPoint);
+      spdlog::info("Spread: {0:.2f} bps", level1Snapshot.spreadBps);
+
+      constexpr auto depth = 2;
+      spdlog::info("Market depth -{}%: {}", depth, orderbook.getDepth(-depth));
+      spdlog::info("Market depth +{}%: {}", depth, orderbook.getDepth(depth));
+    }
+  }
+
+ private:
+  std::mutex updateMtx;
+  mango_v3::orderbook::book& orderbook;
+  mango_v3::subscription::trades& trades;
+};
+
+int main() {
+  const auto& config = mango_v3::MAINNET;
+  const solana::rpc::Connection solCon;
+  const auto group = solCon.getAccountInfo<mango_v3::MangoGroup>(config.group);
+
+  const auto symbolIt =
+      std::find(config.symbols.begin(), config.symbols.end(), "SOL");
+  const auto marketIndex = symbolIt - config.symbols.begin();
+  assert(config.symbols[marketIndex] == "SOL");
+
+  const auto perpMarketPk = group.perpMarkets[marketIndex].perpMarket;
+  auto market =
+      solCon.getAccountInfo<mango_v3::PerpMarket>(perpMarketPk.toBase58());
+  assert(market.mangoGroup.toBase58() == config.group);
+
+  mango_v3::subscription::bookSide bids(mango_v3::Buy, market.bids.toBase58());
+  mango_v3::subscription::bookSide asks(mango_v3::Sell, market.asks.toBase58());
+  mango_v3::subscription::trades trades(market.eventQueue.toBase58());
+
+  mango_v3::orderbook::book orderbook(bids, asks);
+
+  updateLogger logger(orderbook, trades);
+  logger.start();
+
+  while (true) {
+  }
+  return 0;
+}
+
+// void updateReceived() {}

include/mango_v3.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <stack>
 #include <string>
 
 #include "fixedp.h"
@@ -15,6 +16,8 @@ const int MAX_PAIRS = 15;
 const int QUOTE_INDEX = 15;
 const int EVENT_SIZE = 200;
 const int EVENT_QUEUE_SIZE = 256;
+const int BOOK_NODE_SIZE = 88;
+const int BOOK_SIZE = 1024;
 
 struct Config {
   std::string endpoint;
@@ -135,8 +138,10 @@ struct EventQueueHeader {
   uint64_t seqNum;
 };
 
+// todo: change to scoped enum class
 enum EventType : uint8_t { Fill, Out, Liquidate };
 
+// todo: change to scoped enum class
 enum Side : uint8_t { Buy, Sell };
 
 struct AnyEvent {
@@ -197,6 +202,93 @@ struct EventQueue {
   AnyEvent items[EVENT_QUEUE_SIZE];
 };
 
+// todo: change to scoped enum class
+enum NodeType : uint32_t {
+  Uninitialized = 0,
+  InnerNode,
+  LeafNode,
+  FreeNode,
+  LastFreeNode
+};
+
+struct AnyNode {
+  NodeType tag;
+  uint8_t padding[BOOK_NODE_SIZE - 4];
+};
+
+struct InnerNode {
+  NodeType tag;
+  uint32_t prefixLen;
+  __uint128_t key;
+  uint32_t children[2];
+  uint8_t padding[BOOK_NODE_SIZE - 32];
+};
+
+struct LeafNode {
+  NodeType tag;
+  uint8_t ownerSlot;
+  uint8_t orderType;
+  uint8_t version;
+  uint8_t timeInForce;
+  __uint128_t key;
+  solana::PublicKey owner;
+  uint64_t quantity;
+  uint64_t clientOrderId;
+  uint64_t bestInitial;
+  uint64_t timestamp;
+};
+
+struct FreeNode {
+  NodeType tag;
+  uint32_t next;
+  uint8_t padding[BOOK_NODE_SIZE - 8];
+};
+
+struct BookSide {
+  MetaData metaData;
+  uint64_t bumpIndex;
+  uint64_t freeListLen;
+  uint32_t freeListHead;
+  uint32_t rootNode;
+  uint64_t leafCount;
+  AnyNode nodes[BOOK_SIZE];
+
+  struct iterator {
+    Side side;
+    const BookSide &bookSide;
+    std::stack<uint32_t> stack;
+    uint32_t left, right;
+
+    iterator(Side side, const BookSide &bookSide)
+        : side(side), bookSide(bookSide) {
+      stack.push(bookSide.rootNode);
+      left = side == Side::Buy ? 1 : 0;
+      right = side == Side::Buy ? 0 : 1;
+    }
+
+    bool operator==(const iterator &other) const {
+      return &bookSide == &other.bookSide && stack.top() == other.stack.top();
+    }
+
+    iterator &operator++() {
+      if (stack.size() > 0) {
+        const auto &elem = **this;
+        stack.pop();
+
+        if (elem.tag == NodeType::InnerNode) {
+          const auto innerNode =
+              reinterpret_cast<const struct InnerNode *>(&elem);
+          stack.push(innerNode->children[right]);
+          stack.push(innerNode->children[left]);
+        }
+      }
+      return *this;
+    }
+
+    const AnyNode &operator*() const { return bookSide.nodes[stack.top()]; }
+  };
+};
+
 #pragma pack(pop)
 
 // instructions are even tighter packed, every byte counts

include/orderbook/levelOne.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+namespace mango_v3 {
+namespace orderbook {
+
+struct levelOne {
+  uint64_t highestBid;
+  uint64_t highestBidSize;
+  uint64_t lowestAsk;
+  uint64_t lowestAskSize;
+  double midPoint;
+  double spreadBps;
+
+  bool valid() const {
+    return ((highestBid && lowestAsk) && (lowestAsk > highestBid)) ? true
+                                                                   : false;
+  }
+};
+
+}  // namespace orderbook
+}  // namespace mango_v3

include/orderbook/order.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace mango_v3 {
+namespace orderbook {
+
+struct order {
+  order(uint64_t price, uint64_t quantity) : price(price), quantity(quantity) {}
+
+  bool operator<(const order& compare) const {
+    return (price < compare.price) ? true : false;
+  }
+
+  bool operator>(const order& compare) const {
+    return (price > compare.price) ? true : false;
+  }
+
+  uint64_t price;
+  uint64_t quantity;
+};
+
+}  // namespace orderbook
+}  // namespace mango_v3

include/orderbook/orderbook.hpp

@@ -0,0 +1,74 @@
+#pragma once
+#include <spdlog/spdlog.h>
+
+#include <functional>
+#include <mutex>
+
+#include "levelOne.hpp"
+#include "orderbook/order.hpp"
+#include "subscriptions/bookSide.hpp"
+
+namespace mango_v3 {
+namespace orderbook {
+class book {
+ public:
+  book(subscription::bookSide& bids, subscription::bookSide& asks)
+      : bids(bids), asks(asks) {
+    bids.registerUpdateCallback(std::bind(&book::updateCallback, this));
+    asks.registerUpdateCallback(std::bind(&book::updateCallback, this));
+  }
+
+  void registerUpdateCallback(std::function<void()> callback) {
+    onUpdateCb = callback;
+  }
+
+  void subscribe() {
+    bids.subscribe();
+    asks.subscribe();
+  }
+
+  void updateCallback() {
+    const std::scoped_lock lock(callbackMtx);
+    levelOne newL1;
+    auto bestBid = bids.getBestOrder();
+    auto bestAsk = asks.getBestOrder();
+    newL1.highestBid = bestBid.price;
+    newL1.highestBidSize = bestBid.quantity;
+    newL1.lowestAsk = bestAsk.price;
+    newL1.lowestAskSize = bestAsk.quantity;
+
+    if (newL1.valid()) {
+      newL1.midPoint = ((double)newL1.lowestAsk + newL1.highestBid) / 2;
+      newL1.spreadBps =
+          ((newL1.lowestAsk - newL1.highestBid) * 10000) / newL1.midPoint;
+      {
+        const std::scoped_lock lock(levelOneMtx);
+        level1 = newL1;
+      }
+      onUpdateCb();
+    }
+  }
+
+  levelOne getLevel1() const {
+    const std::scoped_lock lock(levelOneMtx);
+    return level1;
+  }
+
+  uint64_t getDepth(int8_t percent) {
+    const std::scoped_lock lock(levelOneMtx);
+    auto price = (level1.midPoint * (100 + percent)) / 100;
+    return (percent > 0) ? asks.getVolume<std::less_equal<uint64_t>>(price)
+                         : bids.getVolume<std::greater_equal<uint64_t>>(price);
+  }
+
+ private:
+  levelOne level1;
+  // todo:macos latomic not found issue, otherwise replace mtx with std::atomic
+  mutable std::mutex levelOneMtx;
+  std::function<void()> onUpdateCb;
+  std::mutex callbackMtx;
+  subscription::bookSide& bids;
+  subscription::bookSide& asks;
+};
+}  // namespace orderbook
+}  // namespace mango_v3

include/solana.hpp

@@ -250,7 +250,8 @@ class Connection {
   ///
   json getAccountInfoRequest(const std::string &account,
                              const std::string &encoding = "base64",
-                             const size_t offset = 0, const size_t length = 0);
+                             const size_t offset = 0,
+                             const size_t length = 0) const;
   json getRecentBlockhashRequest(const std::string &commitment = "finalized");
   json sendTransactionRequest(
       const std::string &transaction, const std::string &encoding = "base58",
@@ -269,7 +270,8 @@ class Connection {
   template <typename T>
   inline T getAccountInfo(const std::string &account,
                           const std::string &encoding = "base64",
-                          const size_t offset = 0, const size_t length = 0) {
+                          const size_t offset = 0,
+                          const size_t length = 0) const {
     const json req = getAccountInfoRequest(account, encoding, offset, length);
     cpr::Response r =
         cpr::Post(cpr::Url{rpc_url_}, cpr::Body{req.dump()},
@@ -309,4 +311,4 @@ inline json accountSubscribeRequest(const std::string &account,
 }
 }  // namespace subscription
 }  // namespace rpc
-}  // namespace solana
+}  // namespace solana