network fixes

fixes
uwu
2025-02-19 18:04:49 +05:00 · 2025-02-10 16:17:48 +05:00 · 2025-02-10 15:29:15 +05:00 · 2025-02-02 00:11:39 +05:00 · 2025-01-31 13:04:37 +05:00 · 2025-01-31 00:11:03 +05:00
40 changed files with 838 additions and 25437 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -0,0 +1,8 @@
+Checks: 
+  '-*,
+  clang-analyzer-*,
+  modernize-*,
+  performance-*,
+  bugprone-*,
+  cppcoreguidelines-*,
+  -performance-avoid-endl'
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,3 @@
 build/
-.vscode/
+.vscode/
+.cache/
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,34 +1,39 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.16)

 project(sparkle)

-include(GoogleTest)
+#include(GoogleTest)

+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(SOURCE sources/main.cpp)
 set(LIBS ${CMAKE_SOURCE_DIR}/libs/)
 set(INCLUDE ${CMAKE_SOURCE_DIR}/include/)
-set(TESTS ${CMAKE_SOURCE_DIR}/tests)
-set(CMAKE_C_COMPILER "clang")
-set(CMAKE_CXX_COMPILER "clang++")
+#set(TESTS ${CMAKE_SOURCE_DIR}/tests)
+set(ADDITIONAL_CXX_FLAGS_DEBUG "-march=native -O0 -pipe -Wall -Wextra -Wpedantic -Wconversion -Wuninitialized -Wsign-conversion -Wshadow -fsanitize=address") #-Werror
+set(ADDITIONAL_CXX_FLAGS_RELEASE "-march=native -O2 -pipe -Wall -Wextra -Wpedantic -Wconversion -Wuninitialized -Wsign-conversion -Wshadow -flto=full")
+
+file(GLOB NETWORK_SOURCES libs/network/*.cpp)

 find_package(CURL REQUIRED)
 find_path(IXWEBSOCKET_INCLUDE_DIR ixwebsocket)
 find_library(IXWEBSOCKET_LIBRARIES ixwebsocket)
-find_program(CMAKE_C_COMPILER clang)
-find_program(CLANG_CXX_COMPILER clang++)

-message(STATUS "ixwebsocket: ${IXWEBSOCKET_LIBRARIES}")
-message(STATUS "curl: ${CURL_LIBRARIES}")
-
-if(NOT CMAKE_C_COMPILER OR NOT CLANG_CXX_COMPILER)
-    message(STATUS "clang not found")
-    set(CMAKE_C_COMPILER "gcc")
-    set(CMAKE_CXX_COMPILER "g++")
-    find_program(CMAKE_C_COMPILER clang)
-    find_program(CLANG_CXX_COMPILER clang++)
-    if(NOT CMAKE_C_COMPILER OR NOT CLANG_CXX_COMPILER)
-    message(FATAL_ERROR "gcc not found")
+if(CMAKE_BUILD_TYPE)
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        add_definitions(-DDEBUG)
+        set(CMAKE_CXX_FLAGS_DEBUG "${ADDITIONAL_CXX_FLAGS_DEBUG}")
+        message(STATUS "cflags: ${CMAKE_CXX_FLAGS_DEBUG}")
+    elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
+        add_definitions(-DRELEASE)
+        set(CMAKE_CXX_FLAGS_RELEASE "${ADDITIONAL_CXX_FLAGS_RELEASE}")
+        message(STATUS "cflags: ${CMAKE_CXX_FLAGS_RELEASE}")
    endif()
+elseif(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE)
+    set(CMAKE_CXX_FLAGS_RELEASE "${ADDITIONAL_CXX_FLAGS_RELEASE}")
+    message(STATUS "cflags: ${CMAKE_CXX_FLAGS_RELEASE}")
 endif()

 if(NOT IXWEBSOCKET_INCLUDE_DIR OR NOT IXWEBSOCKET_LIBRARIES)
@ -39,17 +44,12 @@ if(NOT CURL_INCLUDE_DIRS OR NOT CURL_LIBRARIES)
    message(FATAL_ERROR "curl not found")
 endif()

-add_executable(${PROJECT_NAME} ${SOURCE})
-#add_library(sparkles STATIC ${SOURCE})
-add_executable(tests ${TESTS}/tests.cpp)
+message(STATUS "Current compiler: ${CMAKE_CXX_COMPILER}")
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

-#enable_testing()
+add_executable(${PROJECT_NAME} ${SOURCE} ${NETWORK_SOURCES})

-add_test(NAME network COMMAND tests)
-
-#target_include_directories(sparkles PRIVATE ${LIBS} ${INCLUDE} ${IXWEBSOCKET_INCLUDE_DIR} ${CURL_INCLUDE_DIRS})
-
-#target_link_libraries(sparkles PRIVATE ${IXWEBSOCKET_LIBRARIES} ${CURL_LIBRARIES})
+target_precompile_headers(${PROJECT_NAME} PRIVATE ${INCLUDE}pch.hpp)

 target_include_directories(${PROJECT_NAME} PRIVATE
    ${LIBS}
@ -63,20 +63,22 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
    ${CURL_LIBRARIES}
 )

-target_include_directories(tests PRIVATE
-    ${LIBS}
-    ${INCLUDE}
-    ${IXWEBSOCKET_INCLUDE_DIR}
-    ${CURL_INCLUDE_DIRS}
-)
+#add_library(sparkles STATIC ${SOURCE})
+#add_executable(tests ${TESTS}/tests.cpp)

-target_link_libraries(tests gtest
-    ${IXWEBSOCKET_LIBRARIES}
-    ${CURL_LIBRARIES}
-    gtest_main
-)
+#enable_testing()

-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
-set(CMAKE_CXX_FLAGS "-march=native -O2 -pipe")
-#set(CMAKE_CXX_FLAGS "-O0 -pipe")
+#add_test(NAME NetworkManagerTest COMMAND tests)
+
+#target_include_directories(tests PRIVATE
+#    ${LIBS}
+#    ${INCLUDE}
+#    ${IXWEBSOCKET_INCLUDE_DIR}
+#    ${CURL_INCLUDE_DIRS}
+#)
+
+#target_link_libraries(tests gtest
+#    ${IXWEBSOCKET_LIBRARIES}
+#    ${CURL_LIBRARIES}
+#    gtest_main
+#)
--- a/README.md
+++ b/README.md
@ -1,20 +1,26 @@
 # Sparkle
-Library for creating discord bots
-# ToDo
- - [x] Websocket support
- - [x] Minimal discord api support
- - [x] Selfbot support
- - [x] Easy to use
- - [ ] Support json extraction from server response
- - [ ] Optimised for high loads
- - [ ] Full api support
- - [ ] Fixes for known bugs
- - [ ] Windows support
- - [ ] Sharding
-# How to build
+Library for creating Discord bots.
+## How to Build
+### Required Libraries
+- `curl`
+- `ixwebsocket`
+- `nlohmann-json`
+- `cxxopts`
+### Build Instructions
 ```sh
-git clone http://applejack.ygg/fluttershy/sparkle.git
-mkdir sparkle/build && cd sparkle/build
-cmake .. && make -j$(nproc)
-./sparkle -t <BOT_TOKEN>
+git clone http://applejack.ygg/fluttershy/sparkle.git && cd sparkle
+cmake -B build && cmake --build build -j$(nproc)
+build/sparkle -t <BOT_TOKEN>
 ```
+# ToDo
+- [x] Websocket support
+- [x] Selfbot support
+- [x] Easy to use
+- [ ] Optimised for high loads (not tested)
+- [ ] Full api support
+- [ ] Windows support
+- [ ] Sharding
+- [ ] Interactions
+- [ ] Tests
+#
+![](res/fluttershy.gif)
--- a/include/api.h
+++ b/include/api.h
@ -1,10 +0,0 @@
-#ifndef INCLUDE_API_H_
-#define INCLUDE_API_H_
-#include <api/Author.hpp>
-#include <api/Message.hpp>
-#include <api/Channel.hpp>
-#include <api/Embed.hpp>
-#include <api/Bot.hpp>
-#include <api/User.hpp>
-#include <api/Guild.hpp>
-#endif
--- a/include/api.hpp
+++ b/include/api.hpp
@ -0,0 +1,10 @@
+#ifndef INCLUDE_INTERFACE_HPP_
+#define INCLUDE_INTERFACE_HPP_
+#include <interface/Author.hpp>
+#include <interface/Message.hpp>
+#include <interface/Channel.hpp>
+#include <interface/Embed.hpp>
+#include <interface/Bot.hpp>
+#include <interface/User.hpp>
+#include <interface/Guild.hpp>
+#endif
--- a/include/includes.h
+++ b/include/includes.h
@ -1,9 +0,0 @@
-#ifndef INCLUDE_INCLUDES_H_
-#define INCLUDE_INCLUDES_H_
-#include <utils/types.hpp>
-#include <utils/json.hpp>
-#include <utils/log.hpp>
-#include <utils/enums.hpp>
-#include <iostream>
-#include <string>
-#endif
--- a/include/includes.hpp
+++ b/include/includes.hpp
@ -0,0 +1,7 @@
+#ifndef INCLUDE_INCLUDES_HPP_
+#define INCLUDE_INCLUDES_HPP_
+#include <utils/types.hpp>
+#include <utils/log.hpp>
+#include <utils/enums.hpp>
+#include <utils/functions.hpp>
+#endif
--- a/include/net.h
+++ b/include/net.h
@ -1,5 +0,0 @@
-#ifndef INCLUDE_NET_H_
-#define INCLUDE_NET_H_
-#include <gateway/Websocket.hpp>
-#include <tls/Network.hpp>
-#endif
--- a/include/network.hpp
+++ b/include/network.hpp
@ -0,0 +1,5 @@
+#ifndef INCLUDE_NET_HPP_
+#define INCLUDE_NET_HPP_
+#include <network/websocket.hpp>
+#include <network/network.hpp>
+#endif
--- a/include/pch.hpp
+++ b/include/pch.hpp
@ -0,0 +1,12 @@
+#ifndef INCLUDE_PCH_HPP_
+#define INCLUDE_PCH_HPP_
+#include <iostream>
+#include <string>
+#include <functional>
+#include <algorithm>
+#include <utils/types.hpp>
+#include <utils/log.hpp>
+#include <utils/enums.hpp>
+#include <utils/functions.hpp>
+#include <nlohmann/json.hpp>
+#endif
--- a/libs/api/Activity.hpp
+++ b/libs/api/Activity.hpp
@ -0,0 +1,3 @@
+#ifndef API_ACTIVITY_HPP_
+#define API_ACTIVITY_HPP_
+#endif
--- a/libs/api/Author.hpp
+++ b/libs/api/Author.hpp
@ -1,57 +0,0 @@
-#ifndef API_AUTHOR_HPP_
-#define API_AUTHOR_HPP_
-#include <includes.h>
-#include <net.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-class Author {
-private:
-    json data;
-    WebSocket& web;
-    NetworkManager& req;
-public:
-    Author(const json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}
-    string content() {
-        try {
-            return data["d"]["content"];
-        }
-        catch (...) {
-            return "";
-        }
-    }
-    string channel_id() {
-        return data["d"]["channel_id"];
-    }
-    string id() {
-        return data["d"]["author"]["id"];
-    }
-    string global_name() {
-        return data["d"]["author"]["global_name"].dump();
-    }
-    string discriminator() {
-        return data["d"]["author"]["discriminator"];
-    }
-    bool isBot() {
-        try {
-            return data["d"]["author"]["bot"];
-        }
-        catch (...) {
-            return 0;
-        }
-    }
-    string guild_id() {
-        return data["d"]["guild_id"];
-    }
-    string msg_id() {
-        return data["d"]["id"];
-    }
-    bool isPinned() {
-        return data["d"]["pinned"];
-    }
-    string avatar() {
-        return data["d"]["author"]["avatar"];
-    }
-    string send(const json& msg) {
-        return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + data["d"]["channel_id"].get<string>() + "/messages", msg.dump());
-    }
-};
-#endif
--- a/libs/api/Bot.hpp
+++ b/libs/api/Bot.hpp
@ -1,39 +0,0 @@
-#ifndef API_BOT_HPP_
-#define API_BOT_HPP_
-#include <includes.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-template<typename...Args>
-class Discord {
-private:
-    void initializeNets(const json& data) {
-        initializeNetsImpl(data, std::index_sequence_for<Args...>{});
-    }
-    template<unsigned long... Is>
-    void initializeNetsImpl(const json& data, std::index_sequence<Is...>) {
-        net = std::make_tuple(std::make_unique<Args>(data)...);
-    }
-    json data;
-public:
-    std::tuple<std::unique_ptr<Args>...> net;
-    Discord(const json& data) : data(data) {
-        initializeNets(data);
-    }
-};
-class Bot {
-private:
-    json data;
-public:
-    Bot(const json& data) : data(data) {};
-    string id() {
-        return data["d"]["id"];
-    }
-    bool isBot() {
-        try {
-            return data["d"]["bot"];
-        }
-        catch (...) {
-            return false;
-        }
-    }
-};
-#endif
--- a/libs/api/Channel.hpp
+++ b/libs/api/Channel.hpp
@ -1,17 +0,0 @@
-#ifndef API_CHANNEL_HPP_
-#define API_CHANNEL_HPP_
-#include <includes.h>
-#include <net.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-class Channel {
-private:
-    json data;
-    WebSocket& web;
-    NetworkManager& req;
-public:
-    Channel(const json& data = "") : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}
-    string send(const json& msg) {
-        return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + data["d"]["channel_id"].get<string>() + "/messages", msg.dump());
-    }
-};
-#endif
--- a/libs/api/Embed.hpp
+++ b/libs/api/Embed.hpp
@ -1,59 +0,0 @@
-#ifndef API_EMBED_HPP_
-#define API_EMBED_HPP_
-#include <includes.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-class EmbedBuilder {
-private:
-    json embed = {
-        {"content", ""},
-        {"tts", false},
-        {"embeds", json::array()}
-    }, data;
-public:
-    EmbedBuilder(const json& data) : data(data) {
-        embed = {
-            {"content", ""},
-            {"tts", false},
-            {"embeds", json::array()}
-        };
-    }
-    EmbedBuilder& addTitle(const string& title) {
-        if (embed["embeds"].size() == 0) {
-            embed["embeds"].push_back(json::object());
-        }
-        embed["embeds"].back()["title"] = title;
-        return *this;
-    }
-    EmbedBuilder& addDescription(const string& desc) {
-        if (embed["embeds"].size() == 0) {
-            embed["embeds"].push_back(json::object());
-        }
-        embed["embeds"].back()["description"] = desc;
-        return *this;
-    }
-    EmbedBuilder& addColor(const string& color) {
-        if (embed["embeds"].size() == 0) {
-            embed["embeds"].push_back(json::object());
-        }
-        embed["embeds"].back()["color"] = color;
-        return *this;
-    }
-    EmbedBuilder& addUrl(const string& url) {
-        if (embed["embeds"].size() == 0) {
-            embed["embeds"].push_back(json::object());
-        }
-        embed["embeds"].back()["url"] = url;
-        return *this;
-    }
-    EmbedBuilder& addImage(const string& imageurl) {
-        if (embed["embeds"].size() == 0) {
-            embed["embeds"].push_back(json::object());
-        }
-        embed["embeds"].back()["image"] = { {"url", imageurl} };
-        return *this;
-    }
-    json getEmbed() const {
-        return embed;
-    }
-};
-#endif
--- a/libs/api/Guild.hpp
+++ b/libs/api/Guild.hpp
@ -1,15 +0,0 @@
-#ifndef API_GUILD_HPP_
-#define API_GUILD_HPP_
-#include <includes.h>
-//#include <net.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-class Guild {
-private:
-    json data;
-public:
-    Guild(const json& data) : data(data) {}
-    string id() {
-        return data["d"]["user"]["id"];
-    }
-};
-#endif
--- a/libs/api/Message.hpp
+++ b/libs/api/Message.hpp
@ -1,29 +0,0 @@
-#ifndef API_MESSAGE_HPP_
-#define API_MESSAGE_HPP_
-#include <includes.h>
-#include <net.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-class Message {
-private:
-    json data;
-    WebSocket& web;
-    NetworkManager& req;
-public:
-    Message(const json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {};
-    string send(const string& id, const json& msg) {
-        return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + id + "/messages", msg.dump());
-    }
-    string getMessages(const string& id, const string& count, const string& before = "") {
-        if (before.empty()) {
-            return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/channels/" + id + "/messages?limit=" + count);
-        }
-        else {
-            return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/channels/" + id + "/messages?before=" + before + "&limit=" + count);
-        }
-        return "";
-    }
-    string deleteMessage(const string& channel_id, const string& message_id) {
-        return req.request(HttpMethods::DELETE, DiscordEndpoints::details::latest + "/channels/" + channel_id + "/messages/" + message_id);
-    }
-};
-#endif
--- a/libs/api/User.hpp
+++ b/libs/api/User.hpp
@ -1,40 +0,0 @@
-#ifndef API_USER_HPP_
-#define API_USER_HPP_
-#include <includes.h>
-#include <net.h>
-#include <vector>
-using std::string, std::cout, std::endl, nlohmann::json;
-class User {
-private:
-    json data;
-    WebSocket& web;
-    NetworkManager& req;
-public:
-    User(const json& data = "") : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}
-    json extract(const std::vector<string>& keys) {
-        std::vector<string> d = { "d" };
-        d.insert(d.end(), keys.begin(), keys.end());
-        json current = data;
-        for (const auto& key : d) {
-            if (current.contains(key)) {
-                current = current[key];
-            }
-            else {
-                return "Key not found.";
-            }
-        }
-        return current;
-    }
-    virtual string me() {
-        return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/users/@me");
-    }
-    bool isBot() {
-        try {
-            return data["d"]["author"]["bot"];
-        }
-        catch (...) {
-            return false;
-        }
-    }
-};
-#endif
--- a/libs/gateway/Websocket.hpp
+++ b/libs/gateway/Websocket.hpp
@ -1,123 +0,0 @@
-#ifndef GATEWAY_WEBSOCKET_HPP_
-#define GATEWAY_WEBSOCKET_HPP_
-#include <includes.h>
-#include <thread>
-#include <chrono>
-#include <ixwebsocket/IXNetSystem.h>
-#include <ixwebsocket/IXWebSocket.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-using namespace std::chrono;
-using namespace std::chrono_literals;
-class WebSocket {
-private:
-    bool isBot;
-    int intents;
-    std::string token;
-    ix::WebSocket webSocket;
-    json payload = { {"op", 1},{"d", nullptr} }, id;
-    std::unordered_map<std::string, std::function<void(const json&)>> eventHandlers;
-    WebSocket& operator=(const WebSocket&) = delete;
-    WebSocket(const WebSocket&) = delete;
-    WebSocket(const std::string& token, const int& intents, bool& isBot) {
-        WebSocket::token = token;
-        WebSocket::intents = intents;
-        WebSocket::isBot = isBot;
-        id = {
-            {"op", 2},
-            {"d", {
-                {"token", token},
-                {"intents", intents},
-                {"properties", {
-                    {"os", "linux"},
-                    {"browser", "firefox"},
-                    {"device", "firefox"}
-                }},
-                //{"compress", 1},
-                {"presence", {
-                    {"activities", json::array({
-                        {
-                            //{"name", "asdsadsadsadsa"},
-                            //{"type", 2}
-                        }
-                    })},
-                    {"status", "idle"},
-                    {"since", 91879201},
-                    {"afk", false}
-                }}
-            }}
-        };
-        ix::initNetSystem();
-        webSocket.setUrl("wss://gateway.discord.gg/?v=10&encoding=json");
-        webSocket.setHandshakeTimeout(5);
-        Log::create(INFO, WEBSOCKET, "ixwebsocket init");
-        webSocket.setOnMessageCallback([this, res = json(), heartbeat_interval = 0, connected = false](const ix::WebSocketMessagePtr& msg) mutable {
-            if (msg->type == ix::WebSocketMessageType::Message) {
-                res = json::parse(msg->str);
-                Log::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
-                switch (res["op"].get<int>()) {
-                case 10:
-                    heartbeat_interval = res["d"]["heartbeat_interval"].get<int>();
-                    !connected ? connected = true, webSocket.send(id.dump()) : 0;
-                    std::thread([this, &heartbeat_interval, &connected]() {
-                        while (connected && heartbeat_interval != -1) {
-                            Log::create(INFO, WEBSOCKET, "Heartbeat " + std::to_string(heartbeat_interval));
-                            std::this_thread::sleep_for(milliseconds(heartbeat_interval));
-                            webSocket.send(payload.dump());
-                        }
-                    }).detach();
-                    break;
-                case 0:
-                    if (eventHandlers.find(res["t"].get<std::string>()) != eventHandlers.end()) {
-                        eventHandlers[res["t"].get<std::string>()](res);
-                    }
-                    break;
-                }
-            }
-        });
-        webSocket.start();
-    }
-public:
-    /*
-    void sendPresenceUpdate(int statusType, const std::string& activityName) {
-        json prsUpdate = {
-            {"op", 3},
-            {"d", {
-                {"since", 0},
-                {"activities", json::array({{"name", activityName}, {"type", 2}})},
-                {"status", statusType == 1 ? "online" : "idle"},
-                {"afk", false}
-            }}
-        };
-        webSocket.send(prsUpdate.dump());
-    }
-    */
-    static WebSocket& getInstance(const std::string& token = "", const int intents = 0, bool bot = true) {
-        Log::create(WARNING, WEBSOCKET, "Instance event");
-        static WebSocket instance(token, intents, bot);
-        return instance;
-    }
-    ~WebSocket() {
-        webSocket.close();
-        ix::uninitNetSystem();
-    }
-    std::string getToken() const {
-        return isBot ? std::string("Bot " + WebSocket::token) : WebSocket::token;
-    }
-    int getIntents() const {
-        return WebSocket::intents;
-    }
-    void on(const string& event, std::function<void(const json&)> handler) {
-        eventHandlers[event] = [handler](const json& message) {
-            handler(message.get<json>());
-        };
-    }
-    void once(const string& event, std::function<void(const json&)> handler) {
-        eventHandlers[event] = [event, handler, isCalled = false](const json& message) mutable {
-            isCalled == false ? isCalled = true : 0, handler(message.get<json>());
-        };
-    }
-    void start() {
-        while (1) std::this_thread::sleep_for(1ms);
-    }
-};
-#endif
--- a/libs/interface/Author.hpp
+++ b/libs/interface/Author.hpp
@ -0,0 +1,45 @@
+#ifndef INTERFACE_AUTHOR_HPP_
+#define INTERFACE_AUTHOR_HPP_
+#include <pch.hpp>
+#include <network.hpp>
+class Author {
+private:
+    const nlohmann::json& data;
+    WebSocket& web;
+    NetworkManager& req;
+public:
+    _deprecated_t("requires update")
+        struct Channel {
+        std::string channel_id;
+        std::string global_name;
+        std::string id;
+        std::string content;
+        std::string avatar;
+        std::string guild_id;
+        std::string discriminator;
+        std::string message_id;
+        bool isPinned;
+        bool isBot;
+    } authorData;
+    const std::string channel_id, global_name, id, content, avatar, guild_id, discriminator, message_id;
+    bool isPinned, isBot;
+    Author(const nlohmann::json& data)
+        : data(data),
+        web(WebSocket::getInstance()),
+        req(NetworkManager::getInstance()),
+        channel_id(functions::testValue<std::string>(data, { "d", "channel_id" }).value_or("")),
+        global_name(functions::testValue<std::string>(data, { "d", "author", "global_name" }).value_or("")),
+        id(functions::testValue<std::string>(data, { "d", "author", "id" }).value_or("")),
+        content(functions::testValue<std::string>(data, { "d", "content" }).value_or("")),
+        avatar(functions::testValue<std::string>(data, { "d", "author", "avatar" }).value_or("")),
+        guild_id(functions::testValue<std::string>(data, { "d", "guild_id" }).value_or("")),
+        discriminator(functions::testValue<std::string>(data, { "d", "author", "discriminator" }).value_or("")),
+        message_id(functions::testValue<std::string>(data, { "d", "id" }).value_or("")),
+        isPinned(functions::testValue<bool>(data, { "d", "pinned" }).value_or(false)),
+        isBot(functions::testValue<bool>(data, { "d", "author", "bot" }).value_or(false)) {
+    }
+    auto send(const nlohmann::json& msg) -> std::string {
+        return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + data["d"]["channel_id"].get<std::string>() + "/messages", msg.dump());
+    }
+};
+#endif
--- a/libs/interface/Bot.hpp
+++ b/libs/interface/Bot.hpp
@ -0,0 +1,36 @@
+#ifndef INTERFACE_BOT_HPP_
+#define INTERFACE_BOT_HPP_
+#include <pch.hpp>
+template<typename...Args>
+class Discord {
+private:
+    const nlohmann::json& data;
+    std::tuple<std::unique_ptr<Args>...> net;
+public:
+    Discord(const nlohmann::json& data) : data(data), net(std::make_tuple(std::make_unique<Args>(data)...)) {}
+    template<class T>
+    _deprecated_t("Use ctx() instead")
+    auto& get() const {
+        return *std::get<std::unique_ptr<T>>(net);
+    }
+    const auto& ctx() const {
+        return net;
+    }
+};
+class Bot {
+private:
+    const nlohmann::json& data;
+public:
+    Bot(const nlohmann::json& data) : data(data) {};
+    std::string id() const {
+        return data["d"]["id"];
+    }
+    bool isBot() const {
+        try {
+            return data["d"]["bot"];
+        } catch (...) {
+            return false;
+        }
+    }
+};
+#endif
--- a/libs/interface/Channel.hpp
+++ b/libs/interface/Channel.hpp
@ -0,0 +1,16 @@
+#ifndef INTERFACE_CHANNEL_HPP_
+#define INTERFACE_CHANNEL_HPP_
+#include <pch.hpp>
+#include <network.hpp>
+class Channel {
+private:
+    const nlohmann::json& data;
+    WebSocket& web;
+    NetworkManager& req;
+public:
+    Channel(const nlohmann::json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}
+    std::string send(const nlohmann::json& msg) {
+        return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + data["d"]["channel_id"].get<std::string>() + "/messages", msg.dump());
+    }
+};
+#endif
--- a/libs/interface/Embed.hpp
+++ b/libs/interface/Embed.hpp
@ -0,0 +1,58 @@
+#ifndef INTERFACE_EMBED_HPP_
+#define INTERFACE_EMBED_HPP_
+#include <pch.hpp>
+class EmbedBuilder {
+private:
+    nlohmann::json embed = {
+        {"content", ""},
+        {"tts", false},
+        {"embeds", nlohmann::json::array()}
+    }, data;
+public:
+    EmbedBuilder(const nlohmann::json& data) : data(data) {
+        embed = {
+            {"content", ""},
+            {"tts", false},
+            {"embeds", nlohmann::json::array()}
+        };
+    }
+    EmbedBuilder& addTitle(const std::string& title) {
+        if (embed["embeds"].size() == 0) {
+            embed["embeds"].emplace_back(nlohmann::json::object());
+        }
+        embed["embeds"].back()["title"] = title;
+        return *this;
+    }
+    EmbedBuilder& addDescription(const std::string& desc) {
+        if (embed["embeds"].size() == 0) {
+            embed["embeds"].emplace_back(nlohmann::json::object());
+        }
+        embed["embeds"].back()["description"] = desc;
+        return *this;
+    }
+    EmbedBuilder& addColor(const std::string& color) {
+        if (embed["embeds"].size() == 0) {
+            embed["embeds"].emplace_back(nlohmann::json::object());
+        }
+        embed["embeds"].back()["color"] = color;
+        return *this;
+    }
+    EmbedBuilder& addUrl(const std::string& url) {
+        if (embed["embeds"].size() == 0) {
+            embed["embeds"].emplace_back(nlohmann::json::object());
+        }
+        embed["embeds"].back()["url"] = url;
+        return *this;
+    }
+    EmbedBuilder& addImage(const std::string& imageurl) {
+        if (embed["embeds"].size() == 0) {
+            embed["embeds"].emplace_back(nlohmann::json::object());
+        }
+        embed["embeds"].back()["image"] = { {"url", imageurl} };
+        return *this;
+    }
+    nlohmann::json getEmbed() const {
+        return embed;
+    }
+};
+#endif
--- a/libs/interface/Guild.hpp
+++ b/libs/interface/Guild.hpp
@ -0,0 +1,14 @@
+#ifndef INTERFACE_GUILD_HPP_
+#define INTERFACE_GUILD_HPP_
+#include <pch.hpp>
+#include <network.hpp>
+class Guild {
+private:
+    nlohmann::json data;
+public:
+    Guild(const nlohmann::json& data) : data(data) {}
+    std::string id() const {
+        return data["d"]["user"]["id"];
+    }
+};
+#endif
--- a/libs/interface/Message.hpp
+++ b/libs/interface/Message.hpp
@ -0,0 +1,38 @@
+#ifndef INTERFACE_MESSAGE_HPP_
+#define INTERFACE_MESSAGE_HPP_
+#include <pch.hpp>
+#include <network.hpp>
+class Message {
+private:
+    const nlohmann::json& data;
+    WebSocket& web;
+    NetworkManager& req;
+public:
+    Message(const nlohmann::json& json) : data(json), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {};
+    auto send(const std::string& id, const nlohmann::json& msg) -> std::string {
+        return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + id + "/messages", msg.dump());
+    }
+    auto getMessages(const std::string& id, const std::string& count, const std::string& before = "") -> std::string {
+        if (before.empty()) {
+            return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/channels/" + id + "/messages?limit=" + count);
+        } else {
+            return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/channels/" + id + "/messages?before=" + before + "&limit=" + count);
+        }
+        return "";
+    }
+    auto deleteMessage(const std::string& channel_id, const std::string& message_id) -> std::string {
+        return req.request(HttpMethods::DELETE, DiscordEndpoints::details::latest + "/channels/" + channel_id + "/messages/" + message_id);
+    }
+    _nodiscard auto pack(const nlohmann::json& key, const std::string& value) const -> nlohmann::json {
+        return { { key, value } };
+    }
+    struct Api {
+        const nlohmann::json& data;
+        NetworkManager& req;
+        Api(const nlohmann::json& json) : data(json), req(NetworkManager::getInstance()) {};
+        _nodiscard auto latency() const -> unsigned long {
+            return req.getLatency();
+        }
+    };
+};
+#endif
--- a/libs/interface/User.hpp
+++ b/libs/interface/User.hpp
@ -0,0 +1,37 @@
+#ifndef INTERFACE_USER_HPP_
+#define INTERFACE_USER_HPP_
+#include <pch.hpp>
+#include <network.hpp>
+#include <vector>
+class User {
+private:
+    const nlohmann::json& data;
+    WebSocket& web;
+    NetworkManager& req;
+public:
+    User(const nlohmann::json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()),
+        isBot(false) {
+        auto botValue = functions::testValue<bool>(data, { "d", "user", "bot" });
+        if (botValue.has_value()) {
+            isBot = botValue.value();
+        }
+    }
+    bool isBot;
+    auto extract(const std::vector<std::string>& keys) -> nlohmann::json {
+        std::vector<std::string> d = { "d" };
+        d.insert(d.end(), keys.begin(), keys.end());
+        nlohmann::json current = data;
+        for (const auto& key : d) {
+            if (current.contains(key)) {
+                current = current[key];
+            } else {
+                return "Key not found.";
+            }
+        }
+        return current;
+    };
+    auto me() -> std::string {
+        return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/users/@me");
+    }
+};
+#endif
--- a/libs/network/network.cpp
+++ b/libs/network/network.cpp
@ -0,0 +1,50 @@
+#include "network.hpp"
+NetworkManager::NetworkManager() : curl(curl_easy_init(), curl_easy_cleanup), res(CURLE_OK), web(WebSocket::getInstance()) {
+    Log::create(INFO, NETWORK, "Network init");
+    curl_global_init(CURL_GLOBAL_DEFAULT);
+    if (!curl) {
+        Log::create(CRITICAL, NETWORK, "Failed to initialize CURL");
+        abort();
+    }
+}
+NetworkManager::~NetworkManager() {
+    curl_global_cleanup();
+}
+auto NetworkManager::WriteCallback(void* contents, unsigned long size, unsigned long nmemb, void* userp) -> unsigned long {
+    (static_cast<std::string*>(userp))->append(static_cast<char*>(contents), size * nmemb);
+    return size * nmemb;
+}
+auto NetworkManager::getInstance() -> NetworkManager& {
+    Log::create(INFO, NETWORK, "Instance event");
+    static NetworkManager instance;
+    return instance;
+}
+auto NetworkManager::getLatency() const -> unsigned long {
+    return 0;
+}
+auto NetworkManager::request(const std::string& method, const std::string& path, const std::string& data) -> std::string {
+    std::string response;
+    if (curl) {
+        curl_easy_setopt(curl.get(), CURLOPT_URL, path.c_str());
+        curl_easy_setopt(curl.get(), CURLOPT_CUSTOMREQUEST, method.c_str());
+        curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, data.c_str());
+        curl_slist* headers = nullptr;
+        headers = curl_slist_append(headers, "Accept: application/json");
+        headers = curl_slist_append(headers, "Content-Type: application/json");
+        headers = curl_slist_append(headers, ("Authorization: " + web.getToken()).c_str());
+        headers = curl_slist_append(headers, "User-Agent: DiscordBot");
+        curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, headers);
+        curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, WriteCallback);
+        curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);
+        curl_easy_setopt(curl.get(), CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_3ONLY);
+        res = curl_easy_perform(curl.get());
+        if (res != 0) {
+            Log::create(ERROR, NETWORK, "curl_easy_perform() failed: " + std::string(curl_easy_strerror(res)));
+        }
+        curl_slist_free_all(headers);
+    }
+#ifdef DEBUG
+    Log::create(INFO, NETWORK, response);
+#endif
+    return response;
+}
--- a/libs/network/network.hpp
+++ b/libs/network/network.hpp
@ -0,0 +1,23 @@
+#ifndef TLS_NETWORK_HPP_
+#define TLS_NETWORK_HPP_
+#include <pch.hpp>
+#include <network/websocket.hpp>
+#include <curl/curl.h>
+class NetworkManager {
+private:
+    std::unique_ptr<void, decltype(&curl_easy_cleanup)> curl;
+    CURLcode res;
+    WebSocket& web;
+    NetworkManager();
+    ~NetworkManager();
+    static auto WriteCallback(void* contents, unsigned long size, unsigned long nmemb, void* userp) -> unsigned long;
+public:
+    auto operator=(const NetworkManager&)->NetworkManager& = delete;
+    auto operator=(NetworkManager&&)->NetworkManager& = delete;
+    NetworkManager(NetworkManager&&) = delete;
+    NetworkManager(const NetworkManager&) = delete;
+    static auto getInstance() -> NetworkManager&;
+    [[nodiscard]] auto getLatency() const -> unsigned long;
+    auto request(const std::string& method, const std::string& path, const std::string& data = "") -> std::string;
+};
+#endif
--- a/libs/network/websocket.cpp
+++ b/libs/network/websocket.cpp
@ -0,0 +1,127 @@
+#include "websocket.hpp"
+void EventEmitter::emit(const std::string& event, const nlohmann::json& data) {
+    if (auto it = handlers.find(event); it != handlers.end()) {
+        std::for_each(it->second.begin(), it->second.end(), [&data](const auto& handler) {
+            handler(data);
+        });
+    }
+}
+void EventEmitter::getEvents() const {
+    Log::create(CRITICAL, WEBSOCKET, "Event list");
+    for (const auto& handler : handlers) {
+        Log::create(INFO, WEBSOCKET, handler.first);
+    }
+    Log::create(CRITICAL, WEBSOCKET, "End of list");
+}
+void EventEmitter::start() const {
+    while (true) std::this_thread::sleep_for(std::chrono::milliseconds(1));
+}
+void EventEmitter::on(const std::string& event, eventHandlers handler) {
+    handlers[event].emplace_back(std::move(handler));
+}
+void EventEmitter::once(const std::string& event, const eventHandlers& handler) {
+    auto wrappedHandler = [this, event, handler](const nlohmann::json& data) {
+        handler(data);
+        off(event, handler);
+    };
+    handlers[event].emplace_back(std::move(wrappedHandler));
+}
+void EventEmitter::off(const std::string& event, eventHandlers handler) {
+    if (auto it = handlers.find(event); it != handlers.cend()) {
+        it->second.erase(std::ranges::remove_if(it->second, [&handler](const eventHandlers& h) {
+            return h.target<eventHandlers>() == handler.target<eventHandlers>();
+        }).begin(), it->second.cend());
+    }
+}
+WebSocket::WebSocket(const std::string& token, int intents, bool isBot) : token(token), intents(intents), isBot(isBot) {
+    nlohmann::json id = {
+    {"op", GatewayOpcodes::Identify},
+    {"d", {
+        {"token", token},
+        {"intents", intents},
+        {"properties", {
+            {"os", "linux"},
+            {"browser", "firefox"},
+            {"device", "firefox"}
+        }},
+    {"compress", 1},
+    {"presence", {
+        {"activities", nlohmann::json::array({
+            {
+                {"name", "meow"},
+                {"type", 2}
+            }
+        })},
+        {"status", "idle"},
+        {"since", 0},
+        {"afk", false}
+    }}
+}}
+    };
+    ix::initNetSystem();
+    webSocket.setUrl("wss://gateway.discord.gg/?v=10&encoding=json");
+    webSocket.disableAutomaticReconnection();
+    Log::create(INFO, WEBSOCKET, "ixwebsocket init");
+    webSocket.setOnMessageCallback([this, res = nlohmann::json(), heartbeat_interval = 0, connected = false, id](const ix::WebSocketMessagePtr& msg) mutable {
+        switch (msg->type) {
+            case ix::WebSocketMessageType::Message:
+                res = nlohmann::json::parse(msg->str);
+                Log::create(INFO, WEBSOCKET, std::to_string(res["op"].get<int>()) + " " + res["t"].dump());
+                switch (res["op"].get<GatewayOpcodes>()) {
+                    case GatewayOpcodes::Hello:
+                        heartbeat_interval = res["d"]["heartbeat_interval"].get<int>();
+                        if (connected) connected = true; else webSocket.send(id.dump());
+                        std::thread([this, &heartbeat_interval, &connected]() {
+                            while (connected && heartbeat_interval != -1) {
+                                Log::create(INFO, WEBSOCKET, "Heartbeat " + std::to_string(heartbeat_interval));
+                                std::this_thread::sleep_for(std::chrono::milliseconds(heartbeat_interval));
+                                webSocket.send(payload.dump());
+                            }
+                        }).detach();
+                        break;
+                    case GatewayOpcodes::Dispatch:
+                        Log::create(INFO, WEBSOCKET, res.dump());
+                        emit(res["t"].get<std::string>(), res);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case ix::WebSocketMessageType::Error:
+                Log::force_create(ERROR, WEBSOCKET, msg->errorInfo.reason);
+                exit(-1);
+                break;
+            default:
+                break;
+        }
+
+    });
+    webSocket.start();
+}
+auto WebSocket::getInstance(const std::string& token, int intents, bool bot) -> WebSocket& {
+    Log::create(INFO, WEBSOCKET, "Instance event");
+    static WebSocket instance(token, intents, bot);
+    return instance;
+}
+WebSocket::~WebSocket() {
+    webSocket.close();
+    ix::uninitNetSystem();
+}
+auto WebSocket::getToken() const -> std::string {
+    return this->isBot ? std::string("Bot " + this->token) : this->token;
+}
+auto WebSocket::getIntents() const -> int {
+    return this->intents;
+}
+_maybe_unused void WebSocket::sendPresenceUpdate(const char* statusType, const std::string& activityName, const int& activityType) {
+    nlohmann::json prsUpdate = {
+        {"op", 3},
+        {"d", {
+            {"since", 0},
+            {"activities", nlohmann::json::array({{"name", activityName}, {"type", activityType}})},
+            {"status", statusType},
+            {"afk", false}
+        }}
+    };
+    webSocket.send(prsUpdate.dump());
+}
--- a/libs/network/websocket.hpp
+++ b/libs/network/websocket.hpp
@ -0,0 +1,39 @@
+#ifndef NETWORK_WEBSOCKET_HPP_
+#define NETWORK_WEBSOCKET_HPP_
+#include <pch.hpp>
+#include <ranges>
+#include <ixwebsocket/IXNetSystem.h>
+#include <ixwebsocket/IXWebSocket.h>
+class EventEmitter {
+private:
+    using eventHandlers = std::function<void(const nlohmann::json&)>;
+    std::unordered_map<std::string, std::vector<eventHandlers>> handlers;
+protected:
+    void emit(const std::string& event, const nlohmann::json& data);
+public:
+    void getEvents() const;
+    void start() const;
+    void on(const std::string& event, eventHandlers handler);
+    void once(const std::string& event, const eventHandlers& handler);
+    void off(const std::string& event, eventHandlers handler);
+};
+class WebSocket : public EventEmitter {
+private:
+    std::string token;
+    int intents;
+    bool isBot;
+    ix::WebSocket webSocket;
+    const nlohmann::json payload = { {"op", GatewayOpcodes::Heartbeat}, {"d", nullptr} };
+    WebSocket(const std::string& token, int intents, bool isBot);
+public:
+    auto operator=(const WebSocket&)->WebSocket& = delete;
+    auto operator=(WebSocket&&)->WebSocket& = delete;
+    WebSocket(WebSocket&&) = delete;
+    WebSocket(const WebSocket&) = delete;
+    _maybe_unused void sendPresenceUpdate(const char* statusType, const std::string& activityName, const int& activityType);
+    static auto getInstance(const std::string& token = "", int intents = 0, bool bot = true) -> WebSocket&;
+    ~WebSocket();
+    auto getToken() const->std::string;
+    auto getIntents() const -> int;
+};
+#endif
--- a/libs/tls/Network.hpp
+++ b/libs/tls/Network.hpp
@ -1,59 +0,0 @@
-#ifndef TLS_NETWORK_HPP_
-#define TLS_NETWORK_HPP_
-#include <includes.h>
-#include <gateway/Websocket.hpp>
-#include <curl/curl.h>
-using std::string, std::cout, std::endl, nlohmann::json;
-class NetworkManager {
-private:
-    CURL* curl;
-    CURLcode res;
-    WebSocket& web;
-    NetworkManager& operator=(const NetworkManager&) = delete;
-    NetworkManager(const NetworkManager&) = delete;
-    NetworkManager() : web(WebSocket::getInstance()) {
-        Log::create(INFO, NETWORK, "Network init");
-        curl_global_init(CURL_GLOBAL_DEFAULT);
-        curl = curl_easy_init();
-        if (!curl) {
-            Log::create(ERROR, NETWORK, "Failed to initialize CURL");
-            abort();
-        }
-    }
-    ~NetworkManager() {
-        if (curl) {
-            curl_easy_cleanup(curl);
-        }
-        curl_global_cleanup();
-    }
-    static unsigned long WriteCallback(void* contents, unsigned long size, unsigned long nmemb, void* userp) {
-        ((std::string*)userp)->append((char*)contents, size * nmemb);
-        return size * nmemb;
-    }
-public:
-    static NetworkManager& getInstance() {
-        Log::create(WARNING, NETWORK, "Instance event");
-        static NetworkManager instance;
-        return instance;
-    }
-    std::string request(const std::string& method, const std::string& path, const std::string& data = "") {
-        std::string response;
-        if (curl) {
-            curl_easy_setopt(curl, CURLOPT_URL, path.c_str());
-            curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method.c_str());
-            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str());
-            curl_slist* headers = curl_slist_append(headers, "Accept: application/json");
-            headers = curl_slist_append(headers, "Content-Type: application/json");
-            headers = curl_slist_append(headers, ("Authorization: " + web.getToken()).c_str());
-            headers = curl_slist_append(headers, "User-Agent: DiscordBot");
-            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
-            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
-            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
-            curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_3ONLY);
-            if ((res = curl_easy_perform(curl)) != 0) Log::create(ERROR, NETWORK, "curl_easy_perform() failed: " + std::string(curl_easy_strerror(res)));
-            curl_slist_free_all(headers);
-        }
-        return response;
-    }
-};
-#endif
--- a/libs/utils/enums.hpp
+++ b/libs/utils/enums.hpp
@ -1,108 +1,124 @@
 #ifndef UTILS_EVENTS_HPP_
 #define UTILS_EVENTS_HPP_
