616 lines
26 KiB
Python
616 lines
26 KiB
Python
import logging
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
from types import FunctionType
|
|
from unittest.mock import MagicMock
|
|
import arrow
|
|
import pytest
|
|
from math import isclose
|
|
from sqlalchemy import create_engine, inspect, text
|
|
from freqtrade import constants
|
|
from freqtrade.exceptions import DependencyException, OperationalException
|
|
from freqtrade.persistence import LocalTrade, Order, Trade, clean_dry_run_db, init_db
|
|
from tests.conftest import create_mock_trades_with_leverage, log_has, log_has_re
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_interest_kraken(market_leveraged_buy_order, fee):
|
|
"""
|
|
Market trade on Kraken at 3x and 5x leverage
|
|
Short trade
|
|
interest_rate: 0.05%, 0.25% per 4 hrs
|
|
open_rate: 0.00004099 base
|
|
close_rate: 0.00004173 base
|
|
stake_amount: 0.0037707443218227
|
|
borrowed: 0.0075414886436454
|
|
amount:
|
|
275.97543219 crypto
|
|
459.95905365 crypto
|
|
borrowed:
|
|
0.0075414886436454 base
|
|
0.0150829772872908 base
|
|
time-periods: 10 minutes(rounds up to 1 time-period of 4hrs)
|
|
5 hours = 5/4
|
|
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0075414886436454 * 0.0005 * 1 = 3.7707443218227e-06 base
|
|
= 0.0075414886436454 * 0.00025 * 5/4 = 2.3567152011391876e-06 base
|
|
= 0.0150829772872908 * 0.0005 * 5/4 = 9.42686080455675e-06 base
|
|
= 0.0150829772872908 * 0.00025 * 1 = 3.7707443218227e-06 base
|
|
"""
|
|
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0037707443218227,
|
|
amount=275.97543219,
|
|
open_rate=0.00001099,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='kraken',
|
|
leverage=3.0,
|
|
interest_rate=0.0005
|
|
)
|
|
|
|
# The trades that last 10 minutes do not need to be rounded because they round up to 4 hours on kraken so we can predict the correct value
|
|
assert float(trade.calculate_interest()) == 3.7707443218227e-06
|
|
trade.open_date = datetime.utcnow() - timedelta(hours=5, minutes=0)
|
|
# The trades that last for 5 hours have to be rounded because the length of time that the test takes will vary every time it runs, so we can't predict the exact value
|
|
assert float(round(trade.calculate_interest(interest_rate=0.00025), 11)
|
|
) == round(2.3567152011391876e-06, 11)
|
|
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0037707443218227,
|
|
amount=459.95905365,
|
|
open_rate=0.00001099,
|
|
open_date=datetime.utcnow() - timedelta(hours=5, minutes=0),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='kraken',
|
|
leverage=5.0,
|
|
interest_rate=0.0005
|
|
)
|
|
|
|
assert float(round(trade.calculate_interest(), 11)
|
|
) == round(9.42686080455675e-06, 11)
|
|
trade.open_date = datetime.utcnow() - timedelta(hours=0, minutes=10)
|
|
assert float(trade.calculate_interest(interest_rate=0.00025)) == 3.7707443218227e-06
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_interest_binance(market_leveraged_buy_order, fee):
|
|
"""
|
|
Market trade on Kraken at 3x and 5x leverage
|
|
Short trade
|
|
interest_rate: 0.05%, 0.25% per 4 hrs
|
|
open_rate: 0.00001099 base
|
|
close_rate: 0.00001173 base
|
|
stake_amount: 0.0009999999999226999
|
|
borrowed: 0.0019999999998453998
|
|
amount:
|
|
90.99181073 * leverage(3) = 272.97543219 crypto
|
|
90.99181073 * leverage(5) = 454.95905365 crypto
|
|
borrowed:
|
|
0.0019999999998453998 base
|
|
0.0039999999996907995 base
|
|
time-periods: 10 minutes(rounds up to 1/24 time-period of 24hrs)
|
|
5 hours = 5/24
|
|
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0019999999998453998 * 0.00050 * 1/24 = 4.166666666344583e-08 base
|
|
= 0.0019999999998453998 * 0.00025 * 5/24 = 1.0416666665861459e-07 base
|
|
= 0.0039999999996907995 * 0.00050 * 5/24 = 4.1666666663445834e-07 base
|
|
= 0.0039999999996907995 * 0.00025 * 1/24 = 4.166666666344583e-08 base
|
|
"""
|
|
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0009999999999226999,
|
|
amount=272.97543219,
|
|
open_rate=0.00001099,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='binance',
|
|
|
|
leverage=3.0,
|
|
interest_rate=0.0005
|
|
)
|
|
# The trades that last 10 minutes do not always need to be rounded because they round up to 4 hours on kraken so we can predict the correct value
|
|
assert round(float(trade.calculate_interest()), 22) == round(4.166666666344583e-08, 22)
|
|
trade.open_date = datetime.utcnow() - timedelta(hours=5, minutes=0)
|
|
# The trades that last for 5 hours have to be rounded because the length of time that the test takes will vary every time it runs, so we can't predict the exact value
|
|
assert float(round(trade.calculate_interest(interest_rate=0.00025), 14)
|
|
) == round(1.0416666665861459e-07, 14)
|
|
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0009999999999226999,
|
|
amount=459.95905365,
|
|
open_rate=0.00001099,
|
|
open_date=datetime.utcnow() - timedelta(hours=5, minutes=0),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='binance',
|
|
leverage=5.0,
|
|
interest_rate=0.0005
|
|
)
|
|
|
|
assert float(round(trade.calculate_interest(), 14)) == round(4.1666666663445834e-07, 14)
|
|
trade.open_date = datetime.utcnow() - timedelta(hours=0, minutes=10)
|
|
assert float(round(trade.calculate_interest(interest_rate=0.00025), 22)
|
|
) == round(4.166666666344583e-08, 22)
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_update_open_order(limit_leveraged_buy_order):
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=1.00,
|
|
open_rate=0.01,
|
|
amount=5,
|
|
fee_open=0.1,
|
|
fee_close=0.1,
|
|
interest_rate=0.0005,
|
|
leverage=3.0,
|
|
exchange='binance',
|
|
)
|
|
assert trade.open_order_id is None
|
|
assert trade.close_profit is None
|
|
assert trade.close_date is None
|
|
limit_leveraged_buy_order['status'] = 'open'
|
|
trade.update(limit_leveraged_buy_order)
|
|
assert trade.open_order_id is None
|
|
assert trade.close_profit is None
|
|
assert trade.close_date is None
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_calc_open_trade_value(market_leveraged_buy_order, fee):
|
|
"""
|
|
10 minute leveraged market trade on Kraken at 3x leverage
|
|
Short trade
|
|
fee: 0.25% base
|
|
interest_rate: 0.05% per 4 hrs
|
|
open_rate: 0.00004099 base
|
|
close_rate: 0.00004173 base
|
|
amount: 91.99181073 * leverage(3) = 275.97543219 crypto
|
|
stake_amount: 0.0037707443218227
|
|
borrowed: 0.0075414886436454 base
|
|
time-periods: 10 minutes(rounds up to 1 time-period of 4hrs)
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0075414886436454 * 0.0005 * 1 = 3.7707443218227e-06 crypto
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (275.97543219 * 0.00004099) + (275.97543219 * 0.00004099 * 0.0025)
|
|
= 0.01134051354788177
|
|
"""
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.001,
|
|
amount=5,
|
|
open_rate=0.00004099,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
interest_rate=0.0005,
|
|
exchange='kraken',
|
|
leverage=3
|
|
)
|
|
trade.open_order_id = 'open_trade'
|
|
trade.update(market_leveraged_buy_order) # Buy @ 0.00001099
|
|
# Get the open rate price with the standard fee rate
|
|
assert trade._calc_open_trade_value() == 0.01134051354788177
|
|
trade.fee_open = 0.003
|
|
# Get the open rate price with a custom fee rate
|
|
assert trade._calc_open_trade_value() == 0.011346169664364504
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_calc_open_close_trade_price(limit_leveraged_buy_order, limit_leveraged_sell_order, fee):
|
|
"""
|
|
5 hour leveraged trade on Binance
|
|
|
|
fee: 0.25% base
|
|
interest_rate: 0.05% per day
|
|
open_rate: 0.00001099 base
|
|
close_rate: 0.00001173 base
|
|
amount: 272.97543219 crypto
|
|
stake_amount: 0.0009999999999226999 base
|
|
borrowed: 0.0019999999998453998 base
|
|
time-periods: 5 hours(rounds up to 5/24 time-period of 1 day)
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0019999999998453998 * 0.0005 * 5/24 = 2.0833333331722917e-07 base
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (272.97543219 * 0.00001099) + (272.97543219 * 0.00001099 * 0.0025)
|
|
= 0.0030074999997675204
|
|
close_value: ((amount_closed * close_rate) - (amount_closed * close_rate * fee)) - interest
|
|
= (272.97543219 * 0.00001173) - (272.97543219 * 0.00001173 * 0.0025) - 2.0833333331722917e-07
|
|
= 0.003193788481706411
|
|
total_profit = close_value - open_value
|
|
= 0.003193788481706411 - 0.0030074999997675204
|
|
= 0.00018628848193889044
|
|
total_profit_percentage = total_profit / stake_amount
|
|
= 0.00018628848193889054 / 0.0009999999999226999
|
|
= 0.18628848195329067
|
|
"""
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0009999999999226999,
|
|
open_rate=0.01,
|
|
amount=5,
|
|
open_date=datetime.utcnow() - timedelta(hours=5, minutes=0),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='binance',
|
|
interest_rate=0.0005
|
|
)
|
|
trade.open_order_id = 'something'
|
|
trade.update(limit_leveraged_buy_order)
|
|
assert trade._calc_open_trade_value() == 0.00300749999976752
|
|
trade.update(limit_leveraged_sell_order)
|
|
|
|
# Will be slightly different due to slight changes in compilation time, and the fact that interest depends on time
|
|
assert round(trade.calc_close_trade_value(), 11) == round(0.003193788481706411, 11)
|
|
# Profit in BTC
|
|
assert round(trade.calc_profit(), 8) == round(0.00018628848193889054, 8)
|
|
# Profit in percent
|
|
assert round(trade.calc_profit_ratio(), 8) == round(0.18628848195329067, 8)
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_trade_close(fee):
|
|
"""
|
|
5 hour leveraged market trade on Kraken at 3x leverage
|
|
fee: 0.25% base
|
|
interest_rate: 0.05% per 4 hrs
|
|
open_rate: 0.1 base
|
|
close_rate: 0.2 base
|
|
amount: 5 * leverage(3) = 15 crypto
|
|
stake_amount: 0.5
|
|
borrowed: 1 base
|
|
time-periods: 5/4 periods of 4hrs
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 1 * 0.0005 * 5/4 = 0.000625 crypto
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (15 * 0.1) + (15 * 0.1 * 0.0025)
|
|
= 1.50375
|
|
close_value: (amount_closed * close_rate) + (amount_closed * close_rate * fee) - interest
|
|
= (15 * 0.2) - (15 * 0.2 * 0.0025) - 0.000625
|
|
= 2.9918750000000003
|
|
total_profit = close_value - open_value
|
|
= 2.9918750000000003 - 1.50375
|
|
= 1.4881250000000001
|
|
total_profit_percentage = total_profit / stake_amount
|
|
= 1.4881250000000001 / 0.5
|
|
= 2.9762500000000003
|
|
"""
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.5,
|
|
open_rate=0.1,
|
|
amount=15,
|
|
is_open=True,
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
open_date=datetime.utcnow() - timedelta(hours=5, minutes=0),
|
|
exchange='kraken',
|
|
leverage=3.0,
|
|
interest_rate=0.0005
|
|
)
|
|
assert trade.close_profit is None
|
|
assert trade.close_date is None
|
|
assert trade.is_open is True
|
|
trade.close(0.2)
|
|
assert trade.is_open is False
|
|
assert trade.close_profit == round(2.9762500000000003, 8)
|
|
assert trade.close_date is not None
|
|
|
|
# TODO-mg: Remove these comments probably
|
|
# new_date = arrow.Arrow(2020, 2, 2, 15, 6, 1).datetime,
|
|
# assert trade.close_date != new_date
|
|
# # Close should NOT update close_date if the trade has been closed already
|
|
# assert trade.is_open is False
|
|
# trade.close_date = new_date
|
|
# trade.close(0.02)
|
|
# assert trade.close_date == new_date
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_calc_close_trade_price(market_leveraged_buy_order, market_leveraged_sell_order, fee):
|
|
"""
|
|
10 minute leveraged market trade on Kraken at 3x leverage
|
|
Short trade
|
|
fee: 0.25% base
|
|
interest_rate: 0.05% per 4 hrs
|
|
open_rate: 0.00004099 base
|
|
close_rate: 0.00004173 base
|
|
amount: 91.99181073 * leverage(3) = 275.97543219 crypto
|
|
stake_amount: 0.0037707443218227
|
|
borrowed: 0.0075414886436454 base
|
|
time-periods: 10 minutes(rounds up to 1 time-period of 4hrs)
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0075414886436454 * 0.0005 * 1 = 3.7707443218227e-06 crypto
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (275.97543219 * 0.00004099) + (275.97543219 * 0.00004099 * 0.0025)
|
|
= 0.01134051354788177
|
|
close_value: (amount_closed * close_rate) - (amount_closed * close_rate * fee) - interest
|
|
= (275.97543219 * 0.00001234) - (275.97543219 * 0.00001234 * 0.0025) - 3.7707443218227e-06 = 0.003393252246819716
|
|
= (275.97543219 * 0.00001234) - (275.97543219 * 0.00001234 * 0.003) - 3.7707443218227e-06 = 0.003391549478403104
|
|
= (275.97543219 * 0.00004173) - (275.97543219 * 0.00004173 * 0.005) - 3.7707443218227e-06 = 0.011455101767040435
|
|
|
|
"""
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0037707443218227,
|
|
amount=5,
|
|
open_rate=0.00004099,
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
interest_rate=0.0005,
|
|
|
|
leverage=3.0,
|
|
exchange='kraken',
|
|
)
|
|
trade.open_order_id = 'close_trade'
|
|
trade.update(market_leveraged_buy_order) # Buy @ 0.00001099
|
|
# Get the close rate price with a custom close rate and a regular fee rate
|
|
assert isclose(trade.calc_close_trade_value(rate=0.00001234), 0.003393252246819716)
|
|
# Get the close rate price with a custom close rate and a custom fee rate
|
|
assert isclose(trade.calc_close_trade_value(rate=0.00001234, fee=0.003), 0.003391549478403104)
|
|
# Test when we apply a Sell order, and ask price with a custom fee rate
|
|
trade.update(market_leveraged_sell_order)
|
|
assert isclose(trade.calc_close_trade_value(fee=0.005), 0.011455101767040435)
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_update_limit_order(limit_leveraged_buy_order, limit_leveraged_sell_order, fee, caplog):
|
|
"""
|
|
10 minute leveraged limit trade on binance at 3x leverage
|
|
|
|
Leveraged trade
|
|
fee: 0.25% base
|
|
interest_rate: 0.05% per day
|
|
open_rate: 0.00001099 base
|
|
close_rate: 0.00001173 base
|
|
amount: 272.97543219 crypto
|
|
stake_amount: 0.0009999999999226999 base
|
|
borrowed: 0.0019999999998453998 base
|
|
time-periods: 10 minutes(rounds up to 1/24 time-period of 1 day)
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0019999999998453998 * 0.0005 * 1/24 = 4.166666666344583e-08 base
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (272.97543219 * 0.00001099) + (272.97543219 * 0.00001099 * 0.0025)
|
|
= 0.0030074999997675204
|
|
close_value: (amount_closed * close_rate) - (amount_closed * close_rate * fee)
|
|
= (272.97543219 * 0.00001173) - (272.97543219 * 0.00001173 * 0.0025)
|
|
= 0.003193996815039728
|
|
total_profit = close_value - open_value - interest
|
|
= 0.003193996815039728 - 0.0030074999997675204 - 4.166666666344583e-08
|
|
= 0.00018645514860554435
|
|
total_profit_percentage = total_profit / stake_amount
|
|
= 0.00018645514860554435 / 0.0009999999999226999
|
|
= 0.18645514861995735
|
|
|
|
"""
|
|
trade = Trade(
|
|
id=2,
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0009999999999226999,
|
|
open_rate=0.01,
|
|
amount=5,
|
|
is_open=True,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
leverage=3.0,
|
|
interest_rate=0.0005,
|
|
exchange='binance'
|
|
)
|
|
# assert trade.open_order_id is None
|
|
assert trade.close_profit is None
|
|
assert trade.close_date is None
|
|
|
|
# trade.open_order_id = 'something'
|
|
trade.update(limit_leveraged_buy_order)
|
|
# assert trade.open_order_id is None
|
|
assert trade.open_rate == 0.00001099
|
|
assert trade.close_profit is None
|
|
assert trade.close_date is None
|
|
assert trade.borrowed == 0.0019999999998453998
|
|
assert log_has_re(r"LIMIT_BUY has been fulfilled for Trade\(id=2, "
|
|
r"pair=ETH/BTC, amount=272.97543219, open_rate=0.00001099, open_since=.*\).",
|
|
caplog)
|
|
caplog.clear()
|
|
# trade.open_order_id = 'something'
|
|
trade.update(limit_leveraged_sell_order)
|
|
# assert trade.open_order_id is None
|
|
assert trade.close_rate == 0.00001173
|
|
assert trade.close_profit == round(0.18645514861995735, 8)
|
|
assert trade.close_date is not None
|
|
assert log_has_re(r"LIMIT_SELL has been fulfilled for Trade\(id=2, "
|
|
r"pair=ETH/BTC, amount=272.97543219, open_rate=0.00001099, open_since=.*\).",
|
|
caplog)
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_update_market_order(market_leveraged_buy_order, market_leveraged_sell_order, fee, caplog):
|
|
"""
|
|
10 minute leveraged market trade on Kraken at 3x leverage
|
|
Short trade
|
|
fee: 0.25% base
|
|
interest_rate: 0.05% per 4 hrs
|
|
open_rate: 0.00004099 base
|
|
close_rate: 0.00004173 base
|
|
amount: = 275.97543219 crypto
|
|
stake_amount: 0.0037707443218227
|
|
borrowed: 0.0075414886436454 base
|
|
time-periods: 10 minutes(rounds up to 1 time-period of 4hrs)
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0075414886436454 * 0.0005 * 1 = 3.7707443218227e-06 crypto
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (275.97543219 * 0.00004099) + (275.97543219 * 0.00004099 * 0.0025)
|
|
= 0.01134051354788177
|
|
close_value: (amount_closed * close_rate) - (amount_closed * close_rate * fee)
|
|
= (275.97543219 * 0.00004173) - (275.97543219 * 0.00004173 * 0.0025)
|
|
= 0.011487663648325479
|
|
total_profit = close_value - open_value - interest
|
|
= 0.011487663648325479 - 0.01134051354788177 - 3.7707443218227e-06
|
|
= 0.0001433793561218866
|
|
total_profit_percentage = total_profit / stake_amount
|
|
= 0.0001433793561218866 / 0.0037707443218227
|
|
= 0.03802415223225211
|
|
"""
|
|
trade = Trade(
|
|
id=1,
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0037707443218227,
|
|
amount=5,
|
|
open_rate=0.00004099,
|
|
is_open=True,
|
|
leverage=3,
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
interest_rate=0.0005,
|
|
exchange='kraken'
|
|
)
|
|
trade.open_order_id = 'something'
|
|
trade.update(market_leveraged_buy_order)
|
|
assert trade.leverage == 3.0
|
|
assert trade.open_order_id is None
|
|
assert trade.open_rate == 0.00004099
|
|
assert trade.close_profit is None
|
|
assert trade.close_date is None
|
|
assert trade.interest_rate == 0.0005
|
|
# TODO: Uncomment the next assert and make it work.
|
|
# The logger also has the exact same but there's some spacing in there
|
|
assert log_has_re(r"MARKET_BUY has been fulfilled for Trade\(id=1, "
|
|
r"pair=ETH/BTC, amount=275.97543219, open_rate=0.00004099, open_since=.*\).",
|
|
caplog)
|
|
caplog.clear()
|
|
trade.is_open = True
|
|
trade.open_order_id = 'something'
|
|
trade.update(market_leveraged_sell_order)
|
|
assert trade.open_order_id is None
|
|
assert trade.close_rate == 0.00004173
|
|
assert trade.close_profit == round(0.03802415223225211, 8)
|
|
assert trade.close_date is not None
|
|
# TODO: The amount should maybe be the opening amount + the interest
|
|
# TODO: Uncomment the next assert and make it work.
|
|
# The logger also has the exact same but there's some spacing in there
|
|
assert log_has_re(r"MARKET_SELL has been fulfilled for Trade\(id=1, "
|
|
r"pair=ETH/BTC, amount=275.97543219, open_rate=0.00004099, open_since=.*\).",
|
|
caplog)
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_calc_close_trade_price_exception(limit_leveraged_buy_order, fee):
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.001,
|
|
open_rate=0.1,
|
|
amount=5,
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='binance',
|
|
interest_rate=0.0005,
|
|
leverage=3.0
|
|
)
|
|
trade.open_order_id = 'something'
|
|
trade.update(limit_leveraged_buy_order)
|
|
assert trade.calc_close_trade_value() == 0.0
|
|
|
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
|
def test_calc_profit(market_leveraged_buy_order, market_leveraged_sell_order, fee):
|
|
"""
|
|
# TODO: Update this one
|
|
Leveraged trade on Kraken at 3x leverage
|
|
fee: 0.25% base or 0.3%
|
|
interest_rate: 0.05%, 0.25% per 4 hrs
|
|
open_rate: 0.00004099 base
|
|
close_rate: 0.00004173 base
|
|
stake_amount: 0.0037707443218227
|
|
amount: 91.99181073 * leverage(3) = 275.97543219 crypto
|
|
borrowed: 0.0075414886436454 base
|
|
time-periods: 10 minutes(rounds up to 1 time-period of 4hrs)
|
|
5 hours = 5/4
|
|
|
|
interest: borrowed * interest_rate * time-periods
|
|
= 0.0075414886436454 * 0.0005 * 1 = 3.7707443218227e-06 crypto
|
|
= 0.0075414886436454 * 0.00025 * 5/4 = 2.3567152011391876e-06 crypto
|
|
= 0.0075414886436454 * 0.0005 * 5/4 = 4.713430402278375e-06 crypto
|
|
= 0.0075414886436454 * 0.00025 * 1 = 1.88537216091135e-06 crypto
|
|
open_value: (amount * open_rate) + (amount * open_rate * fee)
|
|
= (275.97543219 * 0.00004099) + (275.97543219 * 0.00004099 * 0.0025) = 0.01134051354788177
|
|
close_value: (amount_closed * close_rate) - (amount_closed * close_rate * fee) - interest
|
|
(275.97543219 * 0.00005374) - (275.97543219 * 0.00005374 * 0.0025) - 3.7707443218227e-06 = 0.01479007168225405
|
|
(275.97543219 * 0.00000437) - (275.97543219 * 0.00000437 * 0.0025) - 2.3567152011391876e-06 = 0.001200640891872485
|
|
(275.97543219 * 0.00005374) - (275.97543219 * 0.00005374 * 0.003) - 4.713430402278375e-06 = 0.014781713536310649
|
|
(275.97543219 * 0.00000437) - (275.97543219 * 0.00000437 * 0.003) - 1.88537216091135e-06 = 0.0012005092285933775
|
|
total_profit = close_value - open_value
|
|
= 0.01479007168225405 - 0.01134051354788177 = 0.003449558134372281
|
|
= 0.001200640891872485 - 0.01134051354788177 = -0.010139872656009285
|
|
= 0.014781713536310649 - 0.01134051354788177 = 0.0034411999884288794
|
|
= 0.0012005092285933775 - 0.01134051354788177 = -0.010140004319288392
|
|
total_profit_percentage = total_profit / stake_amount
|
|
0.003449558134372281/0.0037707443218227 = 0.9148215418394732
|
|
-0.010139872656009285/0.0037707443218227 = -2.6890904793852157
|
|
0.0034411999884288794/0.0037707443218227 = 0.9126049646255184
|
|
-0.010140004319288392/0.0037707443218227 = -2.6891253964381554
|
|
|
|
"""
|
|
trade = Trade(
|
|
pair='ETH/BTC',
|
|
stake_amount=0.0037707443218227,
|
|
amount=5,
|
|
open_rate=0.00004099,
|
|
open_date=datetime.utcnow() - timedelta(hours=0, minutes=10),
|
|
fee_open=fee.return_value,
|
|
fee_close=fee.return_value,
|
|
exchange='kraken',
|
|
leverage=3.0,
|
|
interest_rate=0.0005
|
|
)
|
|
trade.open_order_id = 'something'
|
|
trade.update(market_leveraged_buy_order) # Buy @ 0.00001099
|
|
# Custom closing rate and regular fee rate
|
|
|
|
# Higher than open rate
|
|
assert trade.calc_profit(rate=0.00005374, interest_rate=0.0005) == round(
|
|
0.003449558134372281, 8)
|
|
assert trade.calc_profit_ratio(
|
|
rate=0.00005374, interest_rate=0.0005) == round(0.9148215418394732, 8)
|
|
|
|
# Lower than open rate
|
|
trade.open_date = datetime.utcnow() - timedelta(hours=5, minutes=0)
|
|
assert trade.calc_profit(
|
|
rate=0.00000437, interest_rate=0.00025) == round(-0.010139872656009285, 8)
|
|
assert trade.calc_profit_ratio(
|
|
rate=0.00000437, interest_rate=0.00025) == round(-2.6890904793852157, 8)
|
|
|
|
# Custom closing rate and custom fee rate
|
|
# Higher than open rate
|
|
assert trade.calc_profit(rate=0.00005374, fee=0.003,
|
|
interest_rate=0.0005) == round(0.0034411999884288794, 8)
|
|
assert trade.calc_profit_ratio(rate=0.00005374, fee=0.003,
|
|
interest_rate=0.0005) == round(0.9126049646255184, 8)
|
|
|
|
# Lower than open rate
|
|
trade.open_date = datetime.utcnow() - timedelta(hours=0, minutes=10)
|
|
assert trade.calc_profit(rate=0.00000437, fee=0.003,
|
|
interest_rate=0.00025) == round(-0.010140004319288392, 8)
|
|
assert trade.calc_profit_ratio(rate=0.00000437, fee=0.003,
|
|
interest_rate=0.00025) == round(-2.6891253964381554, 8)
|
|
|
|
# Test when we apply a Sell order. Sell higher than open rate @ 0.00001173
|
|
trade.update(market_leveraged_sell_order)
|
|
assert trade.calc_profit() == round(0.0001433793561218866, 8)
|
|
assert trade.calc_profit_ratio() == round(0.03802415223225211, 8)
|
|
|
|
# Test with a custom fee rate on the close trade
|
|
# assert trade.calc_profit(fee=0.003) == 0.00006163
|
|
# assert trade.calc_profit_ratio(fee=0.003) == 0.06147824
|