add simple ticker example based on json rpc

Author: mschneider

CMakeLists.txt

@@ -14,12 +14,14 @@ add_executable(example-get-account-info examples/getAccountInfo.cpp)
 add_executable(example-account-subscribe examples/accountSubscribe.cpp)
 add_executable(example-send-transaction examples/sendTransaction.cpp)
 add_executable(example-place-order examples/placeOrder.cpp)
+add_executable(example-ticker examples/ticker.cpp)
 
 # link
 target_link_libraries(example-get-account-info ${CONAN_LIBS})
 target_link_libraries(example-account-subscribe ${CONAN_LIBS})
 target_link_libraries(example-send-transaction ${CONAN_LIBS})
 target_link_libraries(example-place-order ${CONAN_LIBS})
+target_link_libraries(example-ticker ${CONAN_LIBS})
 
 # tests
 include(CTest)

examples/ticker.cpp

@@ -0,0 +1,48 @@
+#include <chrono>
+#include <cpr/cpr.h>
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;
+
+#include "../mango_v3.hpp"
+
+int main()
+{
+  const auto &config = mango_v3::MAINNET;
+  const auto group = solana::rpc::getAccountInfo<mango_v3::MangoGroup>(
+      config.endpoint,
+      config.group);
+
+  const auto symbolIt = std::find(config.symbols.begin(), config.symbols.end(), "BTC");
+  const auto marketIndex = symbolIt - config.symbols.begin();
+  assert(config.symbols[marketIndex] == "BTC");
+
+  const auto perpMarketPk = group.perpMarkets[marketIndex].perpMarket;
+
+  const auto market = solana::rpc::getAccountInfo<mango_v3::PerpMarket>(
+      config.endpoint,
+      perpMarketPk.toBase58());
+  assert(market.mangoGroup.toBase58() == config.group);
+
+  while (true)
+  {
+    const auto bids = solana::rpc::getAccountInfo<mango_v3::BookSide>(config.endpoint, market.bids.toBase58());
+
+    auto bidsIt = mango_v3::BookSide::iterator(mango_v3::Side::Buy, bids);
+    while (bidsIt.stack.size() > 0)
+    {
+      if ((*bidsIt).tag == mango_v3::NodeType::LeafNode)
+      {
+        const auto leafNode = reinterpret_cast<const struct mango_v3::LeafNode *>(&(*bidsIt));
+        const auto now = std::chrono::system_clock::now();
+        const auto nowUnix = chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
+        const auto isValid = !leafNode->timeInForce || leafNode->timestamp + leafNode->timeInForce < nowUnix;
+        if (isValid)
+        {
+          std::cout << "best bid prz:" << (uint64_t)(leafNode->key >> 64) << " qty:" << leafNode->quantity << std::endl;
+          break;
+        }
+      }
+      ++bidsIt;
+    }
+  }
+}

mango_v3.hpp

@@ -15,6 +15,8 @@ namespace mango_v3
   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
   {
@@ -218,6 +220,106 @@ namespace mango_v3
     AnyEvent items[EVENT_QUEUE_SIZE];
   };
 
+  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