+#include <string>
 struct GatewayEvents {
-    static constexpr const char* APPLICATION_COMMAND_PERMISSIONS_UPDATE = "APPLICATION_COMMAND_PERMISSIONS_UPDATE";
-    static constexpr const char* AUTO_MODERATION_ACTION_EXECUTION = "AUTO_MODERATION_ACTION_EXECUTION";
-    static constexpr const char* AUTO_MODERATION_RULE_CREATE = "AUTO_MODERATION_RULE_CREATE";
-    static constexpr const char* AUTO_MODERATION_RULE_DELETE = "AUTO_MODERATION_RULE_DELETE";
-    static constexpr const char* AUTO_MODERATION_RULE_UPDATE = "AUTO_MODERATION_RULE_UPDATE";
-    static constexpr const char* CHANNEL_CREATE = "CHANNEL_CREATE";
-    static constexpr const char* CHANNEL_DELETE = "CHANNEL_DELETE";
-    static constexpr const char* CHANNEL_PINS_UPDATE = "CHANNEL_PINS_UPDATE";
-    static constexpr const char* CHANNEL_UPDATE = "CHANNEL_UPDATE";
-    static constexpr const char* ENTITLEMENT_CREATE = "ENTITLEMENT_CREATE";
-    static constexpr const char* ENTITLEMENT_DELETE = "ENTITLEMENT_DELETE";
-    static constexpr const char* ENTITLEMENT_UPDATE = "ENTITLEMENT_UPDATE";
-    static constexpr const char* GUILD_AUDIT_LOG_ENTRY_CREATE = "GUILD_AUDIT_LOG_ENTRY_CREATE";
-    static constexpr const char* GUILD_BAN_ADD = "GUILD_BAN_ADD";
-    static constexpr const char* GUILD_BAN_REMOVE = "GUILD_BAN_REMOVE";
-    static constexpr const char* GUILD_CREATE = "GUILD_CREATE";
-    static constexpr const char* GUILD_DELETE = "GUILD_DELETE";
-    static constexpr const char* GUILD_EMOJIS_UPDATE = "GUILD_EMOJIS_UPDATE";
-    static constexpr const char* GUILD_INTEGRATIONS_UPDATE = "GUILD_INTEGRATIONS_UPDATE";
-    static constexpr const char* GUILD_MEMBER_ADD = "GUILD_MEMBER_ADD";
-    static constexpr const char* GUILD_MEMBER_REMOVE = "GUILD_MEMBER_REMOVE";
-    static constexpr const char* GUILD_MEMBERS_CHUNK = "GUILD_MEMBERS_CHUNK";
-    static constexpr const char* GUILD_MEMBER_UPDATE = "GUILD_MEMBER_UPDATE";
-    static constexpr const char* GUILD_ROLE_CREATE = "GUILD_ROLE_CREATE";
-    static constexpr const char* GUILD_ROLE_DELETE = "GUILD_ROLE_DELETE";
-    static constexpr const char* GUILD_ROLE_UPDATE = "GUILD_ROLE_UPDATE";
-    static constexpr const char* GUILD_SCHEDULED_EVENT_CREATE = "GUILD_SCHEDULED_EVENT_CREATE";
-    static constexpr const char* GUILD_SCHEDULED_EVENT_DELETE = "GUILD_SCHEDULED_EVENT_DELETE";
-    static constexpr const char* GUILD_SCHEDULED_EVENT_UPDATE = "GUILD_SCHEDULED_EVENT_UPDATE";
-    static constexpr const char* GUILD_SCHEDULED_EVENT_USER_REMOVE = "GUILD_SCHEDULED_EVENT_USER_REMOVE";
-    static constexpr const char* GUILD_SOUNDBOARD_SOUND_CREATE = "GUILD_SOUNDBOARD_SOUND_CREATE";
-    static constexpr const char* GUILD_SOUNDBOARD_SOUND_DELETE = "GUILD_SOUNDBOARD_SOUND_DELETE";
-    static constexpr const char* GUILD_SOUNDBOARD_SOUNDS_UPDATE = "GUILD_SOUNDBOARD_SOUNDS_UPDATE";
-    static constexpr const char* GUILD_SOUNDBOARD_SOUND_UPDATE = "GUILD_SOUNDBOARD_SOUND_UPDATE";
-    static constexpr const char* SOUNDBOARD_SOUNDS = "SOUNDBOARD_SOUNDS";
-    static constexpr const char* GUILD_STICKERS_UPDATE = "GUILD_STICKERS_UPDATE";
-    static constexpr const char* GUILD_UPDATE = "GUILD_UPDATE";
-    static constexpr const char* INTEGRATION_CREATE = "INTEGRATION_CREATE";
-    static constexpr const char* INTEGRATION_DELETE = "INTEGRATION_DELETE";
-    static constexpr const char* INTEGRATION_UPDATE = "INTEGRATION_UPDATE";
-    static constexpr const char* INVITE_CREATE = "INVITE_CREATE";
-    static constexpr const char* INVITE_DELETE = "INVITE_DELETE";
-    static constexpr const char* MESSAGE_CREATE = "MESSAGE_CREATE";
-    static constexpr const char* MESSAGE_DELETE = "MESSAGE_DELETE";
-    static constexpr const char* MESSAGE_DELETE_BULK = "MESSAGE_DELETE_BULK";
-    static constexpr const char* MESSAGE_POLL_VOTE_ADD = "MESSAGE_POLL_VOTE_ADD";
-    static constexpr const char* MESSAGE_POLL_VOTE_REMOVE = "MESSAGE_POLL_VOTE_REMOVE";
-    static constexpr const char* MESSAGE_REACTION_ADD = "MESSAGE_REACTION_ADD";
-    static constexpr const char* MESSAGE_REACTION_REMOVE = "MESSAGE_REACTION_REMOVE";
-    static constexpr const char* MESSAGE_REACTION_REMOVE_ALL = "MESSAGE_REACTION_REMOVE_ALL";
-    static constexpr const char* MESSAGE_REACTION_REMOVE_EMOJI = "MESSAGE_REACTION_REMOVE_EMOJI";
-    static constexpr const char* MESSAGE_UPDATE = "MESSAGE_UPDATE";
-    static constexpr const char* PRESENCE_UPDATE = "PRESENCE_UPDATE";
-    static constexpr const char* READY = "READY";
-    static constexpr const char* RESUMED = "RESUMED";
-    static constexpr const char* STAGE_INSTANCE_CREATE = "STAGE_INSTANCE_CREATE";
-    static constexpr const char* STAGE_INSTANCE_DELETE = "STAGE_INSTANCE_DELETE";
-    static constexpr const char* STAGE_INSTANCE_UPDATE = "STAGE_INSTANCE_UPDATE";
-    static constexpr const char* SUBSCRIPTION_CREATE = "SUBSCRIPTION_CREATE";
-    static constexpr const char* SUBSCRIPTION_DELETE = "SUBSCRIPTION_DELETE";
-    static constexpr const char* SUBSCRIPTION_UPDATE = "SUBSCRIPTION_UPDATE";
-    static constexpr const char* THREAD_CREATE = "THREAD_CREATE";
-    static constexpr const char* THREAD_DELETE = "THREAD_DELETE";
-    static constexpr const char* THREAD_LIST_SYNC = "THREAD_LIST_SYNC";
-    static constexpr const char* THREAD_MEMBERS_UPDATE = "THREAD_MEMBERS_UPDATE";
-    static constexpr const char* THREAD_MEMBER_UPDATE = "THREAD_MEMBER_UPDATE";
-    static constexpr const char* THREAD_UPDATE = "THREAD_UPDATE";
-    static constexpr const char* TYPING_START = "TYPING_START";
-    static constexpr const char* USER_UPDATE = "USER_UPDATE";
-    static constexpr const char* VOICE_CHANNEL_EFFECT_SEND = "VOICE_CHANNEL_EFFECT_SEND";
-    static constexpr const char* VOICE_SERVER_UPDATE = "VOICE_SERVER_UPDATE";
-    static constexpr const char* VOICE_STATE_UPDATE = "VOICE_STATE_UPDATE";
-    static constexpr const char* WEBHOOKS_UPDATE = "WEBHOOKS_UPDATE";
+    static inline constexpr char* APPLICATION_COMMAND_PERMISSIONS_UPDATE = "APPLICATION_COMMAND_PERMISSIONS_UPDATE";
+    static inline constexpr char* AUTO_MODERATION_ACTION_EXECUTION = "AUTO_MODERATION_ACTION_EXECUTION";
+    static inline constexpr char* AUTO_MODERATION_RULE_CREATE = "AUTO_MODERATION_RULE_CREATE";
+    static inline constexpr char* AUTO_MODERATION_RULE_DELETE = "AUTO_MODERATION_RULE_DELETE";
+    static inline constexpr char* AUTO_MODERATION_RULE_UPDATE = "AUTO_MODERATION_RULE_UPDATE";
+    static inline constexpr char* CHANNEL_CREATE = "CHANNEL_CREATE";
+    static inline constexpr char* CHANNEL_DELETE = "CHANNEL_DELETE";
+    static inline constexpr char* CHANNEL_PINS_UPDATE = "CHANNEL_PINS_UPDATE";
+    static inline constexpr char* CHANNEL_UPDATE = "CHANNEL_UPDATE";
+    static inline constexpr char* ENTITLEMENT_CREATE = "ENTITLEMENT_CREATE";
+    static inline constexpr char* ENTITLEMENT_DELETE = "ENTITLEMENT_DELETE";
+    static inline constexpr char* ENTITLEMENT_UPDATE = "ENTITLEMENT_UPDATE";
+    static inline constexpr char* GUILD_AUDIT_LOG_ENTRY_CREATE = "GUILD_AUDIT_LOG_ENTRY_CREATE";
+    static inline constexpr char* GUILD_BAN_ADD = "GUILD_BAN_ADD";
+    static inline constexpr char* GUILD_BAN_REMOVE = "GUILD_BAN_REMOVE";
+    static inline constexpr char* GUILD_CREATE = "GUILD_CREATE";
+    static inline constexpr char* GUILD_DELETE = "GUILD_DELETE";
+    static inline constexpr char* GUILD_EMOJIS_UPDATE = "GUILD_EMOJIS_UPDATE";
+    static inline constexpr char* GUILD_INTEGRATIONS_UPDATE = "GUILD_INTEGRATIONS_UPDATE";
+    static inline constexpr char* GUILD_MEMBER_ADD = "GUILD_MEMBER_ADD";
+    static inline constexpr char* GUILD_MEMBER_REMOVE = "GUILD_MEMBER_REMOVE";
+    static inline constexpr char* GUILD_MEMBERS_CHUNK = "GUILD_MEMBERS_CHUNK";
+    static inline constexpr char* GUILD_MEMBER_UPDATE = "GUILD_MEMBER_UPDATE";
+    static inline constexpr char* GUILD_ROLE_CREATE = "GUILD_ROLE_CREATE";
+    static inline constexpr char* GUILD_ROLE_DELETE = "GUILD_ROLE_DELETE";
+    static inline constexpr char* GUILD_ROLE_UPDATE = "GUILD_ROLE_UPDATE";
+    static inline constexpr char* GUILD_SCHEDULED_EVENT_CREATE = "GUILD_SCHEDULED_EVENT_CREATE";
+    static inline constexpr char* GUILD_SCHEDULED_EVENT_DELETE = "GUILD_SCHEDULED_EVENT_DELETE";
+    static inline constexpr char* GUILD_SCHEDULED_EVENT_UPDATE = "GUILD_SCHEDULED_EVENT_UPDATE";
+    static inline constexpr char* GUILD_SCHEDULED_EVENT_USER_REMOVE = "GUILD_SCHEDULED_EVENT_USER_REMOVE";
+    static inline constexpr char* GUILD_SOUNDBOARD_SOUND_CREATE = "GUILD_SOUNDBOARD_SOUND_CREATE";
+    static inline constexpr char* GUILD_SOUNDBOARD_SOUND_DELETE = "GUILD_SOUNDBOARD_SOUND_DELETE";
+    static inline constexpr char* GUILD_SOUNDBOARD_SOUNDS_UPDATE = "GUILD_SOUNDBOARD_SOUNDS_UPDATE";
+    static inline constexpr char* GUILD_SOUNDBOARD_SOUND_UPDATE = "GUILD_SOUNDBOARD_SOUND_UPDATE";
+    static inline constexpr char* SOUNDBOARD_SOUNDS = "SOUNDBOARD_SOUNDS";
+    static inline constexpr char* GUILD_STICKERS_UPDATE = "GUILD_STICKERS_UPDATE";
+    static inline constexpr char* GUILD_UPDATE = "GUILD_UPDATE";
+    static inline constexpr char* INTEGRATION_CREATE = "INTEGRATION_CREATE";
+    static inline constexpr char* INTEGRATION_DELETE = "INTEGRATION_DELETE";
+    static inline constexpr char* INTEGRATION_UPDATE = "INTEGRATION_UPDATE";
+    static inline constexpr char* INVITE_CREATE = "INVITE_CREATE";
+    static inline constexpr char* INVITE_DELETE = "INVITE_DELETE";
+    static inline constexpr char* MESSAGE_CREATE = "MESSAGE_CREATE";
+    static inline constexpr char* MESSAGE_DELETE = "MESSAGE_DELETE";
+    static inline constexpr char* MESSAGE_DELETE_BULK = "MESSAGE_DELETE_BULK";
+    static inline constexpr char* MESSAGE_POLL_VOTE_ADD = "MESSAGE_POLL_VOTE_ADD";
+    static inline constexpr char* MESSAGE_POLL_VOTE_REMOVE = "MESSAGE_POLL_VOTE_REMOVE";
+    static inline constexpr char* MESSAGE_REACTION_ADD = "MESSAGE_REACTION_ADD";
+    static inline constexpr char* MESSAGE_REACTION_REMOVE = "MESSAGE_REACTION_REMOVE";
+    static inline constexpr char* MESSAGE_REACTION_REMOVE_ALL = "MESSAGE_REACTION_REMOVE_ALL";
+    static inline constexpr char* MESSAGE_REACTION_REMOVE_EMOJI = "MESSAGE_REACTION_REMOVE_EMOJI";
+    static inline constexpr char* MESSAGE_UPDATE = "MESSAGE_UPDATE";
+    static inline constexpr char* PRESENCE_UPDATE = "PRESENCE_UPDATE";
+    static inline constexpr char* READY = "READY";
+    static inline constexpr char* RESUMED = "RESUMED";
+    static inline constexpr char* STAGE_INSTANCE_CREATE = "STAGE_INSTANCE_CREATE";
+    static inline constexpr char* STAGE_INSTANCE_DELETE = "STAGE_INSTANCE_DELETE";
+    static inline constexpr char* STAGE_INSTANCE_UPDATE = "STAGE_INSTANCE_UPDATE";
+    static inline constexpr char* SUBSCRIPTION_CREATE = "SUBSCRIPTION_CREATE";
+    static inline constexpr char* SUBSCRIPTION_DELETE = "SUBSCRIPTION_DELETE";
+    static inline constexpr char* SUBSCRIPTION_UPDATE = "SUBSCRIPTION_UPDATE";
+    static inline constexpr char* THREAD_CREATE = "THREAD_CREATE";
+    static inline constexpr char* THREAD_DELETE = "THREAD_DELETE";
+    static inline constexpr char* THREAD_LIST_SYNC = "THREAD_LIST_SYNC";
+    static inline constexpr char* THREAD_MEMBERS_UPDATE = "THREAD_MEMBERS_UPDATE";
+    static inline constexpr char* THREAD_MEMBER_UPDATE = "THREAD_MEMBER_UPDATE";
+    static inline constexpr char* THREAD_UPDATE = "THREAD_UPDATE";
+    static inline constexpr char* TYPING_START = "TYPING_START";
+    static inline constexpr char* USER_UPDATE = "USER_UPDATE";
+    static inline constexpr char* VOICE_CHANNEL_EFFECT_SEND = "VOICE_CHANNEL_EFFECT_SEND";
+    static inline constexpr char* VOICE_SERVER_UPDATE = "VOICE_SERVER_UPDATE";
+    static inline constexpr char* VOICE_STATE_UPDATE = "VOICE_STATE_UPDATE";
+    static inline constexpr char* WEBHOOKS_UPDATE = "WEBHOOKS_UPDATE";
 };
 struct HttpMethods {
-    static constexpr const char* POST = "POST";
-    static constexpr const char* GET = "GET";
-    static constexpr const char* PATCH = "PATCH";
-    static constexpr const char* DELETE = "DELETE";
-    static constexpr const char* PUT = "PUT";
-    static constexpr const char* OPTIONS = "OPTIONS";
+    static inline constexpr char* POST = "POST";
+    static inline constexpr char* GET = "GET";
+    static inline constexpr char* PATCH = "PATCH";
+    static inline constexpr char* DELETE = "DELETE";
+    static inline constexpr char* PUT = "PUT";
+    static inline constexpr char* OPTIONS = "OPTIONS";
 };
 struct ApiVersion {
-    static inline std::string api = "/api/";
-    static inline std::string v10 = "v10";
-    static inline std::string v9 = "v9";
-    static inline std::string v8 = "v8";
-    static inline std::string v7 = "v7";
-    static inline std::string v6 = "v6";
-    static inline std::string current = api + v6;
-    static inline std::string latest = api + v10;
+    static const inline std::string api = "/api/";
+    static const inline std::string v10 = "v10";
+    static const inline std::string v9 = "v9";
+    static const inline std::string v8 = "v8";
+    static const inline std::string v7 = "v7";
+    static const inline std::string v6 = "v6";
+    static const inline std::string current = api + v6;
+    static const inline std::string latest = api + v10;
 };
 struct DiscordEndpoints {
-    static inline std::string main_scheme = "https://";
-    static inline std::string discord = main_scheme + "discord.com";
-    static inline std::string images = main_scheme + "cdn.discord.com";
-    static inline std::string media = main_scheme + "media.discord.com";
+    static const inline std::string main_scheme = "https://";
+    static const inline std::string discord = main_scheme + "discord.com";
+    static const inline std::string images = main_scheme + "cdn.discord.com";
+    static const inline std::string media = main_scheme + "media.discord.com";
    struct details {
-        static inline std::string current = DiscordEndpoints::discord + ApiVersion::current;
-        static inline std::string latest = DiscordEndpoints::discord + ApiVersion::latest;
+        static const inline std::string current = DiscordEndpoints::discord + ApiVersion::current;
+        static const inline std::string latest = DiscordEndpoints::discord + ApiVersion::latest;
    };
 };
