OBJECTIVES:

Stock Rush is a Stock Broker Simulator Game designed to provide users with a risk-free, gamified experience of real-world trading.
Users have the ability to buy and sell stocks using real-world options such as MARKET ORDER and LIMIT ORDER.
Since, stock exchange APIs aren't publicly available, we are using our custom-built stock exchange engine to make sure stock prices change based on in-game trades and events.

(!! The prices and demand of stocks will not have any relevance to the real-world market as we are not using any Stock exchange APIs)
At the start of the game, users receive a fixed amount of funds, which they can utilize to increase their in-game wealth.

TECHNOLOGIES USED

Frontend:

React.js – Component-based UI for a dynamic user experience.
Tailwind CSS – Utility-first CSS framework for fast and responsive design.
React-chart.js – Data visualization for stock price trends.
Redux – State management to handle real-time stock updates.
Axios – Handles API requests efficiently.

Backend:

Node.js & Express.js – Handles API requests and application logic.
C++ (Stock Execution & Exchange Engine) – High-performance execution of trades, order book management, and matching.
Socket.IO – Enables real-time communication for fast trade execution and updates.

Database & Caching:

MongoDB – NoSQL database to store users, orders, stocks, and transaction data.
Redis – In-memory caching for fast access to frequently queried stock data.

SYSTEM DESIGN:

User Authentication

The system uses JWT-based authentication with refresh and access tokens. Once a user logs in, they gain access to the Dashboard, where they can view stocks, track their holdings, manage their watchlist, and place orders.

Dashboard

The Dashboard is the main interface where users can:

View all stock details, including live prices and trends.
Manage their watchlist to keep track of specific stocks.
Place buy and sell orders for any stock.
Check their holdings, active orders, and position details.

Order Processing Flow

Order Validator

Before an order is executed, it goes through a validation step to ensure:

The user has sufficient funds or stocks in their account.
The order follows all trading rules.

To make this validation fast and efficient, we use a Thread Pool Design, allowing multiple orders to be processed in parallel.

Order Manager

Once an order is validated, it is sent to the Order Manager, which handles execution.

Each stock has its own dedicated execution thread.
The system keeps a HashMap that maps stock symbols to their execution threads.
When a new order arrives, the Order Manager checks the HashMap and assigns the appropriate thread for execution.

Order Execution

Once assigned, the order enters the Order Execution Thread, which consists of:

Execution Queue → Orders are queued before execution.
Order Executor → Picks orders from the queue and processes them.
Singleton Pattern → Ensures that only one order at a time is processed for the same stock, preventing race conditions.

For efficient order cancellations, we also maintain an Order ID HashMap for quick lookups.

Order Book Management

The Order Book is where all buy and sell orders are stored and matched.

To efficiently store and match orders, we use two AVL Trees:

Buy Orders AVL Tree → Sorted in descending order (highest price at the top).
Sell Orders AVL Tree → Sorted in ascending order (lowest price at the top).

At each price level, we use a FIFO Queue to ensure fair execution (i.e., first come, first served).

Matching Logic:

The system continuously compares the highest bid (Buy Tree root) with the lowest ask (Sell Tree root).
If the bid price is greater than or equal to the ask price, a trade happens.

Performance:

O(log n) complexity for price lookups and order insertion.
O(1) execution time for orders within the same price level (using FIFO Queue).

Final Execution & Database Update

Once an order is successfully executed:

The system updates the Demat account balance.
The order status is updated in the database.

Stock Manager – Dynamic Price Adjustment

The Stock Manager handles:

Adding new stocks when an admin registers them.
Automatically adjusting stock prices based on demand and supply.

Here’s how the price adjustment works:

Step 1: Track Demand & Supply

Every time an order is executed, we update the last matched price.
We calculate:
- Demand (D) = Total quantity of buy orders at different price levels.
- Supply (S) = Total quantity of sell orders at different price levels.

Step 2: Apply Price Adjustment Rules

If Demand > Supply → Increase Price
- More buyers than sellers = Price rises.
- Formula: New_Price = Last_Matched_Price * { 1 + k * (D−S / D+S )}
- Here, k is a small factor (e.g., 0.02) to prevent extreme fluctuations.
If Supply > Demand → Decrease Price
- More sellers than buyers = Price drops.
- Formula: New_Price = Last_Matched_Price* { 1 − k * (S−D / D+S)}
If Demand = Supply → Price remains unchanged.

Step 3: Update Stock Price

The new price is stored in the database and used for future trades.
The system ensures real-time price updates after every executed order.
This logic repeats continuously to keep the stock prices dynamic.

Database Management

The database stores all critical data:

Users → User profiles, authentication details.
Orders → Active & completed orders.
Demat Accounts → User balances, holdings.
Stock Information → Current prices, trading history.

For frequently accessed stock data, we use Redis caching to improve performance.

Conclusion

Our stock trading simulator provides a realistic and scalable environment for users to experience market dynamics. By leveraging React for the frontend, Node.js & C++ for backend processing, and MongoDB with Redis for efficient data handling, the system ensures high performance, real-time updates, and smooth execution of trades. The integration of AVL Trees and Queues for order book management further optimizes trade matching. Overall, this project successfully simulates stock trading while maintaining fair execution, security, and scalability.

Stock Rush