Infinity Protocol

Infinity Protocol

Self Generating Liquidity Protocol
Infinity protocol was created with the intention of offering token holders access to true and stable passive income after analysing the market and realising that most cryptocurrency projects fail due to the number of rewards they provide that come from the liquid pool the team develop one of the most advanced tools in the field that will change the way crypto staking works.
Our protocol will constantly find opportunities within the markets that could be forex trading, cryptocurrencies and stocks after analysing the trend the protocol makes several calls Monday to Friday with an incredible success rate, we have been testing it for 3 months in the real world with outstanding results these purchases then are constantly monitored by the infinity protocol team as a back up to our amazing protocol.
Good to know: Our protocol works with crypto, stocks or forex.
Each requires a different level of risk and reward ratio.

White Paper

After the collapse of UST and LUNA it was clear that the cryptocurrency world in particular DEFI was on the verge of regulation by US authorities due to the substantial loss from the project.
Most cryptocurrency projects promise a level of return that 99% of the time is not sustainable in fact that was the problem with Anchor Protocol.

Infinity Protocol

Infinity Protocol offers a solution to this by offering rewards in a similar way that company dividends work, the way that the project rewards holders are based on the amount of money generated by the company, this is only possible with the help of the state of art protocol designed by the Unlimited Finance team and later on tweaked by Ami Anderson our head developer and owner of the project.

What is Infinity Protocol? In a nutshell...

The protocol makes constant buy 5 days per week it analyses the market 24/7 going through data constantly finding the moment where the prices will drop of the given assets, when the buy signal is achieved the protocol makes small buys (usually once every 30 minutes) they purchases are created and then sold if they are on profit.
This method generated constant profit, which at the moment is running at .77% compounded daily.
The return is maximised though out 12 months period achieving an average return of 350% to 450% within 12 months the given result is generated without touching the liquidity of the project, only part of the liquidity is linked to the protocol, as with everything there is a risk but the risk is minimised by only using 35 to 50% of the liquidity locked by stakes.
We have had the protocol running for the past 120 days, as most of you know this has been one of the worse times in the crypto and stock market yet our protocol remains profitable.

What would an example of a 10,000 investment look like?

Investment Projection

Investment value $10,000

$46,430.67 Total Interest

$36,430.67 Total Earnings
364.3% Percentage profit
Total days / Business days 365 Total Days / 261 Business days
Daily interest rate 0.59%
End date 03 Aug 2023
The numbers are only an example based on data gathered over the past 4 months currently the results of our 10,000 investments can be accessed on our website under the dashboard section.

Fundamentals: Dive a little deeper

Learn the fundamentals of Infinity Protocol understand backtesting and the way we make money for you.
Ami implemented several libraries to maximise the profitability of the protocol developed by Professor CP the managing director at Unlimited Finance.
Ami has a proven record of being successful trading assets she implemented several strategies and ran them through a Backtesting test the strategy on historical data, simulating the trades the strategy was expected to make. While this is not a guarantee for performance in the real world, it is a good indication of a winning/losing strategy.
Freqtrade backtests strategies through the following steps:
  1. 1.
    Load historic data for coin pairs (ETH/BTC, ADA/BTC, XRP/BTC, etc) in the provided config file
  2. 2.
    Call the strategy's bot_loop_start() function once. This initiates a new loop in live runs, while in backtesting, this is needed only once.
  3. 3.
    Calculate the strategy's technical indicators by calling the populate_indicators() method for every pair
  4. 4.
    Calculate buy/sell signals by calling the populate_buy_trend() and populate_sell_trend() methods for every pair
  5. 5.
    Confirm buy/sell trades by calling the confirm_trade_entry() and confirm_trade_exit() methods if implemented in the strategy
  6. 6.
    Loop through each time period (5m, 1h, 1d, etc.) and simulate entry and exit points
  7. 7.
    Finally, generate a backtest report, which summarises all the trades and the associated profit and loss for the specified period.