+struct StatusType {
+    static inline const char* Offline = "offline";
+    static inline const char* Online = "online";
+    static inline const char* Idle = "idle";
+    static inline const char* DND = "dnd";
+    static inline const char* Invisible = "invisible";
+};
+enum ActivityType : unsigned char {
+    Playing,
+    Streaming,
+    Listening,
+    Watching,
+    Custom,
+    Competing
+};
 enum GatewayIntents {
    AutoModerationConfiguration = 1048576,
    AutoModerationExecution = 2097152,
@ -129,15 +145,21 @@ enum GatewayIntents {
    MessageContent = 32768,
    AllIntents = 131071
 };
-enum UserStatus {
-    Offline,
-    Online,
-    Idle,
-    AFK,
-    DoNotDisturb,
-    Invisible
-};
-enum DiscordTime {
+enum DiscordTime : long {
    Epoch = 1420070400000,
 };
+enum GatewayOpcodes : unsigned char {
+    Dispatch,
+    Heartbeat,
+    Identify,
+    PresenceUpdate,
+    VoiceStateUpdate,
+    Resume = 6,
+    Reconnect,
+    RequestGuildMembers,
+    InvalidSession,
+    Hello,
+    HeartbeatACK,
+    RequestSoundboardSounds = 31,
+};
 #endif
--- a/libs/utils/functions.hpp
+++ b/libs/utils/functions.hpp
@ -0,0 +1,40 @@
+#ifndef UTILS_FUNCTIONS_HPP_
+#define UTILS_FUNCTIONS_HPP_
+#include <optional>
+#include <string>
+#include <nlohmann/json.hpp>
+struct functions {
+    static inline auto isNull(const nlohmann::json& str) -> std::string {
+        return str.is_null() ? str.dump() : str.get<std::string>();
+    }
+    template<typename T>
+    static auto testValue(const nlohmann::json& data, const std::vector<std::string>& keys) -> std::optional<T> {
+        const nlohmann::json* current = &data;
+        for (const auto& key : keys) {
+            if (current->contains(key)) {
+                current = &(*current)[key];
+            } else {
+                return std::nullopt;
+            }
+        }
+        if constexpr (std::is_same_v<T, bool>) {
+            if (current->is_boolean()) {
+                return current->get<bool>();
+            }
+        } else if constexpr (std::is_same_v<T, int>) {
+            if (current->is_number_integer()) {
+                return current->get<int>();
+            }
+        } else if constexpr (std::is_same_v<T, double>) {
+            if (current->is_number_float()) {
+                return current->get<double>();
+            }
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            if (current->is_string()) {
+                return current->get<std::string>();
+            }
+        }
+        return std::nullopt;
+    }
+};
+#endif
--- a/libs/utils/json.hpp
+++ b/libs/utils/json.hpp
--- a/libs/utils/log.hpp
+++ b/libs/utils/log.hpp
@ -5,43 +5,47 @@
 #include <iostream>
 #include <iomanip>
 #include <ctime>
-using std::setfill, std::setw;
-enum level { INFO, WARNING, ERROR, CRITICAL };
-enum type { WEBSOCKET, NETWORK, API };
+#include <utils/types.hpp>
+enum level : unsigned char { INFO, WARNING, ERROR, CRITICAL };
+enum type : unsigned char { WEBSOCKET, NETWORK, API };
 class Log {
 public:
-    static void create(level lvl, type t, const std::string& message) {
+    _maybe_unused static void create(_maybe_unused const level& lvl, _maybe_unused const type& t, _maybe_unused const std::string& message) {
    #ifdef DEBUG
        std::string color;
        switch (lvl) {
-        case INFO:
-        color = "\033[34;1m";
-        break;
-        case WARNING:
-        color = "\033[33;1m";
-        break;
-        case ERROR:
-        color = "\033[31;1m";
-        break;
-        case CRITICAL:
-        color = "\033[31;1;2m";
-        break;
-        default:
-        color = "\033[0m";
-        break;
+            case INFO: color = "\033[34;1m"; break;
+            case WARNING: color = "\033[33;1m"; break;
+            case ERROR: color = "\033[31;1m"; break;
+            case CRITICAL: color = "\033[31;1;2m"; break;
+            default: color = "\033[0m"; break;
        }
        std::cout << color << "[" << getCurrentTime() << "][" << str(t) << "][" << str(lvl) << "] \033[0m" << message << "\033[0m" << std::endl;
    #endif
    }
+    static void force_create(const level& lvl, const type& t, const std::string& message) {
+        std::string color;
+        switch (lvl) {
+            case INFO: color = "\033[34;1m"; break;
+            case WARNING: color = "\033[33;1m"; break;
+            case ERROR: color = "\033[31;1m"; break;
+            case CRITICAL: color = "\033[31;1;2m"; break;
+            default: color = "\033[0m"; break;
+        }
+        std::cout << color << "[" << getCurrentTime() << "][" << str(t) << "][" << str(lvl) << "] \033[0m" << message << "\033[0m" << '\n';
+    }
 private:
-    static std::string getCurrentTime() {
+    static auto getCurrentTime() -> const std::string {
        std::time_t now_c = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
        std::tm* timer = std::localtime(&now_c);
        std::ostringstream oss;
-        oss << setfill('0') << setw(2) << timer->tm_hour << ":" << setfill('0') << setw(2) << timer->tm_min << ":" << setfill('0') << setw(2) << timer->tm_sec;
+        oss << std::setfill('0') << std::setw(2)
+            << timer->tm_hour << ":" << std::setfill('0') << std::setw(2)
+            << timer->tm_min << ":" << std::setfill('0') << std::setw(2)
+            << timer->tm_sec;
        return oss.str();
    }
-    static std::string str(const level& lvl) {
+    static auto str(const level& lvl) noexcept -> std::string {
        switch (lvl) {
        case INFO: return "INFO";
        case WARNING: return "WARNING";
@ -50,7 +54,7 @@ private:
        default: return "UNKNOWN";
        }
    }
-    static std::string str(const type& t) {
+    static auto str(const type& t) noexcept -> std::string {
        switch (t) {
        case WEBSOCKET: return "WEBSOCKET";
        case NETWORK: return "NETWORK";
@ -59,5 +63,4 @@ private:
        }
    }
 };
-
-#endif
+#endif
--- a/libs/utils/types.hpp
+++ b/libs/utils/types.hpp
@ -1,8 +1,7 @@
 #ifndef UTILS_TYPES_HPP_
 #define UTILS_TYPES_HPP_
-#define j(...) {{__VA_ARGS__}}
-#define je(...) {__VA_ARGS__}
-#define g(x, y) (std::get<x>(y))
-#define ALL_INTENTS 131071
-#define DEBUG
+#define _maybe_unused [[maybe_unused]]
+#define _deprecated_t(text) [[deprecated(text)]]
+#define _deprecated [[deprecated]]
+#define _nodiscard [[nodiscard]]
 #endif
--- a/res/fluttershy.gif
+++ b/res/fluttershy.gif
--- a/sources/main.cpp
+++ b/sources/main.cpp
@ -1,14 +1,46 @@
-#include <api.h>
-#include <includes.h>
+#include <api.hpp>
+#include <includes.hpp>
+#include <cxxopts.hpp>
 int main(int argc, char* argv[]) {
-    if (argc != 3) return -1;
-    WebSocket* bot = &WebSocket::getInstance(argv[2], GatewayIntents::AllIntents);
-    bot->on(GatewayEvents::READY, [](const Discord<Message, User>a) {
-        cout << DiscordEndpoints::details::latest << endl;
+    cxxopts::Options options("sparkle", "WIP discord bot library in C++");
+    options.add_options()
+        ("h,help", "Print help")
+        ("V,version", "Show version information")
+        ("t,token", "Discord bot token", cxxopts::value<std::string>());
+
+    auto result = options.parse(argc, argv);
+
+    if (result.count("version")) {
+        std::cout << "sparkle version 0.3" << std::endl;
+        return 0;
+    }
+
+    if (result.count("help")) {
+        std::cout << options.help() << std::endl;
+        return 0;
+    }
+    
+    if (!result.count("token")) {
+        std::cout << "\033[31mError: no token provided.\033[0m" << std::endl;
+        std::cout << options.help() << std::endl;
+        return -1;
+    }
+
+    class WebSocket* bot = &WebSocket::getInstance(result["token"].as<std::string>(), GatewayIntents::AllIntents);
+    
+    bot->once(GatewayEvents::READY, [](const Discord<User>& ctx) {
+        auto& [user] = ctx.ctx();
+        std::cout << std::boolalpha << user->isBot << std::endl;
+        std::cout << nlohmann::json::parse(user->me())["username"].get<std::string>() << std::endl;
    });
-    bot->on(GatewayEvents::MESSAGE_CREATE, [](const Discord<Message, User, Author> msg) {
-        g(0, msg.net)->send("939957962972229634", j("content", g(2, msg.net)->content()));
+
+    bot->on(GatewayEvents::MESSAGE_CREATE, [](const Discord<Message, User, Author>& msg) {
+        auto& [message, user, author] = msg.ctx();
+        if (!author->isBot) {
+            message->send("1334963948767940648", message->pack("content", std::to_string(user->isBot)));
+        }
    });
+    
    bot->start();
    return 0;
 }
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@ -1,12 +1,7 @@
 #include <gtest/gtest.h>
-int add(int a, int b) {
-    return a + b;
-}
-TEST(AddTest, PositiveNumbers) {
-    EXPECT_EQ(add(1, 2), 3);
-    EXPECT_EQ(add(2, 3), 5);
-}
-TEST(AddTest, NegativeNumbers) {
-    EXPECT_EQ(add(-1, -1), -2);
-    EXPECT_EQ(add(-1, 1), 0);
+#include <includes.hpp>
+#include <network.hpp>
+TEST(NetworkManagerTest, RequestReturnsExpectedValue) {
+    NetworkManager& networkManager = NetworkManager::getInstance();
+    EXPECT_FALSE(networkManager.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/939957962972229634/messages", { "content", "test" }).empty());
 }
Author	SHA1	Message	Date
fluttershy	84844cee6c	network fixes	2025-02-19 18:04:49 +05:00
fluttershy	227c77604f	fixes	2025-02-10 16:17:48 +05:00
fluttershy	eee362d419	uwu	2025-02-10 15:29:15 +05:00
fluttershy	61e59be26e	fixes	2025-02-02 00:11:39 +05:00
fluttershy	2a9297a3b2	fixes	2025-01-31 13:04:37 +05:00
fluttershy	188bf75a50	fixes	2025-01-31 00:11:03 +05:00
fluttershy	6e0d3ace47	for each	2025-01-30 23:21:16 +05:00
fluttershy	5a34d87814	fixes	2025-01-30 23:05:59 +05:00
fluttershy	d75860b300	fixes	2025-01-30 17:21:08 +05:00
fluttershy	2e54a17b5d	fixes	2025-01-29 16:06:47 +05:00
fluttershy	90ddcff78b	deleted something	2025-01-27 22:05:20 +05:00
fluttershy	9205584e70	test	2025-01-27 22:02:21 +05:00
fluttershy	84d6b3d71c	meow	2025-01-27 18:15:34 +05:00
fluttershy	f5341d6ea5	fixes	2025-01-27 17:24:33 +05:00
fluttershy	9542885b42	deleted flto	2025-01-26 23:39:59 +05:00
fluttershy	4a0af5a1e5	more fixes	2025-01-26 23:33:52 +05:00
fluttershy	a32954453b	fixes	2025-01-26 17:34:10 +05:00
fluttershy	99cf38cf12	ifelse -> switch	2025-01-26 16:12:25 +05:00
fluttershy	69e16e9c96	patches	2025-01-26 15:48:38 +05:00
fluttershy	a72a3e3869	Merge pull request 'add cxxopts and change args handling' (#2 ) from lame_lexem/sparkle:main into main Reviewed-on: http://applejack.ygg/fluttershy/sparkle/pulls/2	2025-01-25 15:22:54 +01:00
lexeyOK	728c65b8b3	add cxxopts and change args handling this adds library cxxopts in utils/cxxopts.hpp and adds several flags (version, help, token) we should foind how to update the vesrion in the furute	2025-01-25 18:49:20 +05:00
fluttershy	85779d857c	fixes	2025-01-25 18:40:57 +05:00
fluttershy	02cd1298c4	todo	2025-01-25 17:23:20 +05:00
fluttershy	4e6d1f7998	ctx instead get	2025-01-25 17:21:44 +05:00
fluttershy	2ee04ba9ca	patches	2025-01-25 15:46:27 +05:00
fluttershy	b978dd998f	fixes	2025-01-25 14:21:16 +05:00
fluttershy	dce9bfef07	cd	2025-01-25 13:43:44 +05:00
fluttershy	00d3df8784	Merge pull request 'main' (#1 ) from main into tests Reviewed-on: http://applejack.ygg/fluttershy/sparkle/pulls/1	2025-01-25 09:36:15 +01:00
fluttershy	2da2fb1ca2	.h -> .hpp	2025-01-25 13:22:59 +05:00
fluttershy	ebdefba4e2	readme update	2025-01-25 13:08:18 +05:00
fluttershy	ea60dff81e	deleted debug info	2025-01-25 12:57:43 +05:00
fluttershy	fc402ce9c1	fixes	2025-01-25 12:52:32 +05:00
fluttershy	ff66de918f	fixes	2025-01-25 12:23:31 +05:00
fluttershy	b0ec03ba36	cmake flags	2025-01-25 11:25:59 +05:00
fluttershy	4a230f8491	cmake flags, some fixes in api	2025-01-25 11:24:56 +05:00
fluttershy	0f05501ea3	cmake flags, some fixes in api	2025-01-25 11:22:04 +05:00
fluttershy	d7511fda92	cmake release/debug	2025-01-20 17:10:52 +05:00
fluttershy	802478eab4	cmake release/debug	2025-01-20 17:08:23 +05:00
fluttershy	10d0a81e84	cmake fix	2025-01-20 16:50:41 +05:00
fluttershy	c75cdae0c2	cmake fix	2025-01-20 16:50:13 +05:00
fluttershy	34fa837413	cmake clang only	2025-01-20 16:44:33 +05:00
fluttershy	5e3bad0c34	cmake clang only	2025-01-20 16:44:01 +05:00
fluttershy	4bcd2c0d6a	cmake fix	2025-01-20 16:33:12 +05:00
fluttershy	dbe872b1ff	cmake fix	2025-01-20 16:22:58 +05:00
fluttershy	8b01903e7f	cmake fix	2025-01-20 16:21:12 +05:00
fluttershy	8747d65e7d	cmake fix	2025-01-20 16:19:31 +05:00
fluttershy	f70201131c	structure update	2025-01-20 16:11:58 +05:00
fluttershy	fd16e499b3	fixes	2025-01-20 16:07:42 +05:00
fluttershy	7079675d94	deleted try catch	2025-01-20 15:14:27 +05:00
fluttershy	b85478d64b	compiler	2025-01-20 15:12:57 +05:00
fluttershy	8e506ecd22	default	2025-01-20 15:07:30 +05:00
fluttershy	830f2129b4	cmake update	2025-01-20 15:07:18 +05:00
fluttershy	63d325e715	readme update	2025-01-20 15:03:03 +05:00
fluttershy	64a43c9358	cmake update	2025-01-20 15:02:08 +05:00
fluttershy	fd81f46315	readme update	2025-01-20 15:01:44 +05:00
fluttershy	1cbfe59bf6	fixes	2025-01-20 04:03:27 +05:00
fluttershy	be0be09a24	code cleanup	2025-01-20 03:09:27 +05:00
fluttershy	62de22e02e	default	2025-01-20 01:53:09 +05:00
fluttershy	626ddc1121	default	2025-01-20 01:52:54 +05:00
fluttershy	c401269c4b	cmake update	2025-01-19 23:39:20 +05:00
fluttershy	d8cf6e742f	test	2025-01-19 04:43:55 +05:00
fluttershy	e0c7c1fcd1	code cleanup	2025-01-19 04:41:20 +05:00
fluttershy	cb7adad834	code cleanup	2025-01-19 04:40:15 +05:00
fluttershy	f291deba36	ctests and cmake update	2025-01-18 05:48:11 +05:00