A simple and straightforward bot with an easy way to implement basic strategies via a config file for crypto trading. Define a list of crypto currencies, and strategies to trigger when to BUY and SELL said crypto currencies. The bot iterates over the list of crypto currencies synchronously and execute the appropriate trades.

Note: The crypto-bot is overly optimistic by default and will NEVER SELL at a loss even if a SELL signal is triggered (This can be overriden in the config file).

1. Python 3.10.x
   Due to some dependency conflicts with TALib, Python 3.10.x is recommended. I recommend pyenv (macOS/Linux) or pyenv-win (Windows) so you can easily manage different versions Python easily

2. MongoDB
   Trades are stored in MongoDB to keep track of your current positions across multiple sessions. It's also used to calculate your overall performance. MongoDB community version will suffice but using any other tier will work as long as you have a connection string

3. TALib Core Libraries
   The crypto-bot has a dependency on the TA-Lib python library, which will automatically be installed with pip install. BUT installing the python library does NOT install the necessary dependencies for the TAL-Lib library. The TA-Lib python library requies the core TA-Lib libraries, which you can go here to install the core TA-Lib libraries.

4. Coinbase API Key
   Currently, the crypto-bot only supports Coinbase exchange but more exchanges will be suppported in the future. You'll need to create an API key through your coinbase account. See here for instructions. The below scope should be enabled AND please ensure to enable the specific Crypto Currencies you plan to run.

wallet:accounts:read, wallet:buys:create, wallet:buys:read,  
wallet:notifications:read, wallet:orders:create,  
wallet:orders:read, wallet:sells:create, wallet:sells:read,  
wallet:supported-assets:read, wallet:trades:create,  
wallet:trades:read, wallet:transactions:read,  
wallet:transactions:request, wallet:transactions:send,  
wallet:transactions:transfer, wallet:user:read

1. Create a virtual environment

python -m vnenv env

2. Activate virtual environment (chose the appropriate command corresponding to your system and environment)

.\env\Scripts\activate.bat  \\Windows cmd
.\env\Scripts\Activate.ps1  \\Windows powershell

$ source env/bin/activate \\ POSIX bash/zsh
$ source env/bin/activate.fish \\ POSIX fish
$ source env/bin/activate.csh \\ POSIX csh/tcsh
$ source env/bin/Activate.ps1 \\ POSIX powershell

3. Install dependencies

python -m pip install -r requirements.txt

4. Create .env file

cp .env.copy .env

5. Set environment variables

API_KEY=<EXCHANGE_API_KEY>
API_SECRET=<EXCHANGE API_SECRET>
MONGO_CONNECTION_STRING=<MONGO_CONNECTION_STRING>

The config.json, in your root dir, is the default config file the crypto-bot will load. It will defines various parameters and your trading strategy. See the following table for details:

* Required Fields

Stratgies are defined in the strategies attribute of config.json. You define multiple indicators to develop your strategy and the indicators are evaluated based on its priority (defined by the priority attribute). If multiple indicators have the same priority then all must return the same action (i.e. BUY, SELL, HOLD) for the bot to perform said action. If the bot is triggered to take action, the rest of the indicators at lower priorities are skipped.

Indicator Parameters

RSI
The Relative Strength Index (RSI) is a momentum oscillator used in technical analysis that measures the speed and change of price movements of a security or market. The RSI is popular among traders and analysts for identifying overbought or oversold conditions in the price of a stock or other asset, potentially indicating reversals or a weakening trend.

MACD
The Moving Average Convergence Divergence (MACD) is a widely used technical analysis indicator that helps to identify momentum trends and potential reversals in the price of an asset. It does this by comparing two moving averages of an asset's price, and it's defined by three key components: the fast period, slow period, and signal period

Bollinger Bands
Bollinger Bands are a technical analysis tool used in trading to identify potential overbought or oversold conditions in a market, as well as to gauge the volatility of a financial instrument. Bollinger Bands consist of a middle band being an N-period simple moving average (window), an upper band at K times an N-period standard deviation above the middle band, and a lower band at K times an N-period standard deviation below the middle band.

AVERAGE_DOWN Allows you to perform dollar cost averaging by setting a threshold and if the price falls below, it will trigger a BUY signal to reduce your average price

ADAPTIVE_RSI (Experimental) Dynamically shift the overbought and oversold thresholds depending on the recent price movement and momentum

The strategies will execute with the following heuristics:

1. Lowest priority first
2. If a BUY/SIGNAL signal is triggered, order is executed and lower priority strategies are skipped
3. If multiple strategies have the same priority, the ALL strategies at that priority MUST have consensus to execute a trade. (e.g All BUY or SELL signals must be returned)
4. If a SELL signal is triggered AND the current position is at a loss, AND prevent_loss=TRUE then the signal will be converted to a HOLD signal

For example given the following example strategy:

.
.
.
    "strategies": [
        {
            "name": "TAKE_PROFIT",
            "priority": 0,
            "parameters": {
                "threshold_percent": 10
            } 
        },
        {
            "name": "AVERAGE_DOWN",
            "priority": 1,
            "parameters": {
                "threshold_percent": 25,
                "num_times": 2
            } 
        },
        {
            "name": "BOLLINGER_BANDS",
            "priority": 2,
            "parameters": {
                "window": 20,
                "std_dev": 2
                
            }
        },
        {
            "name": "RSI",
            "priority": 2,
            "parameters": {
                "overbought_signal_threshold": 70,
                "oversold_signal_threshold": 32
            }
        },
        {
            "name": "MACD",
            "priority": 2,
            "prevent_loss": true
        }
    ]
     "support_currencies": [
        "BTC",
        "SHIB"
        .
        .
        .
     ]
    .
    .
    .

For EACH crypto currency defined in the support_currencies array the crypto bot will evaluate each strategy like the following:

1. TAKE_PROFIT will trigger a BUY signal if there's an open position AND profit > 10%, otherwise trigger a HOLD signal
2. If a BUY signal is triggered, skip other strategies and move on to the next crypto currency on the list, otherwise go to #3
3. AVERAGE_DOWN will trigger a BUY signal if there's an open position and profit <= -25%, otherwise trigger a HOLD
4. If BUY signal is triggered, skip other strategies and move on to the next crypto currency on the list, otherwise go to #5
5. RSI, MACD, BOLLINGER_BANDS all have same priorty so ALL three must trigger BUY/SELL, otherwise is NOOP signal is triggered
6. If all three above triggers BUY/SELL then execute the appropriate order and move on to the next crypto currency

Anyone is free to submit pull requests to improve the usability of crypto-bot. Few high priority features still needed are:

1. Implementation of other common indicators/strategies
2. Configurable parameters for fetching candles for each strategy
3. Running each crypto currency asynchronously
4. Adding support for other exchanges

Anyone is free to use the crypto-bot as they like. But it's the user's responsibility to ensure the bot performs the transactions as expected. It's recommended users do their own due diligence when creating their strategies. It's important to always perform necessary testing before running the crypto-bot in production. There's no guarantee the bot is bug free, so it's important to do comprehensive testing before letting the bot execute real trades. Users can use the dry-run flat to help in testing and confirming expected behavior.