Downloading Data

To perform backtesting, we need historical price data from an exchange. Let's start by downloading some data from Binance with the following command:
docker-compose run --rm freqtrade download-data -p ETH/BTC -t 1d --timerange 20200101-20201231 --exchange binance
The command's arguments tell freqtrade the following:
  • -p ETH/BTC - Download data for the Ethereum (ETH) - Bitcoin (BTC) pair
  • -t 1d - Download data that have a timeframe of 1 day
  • --timerange 20200101-20201231 - Download data from 01/01/2020 to 31/12/2020.
  • --exchange binance - Download data from the Binance exchange. Here, you can use any exchange that freqtrade supports.
This command generated the file:
Which contains multiple open-high-low-close-volume (OHLCV) data artifacts like the following:
Where the columns mean the following:
  • time: Unix timestamp in milliseconds
  • Open: Opening price at the beginning of the candlestick
  • High: Highest price reached during the candlestick
  • Low: Lowest price reached during the candlestick
  • Close: Closing price at the end of the candlestick
  • Volume: Quantity of asset bought or sold, displayed in base currency, in our case ETH. BTC is the quote currency.
This data can be represented neatly in the following candlestick chart:
ETH/BTC price in the form of one-day (1d) candlesticks.

How to read the graph above

The chart above uses candlesticks to represent much more information than just a simple line. You can see a quick depiction of what candlesticks mean in the following image.
What is a candlestick in trading? by Callum CliffeSource: www.ig.com
If you recall the example OHLCV row from the previous section, you can see each candlestick represents the open, high, low, close part of each row of data. Many technical trading strategies look for candlestick patterns, which we may explore in later articles.
An excellent book for learning some of these patterns is Technical Analysis for Financial Markets. For a brief overview, you can also view Investopedia's article, Understanding Basic Candlestick Charts.
Now that we've seen an example of the data and understand each row's meaning, let's move on to configuring freqtrade to run our strategy.

Freqtrade Configuration

We have the required data for backtesting a strategy, but we need to create a config file, which will allow us to control several parameters of our strategy easily.
To create a new config, we run the following command:
docker-compose run --rm freqtrade new-config --config user_data/learndatasci-config.json
You will see a few initial questions, to which we answered with the following values:
Before continuing, we need to open the config file and set pair_whitelist = ["ETH/BTC"], which establishes our coin-pair of interest. Then we are ready to go.
You don't need to worry about anything else for the time being, but you should make sure to understand what the other configuration options mean, so be sure to visit the relevant docs.

Implementing a simple, custom strategy - Moving Average Crossover

Here, we will be defining a simple moving average strategy similar to the one in the Python for Finance series. If you haven't read that yet, make sure to checkout. You can find more details in Investopedia.

Understanding the strategy

I am going to tell you a little secret. Trading is really very simple, and you only have to do two things right:
  1. 1.
    Buy Low
  2. 2.
    Sell High
That easy? What's the catch? The tricky thing is to find the actual low and high points.
The idea behind the Moving Average strategy is the following:
  • You have two lines
    • The Slow Moving Average (SMA): a longer-term average of past values and represents a general trend.
    • The Fast Moving Average (FMA): a shorter-term average of past values and represents the current trend.
For our strategy, we will use the following indicators:
  • Buy when the FMA crosses above SMA, indicating an upward trend.
  • Sell when the FMA crosses below SMA, indicating a downward trend.
This is called a Moving Average Crossover Strategy.

Defining a custom strategy for freqtrade

