diff --git a/fastlane_bot/testing.py b/fastlane_bot/testing.py
index cf47d1c2f..1267ed662 100644
--- a/fastlane_bot/testing.py
+++ b/fastlane_bot/testing.py
@@ -67,7 +67,7 @@ class VersionRequirementNotMetError(RuntimeError): pass
def _split_version_str(vstr):
"""splits version mumber string into tuple (int, int, int, ...)"""
- m = _re.match("^([0-9\.]*)", vstr.strip())
+ m = _re.match(r"^([0-9\.]*)", vstr.strip())
if m is None:
raise ValueError("Invalid version number string", vstr)
vlst = tuple(int(x) for x in m.group(0).split("."))
diff --git a/fastlane_bot/tests/nbtest/test_003_Serialization.py b/fastlane_bot/tests/nbtest/test_003_Serialization.py
index 12076f10f..7a894fbf4 100644
--- a/fastlane_bot/tests/nbtest/test_003_Serialization.py
+++ b/fastlane_bot/tests/nbtest/test_003_Serialization.py
@@ -31,23 +31,30 @@
def notest_optimizer_pickling():
# ------------------------------------------------------------
- N=5
- curves = [
- CPC.from_xy(x=1, y=2000, pair="ETH/USDC"),
- CPC.from_xy(x=1, y=2200, pair="ETH/USDC"),
- CPC.from_xy(x=1, y=2400, pair="ETH/USDC"),
- ]
- # note: the below is a bit icky as the same curve objects are added multiple times
- CC = CPCContainer(curves*N)
- O = CPCArbOptimizer(CC)
- O.CC.asdf()
+ pass
- O.pickle("delme")
- O.pickle("delme", addts=False)
+ # +
+ # N=5
+ # curves = [
+ # CPC.from_xy(x=1, y=2000, pair="ETH/USDC"),
+ # CPC.from_xy(x=1, y=2200, pair="ETH/USDC"),
+ # CPC.from_xy(x=1, y=2400, pair="ETH/USDC"),
+ # ]
+
+ # CC = CPCContainer(curves*N)
+ # O = CPCArbOptimizer(CC)
+ # O.CC.asdf()
- # !ls *.pickle
+ # +
+ # O.pickle("delme")
+ # O.pickle("delme", addts=False)
- O.unpickle("delme")
+ # +
+
+
+ # +
+ # O.unpickle("delme")
+ # -
# ------------------------------------------------------------
@@ -92,6 +99,7 @@ def test_creating_curves():
'x': 100,
'x_act': 100,
'y_act': 100,
+ 'alpha': 0.5,
'pair': 'TKNB/TKNQ',
'cid': "1",
'fee': 0,
@@ -278,7 +286,7 @@ def test_serializing_curves():
df = CC.asdf()
assert len(df) == 3
- assert tuple(df.reset_index().columns) == ('cid', 'k', 'x', 'x_act', 'y_act',
+ assert tuple(df.reset_index().columns) == ('cid', 'k', 'x', 'x_act', 'y_act', 'alpha',
'pair', 'fee', 'descr', 'constr', 'params')
assert tuple(df["k"]) == (2000, 8040, 1970)
assert CPCContainer.from_df(df) == CC
@@ -395,4 +403,6 @@ def notest_saving_curves():
+
+
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_037_Exchanges.py b/fastlane_bot/tests/nbtest/test_037_Exchanges.py
index 29fcdf253..944353a3a 100644
--- a/fastlane_bot/tests/nbtest/test_037_Exchanges.py
+++ b/fastlane_bot/tests/nbtest/test_037_Exchanges.py
@@ -39,6 +39,7 @@
mocked_contract.functions.token0.return_value.call.return_value = 'token0'
mocked_contract.functions.token1.return_value.call.return_value = 'token1'
mocked_contract.functions.fee.return_value.call.return_value = 3000
+mocked_contract.functions.tradingFeePPM.return_value.call.return_value = 2000
# ------------------------------------------------------------
@@ -107,7 +108,7 @@ def test_test_carbon_v1_exchange_update():
carbon_v1_exchange = CarbonV1()
assert (carbon_v1_exchange.get_abi() == CARBON_CONTROLLER_ABI)
- assert (carbon_v1_exchange.get_fee('', mocked_contract) == ('0.002', 0.002))
+ assert (carbon_v1_exchange.get_fee('', mocked_contract) == ('2000', 0.002))
assert (carbon_v1_exchange.get_tkn0('', mocked_contract, setup_data['carbon_v1_event_update']) == setup_data['carbon_v1_event_update']['args']['token0'])
@@ -121,7 +122,7 @@ def test_test_carbon_v1_exchange_create():
carbon_v1_exchange = CarbonV1()
assert (carbon_v1_exchange.get_abi() == CARBON_CONTROLLER_ABI)
- assert (carbon_v1_exchange.get_fee('', mocked_contract) == ('0.002', 0.002))
+ assert (carbon_v1_exchange.get_fee('', mocked_contract) == ('2000', 0.002))
assert (carbon_v1_exchange.get_tkn0('', mocked_contract, setup_data['carbon_v1_event_create']) == setup_data['carbon_v1_event_create']['args']['token0'])
diff --git a/fastlane_bot/tests/nbtest/test_038_TestBancorV3Mode.py b/fastlane_bot/tests/nbtest/test_038_TestBancorV3Mode.py
index f1eb2a048..cc7f317d8 100644
--- a/fastlane_bot/tests/nbtest/test_038_TestBancorV3Mode.py
+++ b/fastlane_bot/tests/nbtest/test_038_TestBancorV3Mode.py
@@ -196,17 +196,7 @@ def init_bot(mgr: Manager) -> CarbonBot:
assert pool.cid in pool_cids, f"[test_bancor_v3] Validation missing pool.cid {pool.cid} in {pool_cids}"
optimal_arb = finder.get_optimal_arb_trade_amts(pool_cids, 'BNT-FF1C')
assert type(optimal_arb) == float, f"[test_bancor_v3] Optimal arb calculation type is {type(optimal_arb)} not float"
-assert iseq(optimal_arb, 5003.2368760578265), f"[test_bancor_v3] Optimal arb calculation type is {optimal_arb}, expected 5003.2368760578265"
-
-
-
-
-
-
-
-
-
-
+assert iseq(optimal_arb, 4051.1611717583105), f"[test_bancor_v3] Optimal arb calculation type is {optimal_arb}, expected 4051.1611717583105"
# ------------------------------------------------------------
# Test 038
@@ -282,7 +272,7 @@ def test_test_get_fee_safe():
)
ext_fee = finder.get_fee_safe(first_check_pools[1].fee)
assert type(ext_fee) == float, f"[test_bancor_v3] Testing external pool, fee type is {type(ext_fee)} not float"
- assert iseq(ext_fee, 0.003), f"[test_bancor_v3] Testing external pool, fee amt is {ext_fee} not 0.003"
+ assert iseq(ext_fee, 0.0005), f"[test_bancor_v3] Testing external pool, fee amt is {ext_fee} not 0.0005"
# ------------------------------------------------------------
diff --git a/fastlane_bot/tests/nbtest/test_048_RespectFlashloanTokensClickParam.py b/fastlane_bot/tests/nbtest/test_048_RespectFlashloanTokensClickParam.py
new file mode 100644
index 000000000..8d553c5c2
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_048_RespectFlashloanTokensClickParam.py
@@ -0,0 +1,100 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_048_RespectFlashloanTokensClickParam.py`
+# ------------------------------------------------------------
+# source file = NBTest_048_RespectFlashloanTokensClickParam.py
+# test id = 048
+# test comment = RespectFlashloanTokensClickParam
+# ------------------------------------------------------------
+
+
+
+"""
+This module contains the tests which ensure that the flashloan tokens click parameters are respected.
+"""
+from fastlane_bot import Bot
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
+import subprocess, os, sys
+import pytest
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
+from fastlane_bot.testing import *
+plt.rcParams['figure.figsize'] = [12,6]
+from fastlane_bot import __VERSION__
+require("3.0", __VERSION__)
+
+
+
+
+def find_main_py():
+ # Start at the directory of the current script
+ cwd = os.path.abspath(os.path.join(os.getcwd()))
+
+ print(f"Searching for main.py in {cwd}")
+ while True:
+ # Check if main.py exists in the current directory
+ if "main.py" in os.listdir(cwd):
+ return cwd # Found the directory containing main.py
+ else:
+ # If not, go up one directory
+ new_cwd = os.path.dirname(cwd)
+
+ # If we're already at the root directory, stop searching
+ if new_cwd == cwd:
+ raise FileNotFoundError("Could not find main.py in any parent directory")
+
+ cwd = new_cwd
+
+
+def run_command(arb_mode, expected_log_line):
+
+ # Find the correct path to main.py
+ main_script_path = find_main_py()
+ print(f"Found main.py in {main_script_path}")
+ main_script_path = main_script_path + "/main.py"
+
+ # Run the command
+ cmd = [
+ "python",
+ main_script_path,
+ f"--arb_mode={arb_mode}",
+ "--default_min_profit_bnt=60",
+ "--limit_bancor3_flashloan_tokens=False",
+ "--use_cached_events=True",
+ "--logging_path=fastlane_bot/data/",
+ "--timeout=1",
+ "--loglevel=DEBUG",
+ "--flashloan_tokens=BNT-FF1C,ETH-EEeE,ETH2X-FLI-USD",
+ ]
+ subprocess.Popen(cmd)
+
+ # Wait for the expected log line to appear
+ found = False
+ result = subprocess.run(cmd, text=True, capture_output=True, check=True, timeout=7)
+
+ # Check if the expected log line is in the output
+ if expected_log_line in result.stderr or expected_log_line in result.stdout:
+ found = True
+
+ if not found:
+ pytest.fail("Expected log line was not found within 1 minute") # If we reach this point, the test has failed
+
+
+
+
+# ------------------------------------------------------------
+# Test 048
+# File test_048_RespectFlashloanTokensClickParam.py
+# Segment Test flashloan_tokens is Respected
+# ------------------------------------------------------------
+def test_test_flashloan_tokens_is_respected():
+# ------------------------------------------------------------
+
+ expected_log_line = "Flashloan tokens are set as: ['BNT-FF1C', 'ETH-EEeE', 'ETH2X_FLI-USD']"
+ arb_mode = "multi"
+ run_command(arb_mode=arb_mode, expected_log_line=expected_log_line)
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_049_CPCBalancer.py b/fastlane_bot/tests/nbtest/test_049_CPCBalancer.py
new file mode 100644
index 000000000..2e5d4b1b4
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_049_CPCBalancer.py
@@ -0,0 +1,556 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_049_CPCBalancer.py`
+# ------------------------------------------------------------
+# source file = NBTest_049_CPCBalancer.py
+# test id = 049
+# test comment = CPCBalancer
+# ------------------------------------------------------------
+
+
+
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+#from flbtools.cpc import ConstantProductCurve as CPC
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+
+from fastlane_bot.testing import *
+#from flbtesting import *
+from math import sqrt
+
+
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CPCBalancer.py
+# Segment Constant product constructor
+# ------------------------------------------------------------
+def test_constant_product_constructor():
+# ------------------------------------------------------------
+
+ c0 = CPC.from_xy(100, 200)
+ assert c0.x == 100
+ assert c0.y == 200
+ assert c0.k == 20000
+ assert c0.x == c0.x_act
+ assert c0.y == c0.y_act
+ assert c0.alpha == 0.5
+ assert c0.eta == 1
+ assert c0.constr == "xy"
+ assert c0.is_constant_product() == True
+ c0
+
+ assert c0.asdict() == {
+ 'k': 20000,
+ 'x': 100,
+ 'x_act': 100,
+ 'y_act': 200.0,
+ 'alpha': 0.5,
+ 'pair': 'TKNB/TKNQ',
+ 'cid': 'None',
+ 'fee': None,
+ 'descr': None,
+ 'constr': 'xy',
+ 'params': {}
+ }
+
+ c1 = CPC.from_xyal(100, 200)
+ assert c1.constr == "xyal"
+ assert c1.is_constant_product() == True
+ assert c1==c0
+ c1
+
+ assert c1.asdict() == {
+ 'k': 20000,
+ 'x': 100,
+ 'x_act': 100,
+ 'y_act': 200.0,
+ 'alpha': 0.5,
+ 'pair': 'TKNB/TKNQ',
+ 'cid': 'None',
+ 'fee': None,
+ 'descr': None,
+ 'constr': 'xyal',
+ 'params': {}
+ }
+
+ c2 = CPC.from_xyal(100, 200, alpha=0.5)
+ assert c2.constr == "xyal"
+ assert c2.is_constant_product() == True
+ assert c2==c0
+ assert c2.asdict() == c1.asdict()
+ c2
+
+ c3 = CPC.from_xyal(100, 200, eta=1)
+ assert c3.constr == "xyal"
+ assert c3.is_constant_product() == True
+ assert c3==c0
+ assert c3.asdict() == c1.asdict()
+ c3
+
+ assert raises(CPC.from_xyal, 100, 200,
+ alpha=0.5, eta=1) == 'at most one of alpha and eta must be given [0.5, 1]'
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CPCBalancer.py
+# Segment Weighted constructor
+# ------------------------------------------------------------
+def test_weighted_constructor():
+# ------------------------------------------------------------
+
+ c0 = CPC.from_xy(100, 200)
+ assert c0.x == 100
+ assert c0.y == 200
+ assert c0.k == 20000
+ assert c0.x == c0.x_act
+ assert c0.y == c0.y_act
+ assert c0.alpha == 0.5
+ assert c0.eta == 1
+ assert c0.constr == "xy"
+ assert c0.is_constant_product() == True
+ c0
+
+ c1 = CPC.from_xyal(100, 200)
+ assert c1.constr == "xyal"
+ assert c1.is_constant_product() == True
+ assert c1 == c0
+ assert c1.asdict()["alpha"] == 0.5
+ c1
+
+ c2 = CPC.from_xyal(100, 200, alpha=0.25)
+ assert c2.constr == "xyal"
+ assert c2.is_constant_product() == False
+ assert c2.alpha == 0.25
+ assert c2.asdict()["alpha"] == 0.25
+ assert iseq(c2.eta, 0.25/0.75)
+ assert c2 != c0
+ assert c2 != c1
+ c2
+
+ c3 = CPC.from_xyal(100, 200, alpha=0.8)
+ assert c3.constr == "xyal"
+ assert c3.is_constant_product() == False
+ assert iseq(c3.alpha, 0.8)
+ assert c3.asdict()["alpha"] == 0.8
+ assert iseq(c3.eta, 0.8/0.2)
+ assert c3 != c0
+ assert c3 != c1
+ assert c3 != c2
+ c2
+
+ c3b = CPC.fromdict(c3.asdict())
+ assert c3b == c3
+ c3b
+
+ assert raises(CPC.from_xyal,100, 200, alpha=0) == 'alpha must be > 0 [0]'
+ assert raises(CPC.from_xyal,100, 200, alpha=-1) == 'alpha must be > 0 [-1]'
+ assert raises(CPC.from_xyal,100, 200, alpha=1) == 'alpha must be < 1 [1]'
+ assert raises(CPC.from_xyal,100, 200, alpha=2) == 'alpha must be < 1 [2]'
+
+ raises(CPC.from_xyal,100, 200, alpha=0)
+
+ assert not raises(CPC.from_xyal,100, 200, alpha=1-1e-10)
+ assert not raises(CPC.from_xyal,100, 200, alpha=0.01)
+
+ raises(CPC.from_xyal,100, 200, alpha=0.001)
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CPCBalancer.py
+# Segment High level testing of all functions
+# ------------------------------------------------------------
+def test_high_level_testing_of_all_functions():
+# ------------------------------------------------------------
+ #
+ # (including not YET implemented)
+
+ c0 = CPC.from_xyal(100, 200)
+ assert c0.is_constant_product() == True
+ c0
+
+ c1 = CPC.from_xyal(100, 200, alpha=0.25)
+ assert c1.is_constant_product() == False
+ c1
+
+ # #### Not (yet) implemented functions
+ #
+ # Those function groups are not currently planned to be implemented at all
+ #
+ # - `execute` as there is no need to simulate those curves for the time being; that was a Carbon thing
+ #
+ # The functions we may implement at a later stage are
+ #
+ # - `description` should probably be updated, but it is tedious; `format` ditto
+ # - `x_max`, `x_min`, `p_max`, `p_min` and the other leverage functions once we consider it important and safe
+
+ # execute
+
+ assert not raises(c0.execute)
+ assert raises(c1.execute).startswith("only implemented for")
+
+ # description and format
+
+ assert not raises(c0.description)
+ assert raises(c1.description).startswith("only implemented for")
+
+ assert not raises(c0.format)
+ assert raises(c1.format).startswith("only implemented for")
+
+ # leverage related functions (primary)
+
+ assert not raises(lambda: c0.p_max)
+ assert raises(lambda: c1.p_max).startswith("only implemented for")
+
+ assert not raises(lambda: c0.p_min)
+ assert raises(lambda: c1.p_min).startswith("only implemented for")
+
+ assert not raises(lambda: c0.x_min)
+ assert raises(lambda: c1.x_min).startswith("only implemented for")
+
+ assert not raises(lambda: c0.x_max)
+ assert raises(lambda: c1.x_max).startswith("only implemented for")
+
+ assert not raises(lambda: c0.y_min)
+ assert raises(lambda: c1.y_min).startswith("only implemented for")
+
+ assert not raises(lambda: c0.y_max)
+ assert raises(lambda: c1.y_max).startswith("only implemented for")
+
+ # leverage related functions (secondary, ie calling primary ones)
+
+ assert not raises(c0.p_max_primary)
+ assert raises(c1.p_max_primary).startswith("only implemented for")
+
+ assert not raises(c0.p_min_primary)
+ assert raises(c1.p_min_primary).startswith("only implemented for")
+
+ assert not raises(lambda: c0.at_xmin)
+ assert raises(lambda: c1.at_xmin).startswith("only implemented for")
+
+ assert not raises(lambda: c0.at_xmax)
+ assert raises(lambda: c1.at_xmax).startswith("only implemented for")
+
+ assert not raises(lambda: c0.at_ymin)
+ assert raises(lambda: c1.at_ymin).startswith("only implemented for")
+
+ assert not raises(lambda: c0.at_ymax)
+ assert raises(lambda: c1.at_ymax).startswith("only implemented for")
+
+ assert not raises(lambda: c0.at_boundary)
+ assert raises(lambda: c1.at_boundary).startswith("only implemented for")
+
+ # todo
+
+ assert not raises(c0.xyfromp_f)
+ assert raises(c1.xyfromp_f).startswith("only implemented for")
+
+ assert not raises(c0.dxdyfromp_f)
+ assert raises(c1.dxdyfromp_f).startswith("only implemented for")
+
+ # #### Implemented functions
+
+ assert not raises(lambda: c0.y)
+ assert not raises(lambda: c1.y)
+
+ assert not raises(lambda: c0.p)
+ assert not raises(lambda: c1.p)
+
+ assert not raises(lambda: c0.kbar)
+ assert not raises(lambda: c1.kbar)
+
+ assert not raises(c0.tvl)
+ assert not raises(c1.tvl)
+
+ assert not raises(c0.yfromx_f, 110)
+ assert not raises(c1.yfromx_f, 110, ignorebounds=True)
+ assert raises(c1.yfromx_f, 110, ignorebounds=False)
+
+ assert not raises(c0.xfromy_f, 210)
+ assert not raises(c1.xfromy_f, 110, ignorebounds=True)
+ assert raises(c1.xfromy_f, 110, ignorebounds=False)
+
+ assert not raises(c0.dyfromdx_f, 1)
+ assert not raises(c1.dyfromdx_f, 1, ignorebounds=True)
+ assert raises(c1.dyfromdx_f, 1, ignorebounds=False)
+
+ assert not raises(c0.dxfromdy_f, 1)
+ assert not raises(c1.dxfromdy_f, 1, ignorebounds=True)
+ assert raises(c1.dxfromdy_f, 1, ignorebounds=False)
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CPCBalancer.py
+# Segment Simple Tests
+# ------------------------------------------------------------
+def test_simple_tests():
+# ------------------------------------------------------------
+
+ c0 = CPC.from_xyal(100, 200)
+ c1 = CPC.from_xyal(100, 200, eta=2)
+ c2 = CPC.from_xyal(100, 200, eta=0.5)
+
+ assert iseq(c0.alpha, 1/2)
+ assert iseq(c1.alpha, 2/3)
+ assert iseq(c2.alpha, 1/3)
+
+ # #### Current token balance $y$
+ #
+ # $$
+ # y = \left( \frac k x \right)^\eta
+ # $$
+
+ assert iseq(c0.y, 200)
+ assert iseq(c1.y, 200)
+ assert iseq(c2.y, 200)
+
+ # #### Current price $p$
+ #
+ # $$
+ # p = \eta\, \frac y x
+ # $$
+
+ assert iseq(c0.p, 2 * c0.eta)
+ assert iseq(c1.p, 2 * c1.eta)
+ assert iseq(c2.p, 2 * c2.eta)
+
+ # #### TVL
+ #
+ # $$
+ # \mathrm{TVL} = x_a*p + y_a
+ # $$
+
+ assert c0.x == c0.x_act
+ assert c0.y == c0.y_act
+ assert c1.x == c1.x_act
+ assert c1.y == c1.y_act
+ assert c2.x == c2.x_act
+ assert c2.y == c2.y_act
+
+ assert iseq(c0.tvl(), 100 * c0.p + 200)
+ assert iseq(c1.tvl(), 100 * c1.p + 200)
+ assert iseq(c2.tvl(), 100 * c2.p + 200)
+
+ # #### Pool constant $k$
+ #
+ # $$
+ # k^\alpha = x^\alpha\, y^{1-\alpha}
+ # $$
+ #
+ # $$
+ # k = x\,y^\frac{1-\alpha}{\alpha} = x\,y^{\frac 1 \eta}
+ # $$
+ #
+
+ assert iseq(c0.k**(1/2), c0.x**(1/2) * c0.y**(1/2))
+ assert iseq(c1.k**(2/3), c1.x**(2/3) * c1.y**(1/3))
+ assert iseq(c2.k**(1/3), c1.x**(1/3) * c1.y**(2/3))
+
+ # #### Pool constant $\bar k$
+ #
+ # $$
+ # x^\alpha\, y^{1-\alpha} = \bar k = k^\alpha
+ # $$
+
+ assert iseq(c0.kbar, c0.x**(1/2) * c0.y**(1/2))
+ assert iseq(c1.kbar, c1.x**(2/3) * c1.y**(1/3))
+ assert iseq(c2.kbar, c1.x**(1/3) * c1.y**(2/3))
+
+ assert iseq(c0.kbar, c0.k**c0.alpha)
+ assert iseq(c1.kbar, c1.k**c1.alpha)
+ assert iseq(c2.kbar, c2.k**c2.alpha)
+
+ # #### Token balance function $y(x)$
+ #
+ # $$
+ # y(x) = \left( \frac k x \right)^\eta
+ # $$
+
+ assert c0.eta == 1
+ assert iseq(c0.yfromx_f(100, ignorebounds=True), 200)
+ assert iseq(c0.yfromx_f( 50, ignorebounds=True), 400)
+ assert iseq(c0.yfromx_f(200, ignorebounds=True), 100)
+
+ assert iseq(c1.eta, 2)
+ assert iseq(c1.yfromx_f(100, ignorebounds=True), 200)
+ assert iseq(c1.yfromx_f( 50, ignorebounds=True), 200*2**2)
+ assert iseq(c1.yfromx_f(200, ignorebounds=True), 200/2**2)
+
+ assert iseq(c2.eta, 1/2)
+ assert iseq(c2.yfromx_f(100, ignorebounds=True), 200)
+ assert iseq(c2.yfromx_f( 50, ignorebounds=True), 200*sqrt(2))
+ assert iseq(c2.yfromx_f(200, ignorebounds=True), 200/sqrt(2))
+
+ # #### Token balance function $x(y)$
+ #
+ # $$
+ # x(y)
+ # = \frac{k}{ y^{\frac{1-\alpha}{\alpha}} }
+ # = \frac{k}{ y^{\frac{1}{\eta}} }
+ # $$
+
+ assert c0.eta == 1
+ assert iseq(c0.xfromy_f(200, ignorebounds=True), 100)
+ assert iseq(c0.xfromy_f(100, ignorebounds=True), 200)
+ assert iseq(c0.xfromy_f(400, ignorebounds=True), 50)
+
+ assert iseq(c1.eta, 2)
+ assert iseq(c1.xfromy_f(200, ignorebounds=True), 100)
+ assert iseq(c1.xfromy_f(100, ignorebounds=True), 100*2**0.5)
+ assert iseq(c1.xfromy_f(400, ignorebounds=True), 100/2**0.5)
+
+ assert iseq(c2.eta, 1/2)
+ assert iseq(c2.xfromy_f(200, ignorebounds=True), 100)
+ assert iseq(c2.xfromy_f(100, ignorebounds=True), 100*2**2)
+ assert iseq(c2.xfromy_f(400, ignorebounds=True), 100/2**2)
+
+ # #### Price response function $(x(p), y(p))$
+ #
+ # $$
+ # x(p)
+ # =
+ # \left(\frac \eta p\right)^{1-\alpha} k^\alpha
+ # $$
+ #
+ # $$
+ # y(p) = \left( \frac{kp}{\eta} \right)^\alpha
+ # $$
+
+ assert iseq(c0.xyfromp_f(c0.p, ignorebounds=True)[0], c0.x)
+ assert iseq(c1.xyfromp_f(c1.p, ignorebounds=True)[0], c1.x)
+ assert iseq(c2.xyfromp_f(c2.p, ignorebounds=True)[0], c2.x)
+
+ assert iseq(c0.xyfromp_f(c0.p, ignorebounds=True)[1], c0.y)
+ assert iseq(c1.xyfromp_f(c1.p, ignorebounds=True)[1], c1.y)
+ assert iseq(c2.xyfromp_f(c2.p, ignorebounds=True)[1], c2.y)
+
+ for ci in [c0, c1, c2]:
+ for p in [2, 1, 4]:
+ eta_over_p = ci.eta / p
+ x = eta_over_p ** (1-ci.alpha) * ci.kbar
+ y = 1/eta_over_p**ci.alpha * ci.kbar
+ xx, yy, pp = ci.xyfromp_f (p, ignorebounds=True)
+ dx, dy, _ = ci.dxdyfromp_f(p, ignorebounds=True)
+ assert iseq(x, xx)
+ assert iseq(y, yy)
+ assert iseq(p, pp)
+ assert iseq(dx, xx-ci.x)
+ assert iseq(dy, yy-ci.y)
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CPCBalancer.py
+# Segment Consistency tests
+# ------------------------------------------------------------
+def test_consistency_tests():
+# ------------------------------------------------------------
+
+ c0 = CPC.from_xyal(100, 200)
+ c1 = CPC.from_xyal(100, 200, eta=2)
+ c2 = CPC.from_xyal(100, 200, eta=0.5)
+ cc = [c0, c1, c2]
+
+ assert iseq(c0.alpha, 1/2)
+ assert iseq(c1.alpha, 2/3)
+ assert iseq(c2.alpha, 1/3)
+
+ # ### Assert inversions
+ #
+ # $$
+ # y(x(y)) = y
+ # $$
+ #
+ # and vice versa
+
+ for xy in np.logspace(1, 3, 100):
+ for ci in cc:
+ #print(f"xy={xy}, eta={ci.eta}")
+ assert iseq(ci.yfromx_f(ci.xfromy_f(xy, ignorebounds=True), ignorebounds=True), xy)
+ assert iseq(ci.xfromy_f(ci.yfromx_f(xy, ignorebounds=True), ignorebounds=True), xy)
+
+ # ### Assert that prices are correct
+ #
+ # $$
+ # p \simeq -\frac{\Delta y}{\Delta x}
+ # $$
+
+ for alpha in np.linspace(0.01, 0.99, 100):
+ ci = CPC.from_xyal(100, 200, alpha=alpha)
+ dy = ci.yfromx_f(ci.x+0.1, ignorebounds=True)-ci.yfromx_f(ci.x-0.1, ignorebounds=True)
+ assert iseq(dy/0.2, -ci.p, eps=1e-2), f"error: {dy/0.2/ci.p+1}"
+
+ # ### Check `dyfromdx_f` against `yfromx_f`
+
+ for dxy in np.linspace(0.1, 99, 100):
+ for ci in cc:
+ assert iseq(ci.dyfromdx_f(dxy, ignorebounds=True),
+ (ci.yfromx_f(ci.x+dxy, ignorebounds=True)-ci.y))
+ assert iseq(ci.dxfromdy_f(dxy, ignorebounds=True),
+ (ci.xfromy_f(ci.y+dxy, ignorebounds=True)-ci.x))
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CPCBalancer.py
+# Segment Charts [NOTEST]
+# ------------------------------------------------------------
+def notest_charts():
+# ------------------------------------------------------------
+
+ plt.style.use('seaborn-v0_8-dark')
+ plt.rcParams['figure.figsize'] = [12,6] # only picked up at second run (?!?)
+
+ c0 = CPC.from_xyal(100, 200)
+ c1 = CPC.from_xyal(100, 200, eta=2)
+ c2 = CPC.from_xyal(100, 200, eta=0.5)
+ cc = [c0, c1, c2]
+ xvals = np.linspace(50,200)
+ pvals = np.linspace(1,4)
+
+ for ci in cc:
+ plt.plot(xvals, [ci.yfromx_f(x, ignorebounds=True) for x in xvals], label=f"eta={ci.eta:0.2f}")
+ plt.grid()
+ plt.legend()
+ plt.title("Indifference curve token balance y vs token balance x at different weights")
+ plt.xlabel("Token balance x [native units]")
+ plt.ylabel("Token balance y [native units]")
+ plt.show()
+
+ for ci in cc:
+ plt.plot(
+ xvals,
+ [
+ -(ci.yfromx_f(x+0.1, ignorebounds=True) - ci.yfromx_f(x-0.1, ignorebounds=True))/0.2
+ for x in xvals
+
+ ],
+ label=f"eta={ci.eta:0.2f}")
+ plt.grid()
+ plt.legend()
+ plt.title("Price vs token balance x at different weights")
+ plt.xlabel("Token balance x [native units]")
+ plt.ylabel("Price [dy/dx]")
+ plt.show()
+
+ for ci in cc:
+ plt.plot(
+ pvals,
+ [
+ ci.xyfromp_f(p, ignorebounds=True)[1]
+ for p in pvals
+
+ ],
+ label=f"eta={ci.eta:0.2f}")
+ plt.grid()
+ plt.legend()
+ plt.title("Token balance y vs price at different weights")
+ plt.xlabel("Price [dy/dx]")
+ plt.ylabel("Token balance y [native units]")
+ plt.show()
+
+
+
+
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_049_CustomTradingFees.py b/fastlane_bot/tests/nbtest/test_049_CustomTradingFees.py
new file mode 100644
index 000000000..6c7db1998
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_049_CustomTradingFees.py
@@ -0,0 +1,150 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_049_CustomTradingFees.py`
+# ------------------------------------------------------------
+# source file = NBTest_049_CustomTradingFees.py
+# test id = 049
+# test comment = CustomTradingFees
+# ------------------------------------------------------------
+
+
+
+from unittest.mock import Mock, patch, call
+
+import brownie
+import pytest
+from unittest.mock import MagicMock
+from brownie import multicall as brownie_multicall
+
+from fastlane_bot import Bot, Config
+from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
+from fastlane_bot.events.managers.manager import Manager
+Base = None
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
+from fastlane_bot.testing import *
+
+#plt.style.use('seaborn-dark')
+plt.rcParams['figure.figsize'] = [12,6]
+from fastlane_bot import __VERSION__
+require("3.0", __VERSION__)
+
+
+#
+
+import json
+
+with open("fastlane_bot/data/event_test_data.json", "r") as f:
+ event_data = json.load(f)
+
+with open("fastlane_bot/data/test_pool_data.json", "r") as f:
+ pool_data = json.load(f)
+
+
+cfg = Config.new(config=Config.CONFIG_MAINNET)
+
+manager = Manager(cfg.w3, cfg, pool_data, 20, SUPPORTED_EXCHANGES=['bancor_v3', 'carbon_v1', 'uniswap_v2', 'uniswap_v3'])
+
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CustomTradingFees.py
+# Segment test_update_from_event_carbon_v1_pair_create
+# ------------------------------------------------------------
+def test_test_update_from_event_carbon_v1_pair_create():
+# ------------------------------------------------------------
+
+ # +
+ event = event_data['carbon_v1_event_pair_created']
+ assert (event['args']['token0'], event['args']['token1']) not in manager.fee_pairs
+
+ manager.update_from_event(event)
+
+ assert (event['args']['token0'], event['args']['token1']) in manager.fee_pairs
+
+ # -
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CustomTradingFees.py
+# Segment test_update_from_event_carbon_v1_trading_fee_updated
+# ------------------------------------------------------------
+def test_test_update_from_event_carbon_v1_trading_fee_updated():
+# ------------------------------------------------------------
+ #
+
+ # +
+ event = event_data['carbon_v1_trading_fee_updated']
+ prevFeePPM = event['args']['prevFeePPM']
+ newFeePPM = event['args']['newFeePPM']
+
+ mocked_contract = Mock()
+ mocked_contract.functions.tradingFeePPM.return_value.call.return_value = prevFeePPM
+ assert int(manager.exchanges['carbon_v1'].get_fee('', mocked_contract)[0]) == prevFeePPM
+
+ # find all pools with fee==prevFeePPM
+ prev_default_pools = [idx for idx, pool in enumerate(manager.pool_data) if pool['fee'] == prevFeePPM]
+
+ manager.update_from_event(event)
+
+ for idx in prev_default_pools:
+ assert manager.pool_data[idx]['fee'] == newFeePPM
+
+ mocked_contract.functions.tradingFeePPM.return_value.call.return_value = newFeePPM
+
+ assert int(manager.exchanges['carbon_v1'].get_fee('', mocked_contract)[0]) == newFeePPM
+ # -
+
+
+# ------------------------------------------------------------
+# Test 049
+# File test_049_CustomTradingFees.py
+# Segment test_update_from_event_carbon_v1_pair_trading_fee_updated
+# ------------------------------------------------------------
+def test_test_update_from_event_carbon_v1_pair_trading_fee_updated():
+# ------------------------------------------------------------
+
+ # +
+ event = event_data['carbon_v1_pair_trading_fee_updated']
+ prevFeePPM = event['args']['prevFeePPM']
+ newFeePPM = event['args']['newFeePPM']
+ token0 = event['args']['token0']
+ token1 = event['args']['token1']
+
+ # set the fee for the pair to prevFeePPM
+ idxs = [idx for idx, pool in enumerate(manager.pool_data) if pool['tkn0_address'] == token0 and pool['tkn1_address'] == token1 and pool['exchange_name'] == 'carbon_v1']
+ for idx in idxs:
+ manager.pool_data[idx]['fee'] = f"{prevFeePPM}"
+ manager.pool_data[idx]['fee_float'] = prevFeePPM / 1e6
+
+ # set all other pools with a different fee than prevFeePPM
+ others = [i for i, pool in enumerate(manager.pool_data) if i not in idxs and pool['exchange_name'] == 'carbon_v1']
+ for i in others:
+ manager.pool_data[i]['fee'] = f"{prevFeePPM-1}"
+ manager.pool_data[i]['fee_float'] = (prevFeePPM-1) / 1e6
+
+ manager.update_from_event(event)
+
+ # check that the fee for the pair is now newFeePPM
+ for idx in idxs:
+ assert manager.pool_data[idx]['fee'] == f"{newFeePPM}"
+ assert manager.pool_data[idx]['fee_float'] == newFeePPM / 1e6
+
+ # check that all other pools have not been changed
+ for i in others:
+ assert manager.pool_data[i]['fee'] == f"{prevFeePPM-1}"
+ assert manager.pool_data[i]['fee_float'] == (prevFeePPM-1) / 1e6
+
+ # -
+
+ #
+
+ #
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_900_OptimizerDetailedSlow.py b/fastlane_bot/tests/nbtest/test_900_OptimizerDetailedSlow.py
index 7a4f1d147..10072420b 100644
--- a/fastlane_bot/tests/nbtest/test_900_OptimizerDetailedSlow.py
+++ b/fastlane_bot/tests/nbtest/test_900_OptimizerDetailedSlow.py
@@ -499,7 +499,7 @@ def test_general_and_specific_tests():
assert type(r) == ConvexOptimizer.NofeesOptimizerResult
# assert round(r.result,-5) <= -1500000.0
# assert round(r.result,-5) >= -2500000.0
- assert r.time < 5
+ # assert r.time < 8
assert r.method == "convex"
assert set(r.token_table.keys()) == set(['USDT-1ec7', 'WETH-6Cc2', 'LINK-86CA', 'DAI-1d0F', 'HEX-eb39'])
assert len(r.token_table[T.USDT].x)==0
diff --git a/fastlane_bot/tests/nbtest/test_902_ValidatorSlow.py b/fastlane_bot/tests/nbtest/test_902_ValidatorSlow.py
deleted file mode 100644
index 0b5ac3fd1..000000000
--- a/fastlane_bot/tests/nbtest/test_902_ValidatorSlow.py
+++ /dev/null
@@ -1,283 +0,0 @@
-# ------------------------------------------------------------
-# Auto generated test file `test_902_ValidatorSlow.py`
-# ------------------------------------------------------------
-# source file = NBTest_902_ValidatorSlow.py
-# test id = 902
-# test comment = ValidatorSlow
-# ------------------------------------------------------------
-
-
-
-"""
-This module contains the tests for the exchanges classes
-"""
-from fastlane_bot import Bot, Config
-from fastlane_bot.bot import CarbonBot
-from fastlane_bot.tools.cpc import ConstantProductCurve
-from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
-from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
-from fastlane_bot.events.interface import QueryInterface
-from fastlane_bot.helpers.poolandtokens import PoolAndTokens
-from fastlane_bot.helpers import TradeInstruction, TxReceiptHandler, TxRouteHandler, TxSubmitHandler, TxHelpers, TxHelper
-from fastlane_bot.events.managers.manager import Manager
-from fastlane_bot.events.interface import QueryInterface
-from joblib import Parallel, delayed
-import pytest
-import math
-import json
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
-print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
-from fastlane_bot.testing import *
-from fastlane_bot.modes import triangle_single_bancor3
-#plt.style.use('seaborn-dark')
-plt.rcParams['figure.figsize'] = [12,6]
-from fastlane_bot import __VERSION__
-require("3.0", __VERSION__)
-
-
-
-C = cfg = Config.new(config=Config.CONFIG_MAINNET)
-C.DEFAULT_MIN_PROFIT_BNT = 0.02
-C.DEFAULT_MIN_PROFIT = 0.02
-cfg.DEFAULT_MIN_PROFIT_BNT = 0.02
-cfg.DEFAULT_MIN_PROFIT = 0.02
-assert (C.NETWORK == C.NETWORK_MAINNET)
-assert (C.PROVIDER == C.PROVIDER_ALCHEMY)
-setup_bot = CarbonBot(ConfigObj=C)
-pools = None
-with open('fastlane_bot/data/tests/latest_pool_data_testing.json') as f:
- pools = json.load(f)
-pools = [pool for pool in pools]
-pools[0]
-static_pools = pools
-state = pools
-exchanges = list({ex['exchange_name'] for ex in state})
-db = QueryInterface(state=state, ConfigObj=C, exchanges=exchanges)
-setup_bot.db = db
-
-static_pool_data_filename = "static_pool_data"
-
-static_pool_data = pd.read_csv(f"fastlane_bot/data/{static_pool_data_filename}.csv", low_memory=False)
-
-uniswap_v2_event_mappings = pd.read_csv("fastlane_bot/data/uniswap_v2_event_mappings.csv", low_memory=False)
-
-tokens = pd.read_csv("fastlane_bot/data/tokens.csv", low_memory=False)
-
-exchanges = "carbon_v1,bancor_v3,uniswap_v3,uniswap_v2,sushiswap_v2"
-
-exchanges = exchanges.split(",")
-
-
-alchemy_max_block_fetch = 20
-static_pool_data["cid"] = [
- cfg.w3.keccak(text=f"{row['descr']}").hex()
- for index, row in static_pool_data.iterrows()
- ]
-static_pool_data = [
- row for index, row in static_pool_data.iterrows()
- if row["exchange_name"] in exchanges
-]
-
-static_pool_data = pd.DataFrame(static_pool_data)
-static_pool_data['exchange_name'].unique()
-mgr = Manager(
- web3=cfg.w3,
- cfg=cfg,
- pool_data=static_pool_data.to_dict(orient="records"),
- SUPPORTED_EXCHANGES=exchanges,
- alchemy_max_block_fetch=alchemy_max_block_fetch,
- uniswap_v2_event_mappings=uniswap_v2_event_mappings,
- tokens=tokens.to_dict(orient="records"),
-)
-
-start_time = time.time()
-Parallel(n_jobs=-1, backend="threading")(
- delayed(mgr.add_pool_to_exchange)(row) for row in mgr.pool_data
-)
-cfg.logger.info(f"Time taken to add initial pools: {time.time() - start_time}")
-
-mgr.deduplicate_pool_data()
-cids = [pool["cid"] for pool in mgr.pool_data]
-assert len(cids) == len(set(cids)), "duplicate cid's exist in the pool data"
-def init_bot(mgr: Manager) -> CarbonBot:
- """
- Initializes the bot.
-
- Parameters
- ----------
- mgr : Manager
- The manager object.
-
- Returns
- -------
- CarbonBot
- The bot object.
- """
- mgr.cfg.logger.info("Initializing the bot...")
- bot = CarbonBot(ConfigObj=mgr.cfg)
- bot.db = db
- bot.db.mgr = mgr
- assert isinstance(
- bot.db, QueryInterface
- ), "QueryInterface not initialized correctly"
- return bot
-bot = init_bot(mgr)
-bot.db.handle_token_key_cleanup()
-bot.db.remove_unmapped_uniswap_v2_pools()
-bot.db.remove_zero_liquidity_pools()
-bot.db.remove_unsupported_exchanges()
-tokens = bot.db.get_tokens()
-ADDRDEC = {t.key: (t.address, int(t.decimals)) for t in tokens if not math.isnan(t.decimals)}
-flashloan_tokens = bot.setup_flashloan_tokens(None)
-CCm = bot.setup_CCm(None)
-pools = db.get_pool_data_with_tokens()
-
-arb_mode = "multi"
-
-
-# ------------------------------------------------------------
-# Test 902
-# File test_902_ValidatorSlow.py
-# Segment Test_MIN_PROFIT
-# ------------------------------------------------------------
-def test_test_min_profit():
-# ------------------------------------------------------------
-
- assert(cfg.DEFAULT_MIN_PROFIT_BNT <= 0.02), f"[TestMultiMode], DEFAULT_MIN_PROFIT_BNT must be <= 0.02 for this Notebook to run, currently set to {cfg.DEFAULT_MIN_PROFIT_BNT}"
- assert(C.DEFAULT_MIN_PROFIT_BNT <= 0.02), f"[TestMultiMode], DEFAULT_MIN_PROFIT_BNT must be <= 0.02 for this Notebook to run, currently set to {cfg.DEFAULT_MIN_PROFIT_BNT}"
-
-
-# ------------------------------------------------------------
-# Test 902
-# File test_902_ValidatorSlow.py
-# Segment Test_validator_in_out
-# ------------------------------------------------------------
-def test_test_validator_in_out():
-# ------------------------------------------------------------
-
- arb_finder = bot._get_arb_finder("multi")
- assert arb_finder.__name__ == "FindArbitrageMultiPairwise", f"[TestMultiMode] Expected arb_finder class name name = FindArbitrageMultiPairwise, found {arb_finder.__name__}"
-
-
-# ------------------------------------------------------------
-# Test 902
-# File test_902_ValidatorSlow.py
-# Segment Test_validator_multi
-# ------------------------------------------------------------
-def test_test_validator_multi():
-# ------------------------------------------------------------
-
- # +
- arb_finder = bot._get_arb_finder("multi")
- finder = arb_finder(
- flashloan_tokens=flashloan_tokens,
- CCm=CCm,
- mode="bothin",
- result=bot.AO_CANDIDATES,
- ConfigObj=bot.ConfigObj,
- )
- r = finder.find_arbitrage()
-
- arb_opp = r[0]
-
- validated = bot.validate_optimizer_trades(arb_opp=arb_opp, arb_mode="multi", arb_finder=finder)
-
-
-
- assert arb_opp == validated
-
- # -
-
-
-# ------------------------------------------------------------
-# Test 902
-# File test_902_ValidatorSlow.py
-# Segment Test_validator_single
-# ------------------------------------------------------------
-def test_test_validator_single():
-# ------------------------------------------------------------
-
- # +
- arb_mode="single"
- arb_finder = bot._get_arb_finder(arb_mode)
- finder = arb_finder(
- flashloan_tokens=flashloan_tokens,
- CCm=CCm,
- mode="bothin",
- result=bot.AO_CANDIDATES,
- ConfigObj=bot.ConfigObj,
- )
- r = finder.find_arbitrage()
-
- arb_opp = r[0]
-
- validated = bot.validate_optimizer_trades(arb_opp=arb_opp, arb_mode=arb_mode, arb_finder=finder)
-
-
- assert arb_opp == validated
- # -
-
-
-# ------------------------------------------------------------
-# Test 902
-# File test_902_ValidatorSlow.py
-# Segment Test_validator_bancor_v3
-# ------------------------------------------------------------
-def test_test_validator_bancor_v3():
-# ------------------------------------------------------------
-
- # +
- arb_mode="bancor_v3"
-
- arb_finder = bot._get_arb_finder(arb_mode)
- finder = arb_finder(
- flashloan_tokens=flashloan_tokens,
- CCm=CCm,
- mode="bothin",
- result=bot.AO_CANDIDATES,
- ConfigObj=bot.ConfigObj,
- )
- r = finder.find_arbitrage()
-
- arb_opp = r[0]
-
- validated = bot.validate_optimizer_trades(arb_opp=arb_opp, arb_mode=arb_mode, arb_finder=finder)
-
-
-
- assert arb_opp != validated
- # -
-
-
-# ------------------------------------------------------------
-# Test 902
-# File test_902_ValidatorSlow.py
-# Segment Test_validator_multi_triangle
-# ------------------------------------------------------------
-def test_test_validator_multi_triangle():
-# ------------------------------------------------------------
-
- # +
- arb_mode="multi_triangle"
- arb_finder = bot._get_arb_finder(arb_mode)
- finder = arb_finder(
- flashloan_tokens=flashloan_tokens,
- CCm=CCm,
- mode="bothin",
- result=bot.AO_CANDIDATES,
- ConfigObj=bot.ConfigObj,
- )
- r = finder.find_arbitrage()
-
- arb_opp = r[0]
-
- validated = bot.validate_optimizer_trades(arb_opp=arb_opp, arb_mode=arb_mode, arb_finder=finder)
-
-
-
- assert arb_opp == validated
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_903_FlashloanTokens.py b/fastlane_bot/tests/nbtest/test_903_FlashloanTokens.py
new file mode 100644
index 000000000..827e60b5d
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_903_FlashloanTokens.py
@@ -0,0 +1,100 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_903_FlashloanTokens.py`
+# ------------------------------------------------------------
+# source file = NBTest_903_FlashloanTokens.py
+# test id = 903
+# test comment = FlashloanTokens
+# ------------------------------------------------------------
+
+
+
+"""
+This module contains the tests which ensure the the flashloan_tokens parameter is respected when using the b3_two_hop and bancor_v3 arb modes.
+"""
+from fastlane_bot import Bot
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
+import subprocess, os, sys
+import pytest
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
+from fastlane_bot.testing import *
+plt.rcParams['figure.figsize'] = [12,6]
+from fastlane_bot import __VERSION__
+require("3.0", __VERSION__)
+
+
+
+
+def find_main_py():
+ # Start at the directory of the current script
+ cwd = os.path.abspath(os.path.join(os.getcwd()))
+
+ with open("log.txt", "w") as f:
+ f.write(f"Searching for main.py in {cwd}")
+
+ print(f"Searching for main.py in {cwd}")
+ while True:
+ # Check if main.py exists in the current directory
+ if "main.py" in os.listdir(cwd):
+ return cwd # Found the directory containing main.py
+ else:
+ # If not, go up one directory
+ new_cwd = os.path.dirname(cwd)
+
+ # If we're already at the root directory, stop searching
+ if new_cwd == cwd:
+ raise FileNotFoundError("Could not find main.py in any parent directory")
+
+ cwd = new_cwd
+
+
+def run_command(mode):
+
+ # Find the correct path to main.py
+ main_script_path = find_main_py()
+ print(f"Found main.py in {main_script_path}")
+ main_script_path = main_script_path + "/main.py"
+
+ # Run the command
+ cmd = [
+ "python",
+ main_script_path,
+ f"--arb_mode={mode}",
+ "--default_min_profit_bnt=60",
+ "--limit_bancor3_flashloan_tokens=True",
+ "--use_cached_events=True",
+ "--logging_path=fastlane_bot/data/",
+ "--timeout=45"
+ ]
+ subprocess.Popen(cmd)
+
+ # Wait for the expected log line to appear
+ expected_log_line = "limiting flashloan_tokens to ["
+ found = False
+ result = subprocess.run(cmd, text=True, capture_output=True, check=True, timeout=120)
+
+ # Check if the expected log line is in the output
+ if expected_log_line in result.stderr:
+ found = True
+
+ if not found:
+ pytest.fail("Expected log line was not found within 1 minute") # If we reach this point, the test has failed
+
+
+
+
+# ------------------------------------------------------------
+# Test 903
+# File test_903_FlashloanTokens.py
+# Segment Test Flashloan Tokens b3_two_hop
+# ------------------------------------------------------------
+def test_test_flashloan_tokens_b3_two_hop():
+# ------------------------------------------------------------
+
+ run_command("b3_two_hop")
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_904_Bancor3DataValidation.py b/fastlane_bot/tests/nbtest/test_904_Bancor3DataValidation.py
new file mode 100644
index 000000000..4e6c2901b
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_904_Bancor3DataValidation.py
@@ -0,0 +1,98 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_904_Bancor3DataValidation.py`
+# ------------------------------------------------------------
+# source file = NBTest_904_Bancor3DataValidation.py
+# test id = 904
+# test comment = Bancor3DataValidation
+# ------------------------------------------------------------
+
+
+
+"""
+This module contains the tests which ensure that data validation checks always occur when running a bancor3-related arb_mode.
+"""
+from fastlane_bot import Bot
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
+import subprocess, os, sys
+import pytest
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
+from fastlane_bot.testing import *
+plt.rcParams['figure.figsize'] = [12,6]
+from fastlane_bot import __VERSION__
+require("3.0", __VERSION__)
+
+
+
+
+def find_main_py():
+ # Start at the directory of the current script
+ cwd = os.path.abspath(os.path.join(os.getcwd()))
+
+ print(f"Searching for main.py in {cwd}")
+ while True:
+ # Check if main.py exists in the current directory
+ if "main.py" in os.listdir(cwd):
+ return cwd # Found the directory containing main.py
+ else:
+ # If not, go up one directory
+ new_cwd = os.path.dirname(cwd)
+
+ # If we're already at the root directory, stop searching
+ if new_cwd == cwd:
+ raise FileNotFoundError("Could not find main.py in any parent directory")
+
+ cwd = new_cwd
+
+
+def run_command(arb_mode, expected_log_line):
+
+ # Find the correct path to main.py
+ main_script_path = find_main_py()
+ print(f"Found main.py in {main_script_path}")
+ main_script_path = main_script_path + "/main.py"
+
+ # Run the command
+ cmd = [
+ "python",
+ main_script_path,
+ f"--arb_mode={arb_mode}",
+ "--default_min_profit_bnt=60",
+ "--limit_bancor3_flashloan_tokens=False",
+ "--use_cached_events=True",
+ "--logging_path=fastlane_bot/data/",
+ "--timeout=45"
+ ]
+ subprocess.Popen(cmd)
+
+ # Wait for the expected log line to appear
+ found = False
+ result = subprocess.run(cmd, text=True, capture_output=True, check=True, timeout=120)
+
+ # Check if the expected log line is in the output
+ if expected_log_line in result.stderr or expected_log_line in result.stdout:
+ found = True
+
+ if not found:
+ pytest.fail("Expected log line was not found within 1 minute") # If we reach this point, the test has failed
+
+
+
+
+# ------------------------------------------------------------
+# Test 904
+# File test_904_Bancor3DataValidation.py
+# Segment Test Data Validation For b3_two_hop
+# ------------------------------------------------------------
+def test_test_data_validation_for_b3_two_hop():
+# ------------------------------------------------------------
+
+ expected_log_line = "Transactions will be required to pass data validation for"
+ arb_mode = "b3_two_hop"
+ run_command(arb_mode=arb_mode, expected_log_line=expected_log_line)
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_905_RespectMinProfitClickParam.py b/fastlane_bot/tests/nbtest/test_905_RespectMinProfitClickParam.py
new file mode 100644
index 000000000..f878b3974
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_905_RespectMinProfitClickParam.py
@@ -0,0 +1,99 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_905_RespectMinProfitClickParam.py`
+# ------------------------------------------------------------
+# source file = NBTest_905_RespectMinProfitClickParam.py
+# test id = 905
+# test comment = RespectMinProfitClickParam
+# ------------------------------------------------------------
+
+
+
+"""
+This module contains the tests which ensure that the minimum profit BNT parameter is respected.
+"""
+from fastlane_bot import Bot
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
+import subprocess, os, sys
+import pytest
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
+from fastlane_bot.testing import *
+plt.rcParams['figure.figsize'] = [12,6]
+from fastlane_bot import __VERSION__
+require("3.0", __VERSION__)
+
+
+
+
+def find_main_py():
+ # Start at the directory of the current script
+ cwd = os.path.abspath(os.path.join(os.getcwd()))
+
+ print(f"Searching for main.py in {cwd}")
+ while True:
+ # Check if main.py exists in the current directory
+ if "main.py" in os.listdir(cwd):
+ return cwd # Found the directory containing main.py
+ else:
+ # If not, go up one directory
+ new_cwd = os.path.dirname(cwd)
+
+ # If we're already at the root directory, stop searching
+ if new_cwd == cwd:
+ raise FileNotFoundError("Could not find main.py in any parent directory")
+
+ cwd = new_cwd
+
+
+def run_command(arb_mode, expected_log_line):
+
+ # Find the correct path to main.py
+ main_script_path = find_main_py()
+ print(f"Found main.py in {main_script_path}")
+ main_script_path = main_script_path + "/main.py"
+
+ # Run the command
+ cmd = [
+ "python",
+ main_script_path,
+ f"--arb_mode={arb_mode}",
+ "--default_min_profit_bnt=60",
+ "--limit_bancor3_flashloan_tokens=False",
+ "--use_cached_events=True",
+ "--logging_path=fastlane_bot/data/",
+ "--timeout=45",
+ "--loglevel=DEBUG",
+ ]
+ subprocess.Popen(cmd)
+
+ # Wait for the expected log line to appear
+ found = False
+ result = subprocess.run(cmd, text=True, capture_output=True, check=True, timeout=120)
+
+ # Check if the expected log line is in the output
+ if expected_log_line in result.stderr or expected_log_line in result.stdout:
+ found = True
+
+ if not found:
+ pytest.fail("Expected log line was not found within 1 minute") # If we reach this point, the test has failed
+
+
+
+
+# ------------------------------------------------------------
+# Test 905
+# File test_905_RespectMinProfitClickParam.py
+# Segment Test Minimum Profit BNT Is Respected
+# ------------------------------------------------------------
+def test_test_minimum_profit_bnt_is_respected():
+# ------------------------------------------------------------
+
+ expected_log_line = "Bot successfully updated min profit"
+ arb_mode = "multi"
+ run_command(arb_mode=arb_mode, expected_log_line=expected_log_line)
\ No newline at end of file
diff --git a/fastlane_bot/tests/nbtest/test_906_TargetTokens.py b/fastlane_bot/tests/nbtest/test_906_TargetTokens.py
new file mode 100644
index 000000000..e7852d1a9
--- /dev/null
+++ b/fastlane_bot/tests/nbtest/test_906_TargetTokens.py
@@ -0,0 +1,101 @@
+# ------------------------------------------------------------
+# Auto generated test file `test_906_TargetTokens.py`
+# ------------------------------------------------------------
+# source file = NBTest_906_TargetTokens.py
+# test id = 906
+# test comment = TargetTokens
+# ------------------------------------------------------------
+
+
+
+"""
+This module contains the tests which ensure the target_tokens parameter is respected.
+"""
+from fastlane_bot import Bot
+from fastlane_bot.tools.cpc import ConstantProductCurve as CPC
+from fastlane_bot.events.exchanges import UniswapV2, UniswapV3, SushiswapV2, CarbonV1, BancorV3
+import subprocess, os, sys
+import pytest
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CPC))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(Bot))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(UniswapV3))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(SushiswapV2))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(CarbonV1))
+print("{0.__name__} v{0.__VERSION__} ({0.__DATE__})".format(BancorV3))
+from fastlane_bot.testing import *
+plt.rcParams['figure.figsize'] = [12,6]
+from fastlane_bot import __VERSION__
+require("3.0", __VERSION__)
+
+
+
+from fastlane_bot.tools.cpc import T
+
+
+def find_main_py():
+ # Start at the directory of the current script
+ cwd = os.path.abspath(os.path.join(os.getcwd()))
+
+ with open("log.txt", "w") as f:
+ f.write(f"Searching for main.py in {cwd}")
+
+ print(f"Searching for main.py in {cwd}")
+ while True:
+ # Check if main.py exists in the current directory
+ if "main.py" in os.listdir(cwd):
+ return cwd # Found the directory containing main.py
+ else:
+ # If not, go up one directory
+ new_cwd = os.path.dirname(cwd)
+
+ # If we're already at the root directory, stop searching
+ if new_cwd == cwd:
+ raise FileNotFoundError("Could not find main.py in any parent directory")
+
+ cwd = new_cwd
+
+
+def run_command(mode):
+
+ # Find the correct path to main.py
+ main_script_path = find_main_py()
+ print(f"Found main.py in {main_script_path}")
+ main_script_path = main_script_path + "/main.py"
+
+ # Run the command
+ cmd = [
+ "python",
+ main_script_path,
+ f"--arb_mode={mode}",
+ "--use_cached_events=True",
+ "--logging_path=fastlane_bot/data/",
+ "--timeout=45",
+ f"--target_tokens={T.WETH},{T.DAI}"
+ ]
+ subprocess.Popen(cmd)
+
+ # Wait for the expected log line to appear
+ expected_log_line = "Limiting pools by target_tokens. Removed "
+ found = False
+ result = subprocess.run(cmd, text=True, capture_output=True, check=True, timeout=120)
+
+ # Check if the expected log line is in the output
+ if expected_log_line in result.stderr:
+ found = True
+
+ if not found:
+ pytest.fail("Expected log line was not found within 1 minute") # If we reach this point, the test has failed
+
+
+
+
+# ------------------------------------------------------------
+# Test 906
+# File test_906_TargetTokens.py
+# Segment Test Flashloan Tokens b3_two_hop
+# ------------------------------------------------------------
+def test_test_flashloan_tokens_b3_two_hop():
+# ------------------------------------------------------------
+
+ run_command("single")
\ No newline at end of file
diff --git a/fastlane_bot/tools/cpc.py b/fastlane_bot/tools/cpc.py
index 116163537..e00cd5c3e 100644
--- a/fastlane_bot/tools/cpc.py
+++ b/fastlane_bot/tools/cpc.py
@@ -7,8 +7,8 @@
NOTE: this class is not part of the API of the Carbon protocol, and you must expect breaking
changes even in minor version updates. Use at your own risk.
"""
-__VERSION__ = "2.14"
-__DATE__ = "23/May/2023"
+__VERSION__ = "3.0"
+__DATE__ = "22/Aug/2023"
from dataclasses import dataclass, field, asdict, InitVar
from .simplepair import SimplePair as Pair
@@ -351,10 +351,12 @@ class ConstantProductCurve:
"""
represents a, potentially levered, constant product curve
- :k: pool constant k = xy [x=k/y, y=k/x]
+ :k: pool invariant k (see NOTE2 below)
:x: (virtual) pool state x (virtual number of base tokens for sale)
:x_act: actual pool state x (actual number of base tokens for sale)
:y_act: actual pool state y (actual number of quote tokens for sale)
+ :alpha: weight factor alpha of token x (default = 0.5; see NOTE3 below)
+ :eta: portfolio weight factor eta (default = 1; see NOTE3 below)
:pair: token pair in slash notation ("TKNB/TKNQ"); TKNB is on the x-axis, TKNQ on the y-axis
:cid: unique id (optional)
:fee: fee (optional); eg 0.01 for 1%
@@ -362,7 +364,20 @@ class ConstantProductCurve:
:constr: which (alternative) constructor was used (optional; user should not set)
:params: additional parameters (optional)
- NOTE: use the alternative constructors `from_xx` rather then the canonical one
+ NOTE1: always use the alternative constructors `from_xx` rather then the
+ canonical one; if you insist on using the canonical one then keep in mind
+ that the order of the parameters may change in future versions, so you
+ MUST use keyword arguments
+
+ NOTE2: This class implements two distinct types of constant product curves:
+ (1) the standard constant product curve xy=k
+ (2) the weighted constant product curve x^al y^1-al = k^al
+ Note that the case alpha=0.5 is equivalent to the standard constant product curve
+ xy=k, including the value of k
+
+ NOTE3: There are two different ways of specifying the weights of the tokens
+ (1) alpha: the weight of the x token (equal weight = 0.5), such that x^al y^1-al = k^al
+ (2) eta = alpha / (1-alpha): the relative weight (equal weight = 1; x overweight > 1)
"""
__VERSION__ = __VERSION__
@@ -372,6 +387,7 @@ class ConstantProductCurve:
x: float
x_act: float = None
y_act: float = None
+ alpha: float = None
pair: str = None
cid: str = None
fee: float = None
@@ -380,6 +396,16 @@ class ConstantProductCurve:
params: AttrDict = field(default=None, repr=True, compare=False, hash=False)
def __post_init__(self):
+
+ if self.alpha is None:
+ super().__setattr__("_is_constant_product", True)
+ super().__setattr__("alpha", 0.5)
+ else:
+ super().__setattr__("_is_constant_product", self.alpha == 0.5)
+ #print(f"[ConstantProductCurve] _is_constant_product = {self._is_constant_product}")
+ assert self.alpha > 0, f"alpha must be > 0 [{self.alpha}]"
+ assert self.alpha < 1, f"alpha must be < 1 [{self.alpha}]"
+
if self.constr is None:
super().__setattr__("constr", "default")
@@ -440,6 +466,15 @@ def cid0(self):
"short cid [last 8 characters]"
return self.cid[-8:]
+ @property
+ def eta(self):
+ "portfolio weight factor eta = alpha / (1-alpha)"
+ return self.alpha / (1 - self.alpha)
+
+ def is_constant_product(self):
+ "True iff alpha == 0.5"
+ return self._is_constant_product
+
TOKENSCALE = ts.TokenScale1Data
# default token scale object is the trivial scale (everything one)
# change this to a different scale object be creating a derived class
@@ -469,9 +504,11 @@ def asdict(self):
return asdict(self)
@classmethod
- def from_dict(cls, d):
+ def fromdict(cls, d):
"returns a curve from a dict representation"
return cls(**d)
+
+ from_dict = fromdict # DEPRECATED (use fromdict)
def setcid(self, cid):
"""sets the curve id [can only be done once]"""
@@ -562,6 +599,50 @@ def from_xy(
params=params,
)
+ @classmethod
+ def from_xyal(
+ cls,
+ x,
+ y,
+ *,
+ alpha=None,
+ eta=None,
+ x_act=None,
+ y_act=None,
+ pair=None,
+ cid=None,
+ fee=None,
+ descr=None,
+ params=None,
+ ):
+ "constructor: from x,y,alpha/eta (and x_act, y_act)"
+ if not alpha is None and not eta is None:
+ raise ValueError(f"at most one of alpha and eta must be given [{alpha}, {eta}]")
+ if not eta is None:
+ alpha = eta / (eta + 1)
+ if alpha is None:
+ alpha = 0.5
+ assert alpha > 0, f"alpha must be > 0 [{alpha}]"
+ eta_inv = (1-alpha) / alpha
+ k = x * (y**eta_inv)
+ #print(f"[from_xyal] eta_inv = {eta_inv}")
+ #print(f"[from_xyal] x={x}, y={y}, k = {k}")
+ return cls(
+ #k=(x**alpha * y**(1-alpha))**(1/alpha),
+ k=k,
+ x=x,
+ alpha=alpha,
+ x_act=x_act,
+ y_act=y_act,
+ pair=pair,
+ cid=cid,
+ fee=fee,
+ descr=descr,
+ constr="xyal",
+ params=params,
+ )
+
+
@classmethod
def from_pk(
cls,
@@ -915,6 +996,8 @@ def execute(self, dx=None, dy=None, *, ignorebounds=False, verbose=False):
*at least one of dx, dy must be None
"""
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
if not dx is None and not dy is None:
raise ValueError(f"either dx or dy must be None dx={dx} dy={dy}")
@@ -995,6 +1078,8 @@ def pairp(self):
def description(self):
"description of the pool"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
s = ""
s += f"cid = {self.cid0} [{self.cid}]\n"
s += f"primary = {Pair.n(self.pairo.primary)} [{self.pairo.primary}]\n"
@@ -1010,15 +1095,21 @@ def description(self):
@property
def y(self):
"(virtual) pool state x (virtual number of base tokens for sale)"
+
if self.k == 0:
return 0
- return self.k / self.x
-
+ if self.is_constant_product():
+ return self.k / self.x
+ return (self.k / self.x)**(self.eta)
+
@property
def p(self):
"pool price (in dy/dx)"
- return self.y / self.x
-
+ if self.is_constant_product():
+ return self.y / self.x
+
+ return self.eta * self.y / self.x
+
def buysell(self, *, verbose=False, withprice=False):
"""
returns b (buy primary tknb), s (sells primary tknb) or bs (buys and sells)
@@ -1081,6 +1172,8 @@ def itm(self, other, *, thresholdpc=None, aggr=True):
:thresholdpc: in-the-money threshold in percent (default: ITM_THRESHOLD)
:aggr: if True, and an iterable is passed, True iff one is in the money
"""
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
try:
itm_t = tuple(self.itm(o) for o in other)
if not aggr:
@@ -1103,7 +1196,6 @@ def tvl(self, tkn=None, *, mult=1.0, incltkn=False, raiseonerror=True):
:raiseonerror: if True, raises ValueError if tkn is not tknb or tknq
:returns: tvl (in tkn) or (tvl, tkn, mult) if incltkn is True
"""
-
if tkn is None:
tkn = self.tknq
if not tkn in {self.tknb, self.tknq}:
@@ -1145,12 +1237,21 @@ def pp(self):
@property
def kbar(self):
- "kbar = sqrt(k); kbar scales linearly with the pool size"
- return sqrt(self.k)
+ """
+ kbar is pool invariant the scales linearly with the pool size
+
+ kbar = sqrt(k) for constant product
+ kbar = k^alpha for general curves
+ """
+ if self.is_constant_product():
+ return sqrt(self.k)
+ return self.k**self.alpha
@property
def x_min(self):
"minimum (virtual) x value"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
return self.x - self.x_act
@property
@@ -1179,11 +1280,15 @@ def at_boundary(self):
@property
def y_min(self):
"minimum (virtual) y value"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
return self.y - self.y_act
@property
def x_max(self):
"maximum (virtual) x value"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
if self.y_min > 0:
return self.k / self.y_min
else:
@@ -1192,6 +1297,8 @@ def x_max(self):
@property
def y_max(self):
"maximum (virtual) y value"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
if self.x_min > 0:
return self.k / self.x_min
else:
@@ -1200,6 +1307,8 @@ def y_max(self):
@property
def p_max(self):
"maximum pool price (in dy/dx; None if unlimited) = y_max/x_min"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
if not self.x_min is None and self.x_min > 0:
return self.y_max / self.x_min
else:
@@ -1214,6 +1323,8 @@ def p_max_primary(self, swap=True):
@property
def p_min(self):
"minimum pool price (in dy/dx; None if unlimited) = y_min/x_max"
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
if not self.x_max is None and self.x_max > 0:
return self.y_min / self.x_max
else:
@@ -1227,6 +1338,8 @@ def p_min_primary(self, swap=True):
def format(self, *, heading=False, formatid=None):
"""returns info about the curve as a formatted string"""
+ assert self.is_constant_product(), "only implemented for constant product curves"
+
if formatid is None:
formatid = 0
assert formatid in [0], "only formatid in [0] is supported"
@@ -1244,20 +1357,34 @@ def format(self, *, heading=False, formatid=None):
return s
def xyfromp_f(self, p=None, *, ignorebounds=False, withunits=False):
- """
- returns x,y for a given marginal price p (stuck at the boundaries if ignorebounds=False)
+ r"""
+ returns x,y,p for a given marginal price p (stuck at the boundaries if ignorebounds=False)
:p: marginal price (in dy/dx)
:ignorebounds: if True, ignore x_act and y_act; if False, return the x,y values where
x_act and y_act are at zero (i.e. the pool is empty in this direction)
:withunits: if False, return x,y,p; if True, also return tknx, tkny, pair
+
+
+ $$
+ x(p) = \left( \frac{\eta}{p} \right) ^ {1-\alpha} k^\alpha
+ y(p) = \left( \frac{p}{\eta} \right) ^ \alpha k^\alpha
+ $$
"""
if p is None:
p = self.p
- sqrt_p = sqrt(p)
- sqrt_k = self.kbar
- x = sqrt_k / sqrt_p
- y = sqrt_k * sqrt_p
+
+ if self.is_constant_product():
+ sqrt_p = sqrt(p)
+ sqrt_k = self.kbar
+ x = sqrt_k / sqrt_p
+ y = sqrt_k * sqrt_p
+ else:
+ eta = self.eta
+ alpha = self.alpha
+ x = (eta/p)**(1-alpha) * self.kbar
+ y = (p/eta)**alpha * self.kbar
+
if not ignorebounds:
if not self.x_min is None:
if x < self.x_min:
@@ -1278,7 +1405,7 @@ def xyfromp_f(self, p=None, *, ignorebounds=False, withunits=False):
return x, y, p
def dxdyfromp_f(self, p=None, *, ignorebounds=False, withunits=False):
- """like xyfromp_f, but returns dx,dy instead of x,y"""
+ """like xyfromp_f, but returns dx,dy,p instead of x,y,p"""
x, y, p = self.xyfromp_f(p, ignorebounds=ignorebounds)
dx = x - self.x
dy = y - self.y
@@ -1288,7 +1415,11 @@ def dxdyfromp_f(self, p=None, *, ignorebounds=False, withunits=False):
def yfromx_f(self, x, *, ignorebounds=False):
"y value for given x value (if in range; None otherwise)"
- y = self.k / x
+ if self.is_constant_product():
+ y = self.k / x
+ else:
+ y = (self.k / x) ** self.eta
+
if ignorebounds:
return y
if not self.inrange(y, self.y_min, self.y_max):
@@ -1297,7 +1428,10 @@ def yfromx_f(self, x, *, ignorebounds=False):
def xfromy_f(self, y, *, ignorebounds=False):
"x value for given y value (if in range; None otherwise)"
- x = self.k / y
+ if self.is_constant_product():
+ x = self.k / y
+ else:
+ x = self.k / (y ** (1/self.eta))
if ignorebounds:
return x
if not self.inrange(x, self.x_min, self.x_max):
diff --git a/fastlane_bot/tools/optimizer/margpoptimizer.py b/fastlane_bot/tools/optimizer/margpoptimizer.py
index 6b384a1b2..68834d99c 100644
--- a/fastlane_bot/tools/optimizer/margpoptimizer.py
+++ b/fastlane_bot/tools/optimizer/margpoptimizer.py
@@ -214,7 +214,11 @@ def dtknfromp_f(p, *, islog10=True, asdct=False, quiet=False):
sum_by_tkn = {t: 0 for t in alltokens_s}
for pair, (tknb, tknq) in zip(pairs, pairs_t):
- price = get(p, tokens_ix.get(tknb)) / get(p, tokens_ix.get(tknq))
+ if get(p, tokens_ix.get(tknq)) > 0:
+ price = get(p, tokens_ix.get(tknb)) / get(p, tokens_ix.get(tknq))
+ else:
+ #print(f"[dtknfromp_f] warning: price for {pair} is unknown, using 1 instead")
+ price = 1
curves = curves_by_pair[pair]
c0 = curves[0]
dxdy = tuple(dxdy_f(c.dxdyfromp_f(price)) for c in curves)
diff --git a/resources/NBTest/NBTest_003_Serialization.ipynb b/resources/NBTest/NBTest_003_Serialization.ipynb
index 62f857786..0788a5f6a 100644
--- a/resources/NBTest/NBTest_003_Serialization.ipynb
+++ b/resources/NBTest/NBTest_003_Serialization.ipynb
@@ -10,8 +10,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "ConstantProductCurve v2.14 (23/May/2023)\n",
- "CPCArbOptimizer v4.0 (10/May/2023)\n",
+ "ConstantProductCurve v3.0 (22/Aug/2023)\n",
+ "CPCArbOptimizer v5.0 (26/Jul/2023)\n",
"imported m, np, pd, plt, os, sys, decimal; defined iseq, raises, require\n",
"Version = 3-b2.2 [requirements >= 2.0 is met]\n"
]
@@ -50,324 +50,61 @@
{
"cell_type": "code",
"execution_count": 2,
- "id": "8cb4f9bc-2f31-4eae-b77f-533aa188e49b",
+ "id": "4030cea3-3e03-4e0f-8d80-7a2bcca05fcf",
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " k | \n",
- " x | \n",
- " x_act | \n",
- " y_act | \n",
- " pair | \n",
- " fee | \n",
- " descr | \n",
- " constr | \n",
- " params | \n",
- "
\n",
- " \n",
- " | cid | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | None | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2200 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2200.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2400 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2400.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2200 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2200.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2400 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2400.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2200 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2200.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2400 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2400.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2200 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2200.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2400 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2400.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2200 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2200.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | None | \n",
- " 2400 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2400.0 | \n",
- " ETH/USDC | \n",
- " None | \n",
- " None | \n",
- " xy | \n",
- " {} | \n",
- "
\n",
- " \n",
- "
\n",
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " k | \n",
- " x | \n",
- " x_act | \n",
- " y_act | \n",
- " pair | \n",
- " fee | \n",
- " descr | \n",
- " constr | \n",
- " params | \n",
- "
\n",
- " \n",
- " | cid | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 1 | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {'meh': 1} | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 8040 | \n",
- " 2 | \n",
- " 2 | \n",
- " 4020 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 1970 | \n",
- " 1 | \n",
- " 1 | \n",
- " 1970 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- "
\n",
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " cid | \n",
- " k | \n",
- " x | \n",
- " x_act | \n",
- " y_act | \n",
- " pair | \n",
- " fee | \n",
- " descr | \n",
- " constr | \n",
- " params | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 1 | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 2 | \n",
- " 8040 | \n",
- " 2 | \n",
- " 2 | \n",
- " 4020 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 3 | \n",
- " 1970 | \n",
- " 1 | \n",
- " 1 | \n",
- " 1970 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- "
\n",
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " k | \n",
- " x | \n",
- " x_act | \n",
- " y_act | \n",
- " pair | \n",
- " fee | \n",
- " descr | \n",
- " constr | \n",
- " params | \n",
- "
\n",
- " \n",
- " | cid | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- " | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 1 | \n",
- " 2000 | \n",
- " 1 | \n",
- " 1 | \n",
- " 2000 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 8040 | \n",
- " 2 | \n",
- " 2 | \n",
- " 4020 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 1970 | \n",
- " 1 | \n",
- " 1 | \n",
- " 1970 | \n",
- " ETH/USDC | \n",
- " 0.001 | \n",
- " UniV2 | \n",
- " uv2 | \n",
- " {} | \n",
- "
\n",
- " \n",
- "
\n",
- "