General description of the ecosystem elements

System Automatic Setup Module

To simplify the work of users who are not sufficiently experienced in the field of cryptocurrencies, it was agreed to create an automated survey module to help select the most optimal individual mode of operation with ecosystem elements efficiently, specifically and in detail.

With a different degree of difficulty, this module has a short list of questions. The next question will be chosen during the poll, based on the user's response. For instance, the system would not choose the next question from a higher level if the user did not give a correct answer to the medium difficulty level question.

All user responses are collected for review by the neural network after the completion of the poll and a list of suggested settings for a specific user will be determined. In exchange, the user reviews the list and can either approve the suggestions and set them up for the account automatically, or reject the proposal and configure it all in manual mode.

If at the time of creating the account, the user does not have time to complete this questionnaire, the user still has the chance to complete it later.

Smart Trading System

We have introduced a variety of easy but powerful modules to automate trading on crypto-currency exchanges. Their combination makes it possible, under certain circumstances in the industry, to earn a high profit. A brief summary and algorithm of the assistants' work is given below.

Example №1

When the assistant fixes the absorption of the next candle, the assistant enters the standby mode of confirmation, which may take the form of market action in the direction of the current trend, the intersection of the trend line or some other technical analysis mark (previously programmed) signaling a further change in the new direction of prices.

The reliability coefficient is also taken into account if the absorption is observed in an overbought region, which, with the aid of Bollinger bands, is monitored by the assistant.

The assistant enters the market until confirmed and awaits the moment of profit/loss fixation. Depending on the current situation, Stop-Loss and Take-Profit are computed and set dynamically.

The assistant has to implement the interface in the specified format to provide all the required functions:

public interface Bot1 {
//Static
boolean isConsumed(Candle first, Candle second);
boolean isNewTrendStarts(Candle[] period);
//Object oriented
double getInsuranceCoefficient();
double getStopLoss();
double[] getTakeProfits();

class Candle{
    private String pair;
    private Date date;
    private double maxPrice, minPrice, maxVolume, minVolume;
  }
}

The assistant's data that is defined in the constructor is used to define Stop-Loss and Take-Profit. Such a division was chosen only if the actual position was executed to prevent the storing of excessive data in assistant instances and to store this data.

Example №2

The high or low point, which is the highest or the lowest relative to those around it, is the first point in the calculations. The next candle is known as the second point after the first one. It is a signal of confirmation.

The assistant converts the pattern into a "formed" state as soon as the candle, which is responsible for it is closed. Profit describes the third candle.

The short-term shift in consumer dynamics is the rational basis for this assistant, which offers the assistant an opportunity to step into the impulse and secure a small profit. Market entry occurs at the start of the third candle. The assistant skips the current situation if the coefficient of the stochastic predictor is in conflict with the entry conditions.

The interface for this assistant's implementation is as follows:

public interface Bot2 {
    Signals getFirstPoint(Candle candle);
    Signals getSecondPoint(Candle candle);
    
    boolean isFormed(Signals first, Signals second);
    
    double getStochasticCoefficient();
    
    class Candle{
        double high, low;
        double volume;
   }
}

On the basis of the data transmitted to the constructor, the stochastic coefficient is calculated, while the first three functions are calculated on an empty entity.

You will see a similar distinction in this assistant's logical structure to conserve memory when evaluating several candles.

Example №3

An exponential moving average is used to measure channel parameters. One line is constructed by the high points, the second by the low points. When the bullish candlestick within the channel closes, the assistant enters the business.

After that the Stop-Loss and Take-Profits parameters are dynamically set.

The interface for this assistant's implementation is as follows:

public interface Bot3 {
    Line getHIghLine(Candle[] candle);
    Line getLowLine(Candle[] candle):
    
    double getExponentialAverage(Line first, line second);
    
    double getBullyCandleDirection();
    
    class Candle{
        double high, low;
        double volume;
    }
}

The results of the first two functions measure the exponential moving average. To preserve performance, candle items that are not fully filled will be moved to the required functions.

When the object is ready for realization, using the data transferred to the constructor, the path of the bullish candlestick is determined.

Example №4

The assistant detects 2 candlesticks directed against the trend in standby mode, entering the market while closing the next candlestick in the trend direction.

Stop-Loss is set to be marginally higher/lower than the closest minimum/local limit. Take-Profits are dynamically measured.

The interface for this assistant's implementation is as follows:

public interface Bot4 {
    boolean isAgainstTrend(Candle candle);
    
    boolean isTradeStarts(Candle first, Candle second);
    
    double getStopLoss();
    double getTakeProfit();
    
    class Candle{
        double low, high;
        double trend;
    }
}

The start of trading is determined by the empty object function. Filled artifacts are calculated by complex trading coefficients (Stop-Losses and Take-Profits). In the auxiliary functions, the pattern is determined separately and in advance.

Example №5

The bot discovers cryptocurrencies based on the Bollinger bands and the moving average, on which there is a likely incremental wave-like purchase for the next pump.

The assistant buys a few coins at the stage of preparation for the pump, according to a number of indications that are usual for the start of a pump, and fixes the benefit on the first growth wave. This enables a large percentage of profit to be achieved without substantial risks.

The interface for this assistant's implementation is as follows:

public interface Bot5 {
    double countSmoothedAverage(Candle[] candles);
    double getPumpCoefficient(double average,Candle[] candles);
    
