alpha rptr

About

The Github repository features a trading system designed for automated algorithmic trading on Binance Futures, Bybit, BitMEX and FTX.

This trading system aims to offer an easy-to-use platform for users to test their trading strategies through backtesting and paper trading, as well as execute trades in live environments. With the goal of minimizing discrepancies between simulated and live trading results, the system allows for seamless transitions from backtesting to paper trading and finally to live trading. Additionally, users can expect minimal changes to their strategy code when transitioning from simulated to live trading.

While developing strategies, users are expected to have a basic understanding of trading and are not subject to many limitations. The system is designed around pre-defined events, such as market data updates, order updates, and trade executions, and provides various technical features, including advanced order types, and real-time position and order monitoring, to support the development and execution of trading strategies.

Disclaimer

Please note that the author of this software is not liable for any losses, damages or other adverse consequences resulting from the use of this software. It is highly recommended that you exercise caution and thoroughly test your trading strategy using small sizes over an extended period of time to ensure that it performs as expected before deploying it with larger sums of money.

Table of Contents

• About
• Disclaimer
• Features
• Refrence Strategies
• Installation
  • Install packages
  • Setting keys
  • Exchange config
• How to Run
  • Mode
    • Production Trade Mode
    • Demo Trade Mode
    • Backtest Mode
    • Hyperopt Mode
    • Stub Trade Mode (paper trading)
• How To Add a Custom Strategy
• Key Functions
  • Orders
  • Position
  • Account
  • Indicators and Functions
    • Trend Indicators
    • Volatility Indicators
    • Momentum Indicators
    • Moving Averages
    • Bands and Channels
    • Pattern Recognition

Features

• REST API and Websocket implementation for multiple cryptocurrency exchanges, including Bybit, BitMEX, Binance Futures, and FTX.
• Pre-defined events for market data updates, order updates, and trade executions.
• All types of orders supported including majority of parameters/combinations - if you miss any, you can request
• Supports sophisticated order types, such as limit orders, stop-loss orders,trailing stop orders, iceberg orders and limit chasing orders.
• Custom strategy implementation, allowing traders to define their own trading algorithms and indicators.
• Backtesting framework to test strategies against historical market data.
• Testnet for Bybit, BitMEX and Binance Futures, allowing traders to test their strategies without risking real funds.
• Paper trading or stub trading for simulating trades with fake funds.
• TA-lib indicators and many others including custom indicators
• Simple strategy implementation, allowing traders to migrate strategies from other platforms such as TradingView.
• Discord webhooks and Line notifications supported for receiving real-time updates and notifications.

Reference Strategies

Please note that the implemented reference strategies are provided as examples for educational and reference purposes only. They are not intended to be used as a fully functional trading strategy for live trading without further modifications and proper testing. The strategies may not be suitable for all market conditions and may result in losses. We highly recommend that you thoroughly understand the strategy and test it extensively before using it for live trading. Always use caution and do your own research before making any trading decisions.

1. Supertrend strategy
2. Parabolic SAR
3. MACD
4. CandleTester
5. CandleTesterMult
6. Channel Breakout
7. Cross SMA
8. RCI
9. Open Close Cross Strategy
10. Trading View Strategy (implemented but not currently supported via Gmail integration)

Note: Although TradingView Strategy is not currently supported in this implementation, you can use the following project for TradingView Webhooks trading: https://github.com/CryptoMF/frostybot.

Requirements

• Python: 3.9.9

How to install

1. Install packages

OSX

$ brew install ta-lib
$ git clone https://github.com/TheFourGreatErrors/alpha-rptr.git
$ cd alpha-rptr/
$ pip install -r requirements.txt

LINUX

$ wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
$ tar xvzf ta-lib-0.4.0-src.tar.gz
$ cd ta-lib/
$ ./configure --prefix=/usr
$ make
$ sudo make install
$ git clone https://github.com/TheFourGreatErrors/alpha-rptr.git
$ cd alpha-rptr/
$ pip install -r requirements.txt

