Bot prints exchange feed

Joel Grunbaum

2022-01-19 0b7aa02704f6ece97d17fbb118519c5cc62caaba

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include "strat.hpp"
 
#include "bom.hpp"
#include "book.hpp"
#include "json.hpp"
#include "secrets.hpp"
 
#include "protocol.hpp"
#include <deque>
#include <unordered_map>
 
namespace strat
{
std::unordered_map<std::string, json::Message*> orders;
 
void deleteOrder(json::AddedMessage* m);
void freeMessages(std::deque<json::Message*>& m);
void printFeed(std::deque<json::Message*>& m);
void dumbHit(std::deque<json::Message*>& m);
 
void initialise()
{
    bom::initialise();
    protocol::createWebSocket();
}
 
void destroy()
{
    bom::destroy();
    for (auto& i : orders) {
        switch (i.second->type) {
        case json::FUTURE_TYPE:
        case json::SPREAD_TYPE:
        case json::CALL_TYPE:
        case json::PUT_TYPE:
            deleteOrder((json::AddedMessage*)i.second);
        default:;
        }
        delete i.second;
    }
}
 
void mainLoop()
{
    auto bs = protocol::recoverBook();
    while (true) {
        auto messages = protocol::catchUp(bs);
        // bom::updateBom(bs);
        printFeed(messages);
        freeMessages(messages);
    }
}
 
void deleteOrder(json::AddedMessage* m)
{
    json::DeleteMessage a(json::DELETE, m->product, m->id);
    delete protocol::deleteOrder(a);
}
 
void printFeed(std::deque<json::Message*>& m)
{
    for (auto& i : m) {
        switch (i->type) {
        case json::FUTURE_TYPE:
        case json::SPREAD_TYPE:
        case json::CALL_TYPE:
        case json::PUT_TYPE:
            std::cout << ((json::AnnounceMessage*)i)->as_string() << std::endl;
            break;
        case json::SETTLEMENT:
            std::cout << ((json::SettleMessage*)i)->as_string() << std::endl;
            break;
        case json::ADDED:
            std::cout << ((json::AddedMessage*)i)->as_string() << std::endl;
            break;
        case json::DELETED:
            std::cout << ((json::DeletedMessage*)i)->as_string() << std::endl;
            break;
        case json::TRADE:
            std::cout << ((json::TradeMessage*)i)->as_string() << std::endl;
            break;
        case json::BROKER_REQUEST:
            std::cout << ((json::BrokerRequest*)i)->as_string() << std::endl;
            break;
        case json::BROKER_ACK:
            std::cout << ((json::BrokerAck*)i)->as_string() << std::endl;
            break;
        case json::BROKER_CONFIRM:
            std::cout << ((json::BrokerConfirm*)i)->as_string() << std::endl;
            break;
        default:;
        }
    }
}
 
void freeMessages(std::deque<json::Message*>& m)
{
    for (auto i : m) {
        delete i;
    }
}
 
void dumbHit(std::deque<json::Message*>& m)
{
    for (auto& i : m) {
        if (i->type == json::ADDED) {
            json::AddedMessage* j = (json::AddedMessage*) i;
            if (j->owner == "nseow") {
                book::OrderSideEnum s = j->side == book::Buy ? book::Sell : book::Buy;
                json::AddMessage a(json::ADD, j->product, j->price, s, j->resting);
                auto b = protocol::addOrder(a);
                if (b->type == json::ADDED) {
                    json::DeleteMessage d(json::DELETE, j->product, ((json::AddedMessage*) b)->id);
                    delete protocol::deleteOrder(d);
                }
                delete b;
            }
        }
    }
}
} // namespace strat