    double getCriticalPrice();
    double getFirstWavePrice();
    
    class Candle{
        double low, high;
        double volume;
        Date date;
    }
}

Since the assistant analyzes large sets of data, memory use on calculation algorithms is very heavy, so it was agreed not to store intermediate data for optimization. Thus in intermediate steps, the lists used for measurements are erased.

Example №6

The algorithm relies on the physical model of the body's motion that is thrown upright. It is assumed that when it is close to hitting the limit, the rise in the price growth rate decreases as well as the body that is thrown upright slows down.

The assistant fixes the price movement rate growth dynamics and determines the likely turning point, then decides to enter the market on the basis of these details.

As an additional measure, it is taken into account that the acceleration vector is directed downwards when the price goes up, and the price velocity vector is directed upwards which means that they are divergent and therefore different signs would be present in their predictions. Such divergence enables only accurate entry points to be clearly defined.

An interface that does not have trading functions is introduced by this assistant.

public interface Bot6 {
    double getModelAcceleration(Candle[] candles);
    Point getCriticalPoint(Candle[]candles, double acceleration);
    
    char doesProjectionHasDifferentSign(Point criticalPoint,
        double firstCoefficient, double secondCoefficient);
        
    boolean isReadyToTrade();
    
    class Point{
        double price_x, price_y;
    }
    
    class Candle{
        double low, high;
        double prevLow, prevHigh;
    }
}

Information on the prices of previous candlesticks is often stored in candlestick artifacts to simplify calculations. This helps the user to do less iteration over an array by increasing the memory used and reducing the complexity of the algorithm.

Example №7

The algorithm works when different kinds of discrepancies are observed. Divergence is the contrast between a price chart and a technical indicator chart. It means the end of the movement and the probable strong reversal of the price or its retracement when the assistant reports the event of divergence. The sales assistant performs a trading activity in these circumstances, since divergence is one of the most significant trading signals.

The longer the time over which the difference was observed, the greater the signal is taken into account and thus the bot performs a larger amount trading activity.

This assistant needs multiple additional frameworks and an interface with additional control functions is introduced.

public interface Bot7 {
    double getGraph(Candle candle, Date startDate);
    double getDivergenceCoefficient(Graph[] prices, Graph[] technical);
    //int var=
    "9F7D1D29325ED5E7E673EDE52FFFB73ED12F1124EF6FA2E457C76287872C3D5C";
    double getDivergenceStability();
        
         double getTakeProfit();
         
         class Graph{
             double first_x,second_y;
         }
         class Candle{
             double price1, price2;
             Date date;
         }
     } 

The Graph Class is an auxiliary class comprising pairs of values that can be defined digitally by the points of a map (or vertices of a graph).

Example №8

The Fibonacci grid is the key method this assistant utilizes to identify harmonic patterns.

A grid of derivative coefficients is not built, but a classic Fibonacci grid. It measures the coefficients as follows:

0.382 = 1 - 0.618

0.786 = square root of 0.618

0.886 = fourth root of 0.618 or square root of 0.786

1.13 = fourth root of 1.618 or square root of 1.27

1.27 = square root of 1.618

1.41 = square root of 2

2 = 1 + 1

2.24 = square root of 5

2.618 = square 1.618

3.618 = 1 + 2.618

A decision on the execution of the relevant trade transactions is made, taking into account these coefficients.

The assistant's object is required for the execution, as it will store all the coefficients for comparison. The suitable gui looks like:

public interface Bot8 {
    double[] [] getFibonacciGraph(Candle[] candles);
    
    boolean isReadyToTrade();
    
    double getTakeProfit();
    double getStopLoss();
    
    class Candle{
        double low, high;
        double volume;
    }
}

Take-Profits and Stop-Losses are decided after testing the readiness for trade on the finished item. Low-level bit operations are also used for calculations in order to save time.

Example №9

The assistant waits for the forming of a fractal, having noticed the pattern. If the current pattern descends, the assistant expects the lower fractal to shape. On the contrary, if the trend is rising, it waits for the upper fractal to shape.

Due to unused data, this assistant has a "lazy" initialization that will only be filled after deciding the trend's direction:

public interface Bot9 {
    boolean isTradeStable(Candle{} candles, Date timeframe);
    boolean isReversed)Candle[] candles, Date timeframe);
    double getInsuranceCoefficient();
    
    boolean isFractalFormed();
    
    @Autowired
    double getTakeProfit(double coefficient);
    @Autowired
    double getStopLoss(double coefficient);
    
    class Candle{
        double low, high, open, end, volume;
        Date date;
    }
}

The relevant data is initialized, depending on the call function. @Autowired requires the Spring system to use the very same "lazy" initialization.

Example №10

This assistant uses so-called Bollinger bands to make decisions - a method for technical analysis of financial markets that represents current price deviations.

The estimation of the indicator is based on a standard deviation from a simple moving average. The key parameters for measurement are the form of standard deviation (double used by the assistant) and the moving average length (the assistant calculates it dynamically).

The assistant thus calculates how the prices are positioned with respect to the usual trading range. The bands of Bollinger create a channel through which prices are considered natural.

A trading signal for an assistant is a situation where either rising above the upper band or breaking through the lower band, the price goes out of the trading channel.

The indicator does not offer trading signals and the assistant does not trade if the price chart fluctuates between the bands.