Let's translate the Moving Average Crossover strategy in freqtrade using pandas.
Firstly, we need to create a new strategy file that will hold the logic behind our buy/sell signals.
!docker-compose run --rm freqtrade new-strategy -s SimpleMA_strategy --template minimal`
Now, we can find the newly created file in the strategies folder:
SimpleMA_strategy.py contains an autogenerated class, SimpleMA_strategy, and several functions we'll need to update.
To define our simple strategy, we need to update the following three functions:
  1. 1.
  2. 2.
  3. 3.
Let's walk through each of these individually.

1. populate_indicators()

Here, we calculate the indicators needed by our strategy to produce buy/sell signals.
Indicators for fast moving average (blue line) and slow moving average (yellow line) plotted for ETH/BTC
According to our strategy, we calculate the fast-moving average fast_MA (calculated using the last 5 candlesticks) and the slow-moving average slow_ma (calculated using the previous 50 candlesticks):
class SimpleMA_strategy(IStrategy):
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
fast_period = 5
slow_period = 50
dataframe['fast_MA'] = ta.SMA(dataframe, timeperiod=fast_period)
dataframe['slow_MA'] = ta.SMA(dataframe, timeperiod=slow_period)
return dataframe
Notice that we are passing a dataframe as an argument, manipulating it, then returning it. Working with dataframes in this way is what all of our functions will be doing.
If you're interested in seeing indicators other than simple moving averages, have a look at the docs of ta-lib.
The function definitions in this class use type hinting to define argument and return value types.

2. populate_buy_trend()

This function populates our buy signal, which is triggered when the fast_MA crosses above the slow_MA in our strategy.
We can accomplish this by updating populate_buy_trend() to include the following logic:
class SimpleMA_strategy(IStrategy):
def populate_indicators(...):
def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
qtpylib.crossed_above(dataframe['fast_MA'], dataframe['slow_MA'])
'buy'] = 1
return dataframe
Using qtpylib, we can easily find the crossover point. Essentially, the code above populates the buy column with a 1 when our buy condition (crossed_above) is triggered.

3. populate_sell_trend()

In a similar fashion to the previous function, this function populates our sell signal.
According to our strategy, this is when the fast_MA crosses below the slow_MA.
class SimpleMA_strategy(IStrategy):
def populate_indicators(...):
def populate_buy_trend(...):
def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
qtpylib.crossed_below(dataframe['fast_MA'], dataframe['slow_MA'])
] = 1
return dataframe
We're now using crossed_below—the opposite of crossed_above—which will populate the sell column with a 1 when our sell condition is triggered.
By default, the generated freqtrade strategy file includes more options, such as ROI (Return On Investment) and stop-loss, discussed in part two of the article series. We'll disable them for now:
class SimpleMA_strategy(IStrategy):
# the following statement disables selling due to ROI
minimal_roi = {
"0": 100
# the following statement disables selling due to stop-loss
stoploss = -1.0
def populate_indicators(...):
def populate_buy_trend(...):
def populate_sell_trend(...):
Now that we have a strategy filled out, we can test how it would have performed on past data.

Backtesting the strategy

Having defined our simple strategy, now we want to evaluate it using historical data using backtesting, which allows us to place trades in the past to see how they would have performed.
Backtesting isn't a perfect representation of how well our strategy would have performed because other factors affect returns in live markets, such as slippage.
To perform backtesting with freqtrade, we can run the following command using the class and functions we just created:
docker-compose run --rm freqtrade backtesting
--strategy SimpleMA_strategy -i 1d -p ETH/BTC
--timerange 20200101-20201231
--starting-balance 1
-c ./user_data/learndatasci-config.json
The parameters in the above command are as follows:
--strategy SimpleMA_strategy
use the SimpleMA_strategy strategy we created above.
-i 1d
use 1 day candlesticks
  • -p ETH/BTC - trade the ETH/BTC coin pair, which trades our BTC for ETH
  • --timerange 20200101-20201231 - backtest for the year 2020, from its first day 01/01/2020 to its last day 12/31/2020.
  • c ./user_data/config-learndatasci.json we are using the configuration that we defined earlier in this article.
  • --starting-balance 1 we start with a balance of 1 BTC.
Result for strategy SimpleMA_strategy
========================================================== BACKTESTING REPORT ==========================================================
| Pair | Buys | Avg Profit % | Cum Profit % | Tot Profit BTC | Tot Profit % | Avg Duration | Win Draw Loss Win% |
| ETH/BTC | 6 | 8.47 | 50.81 | 0.05086506 | 5.09 | 34 days, 12:00:00 | 3 0 3 50.0 |
| TOTAL | 6 | 8.47 | 50.81 | 0.05086506 | 5.09 | 34 days, 12:00:00 | 3 0 3 50.0 |
==================================================== SELL REASON STATS =====================================================
| Sell Reason | Sells | Win Draws Loss Win% | Avg Profit % | Cum Profit % | Tot Profit BTC | Tot Profit % |
| sell_signal | 6 | 3 0 3 50.0 | 8.47 | 50.81 | 0.0508651 | 50.81 |
===================================================== LEFT OPEN TRADES REPORT ======================================================
| Pair | Buys | Avg Profit % | Cum Profit % | Tot Profit BTC | Tot Profit % | Avg Duration | Win Draw Loss Win% |
| TOTAL | 0 | 0.00 | 0.00 | 0.00000000 | 0.00 | 0:00 | 0 0 0 0 |
=============== SUMMARY METRICS ===============
| Metric | Value |
| Backtesting from | 2020-01-01 00:00:00 |
| Backtesting to | 2020-12-31 00:00:00 |
| Max open trades | 1 |
| | |
| Total trades | 6 |
| Starting balance | 1.00000000 BTC |
| Final balance | 1.05086506 BTC |
| Absolute profit | 0.05086506 BTC |
| Total profit % | 5.09% |
| Trades per day | 0.02 |
| Avg. stake amount | 0.10000000 BTC |
| Total trade volume | 0.60000000 BTC |
| | |
| Best Pair | ETH/BTC 50.81% |
| Worst Pair | ETH/BTC 50.81% |
| Best trade | ETH/BTC 36.59% |
| Worst trade | ETH/BTC -10.57% |
| Best day | 0.03662727 BTC |
| Worst day | -0.01058107 BTC |
| Days win/draw/lose | 3 / 277 / 3 |
| Avg. Duration Winners | 51 days, 16:00:00 |
| Avg. Duration Loser | 17 days, 8:00:00 |
| Zero Duration Trades | 0.00% (0) |
| Rejected Buy signals | 0 |
| | |
| Min balance | 1.02441263 BTC |
| Max balance | 1.06732320 BTC |
| Drawdown | 16.44% |
| Drawdown | 0.01645814 BTC |
| Drawdown high | 0.06732320 BTC |
| Drawdown low | 0.05086506 BTC |
| Drawdown Start | 2020-09-10 00:00:00 |
| Drawdown End | 2020-12-19 00:00:00 |
| Market change | 24.93% |
We get a full report that contains the results of all our trades during the specified period.
Freqtrade split's the report into four parts:
1. Backtesting report This section shows a performance report for every coin pair, which in our case, is only ETH/BTC.
The column Avg Profit % shows the average profit for all trades made while the column Cum Profit % sums up all the profits/losses. The column Tot Profit % shows instead the total profit % in relation to the starting balance. ~ freqtrade docs
2. Sell reason stats This report shows us the performance of the sell reasons. Based on our strategy, we only used the sell signal, so we only have 1 row. Generally, we could also sell for other reasons such as accepted Return On Investment (ROI) and stop-loss. We will see this in the next article of the series.
3. Left Open Trades Report This part of the report shows any trades that were left open at the end of the backtesting. In our case, we don't have any and in general, it is not very important as it represents the ending state of the backtesting.
4. Summary metrics Personally, this is the area I usually look at first. The most important parts to point out are the following:
  • Trades per day - the average number of closed trades per day. I'm usually looking for strategies that make about ten trades per day.
  • Total profit % - the profit as a percentage of the starting balance.
  • Drawdown - the amount of the largest continuous loss
  • Market change - how much the market grew/shrank at the specified period. When trading more than one coin-pair, this metric is the average of market changes that all pairs incur, from the beginning to the end of the specified period. In our case the market for ETH/BTC grew by 24.93% in 2020. It's crucial to test a strategy in different market conditions, not just upward trending markets.
To understand the report in its entirety, make sure to read the relevant docs.

Notes and improvements

We can see that only six trades occurred. These trades generated a profit of 5.09%, which started with 1 BTC and ended with 1.05086506 BTC.
This result is not impressive, considering the risk involved. However, this strategy is as simple as it gets and has vast room for improvement:
Comparing to buy and hold Just holding ETH, i.e., converting our entire stack of BTC to ETH at the beginning of the testing period, we would gain 24.93% (market change indicator), but this is not something we can generally expect. We had far less exposure staking 10% of our stack per trade and not the whole of it. It is important to test our strategy in different conditions - that is not only when the market is growing, but also when it is shrinking.
Trading more coin-pairs We only considered Ethereum, which is one of the hundreds of coins we can trade. This limit only allows for one trade to happen at a time, which is clearly suboptimal.
Using more advanced strategies We used arguably one of the simplest strategies out there, which used only simple moving averages as indicators. Adding complexity doesn't necessarily mean better performance, but there's a massive number of indicator combinations we can backtest against eachother to find the best strategy.
Optimizing parameters Currently, we haven't attempted to optimized any hyperparameters, such as moving average period, return of investment, and stop-loss.
Smaller time periods We only considered daily candlesticks, which is one of the reasons why the bot finds only about 0.02 trades per day, making far fewer trades than a human trader. A bot can potentially make more profit by making more frequent trades and looking at more fine-detailed candlesticks.

Plotting results

To utilize freqtrade's plot commands, we will need to alter the docker-compose.yml file. The only thing we need to do is comment out one line and uncomment another. See the following excerpt from the file to see an example:
version: '3'
# image: freqtradeorg/freqtrade:stable <--- comment this line
# image: freqtradeorg/freqtrade:develop
# Use plotting image
image: freqtradeorg/freqtrade:develop_plot <--- uncomment this line
This tells docker-compose to pull the freqtrade Docker image that contains the correct plotting libraries.
We can now visualize our data, indicators, and buy/sell signals using the freqtrade plot-dataframe command.
docker-compose run --rm freqtrade plot-dataframe -s SimpleMA_strategy --config ./user_data/learndatasci-config.json -i 1d --timerange 20200101-20201231 --indicators1 fast_MA slow_MA
The --indicators1 option defines the indicators we want to plot, namely fast_MA and slow_MA. These must be defined inside the strategy specified with the -s option.
By default, this creates a plotly html file available in the plot directory: ./user_data/plot/freqtrade-plot-ETH_BTC-1d.html
You can view a full version of this interactive plot here.
Hover over the plot to see how the bot actually does what we wanted it to do, as defined by our simple moving average strategy:
  • Buy when fast_MA crosses below slow_MA.
  • Sell when fast_MA crosses above slow_MA.
To see what else you can do with plot-dataframe, run docker-compose run --rm freqtrade plot-dataframe -h or visit the relevant docs.

Enough of Fundamentals...

The project has been registered in New Zealand, we will comply 100% with worldwide regulations, as you can see we are offering a profitable product not a make rich quick scheme those crypto projects can not be regulated.
Infinity protocol will utilise all the taxation percentages towards the development of the fastest scalable blockchain "Infinity Blockchain".
The office address will be confirmed and this document will be updated, currently we are operating from 1 Bush Road in Auckland New Zealand.

How to maximise your investment?

The most accurate result and profitable is when locking the tokens for 12 months or more, once our staking website is in operations we will update this page to guide you through the process of staking and accumulating your profits.
Last modified 5mo ago