Note: We are using a Python wrapper for the TA-Lib library, which provides a wide range of technical analysis functions for financial markets. It is important to note that the underlying TA-Lib library is written in C language. Therefore, in order to install and use this library, it needs to be properly compiled on your system. The Python wrapper allows these functions to be used from within Python code, but the installation process may require some technical knowledge. It is important to ensure that the C library is properly compiled prior to installation in order to avoid errors and ensure that the library functions correctly.

2. Setting Keys

The src/config.py file is where you can set your API keys and other configuration settings for the trading bot. Here's how to do it:

1. Open the config.py file in a text editor or IDE.
2. Look for the binance_keys section of the configuration dictionary. This is where you'll enter your Binance API keys.
3. Replace the empty string "" in the API_KEY and SECRET_KEY fields with your actual Binance API key and secret key, respectively. You can find your API keys by logging into your Binance account and navigating to the API Management page.
4. If you have additional Binance accounts or other exchanges, you can enter their API keys in the corresponding sections of the configuration dictionary.
5. Save the config.py file.

In addition to API keys, you can also set other configuration settings, such as webhook URLs for Discord and LINE, and health check parameters for monitoring the status of your accounts.

Note that you can also set up different trading profiles using the args_profile field, which allows you to specify different settings for different trading sessions. To use a specific profile, you can run the program with the --profile flag.

When setting up your API keys, make sure to keep them secure and not share them with anyone.

config = {
    "binance_keys": {
            "binanceaccount1": {"API_KEY": "", "SECRET_KEY": ""},
            "binanceaccount2": {"API_KEY": "", "SECRET_KEY": ""},
            # Examaple using environment variable
            "binanceaccount3": {"API_KEY": os.environ.get("BINANCE_API_KEY_3"), 
                                "SECRET_KEY": os.environ.get("BINANCE_SECRET_KEY_3")}
    },
    "line_apikey": {"API_KEY": ""},
    "discord_webhooks": {
            "binanceaccount1": ""        
    },
    "healthchecks.io": {
                    "binanceaccount1": {
                            "websocket_heartbeat": "",
                            "listenkey_heartbeat": ""
                    }     
    },
    # To use Args profiles, add them here and run by using the flag --profile <your profile string>
    "args_profile": {"binanceaccount1_Sample_ethusdt": {"--test": False,
                                                        "--stub": False,
                                                        "--demo": False,
                                                        "--hyperopt": False,
                                                        "--spot": False,
                                                        "--account": "binanceaccount1",
                                                        "--exchange": "binance",
                                                        "--pair": "ETHUSDT",
                                                        "--strategy": "Sample",
                                                        "--session": None}}                                              
}

If you want to send notifications to LINE or Discord, set LINE's API key and/or Discord webhooks - discord will be sending notifications based on the account you choose to trade with. #todo telegram

3. Exchange Config

This is the configuration dictionary (found in src/exchange_config.py) for various exchanges including Binance, Bybit, Bitmex, and FTX. It contains the following parameters:

"binance_f":{"qty_in_usdt": False,
             "minute_granularity": False,
             "timeframes_sorted": True, # True for higher first, False for lower first and None when off 
             "enable_trade_log": True,
             "order_update_log": True,
             "ohlcv_len": 100,
             # Call the strategy function on start. This can be useful if you don't want to wait for the candle to close
             # to trigger the strategy function. However, this can also be problematic for certain operations such as
             # sending orders or duplicates of orders that have already been sent, which were calculated based on closed
             # candle data that is no longer relevant. Be aware of these potential issues and make sure to handle them
             # appropriately in your strategy implementation.
             "call_strat_on_start": False,
             # ==== Papertrading And Backtest Class Config ====
             "balance": 1000,
             "leverage": 1,
             "update_data": True,
             "check_candles_flag": True,
             "days": 1200,
             "search_oldest": 10, # Search for the oldest historical data, integer for increments in days, False or 0 to turn it off
             # Warmup timeframe - used for loading warmup candles for indicators when minute granularity is need
             # highest tf, if None its going to find it automatically based on highest tf and ohlcv_len
             "warmup_tf": None}

How to Run

To use the trading bot, you need to run the main.py script with the appropriate parameters. Here's a breakdown of the available options:

• --account: Specifies the account to use for trading. This should match the name of a configuration file located in the config directory. For example, if you have a file called binanceaccount1 in the config directory, you would use --account binanceaccount1.
• `--excha