diff --git a/Jerry's tests/ASQ_Backtest_Jerry.ipynb b/Jerry's tests/ASQ_Backtest_Jerry.ipynb
new file mode 100644
index 000000000..a9b754e86
--- /dev/null
+++ b/Jerry's tests/ASQ_Backtest_Jerry.ipynb	
@@ -0,0 +1,342 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm  # tqdm库用于显示循环的进度条\n",
+    "import scipy\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_data(target='LDOBUSD'):\n",
+    "    data = pd.read_csv(f'../bookticker/{target}-bookTicker-2023-06.csv')  # JF版本是05，我下载了06，还可以测试最新一个月/一周的数据\n",
+    "    data = data.rename(columns={\n",
+    "        'best_bid_price': 'bp', \n",
+    "        'best_bid_qty': 'bv',\n",
+    "        'best_ask_price': 'ap', \n",
+    "        'best_ask_qty': 'av',\n",
+    "        'event_time': 'time'  \n",
+    "        })\n",
+    "    data['trade_date'] = pd.to_datetime(data['time'] // 1000 // 60 // 60 // 24, unit='d')\n",
+    "    return data\n",
+    "\n",
+    "\"\"\"\n",
+    "用到5种数据，买一/卖一的价格和数量，时间\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_market_speed(data: pd.DataFrame, price_int: float):\n",
+    "    \"\"\"\n",
+    "    该函数用于计算市价单/taker订单的到达速度，是在下一个cell的函数get_params中被调用的\n",
+    "    该函数中max和min是在下一个函数get_params中通过groupby计算出来的，不是数据源自带的\n",
+    "    如果想单独使用这个函数，需要先通过groupby计算出来max和min\n",
+    "    \"\"\"\n",
+    "    deltalist = np.linspace(price_int, price_int * 10, 10)\n",
+    "    deltadict = {}\n",
+    "\n",
+    "    for delta in deltalist:\n",
+    "        price_interval = delta\n",
+    "        ask_limit_order_hit = data[('ap', 'max')].shift(-1) > (data[('ap', 'last')] + price_interval)\n",
+    "        bid_limit_order_hit = data[('bp', 'min')].shift(-1) < (data[('bp', 'last')] - price_interval)\n",
+    "        limit_order_hit = (ask_limit_order_hit | bid_limit_order_hit).astype(int)\n",
+    "        deltas = pd.Series(limit_order_hit[limit_order_hit == 1].index).diff().apply(lambda x: x / 10)\n",
+    "        deltadict[delta] = deltas\n",
+    "    # 这里的max和min是在下一个函数get_params中通过groupby计算出来的，不是数据源自带的\n",
+    "\n",
+    "    lambdas = pd.DataFrame([[key,1/deltadict[key].mean()] for key in deltadict.keys()],\n",
+    "                       columns=['delta','lambda_delta']).set_index('delta')\n",
+    "\n",
+    "    def exp_fit(x,a,b):\n",
+    "        y = a*np.exp(-b*x)\n",
+    "        return y\n",
+    "\n",
+    "    paramsB, cv = scipy.optimize.curve_fit(exp_fit, np.array(lambdas.index), np.array(lambdas['lambda_delta'].values))\n",
+    "    A, k = paramsB\n",
+    "    # curve_fit(function, xdata, ydata)，其中function是要拟合的函数，xdata是自变量，ydata是因变量，输出结果是function的参数\n",
+    "    return A, k\n",
+    "\n",
+    "\"\"\"\n",
+    "该函数在下一个cell中被调用，用于计算market_speed\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_params(data: pd.DataFrame, price_int: float, time_step: int):\n",
+    "    data = data.copy(deep=True)    \n",
+    "\n",
+    "    # 1. 按照time_step的频率把数据采样起来（相当于订单的更新的频率不能太高）\n",
+    "    data['ms-index'] = data['time'] // time_step    # 整除取结果，从而合并数据\n",
+    "    prices = data.groupby('ms-index').agg({\n",
+    "        'ap': ['last', 'max', 'min'],\n",
+    "        'bp': ['last', 'max', 'min']\n",
+    "        }) # 计算每组的last, max, min，从下文开始注意区分prices和price\n",
+    "    \n",
+    "    # 2. 估计当前每条数据平均多少时间，用于估计交易时间\n",
+    "    min_index, max_index = prices.index[0], prices.index[prices.shape[0]-1]\n",
+    "    ave_time = time_step * (max_index - min_index) / prices.shape[0]\n",
+    "\n",
+    "    # 2. 波动率\n",
+    "    prices['mid'] = (prices[('ap', 'last')] + prices[('bp', 'last')]) / 2\n",
+    "    # 这里可以修改，修改为计算自己的price model, 加入对不平衡、成交量等因素的考虑\n",
+    "    sigma = np.log(prices['mid']).diff().std() * np.sqrt(24 * 60 * 60 * 1000 / ave_time) # 用对数收益率计算波动率\n",
+    "    \n",
+    "    # 5. 市价单到达速率参数，调用上一个cell的get_market_speed函数，其中的prices由本cell第6行的prices得到\n",
+    "    A, k = get_market_speed(prices, price_int)\n",
+    "\n",
+    "    return sigma, A, k\n",
+    "\n",
+    "def get_bid_spread(sigma, A, k, gamma, q):\n",
+    "    var1 = (1 / gamma) * np.log(1 + gamma / k)\n",
+    "    var2 = (2 * q + 1) / 2 * np.sqrt(sigma**2 * gamma / (2 * k * A) * (1 + gamma/k)**(1+k/gamma))\n",
+    "    return var1 + var2\n",
+    "\n",
+    "def get_ask_spread(sigma, A, k, gamma, q):\n",
+    "    var1 = (1 / gamma) * np.log(1 + gamma / k)\n",
+    "    var2 = (2 * q - 1) / 2 * np.sqrt(sigma**2 * gamma / (2 * k * A) * (1 + gamma/k)**(1+k/gamma))\n",
+    "    return var1 - var2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluation(data: pd.DataFrame, price_int: float, time_step: int, params: dict):\n",
+    "    \"\"\"\n",
+    "    输入是一段历史成交的数据，来进行策略回测\n",
+    "    并没有加入库存量相关的交易规则\n",
+    "    只使用了best bid and ask进行回测，没有考虑订单在订单薄上的位置\n",
+    "\n",
+    "    \"\"\" \n",
+    "    data = data.copy(deep=True)      # 这里的data是第一步的load data读取的CSV文件的处理结果\n",
+    "    date = data['trade_date'].iloc[0]\n",
+    "    \n",
+    "    # 1. 按照time_step的频率把数据合并起来\n",
+    "    data['ms-index'] = data['time'] // time_step    \n",
+    "    prices = data.groupby('ms-index').agg({\n",
+    "        'ap': ['last', 'max', 'min'],\n",
+    "        'bp': ['last', 'max', 'min']\n",
+    "        })  # 将data按time_step的时间间隔合并分组成一个新的名为prices的dataframe\n",
+    "    \n",
+    "    prices['mid'] = (prices[('ap', 'last')] + prices[('bp', 'last')]) / 2 # 这里可以修改，修改为计算自己的price model, dmp等\n",
+    "    \n",
+    "    # 4. 回测\n",
+    "    N = prices.shape[0]\n",
+    "    q    = np.array([params['q']] + [0] * (N-1))   # 补上上一轮回测的结果； q代表净持仓量，当q>0时，代表多头，q<0时，代表空头\n",
+    "    x    = np.array([params['x']] + [0] * (N-1), dtype=float)\n",
+    "    pnl  = np.array([params['pnl']] + [0] * (N-1), dtype=float)\n",
+    "    fees = np.array([params['fees']] + [0] * (N-1), dtype=float)\n",
+    "    ra = np.zeros(N)\n",
+    "    rb = np.zeros(N)\n",
+    "\n",
+    "    sigma = params['sigma']\n",
+    "    A     = params['A']\n",
+    "    k     = params['k']\n",
+    "    gamma = params['gamma']\n",
+    "    fee_rate = params['fee_rate']\n",
+    "\n",
+    "    for i in tqdm(range(N-1), desc=f'[evaluation {date}] '):\n",
+    "        \n",
+    "        ra[i] = prices['mid'].iloc[i] + get_ask_spread(sigma, A, k, gamma, q[i])\n",
+    "        rb[i] = prices['mid'].iloc[i] - get_bid_spread(sigma, A, k, gamma, q[i])\n",
+    "\n",
+    "        # 这里限制了价格一定得是挂单方的价格，不会变成吃单\n",
+    "        ra[i] = max(prices[('ap', 'last')].iloc[i], np.floor(ra[i] * (1 / price_int)) * price_int)\n",
+    "        rb[i] = min(prices[('bp', 'last')].iloc[i], np.ceil(rb[i] * (1 / price_int)) * price_int)\n",
+    "\n",
+    "        buy = 0\n",
+    "        sell = 0\n",
+    "\n",
+    "        if prices[('ap', 'max')].iloc[i+1] > ra[i]:\n",
+    "            sell = 1\n",
+    "        \n",
+    "        if prices[('bp', 'min')].iloc[i+1] < rb[i]:\n",
+    "            buy = 1\n",
+    "\n",
+    "        q[i+1] = q[i] + buy - sell # q代表净持仓量，当q>0时，代表多头，q<0时，代表空头；这里只是记录了q的变化，没有记录开平仓的信号\n",
+    "        x[i+1] = x[i] + sell*ra[i] - buy*rb[i]\n",
+    "        pnl[i+1]  = x[i+1] + q[i+1] * prices['mid'].iloc[i+1]\n",
+    "        fees[i+1] = fees[i] + sell*ra[i] * fee_rate + buy*rb[i] * fee_rate\n",
+    "    return pnl, x, q, fees"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "This cell is to set up the parameters for the backtest\n",
+    "\"\"\"\n",
+    "\n",
+    "target = 'LDOBUSD'\n",
+    "fee_rate = 1.4e-4 # 1.4/10000，在本程序中是返佣手续费率，因为后面衡量的是pnl+fees\n",
+    "\n",
+    "trade_interval = 1000   # 在下一个cell中被用作time_step输入给evaluation函数，初始时间单位是毫秒，当trader_interval=1000时除完之后变成了秒\n",
+    "gamma = 0.01 # gamma取值代表风险度，该如何优化？\n",
+    "\n",
+    "price_int_dict = {'LDOBUSD': 0.0001, 'LTCBUSD': 0.01, 'BTCBUSD': 0.10, 'ETHBUSD': 0.01}\n",
+    "# price_int_dict中的是每个品种的价格变动最小单位吗？暂时认为是\n",
+    "price_int      = price_int_dict[target]\n",
+    "data = load_data(target=target)\n",
+    "trade_dates = sorted(list(data['trade_date'].unique()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[evaluation 2023-05-16 00:00:00] : 100%|██████████| 33370/33370 [00:50<00:00, 655.06it/s]\n",
+      "[evaluation 2023-05-17 00:00:00] : 100%|██████████| 49993/49993 [01:36<00:00, 518.24it/s]\n",
+      "[evaluation 2023-05-18 00:00:00] : 100%|██████████| 75498/75498 [02:10<00:00, 579.07it/s]\n",
+      "[evaluation 2023-05-19 00:00:00] : 100%|██████████| 70253/70253 [01:52<00:00, 623.25it/s]\n",
+      "[evaluation 2023-05-20 00:00:00] : 100%|██████████| 56879/56879 [01:49<00:00, 519.86it/s]\n",
+      "[evaluation 2023-05-21 00:00:00] : 100%|██████████| 56274/56274 [01:04<00:00, 878.07it/s]\n",
+      "[evaluation 2023-05-22 00:00:00] : 100%|██████████| 60805/60805 [01:30<00:00, 670.07it/s]\n",
+      "[evaluation 2023-05-23 00:00:00] : 100%|██████████| 61767/61767 [01:46<00:00, 577.44it/s]\n",
+      "[evaluation 2023-05-24 00:00:00] : 100%|██████████| 67487/67487 [01:16<00:00, 882.60it/s]\n",
+      "[evaluation 2023-05-25 00:00:00] : 100%|██████████| 66971/66971 [01:51<00:00, 599.55it/s]\n",
+      "[evaluation 2023-05-26 00:00:00] : 100%|██████████| 67846/67846 [02:09<00:00, 521.94it/s]\n",
+      "[evaluation 2023-05-27 00:00:00] : 100%|██████████| 59954/59954 [01:55<00:00, 517.70it/s]\n",
+      "[evaluation 2023-05-28 00:00:00] : 100%|██████████| 66805/66805 [02:07<00:00, 522.33it/s]\n",
+      "[evaluation 2023-05-29 00:00:00] : 100%|██████████| 69053/69053 [02:12<00:00, 520.86it/s]\n",
+      "[evaluation 2023-05-30 00:00:00] : 100%|██████████| 64900/64900 [01:42<00:00, 632.71it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_q = 0\n",
+    "last_x = 0\n",
+    "last_pnl = 0\n",
+    "last_fees = 0\n",
+    "\n",
+    "results = [[], [], [], []]\n",
+    "for i in range(len(trade_dates) - 1):\n",
+    "    valid_data = data[data['trade_date'] == trade_dates[i]]\n",
+    "    test_data  = data[data['trade_date'] == trade_dates[i]]\n",
+    "\n",
+    "    sigma, A, k = get_params(valid_data, time_step=trade_interval, price_int=price_int)\n",
+    "    params = {'q': last_q, 'x': last_x, 'pnl': last_pnl, 'sigma': sigma, 'A': A, 'k': k, 'gamma': gamma, 'fees': last_fees, 'fee_rate': fee_rate}\n",
+    "    pnl, x, q, fees = evaluation(test_data, price_int=price_int, time_step=trade_interval, params=params)\n",
+    "    # 这里的time_step传入的值是在上一个cell中的trade_interval, 代表每次回测的时间间隔，单位是毫秒，trade_interval=1000时，代表1000毫秒/1秒\n",
+    "    # 这里的price_int传入的值是在上一个cell中的price_int_dict[target]，代表每个品种的价格变动最小单位，单位是美元，price_int_dict[target] = 0.0001时，代表0.0001美元\n",
+    "    # 这里的params传入的值是在上一个cell中的params，代表上一次回测的结果，包括q, x, pnl, sigma, A, k, gamma, fees, fee_rate\n",
+    "    # evaluation返回的结果是pnl, x, q, fees的numpy array数组，分别代表每个时间点的pnl, x, q, fees\n",
+    "    results[0].append(pnl)\n",
+    "    results[1].append(x)\n",
+    "    results[2].append(q)\n",
+    "    results[3].append(fees)\n",
+    "\n",
+    "    last_q = q[-1]\n",
+    "    last_x = x[-1]\n",
+    "    last_pnl = pnl[-1]\n",
+    "    last_fees = fees[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1440x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 1, figsize=(20, 8))\n",
+    "ax1, ax2 = axes\n",
+    "\n",
+    "dates_str = [pd.to_datetime(str(item)).strftime('%Y.%m.%d') for item in trade_dates][1:]\n",
+    "# 去掉第一个，因为第一天没有回测，只用来确定参数\n",
+    "\n",
+    "xticks = [0]\n",
+    "for item in results[0][:-1]:\n",
+    "    xticks.append(xticks[-1] + item.shape[0])\n",
+    "\n",
+    "ax1.plot(np.concatenate(results[0], axis=0), label='pnl')\n",
+    "ax1.plot(np.concatenate(results[3], axis=0), label='fees')\n",
+    "ax1.plot(np.concatenate(results[0], axis=0) + np.concatenate(results[3], axis=0) , label='pnl+fees')\n",
+    "ax1.grid()\n",
+    "ax1.legend()\n",
+    "ax1.set_xticks(xticks)\n",
+    "ax1.set_xticklabels(dates_str)\n",
+    "ax1.set_xlabel('Time')\n",
+    "ax1.set_ylabel('Value')\n",
+    "\n",
+    "ax2.plot(np.concatenate(results[2], axis=0), label='pos')\n",
+    "ax2.grid()\n",
+    "ax2.legend()\n",
+    "ax2.set_xticks(xticks)\n",
+    "ax2.set_xticklabels(dates_str)\n",
+    "ax2.set_xlabel('Time')\n",
+    "ax2.set_ylabel('Volume')\n",
+    "plt.suptitle(target)\n",
+    "fig.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "finance",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.9"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Jerry's tests/CSV_Reader_test.py b/Jerry's tests/CSV_Reader_test.py
new file mode 100644
index 000000000..852ecdeeb
--- /dev/null
+++ b/Jerry's tests/CSV_Reader_test.py	
@@ -0,0 +1,36 @@
+import pandas as pd
+from nautilus_trader.core.datetime import dt_to_unix_nanos
+
+# timestamp_ns = pd.Timestamp("2022-01-01").value
+# print(timestamp_ns)
+# start = dt_to_unix_nanos(pd.Timestamp('2022-01-01', tz='UTC'))
+# print(start)
+# end_time=pd.Timestamp("2022-01-01 23:00:00").value
+# print(end_time)
+# 设置显示选项
+pd.set_option('display.max_columns', None)  # 显示所有列
+pd.set_option('display.width', None)        # 确保每一列都能完全显示
+pd.set_option('display.max_rows', None)     # 显示所有行
+pd.set_option('display.max_colwidth', None) # 显示每一列的完整内容
+
+# filename = r"D:\下载\DAT_ASCII_EURUSD_T_202308.csv"
+# filename = r"D:\下载\BTC-USDT-220107.OK.csv"
+# filename = r"D:\下载\LDOBUSD-bookTicker-2023-06\LDOBUSD-bookTicker-2023-06.csv"
+filename = r"D:\下载\BTCUSDT-bookTicker-2023-09-17\BTCUSDT-bookTicker-2023-09-17.csv"
+data = pd.read_csv(filename, nrows=10000)
+data['spread'] = data['best_ask_price'] - data['best_bid_price']
+data['midprice'] = (data['best_ask_price'] + data['best_bid_price']) / 2
+data['midprice_change'] = data['midprice'].diff()
+data['imbalance_-1to1'] = -data['best_ask_qty'] + data['best_bid_qty'] / data['best_ask_qty'] + data['best_bid_qty']  # 取值是-1到1之间，-1表示完全由卖单构成，1表示完全由买单构成
+data['imbalance_0to1'] = data['best_ask_qty'] / data['best_ask_qty'] + data['best_bid_qty']  # 取值是0到1之间，0表示完全由卖单构成，1表示完全由买单构成
+data['wmp'] = data['midprice'] + data['spread'] * data['imbalance_-1to1']/2
+data['wmp_change'] = data['wmp'].diff()
+data['dmp'] = data['midprice'] + data['spread'] * data['imbalance_-1to1'] * (data['imbalance_-1to1'] * data['imbalance_-1to1'] + 1) / 2  # 尚未完成，需要结合DMP公式考虑fee
+
+print(data)
+print(data.dtypes)  # 查看每一列的数据类型
+print(data.head())  # 查看head
+print(data.columns)  # 查看列名
+#
+# # pd.reset_option('display.max_columns')
+
diff --git a/Jerry's tests/External_Data_Loader.py b/Jerry's tests/External_Data_Loader.py
new file mode 100644
index 000000000..e96264b6c
--- /dev/null
+++ b/Jerry's tests/External_Data_Loader.py	
@@ -0,0 +1,72 @@
+import os, shutil
+from datetime import date
+import pandas as pd
+from decimal import Decimal
+from nautilus_trader.model.data.tick import QuoteTick
+from nautilus_trader.model.objects import Price, Quantity
+from nautilus_trader.core.datetime import dt_to_unix_nanos
+from nautilus_trader.persistence.catalog import ParquetDataCatalog
+from nautilus_trader.persistence.external.core import process_files, write_objects
+from nautilus_trader.persistence.external.readers import CSVReader
+from nautilus_trader.test_kit.providers import TestInstrumentProvider
+from nautilus_trader.backtest.node import BacktestNode, BacktestVenueConfig, BacktestDataConfig, BacktestRunConfig, BacktestEngineConfig
+from nautilus_trader.config import ImportableStrategyConfig
+
+
+def parser(data, instrument_id):
+    """
+    Parser function for OKX Tick data, for use with CSV Reader
+    Should check
+    1) the data structure of the file
+    2) “as_dataframe” true or false and
+    use from_str for string data and from_int for int data and return a QuoteTick object
+
+    """
+    dt = pd.Timestamp(data['exchTimeMs'], unit='ms', tz='UTC')
+    yield QuoteTick(
+        instrument_id=instrument_id,
+        bid=Price.from_str(str(data['bidPx1'])),
+        ask=Price.from_str(str(data['askPx1'])),
+        bid_size=Quantity.from_int(data['bidCnt1']),
+        ask_size=Quantity.from_int(data['askCnt1']),
+        ts_event=dt_to_unix_nanos(dt),
+        ts_init=dt_to_unix_nanos(dt),
+    )
+
+input_files = "D:\下载\BTC-USDT-220107.OK.csv"  # "your_path_to_file"
+CATALOG_PATH = "D:/backtest/backtest1/catalog02"  # "your_path_to_catalog"
+# Clear if it already exists, then create fresh
+if os.path.exists(CATALOG_PATH):
+    shutil.rmtree(CATALOG_PATH)
+os.mkdir(CATALOG_PATH)
+catalog = ParquetDataCatalog(CATALOG_PATH)  # Create a new ParquetDataCatalog instance
+
+# Use nautilus test helpers to create a BTC/USDT Crypto instrument for our purposes
+maker1 = Decimal(-0.000001)
+taker1 = Decimal(0.0000143)
+instrument = TestInstrumentProvider.btcusdt_future_OKX(expiry=date(2022, 1, 7), maker=maker1, taker=taker1)
+
+# Add our new instrument to the ParquetDataCatalog and check its existence
+write_objects(catalog, [instrument])
+catalog.instruments()
+
+# Loading the files (the header can be customized)
+process_files(
+    glob_path=input_files,
+    reader=CSVReader(
+        block_parser=lambda x: parser(x, instrument_id=instrument.id),
+        header=None,
+        chunked=False,
+        as_dataframe=True,
+    ),
+    catalog=catalog,
+)
+
+# Also manually write the instrument to the catalog
+write_objects(catalog, [instrument])
+
+# Using the data Catalog
+start = dt_to_unix_nanos(pd.Timestamp('2022-01-01', tz='UTC'))
+end = dt_to_unix_nanos(pd.Timestamp('2022-01-01 23:00:00', tz='UTC'))
+
+catalog.quote_ticks(start=start, end=end)
\ No newline at end of file
diff --git a/Jerry's tests/External_Data_Loader_OKX.py b/Jerry's tests/External_Data_Loader_OKX.py
new file mode 100644
index 000000000..bbe326b44
--- /dev/null
+++ b/Jerry's tests/External_Data_Loader_OKX.py	
@@ -0,0 +1,74 @@
+import os, shutil
+import pandas as pd
+from decimal import Decimal
+from nautilus_trader.model.data.tick import QuoteTick
+from nautilus_trader.model.objects import Price, Quantity
+from nautilus_trader.core.datetime import dt_to_unix_nanos
+from nautilus_trader.persistence.catalog import ParquetDataCatalog
+from nautilus_trader.persistence.external.core import process_files, write_objects
+from nautilus_trader.persistence.external.readers import CSVReader
+from nautilus_trader.test_kit.providers import TestInstrumentProvider
+
+
+
+def parser(data, instrument_id):
+    """
+    Parser function for OKX Tick data, for use with CSV Reader
+    Should check
+    1) the data structure of the file
+    2) “as_dataframe” true or false and
+    use from_str for string data and from_int for int data and return a QuoteTick object
+
+    """
+    dt = pd.Timestamp(data['exchTimeMs'], unit='ms', tz='UTC')
+    yield QuoteTick(
+        instrument_id=instrument_id,
+        bid=Price.from_str(str(data['bidPx1'])),
+        ask=Price.from_str(str(data['askPx1'])),
+        bid_size=Quantity.from_str(str(data['bidSz1'])),
+        ask_size=Quantity.from_str(str(data['askSz1'])),
+        ts_event=dt_to_unix_nanos(dt),
+        ts_init=dt_to_unix_nanos(dt),
+    )
+
+input_files = r"D:\下载\BTC-USDT-220107.OK.csv"  # "your_path_to_file"
+CATALOG_PATH = r"D:/backtest/backtest1/catalog_Sz_01"  # "your_path_to_catalog"
+# Clear if it already exists, then create fresh
+if os.path.exists(CATALOG_PATH):
+    shutil.rmtree(CATALOG_PATH)
+os.mkdir(CATALOG_PATH)
+catalog = ParquetDataCatalog(CATALOG_PATH)  # Create a new ParquetDataCatalog instance
+
+# # For DEFAULT nautilus-trader with default function btcusdt_future_binance in TestInstrumentProvider
+# instrument = TestInstrumentProvider.btcusdt_future_binance()
+
+# For EDITABLE nautilus-trader with customized function btcusdt_future_OKX in TestInstrumentProvider
+# Use nautilus test helpers to create a BTC/USDT Crypto instrument for our purposes
+maker1 = Decimal(-0.000001)
+taker1 = Decimal(0.0000143)
+instrument = TestInstrumentProvider.btcusdt_future_OKX(maker=maker1, taker=taker1)
+
+# Add our new instrument to the ParquetDataCatalog and check its existence
+write_objects(catalog, [instrument])
+catalog.instruments()
+
+# Loading the files (the header can be customized)
+process_files(
+    glob_path=input_files,
+    reader=CSVReader(
+        block_parser=lambda x: parser(x, instrument_id=instrument.id),
+        header=None,
+        chunked=False,
+        as_dataframe=True,
+    ),
+    catalog=catalog,
+)
+
+# Also manually write the instrument to the catalog
+write_objects(catalog, [instrument])
+
+# Using the data Catalog
+start = dt_to_unix_nanos(pd.Timestamp('2022-01-01', tz='UTC'))
+end = dt_to_unix_nanos(pd.Timestamp('2022-01-01 23:00:00', tz='UTC'))
+
+catalog.quote_ticks(start=start, end=end)
\ No newline at end of file
diff --git a/Jerry's tests/OKX_BTCUSDT_Level2_Test.py b/Jerry's tests/OKX_BTCUSDT_Level2_Test.py
new file mode 100644
index 000000000..03d775cf8
--- /dev/null
+++ b/Jerry's tests/OKX_BTCUSDT_Level2_Test.py	
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+# -------------------------------------------------------------------------------------------------
+# This file is a backtest file with imported catalog quote tick data of OKX
+# This file is using BacktestNode to run the backtest
+# Customized by Jerry based on exmaples\notebooks\external_data_backtest.ipynb
+# -------------------------------------------------------------------------------------------------
+
+import time
+from decimal import Decimal
+
+import pandas as pd
+
+from nautilus_trader.backtest.node import BacktestNode
+from nautilus_trader.core.datetime import dt_to_unix_nanos
+from nautilus_trader.config import BacktestRunConfig, BacktestVenueConfig, BacktestDataConfig, BacktestEngineConfig
+from nautilus_trader.config import ImportableStrategyConfig
+from nautilus_trader.config import LoggingConfig
+from nautilus_trader.config.common import ImportableStrategyConfig
+from nautilus_trader.model.data.tick import QuoteTick
+from nautilus_trader.persistence.catalog import ParquetDataCatalog
+
+
+if __name__ == "__main__":
+
+    # Using the data Catalog
+    # catalog = ParquetDataCatalog.from_env()  # Create a new ParquetDataCatalog instance from the environment
+    # ran on 08/28/23 Mon 14:50:00 but failed with no [Nautilus_Path]
+    CATALOG_PATH = "D:/backtest/backtest1/catalog_Sz_01"  # "your_path_to_catalog"
+    catalog = ParquetDataCatalog(CATALOG_PATH)  # Create a new ParquetDataCatalog instance
+    catalog.instruments()  # List all instruments in the catalog
+
+    start = dt_to_unix_nanos(pd.Timestamp('2022-01-01', tz='UTC'))
+    end = dt_to_unix_nanos(pd.Timestamp('2022-01-01 23:00:00', tz='UTC'))
+
+    catalog.quote_ticks(start=start, end=end)
+
+    # Add instruments
+    instrument = catalog.instruments(as_nautilus=True)[0]
+
+    # Add a trading venue (multiple venues possible)
+    venues_config = [
+        BacktestVenueConfig(
+            name="OKX",
+            oms_type="HEDGING",
+            account_type="MARGIN",
+            base_currency="USDT",
+            starting_balances=["1000000 USDT"],
+        )
+    ]
+
+    # Add data
+    data_config = [
+        BacktestDataConfig(
+            catalog_path=str(catalog.path),
+            data_cls=QuoteTick,
+            instrument_id=instrument.id.value,
+            start_time=pd.Timestamp("2022-01-01").value,
+            end_time=pd.Timestamp("2022-01-01 00:00:30").value,
+        )
+    ]
+
+    # Configure your strategy
+    strategies = [
+        ImportableStrategyConfig(
+            strategy_path="nautilus_trader.examples.strategies.orderbook_imbalance:OrderBookImbalance",
+            config_path="nautilus_trader.examples.strategies.orderbook_imbalance:OrderBookImbalanceConfig",
+            config=dict(
+                instrument_id=instrument.id.value,
+                max_trade_size=Decimal(1000),
+                use_quote_ticks=True,
+                trigger_min_size=0.5,
+                trigger_imbalance_ratio=0.4,
+                book_type="L1_TBBO",
+                # order_id_tag=instrument.selection_id,
+                # AttributeError: 'nautilus_trader.model.instruments.crypto_future.Cr' object has no attribute 'selection_id'
+            ),
+        ),
+    ]
+
+    config = BacktestRunConfig(
+        engine=BacktestEngineConfig(
+            strategies=strategies,
+            logging=LoggingConfig(log_level="ERROR"),
+        ),
+        data=data_config,
+        venues=venues_config,
+    )
+
+    node = BacktestNode(configs=[config])  # successfully ran but no reports
+
+    results = node.run()
+    print(results)
diff --git a/Jerry's tests/OKX_backtest_example.ipynb b/Jerry's tests/OKX_backtest_example.ipynb
new file mode 100644
index 000000000..f612cf96c
--- /dev/null
+++ b/Jerry's tests/OKX_backtest_example.ipynb	
@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3fb0574f-6e59-41af-a0ed-f7e4a33e3717",
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2023-08-27T22:47:52.310088Z",
+     "end_time": "2023-08-27T22:47:56.752708Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from decimal import Decimal\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "from nautilus_trader.backtest.node import BacktestNode\n",
+    "from nautilus_trader.core.datetime import dt_to_unix_nanos\n",
+    "from nautilus_trader.config import BacktestRunConfig, BacktestVenueConfig, BacktestDataConfig, BacktestEngineConfig\n",
+    "from nautilus_trader.config import ImportableStrategyConfig\n",
+    "from nautilus_trader.config import LoggingConfig\n",
+    "from nautilus_trader.examples.strategies.orderbook_imbalance import OrderBookImbalance\n",
+    "from nautilus_trader.examples.strategies.orderbook_imbalance import OrderBookImbalanceConfig\n",
+    "from nautilus_trader.model.data.tick import QuoteTick\n",
+    "from nautilus_trader.persistence.catalog import ParquetDataCatalog"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45d39b65-d3af-4d91-bbe7-2e3f109c0e0e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "catalog = ParquetDataCatalog.from_env()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d3ddd1-3987-4a5d-b787-c94a491462aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "catalog.instruments()\n",
+    "start = dt_to_unix_nanos(pd.Timestamp('2022-01-01', tz='UTC'))\n",
+    "end =  dt_to_unix_nanos(pd.Timestamp('2022-01-01 23:00:00', tz='UTC'))\n",
+    "\n",
+    "catalog.quote_ticks(start=start, end=end)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "265677cf-3a93-4b05-88f5-8e7c042a7860",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "instrument = catalog.instruments(as_nautilus=True)[0]\n",
+    "\n",
+    "data_config=[\n",
+    "    BacktestDataConfig(\n",
+    "        catalog_path=str(ParquetDataCatalog.from_env().path),\n",
+    "        data_cls=QuoteTick,\n",
+    "        instrument_id=instrument.id.value,\n",
+    "        start_time=pd.Timestamp(\"2022-01-01\").value,\n",
+    "        end_time=pd.Timestamp(\"2022-01-01 23:00:00\").value,\n",
+    "    )\n",
+    "]\n",
+    "\n",
+    "venues_config=[\n",
+    "    BacktestVenueConfig(\n",
+    "        name=\"OKX\",\n",
+    "        oms_type=\"HEDGING\",\n",
+    "        account_type=\"MARGIN\",\n",
+    "        base_currency=\"USD\",\n",
+    "        starting_balances=[\"1000000 USD\"],\n",
+    "    )\n",
+    "]\n",
+    "\n",
+    "strategies = [\n",
+    "    ImportableStrategyConfig(\n",
+    "        strategy_path=\"nautilus_trader.examples.strategies.orderbook_imbalance:OrderBookImbalance\",\n",
+    "        config_path=\"nautilus_trader.examples.strategies.orderbook_imbalance:OrderBookImbalanceConfig\",\n",
+    "        config=dict(\n",
+    "            instrument_id=instrument.id.value,\n",
+    "            max_trade_size=Decimal(10),\n",
+    "            order_id_tag=instrument.selection_id,\n",
+    "        ),\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "# NautilusTrader currently exceeds the rate limit for Jupyter notebook logging (stdout output),\n",
+    "# this is why the `log_level` is set to \"ERROR\". If you lower this level to see\n",
+    "# more logging then the notebook will hang during cell execution. A fix is currently\n",
+    "# being investigated which involves either raising the configured rate limits for\n",
+    "# Jupyter, or throttling the log flushing from Nautilus.\n",
+    "# https://github.com/jupyterlab/jupyterlab/issues/12845\n",
+    "# https://github.com/deshaw/jupyterlab-limit-output\n",
+    "config = BacktestRunConfig(\n",
+    "    engine=BacktestEngineConfig(\n",
+    "        strategies=strategies,\n",
+    "        logging=LoggingConfig(log_level=\"ERROR\"),\n",
+    "    ),\n",
+    "    data=data_config,\n",
+    "    venues=venues_config,\n",
+    ")\n",
+    "\n",
+    "config"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77f4d5cb-621f-4d5b-843e-7c0da11073ae",
+   "metadata": {},
+   "source": [
+    "## Run the backtest!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "741b9024-6c0d-4cb9-9c28-687add29cd4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node = BacktestNode(configs=[config])\n",
+    "\n",
+    "result = node.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d50d1cd-d778-4e0f-b9da-ff9e44f4499f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Jerry's tests/Parquet_Reader.py b/Jerry's tests/Parquet_Reader.py
new file mode 100644
index 000000000..e52a74f2e
--- /dev/null
+++ b/Jerry's tests/Parquet_Reader.py	
@@ -0,0 +1,15 @@
+import pandas as pd
+
+pd.set_option('display.max_columns', None)  # 显示所有列
+pd.set_option('display.width', None)        # 确保每一列都能完全显示
+pd.set_option('display.max_rows', None)     # 显示所有行
+pd.set_option('display.max_colwidth', None) # 显示每一列的完整内容
+
+filename = r"D:\backtest\backtest1\catalog_Sz_01\data\quote_tick.parquet\instrument_id=BTCUSDT_220325.OKX\1640995200008000000-1640997071853000000-0.parquet"
+# Update the file extension to .parquet
+data = pd.read_parquet(filename, engine='pyarrow')  # Use read_parquet instead of read_csv
+
+print(data)
+print(data.dtypes)  # 查看每一列的数据类型
+print(data.head())  # 查看head
+print(data.columns)  # 查看列名
\ No newline at end of file
diff --git a/Jerry's tests/Price_Model_XC.ipynb b/Jerry's tests/Price_Model_XC.ipynb
new file mode 100644
index 000000000..fd061eac0
--- /dev/null
+++ b/Jerry's tests/Price_Model_XC.ipynb	
@@ -0,0 +1,73 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "from datetime import date,datetime\n",
+    "import time\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import ast\n",
+    "%matplotlib inline\n",
+    "\n",
+    "\"\"\"\n",
+    "数据源：YGGUSDT, BINANCE, 08072023\n",
+    "文章来源：https://www.fmz.com/bbs-topic/10198\n",
+    "作者：小草\n",
+    "\n",
+    "订单流数据和十档的深度数据，来自于实盘收集，更新频率都是100ms。实盘的只包含买一卖一盘口数据是实时更新的，为了简洁，暂时不用。考虑到数据太大，只保留了10万行深度数据，并且把逐档行情也独立为单独的列。\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "tick_size = 0.0001\n",
+    "trades = pd.read_csv('YGGUSDT_aggTrade.csv',names=['type','event_time', 'agg_trade_id','symbol', 'price', 'quantity', 'first_trade_id', 'last_trade_id',\n",
+    "       'transact_time', 'is_buyer_maker'])\n",
+    "# 导入订单流/归集成交数据(大概率是作者自己录制的，频率是100ms)"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/Jerry's tests/backtest_of_asq.ipynb b/Jerry's tests/backtest_of_asq.ipynb
new file mode 100644
index 000000000..e36418da7
--- /dev/null
+++ b/Jerry's tests/backtest_of_asq.ipynb	
@@ -0,0 +1,312 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "import scipy\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_data(target='LDOBUSD'):\n",
+    "    data = pd.read_csv(f'../bookticker/{target}-bookTicker-2023-05.csv')\n",
+    "    data = data.rename(columns={\n",
+    "        'best_bid_price': 'bp', \n",
+    "        'best_bid_qty': 'bv',\n",
+    "        'best_ask_price': 'ap', \n",
+    "        'best_ask_qty': 'av',\n",
+    "        'event_time': 'time'  \n",
+    "        })\n",
+    "    data['trade_date'] = pd.to_datetime(data['time'] // 1000 // 60 // 60 // 24, unit='d')\n",
+    "    return data\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_market_speed(data: pd.DataFrame, price_int: float):\n",
+    "    deltalist = np.linspace(price_int, price_int * 10, 10)\n",
+    "    deltadict = {}\n",
+    "\n",
+    "    for delta in deltalist:\n",
+    "        price_interval = delta\n",
+    "        ask_limit_order_hit = data[('ap', 'max')].shift(-1) > (data[('ap', 'last')] + price_interval) \n",
+    "        bid_limit_order_hit = data[('bp', 'min')].shift(-1) < (data[('bp', 'last')] - price_interval)\n",
+    "        limit_order_hit = (ask_limit_order_hit | bid_limit_order_hit).astype(int)\n",
+    "        deltas = pd.Series(limit_order_hit[limit_order_hit == 1].index).diff().apply(lambda x: x / 10)\n",
+    "        deltadict[delta] = deltas\n",
+    "    \n",
+    "    lambdas = pd.DataFrame([[key,1/deltadict[key].mean()] for key in deltadict.keys()],\n",
+    "                       columns=['delta','lambda_delta']).set_index('delta')\n",
+    "    \n",
+    "    def exp_fit(x,a,b):\n",
+    "        y = a*np.exp(-b*x)\n",
+    "        return y\n",
+    "\n",
+    "    paramsB, cv = scipy.optimize.curve_fit(exp_fit, np.array(lambdas.index), np.array(lambdas['lambda_delta'].values))\n",
+    "    A, k = paramsB\n",
+    "    return A, k"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_params(data: pd.DataFrame, price_int: float, time_step: int):\n",
+    "    data = data.copy(deep=True)    \n",
+    "\n",
+    "    # 1. 按照time_step的频率把数据采样起来（相当于订单的更新的频率不能太高）\n",
+    "    data['ms-index'] = data['time'] // time_step    \n",
+    "    prices = data.groupby('ms-index').agg({\n",
+    "        'ap': ['last', 'max', 'min'],\n",
+    "        'bp': ['last', 'max', 'min']\n",
+    "        })\n",
+    "    \n",
+    "    # 2. 估计当前每条数据平均多少时间，用于估计交易时间\n",
+    "    min_index, max_index = prices.index[0], prices.index[prices.shape[0]-1]\n",
+    "    ave_time = time_step * (max_index - min_index) / prices.shape[0]\n",
+    "\n",
+    "    # 2. 波动率\n",
+    "    prices['mid'] = (prices[('ap', 'last')] + prices[('bp', 'last')]) / 2\n",
+    "    sigma = np.log(prices['mid']).diff().std() * np.sqrt(24 * 60 * 60 * 1000 / ave_time)\n",
+    "    \n",
+    "    # 5. 市价单到达速率参数\n",
+    "    A, k = get_market_speed(prices, price_int)\n",
+    "\n",
+    "    return sigma, A, k\n",
+    "\n",
+    "def get_bid_spread(sigma, A, k, gamma, q):\n",
+    "    var1 = (1 / gamma) * np.log(1 + gamma / k)\n",
+    "    var2 = (2 * q + 1) / 2 * np.sqrt(sigma**2 * gamma / (2 * k * A) * (1 + gamma/k)**(1+k/gamma))\n",
+    "    return var1 + var2\n",
+    "\n",
+    "def get_ask_spread(sigma, A, k, gamma, q):\n",
+    "    var1 = (1 / gamma) * np.log(1 + gamma / k)\n",
+    "    var2 = (2 * q - 1) / 2 * np.sqrt(sigma**2 * gamma / (2 * k * A) * (1 + gamma/k)**(1+k/gamma))\n",
+    "    return var1 - var2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluation(data: pd.DataFrame, price_int: float, time_step: int, params: dict):\n",
+    "    \"\"\" 输入是一段历史成交的数据，来计算波动率\n",
+    "    \"\"\" \n",
+    "    data = data.copy(deep=True)    \n",
+    "    date = data['trade_date'].iloc[0]\n",
+    "    \n",
+    "    # 1. 按照time_step的频率把数据合并起来\n",
+    "    data['ms-index'] = data['time'] // time_step    \n",
+    "    prices = data.groupby('ms-index').agg({\n",
+    "        'ap': ['last', 'max', 'min'],\n",
+    "        'bp': ['last', 'max', 'min']\n",
+    "        })\n",
+    "    \n",
+    "    prices['mid'] = (prices[('ap', 'last')] + prices[('bp', 'last')]) / 2\n",
+    "    \n",
+    "    # 4. 回测\n",
+    "    N = prices.shape[0]\n",
+    "    q    = np.array([params['q']] + [0] * (N-1))   # 补上上一轮回测的结果\n",
+    "    x    = np.array([params['x']] + [0] * (N-1), dtype=float)\n",
+    "    pnl  = np.array([params['pnl']] + [0] * (N-1), dtype=float)\n",
+    "    fees = np.array([params['fees']] + [0] * (N-1), dtype=float)\n",
+    "    ra = np.zeros(N)\n",
+    "    rb = np.zeros(N)\n",
+    "\n",
+    "    sigma = params['sigma']\n",
+    "    A     = params['A']\n",
+    "    k     = params['k']\n",
+    "    gamma = params['gamma']\n",
+    "    fee_rate = params['fee_rate']\n",
+    "\n",
+    "    for i in tqdm(range(N-1), desc=f'[evaluation {date}] '):\n",
+    "        \n",
+    "        ra[i] = prices['mid'].iloc[i] + get_ask_spread(sigma, A, k, gamma, q[i])\n",
+    "        rb[i] = prices['mid'].iloc[i] - get_bid_spread(sigma, A, k, gamma, q[i])\n",
+    "\n",
+    "        # 这里限制了价格一定得是挂单方的价格，不会变成吃单\n",
+    "        ra[i] = max(prices[('ap', 'last')].iloc[i], np.floor(ra[i] * (1 / price_int)) * price_int)\n",
+    "        rb[i] = min(prices[('bp', 'last')].iloc[i], np.ceil(rb[i] * (1 / price_int)) * price_int)\n",
+    "\n",
+    "        buy = 0\n",
+    "        sell = 0\n",
+    "\n",
+    "        if prices[('ap', 'max')].iloc[i+1] > ra[i]:\n",
+    "            sell = 1\n",
+    "        \n",
+    "        if prices[('bp', 'min')].iloc[i+1] < rb[i]:\n",
+    "            buy = 1\n",
+    "\n",
+    "        q[i+1] = q[i] + buy - sell\n",
+    "        x[i+1] = x[i] + sell*ra[i] - buy*rb[i]\n",
+    "        pnl[i+1]  = x[i+1] + q[i+1] * prices['mid'].iloc[i+1]\n",
+    "        fees[i+1] = fees[i] + sell*ra[i] * fee_rate + buy*rb[i] * fee_rate\n",
+    "    return pnl, x, q, fees"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "target = 'LDOBUSD'\n",
+    "fee_rate = 1.4e-4\n",
+    "\n",
+    "trade_interval = 1000   \n",
+    "gamma = 0.01\n",
+    "\n",
+    "price_int_dict = {'LDOBUSD': 0.0001, 'LTCBUSD': 0.01, 'BTCBUSD': 0.10, 'ETHBUSD': 0.01}\n",
+    "price_int      = price_int_dict[target]\n",
+    "data = load_data(target=target)\n",
+    "trade_dates = sorted(list(data['trade_date'].unique()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[evaluation 2023-05-16 00:00:00] : 100%|██████████| 33370/33370 [00:50<00:00, 655.06it/s]\n",
+      "[evaluation 2023-05-17 00:00:00] : 100%|██████████| 49993/49993 [01:36<00:00, 518.24it/s]\n",
+      "[evaluation 2023-05-18 00:00:00] : 100%|██████████| 75498/75498 [02:10<00:00, 579.07it/s]\n",
+      "[evaluation 2023-05-19 00:00:00] : 100%|██████████| 70253/70253 [01:52<00:00, 623.25it/s]\n",
+      "[evaluation 2023-05-20 00:00:00] : 100%|██████████| 56879/56879 [01:49<00:00, 519.86it/s]\n",
+      "[evaluation 2023-05-21 00:00:00] : 100%|██████████| 56274/56274 [01:04<00:00, 878.07it/s]\n",
+      "[evaluation 2023-05-22 00:00:00] : 100%|██████████| 60805/60805 [01:30<00:00, 670.07it/s]\n",
+      "[evaluation 2023-05-23 00:00:00] : 100%|██████████| 61767/61767 [01:46<00:00, 577.44it/s]\n",
+      "[evaluation 2023-05-24 00:00:00] : 100%|██████████| 67487/67487 [01:16<00:00, 882.60it/s]\n",
+      "[evaluation 2023-05-25 00:00:00] : 100%|██████████| 66971/66971 [01:51<00:00, 599.55it/s]\n",
+      "[evaluation 2023-05-26 00:00:00] : 100%|██████████| 67846/67846 [02:09<00:00, 521.94it/s]\n",
+      "[evaluation 2023-05-27 00:00:00] : 100%|██████████| 59954/59954 [01:55<00:00, 517.70it/s]\n",
+      "[evaluation 2023-05-28 00:00:00] : 100%|██████████| 66805/66805 [02:07<00:00, 522.33it/s]\n",
+      "[evaluation 2023-05-29 00:00:00] : 100%|██████████| 69053/69053 [02:12<00:00, 520.86it/s]\n",
+      "[evaluation 2023-05-30 00:00:00] : 100%|██████████| 64900/64900 [01:42<00:00, 632.71it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_q = 0\n",
+    "last_x = 0\n",
+    "last_pnl = 0\n",
+    "last_fees = 0\n",
+    "\n",
+    "results = [[], [], [], []]\n",
+    "for i in range(len(trade_dates) - 1):\n",
+    "    valid_data = data[data['trade_date'] == trade_dates[i]]\n",
+    "    test_data  = data[data['trade_date'] == trade_dates[i]]\n",
+    "\n",
+    "    sigma, A, k = get_params(valid_data, time_step=trade_interval, price_int=price_int)\n",
+    "    params = {'q': last_q, 'x': last_x, 'pnl': last_pnl, 'sigma': sigma, 'A': A, 'k': k, 'gamma': gamma, 'fees': last_fees, 'fee_rate': fee_rate}\n",
+    "    pnl, x, q, fees = evaluation(test_data, price_int=price_int, time_step=trade_interval, params=params)\n",
+    "    results[0].append(pnl)\n",
+    "    results[1].append(x)\n",
+    "    results[2].append(q)\n",
+    "    results[3].append(fees)\n",
+    "\n",
+    "    last_q = q[-1]\n",
+    "    last_x = x[-1]\n",
+    "    last_pnl = pnl[-1]\n",
+    "    last_fees = fees[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1440x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 1, figsize=(20, 8))\n",
+    "ax1, ax2 = axes\n",
+    "\n",
+    "dates_str = [pd.to_datetime(str(item)).strftime('%Y.%m.%d') for item in trade_dates][1:]    # 去掉第一个，因为第一天没有回测，只用来确定参数\n",
+    "\n",
+    "xticks = [0]\n",
+    "for item in results[0][:-1]:\n",
+    "    xticks.append(xticks[-1] + item.shape[0])\n",
+    "\n",
+    "ax1.plot(np.concatenate(results[0], axis=0), label='pnl')\n",
+    "ax1.plot(np.concatenate(results[3], axis=0), label='fees')\n",
+    "ax1.plot(np.concatenate(results[0], axis=0) + np.concatenate(results[3], axis=0) , label='pnl+fees')\n",
+    "ax1.grid()\n",
+    "ax1.legend()\n",
+    "ax1.set_xticks(xticks)\n",
+    "ax1.set_xticklabels(dates_str)\n",
+    "ax1.set_xlabel('Time')\n",
+    "ax1.set_ylabel('Value')\n",
+    "\n",
+    "ax2.plot(np.concatenate(results[2], axis=0), label='pos')\n",
+    "ax2.grid()\n",
+    "ax2.legend()\n",
+    "ax2.set_xticks(xticks)\n",
+    "ax2.set_xticklabels(dates_str)\n",
+    "ax2.set_xlabel('Time')\n",
+    "ax2.set_ylabel('Volume')\n",
+    "plt.suptitle(target)\n",
+    "fig.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "finance",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.9"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Pair_Trading_Brad_JerryModified b/Pair_Trading_Brad_JerryModified
new file mode 160000
index 000000000..fb630f339
--- /dev/null
+++ b/Pair_Trading_Brad_JerryModified
@@ -0,0 +1 @@
+Subproject commit fb630f3393231bf3ef549e30d3bc0db1ad503e34
diff --git a/examples/live/binance_futures_market_maker.py b/examples/live/binance_futures_market_maker.py
index 77202742a..5e9178cce 100644
--- a/examples/live/binance_futures_market_maker.py
+++ b/examples/live/binance_futures_market_maker.py
@@ -73,7 +73,7 @@
 
 # Configure your strategy
 strat_config = VolatilityMarketMakerConfig(
-    instrument_id="ETHUSDT-PERP.BINANCE",
+    instrument_id="ETHUSDT-PERP.BINANCE",  # Q to be solved: is this defined in a file of NT or just defined here by the user?
     bar_type="ETHUSDT-PERP.BINANCE-1-MINUTE-LAST-EXTERNAL",
     atr_period=20,
     atr_multiple=6.0,
diff --git a/examples/notebooks/backtest_example.ipynb b/examples/notebooks/backtest_example.ipynb
index b286d3b31..908f2cd58 100644
--- a/examples/notebooks/backtest_example.ipynb
+++ b/examples/notebooks/backtest_example.ipynb
@@ -39,8 +39,8 @@
    "outputs": [],
    "source": [
     "catalog.instruments()\n",
-    "start = dt_to_unix_nanos(pd.Timestamp('2020-01-01', tz='UTC'))\n",
-    "end =  dt_to_unix_nanos(pd.Timestamp('2020-01-02', tz='UTC'))\n",
+    "start = dt_to_unix_nanos(pd.Timestamp('2022-01-01', tz='UTC'))\n",
+    "end =  dt_to_unix_nanos(pd.Timestamp('2022-01-01 23:00:00', tz='UTC'))\n",
     "\n",
     "catalog.quote_ticks(start=start, end=end)"
    ]
diff --git a/nautilus_trader/adapters/OKX/__init__.py b/nautilus_trader/adapters/OKX/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/nautilus_trader/adapters/binance/common/enums.py b/nautilus_trader/adapters/binance/common/enums.py
index b5372702a..5faf9cb64 100644
--- a/nautilus_trader/adapters/binance/common/enums.py
+++ b/nautilus_trader/adapters/binance/common/enums.py
@@ -112,8 +112,8 @@ class BinanceAccountType(Enum):
     SPOT = "SPOT"
     MARGIN_CROSS = "MARGIN_CROSS"
     MARGIN_ISOLATED = "MARGIN_ISOLATED"
-    FUTURES_USDT = "FUTURES_USDT"
-    FUTURES_COIN = "FUTURES_COIN"
+    FUTURES_USDT = "FUTURES_USDT"  # USDT-M futures
+    FUTURES_COIN = "FUTURES_COIN"  # COIN-M futures
 
     @property
     def is_spot(self):
diff --git a/nautilus_trader/analysis/statistics/sharpe_ratio.py b/nautilus_trader/analysis/statistics/sharpe_ratio.py
index a1512594d..802f15bc8 100644
--- a/nautilus_trader/analysis/statistics/sharpe_ratio.py
+++ b/nautilus_trader/analysis/statistics/sharpe_ratio.py
@@ -29,7 +29,7 @@ class SharpeRatio(PortfolioStatistic):
 
     Parameters
     ----------
-    period : int, default 252
+    period : int, default 252  # 252 trading days in a year in general markets, can be changed to 365 for crypto
         The trading period in days.
     """
 
diff --git a/nautilus_trader/examples/strategies/AS_Market_Maker.py b/nautilus_trader/examples/strategies/AS_Market_Maker.py
new file mode 100644
index 000000000..ef9e850a5
--- /dev/null
+++ b/nautilus_trader/examples/strategies/AS_Market_Maker.py
@@ -0,0 +1,214 @@
+# -------------------------------------------------------------------------------------------------
+#  Copyright 2023 Jerry Li @ Positive Venture Group
+#
+#
+#  This file is a template for Q-quant market making strategies as Avelleneda-Stoikov (AS) market maker.
+#  This strategy is based on tick level data and is designed for HFT market making.
+# -------------------------------------------------------------------------------------------------
+
+from decimal import Decimal
+from typing import Optional
+
+from nautilus_trader.config import StrategyConfig
+from nautilus_trader.model.data.tick import QuoteTick
+from nautilus_trader.model.enums import BookType
+from nautilus_trader.model.enums import OrderSide
+from nautilus_trader.model.enums import TimeInForce
+from nautilus_trader.model.enums import book_type_from_str
+from nautilus_trader.model.identifiers import InstrumentId
+from nautilus_trader.model.instruments.base import Instrument
+from nautilus_trader.model.orderbook.book import OrderBook
+from nautilus_trader.model.orderbook.data import BookOrder
+from nautilus_trader.model.orderbook.data import OrderBookData
+from nautilus_trader.trading.strategy import Strategy
+
+
+# *** Avelleneda-Stoikov (AS) Market making model. ***
+# *** In the initial model, it loses from trades themselves and profits from the maker transaction fee rebate. ***
+
+
+class OrderBookImbalanceConfig(StrategyConfig):
+    """
+    Configuration for ``OrderBookImbalance`` instances.
+
+    Parameters
+    ----------
+    instrument_id : InstrumentId
+        The instrument ID for the strategy.
+    max_trade_size : str
+        The max position size per trade (volume on the level can be less).
+    trigger_min_size : float
+        The minimum size on the larger side to trigger an order.
+    order_id_tag : str
+        The unique order ID tag for the strategy. Must be unique
+        amongst all running strategies for a particular trader ID.
+    oms_type : OmsType
+        The order management system type for the strategy. This will determine
+        how the `ExecutionEngine` handles position IDs (see docs).
+    book_type : BookType {``L1_TBBO``, ``L2_MBP``, ``L3_MBO``}
+        The order book type to use for the strategy.
+    use_quote_ticks : bool
+        Whether to use quote ticks instead of order book data. When set to True,
+        the strategy will use the  "L1_TBBO" orderbook and subscribe quotetick data
+        no matter what the book_type is; When set to False, the strategy will use
+        the book_type orderbook and subscribe to orderbook delta data
+    subscribe_ticker : bool
+        Whether to subscribe to ticker data. When set to True, the strategy will
+        subscribe to ticker data in addition to the data source specified by book_type and use_quote_ticks.
+    gamma : float
+        The risk aversion parameter.
+    Q: float
+        The maximum position size.
+    A： float
+        The parameter of the exponential market speed function (y = A*np.exp(-k*x)).
+    k: float
+        The parameter of the number of times of the exponential market speed function.
+    sigma: float
+        The volotility (std) of the target price
+    trade_interval: int
+        The frequency of trading. The unit is ms
+    fee_rate: float
+        The transaction fee rate
+    """
+
+    instrument_id: str
+    max_trade_size: Decimal
+    trigger_min_size: float = 0.5
+    trigger_imbalance_ratio: float = 0.4
+    book_type: str = "L2_MBP"
+    use_quote_ticks: bool = False
+    subscribe_ticker: bool = False
+
+
+class OrderBookImbalance(Strategy):
+    """
+    A simple strategy that sends FOK limit orders when there is a bid/ask
+    imbalance in the order book.
+
+    Cancels all orders and closes all positions on stop.
+
+    Parameters
+    ----------
+    config : OrderbookImbalanceConfig
+        The configuration for the instance.
+    """
+
+    def __init__(self, config: OrderBookImbalanceConfig):
+        assert 0 < config.trigger_imbalance_ratio < 1
+        super().__init__(config)
+
+        # Configuration
+        self.instrument_id = InstrumentId.from_str(config.instrument_id)
+        self.max_trade_size = Decimal(config.max_trade_size)
+        self.trigger_min_size = config.trigger_min_size
+        self.trigger_imbalance_ratio = config.trigger_imbalance_ratio
+        self.instrument: Optional[Instrument] = None
+        if self.config.use_quote_ticks:
+            assert self.config.book_type == "L1_TBBO"
+        self.book_type: BookType = book_type_from_str(self.config.book_type)
+        self._book = None  # type: Optional[OrderBook]
+
+    def on_start(self):
+        """Actions to be performed on strategy start."""
+        self.instrument = self.cache.instrument(self.instrument_id)
+        if self.instrument is None:
+            self.log.error(f"Could not find instrument for {self.instrument_id}")
+            self.stop()
+            return
+
+        if self.config.use_quote_ticks:
+            book_type = BookType.L1_TBBO
+            self.subscribe_quote_ticks(self.instrument.id)
+        else:
+            book_type = book_type_from_str(self.config.book_type)
+            self.subscribe_order_book_deltas(self.instrument.id, book_type)
+        if self.config.subscribe_ticker:
+            self.subscribe_ticker(self.instrument.id)
+        self._book = OrderBook.create(instrument=self.instrument, book_type=book_type)
+
+    def on_order_book_delta(self, data: OrderBookData):
+        """Actions to be performed when a delta is received."""
+        if not self._book:
+            self.log.error("No book being maintained.")
+            return
+
+        self._book.apply(data)
+        if self._book.spread():
+            self.check_trigger()
+
+    def on_quote_tick(self, tick: QuoteTick):
+        """Actions to be performed when a delta is received."""
+        bid = BookOrder(
+            price=tick.bid.as_double(),
+            size=tick.bid_size.as_double(),
+            side=OrderSide.BUY,
+        )
+        ask = BookOrder(
+            price=tick.ask.as_double(),
+            size=tick.ask_size.as_double(),
+            side=OrderSide.SELL,
+        )
+
+        self._book.clear()
+        self._book.update(bid)
+        self._book.update(ask)
+        if self._book.spread():
+            self.check_trigger()
+
+    def on_order_book(self, order_book: OrderBook):
+        """Actions to be performed when an order book update is received."""
+        self._book = order_book
+        if self._book.spread():
+            self.check_trigger()
+
+    def check_trigger(self):
+        """Check for trigger conditions."""
+        if not self._book:
+            self.log.error("No book being maintained.")
+            return
+
+        if not self.instrument:
+            self.log.error("No instrument loaded.")
+            return
+
+        bid_size = self._book.best_bid_qty()
+        ask_size = self._book.best_ask_qty()
+        if not (bid_size and ask_size):
+            return
+
+        smaller = min(bid_size, ask_size)
+        larger = max(bid_size, ask_size)
+        ratio = smaller / larger
+        self.log.info(
+            f"Book: {self._book.best_bid_price()} @ {self._book.best_ask_price()} ({ratio=:0.4f})",  # ratio was 0.2 initially
+        )
+        if larger > self.trigger_min_size and ratio < self.trigger_imbalance_ratio:
+            if len(self.cache.orders_inflight(strategy_id=self.id)) > 0:
+                pass
+            elif bid_size > ask_size:
+                order = self.order_factory.limit(
+                    instrument_id=self.instrument.id,
+                    price=self.instrument.make_price(self._book.best_ask_price()),
+                    order_side=OrderSide.BUY,
+                    quantity=self.instrument.make_qty(ask_size),
+                    post_only=False,
+                    time_in_force=TimeInForce.FOK,
+                )
+                self.submit_order(order)
+            else:
+                order = self.order_factory.limit(
+                    instrument_id=self.instrument.id,
+                    price=self.instrument.make_price(self._book.best_bid_price()),
+                    order_side=OrderSide.SELL,
+                    quantity=self.instrument.make_qty(bid_size),
+                    post_only=False,
+                    time_in_force=TimeInForce.FOK,
+                )
+                self.submit_order(order)
+
+    def on_stop(self):
+        """Actions to be performed when the strategy is stopped."""
+        if self.instrument is None:
+            return
+        self.cancel_all_orders(self.instrument.id)
+        self.close_all_positions(self.instrument.id)
diff --git a/nautilus_trader/examples/strategies/orderbook_imbalance.py b/nautilus_trader/examples/strategies/orderbook_imbalance.py
index 178f5b645..85c7e527f 100644
--- a/nautilus_trader/examples/strategies/orderbook_imbalance.py
+++ b/nautilus_trader/examples/strategies/orderbook_imbalance.py
@@ -61,8 +61,8 @@ class OrderBookImbalanceConfig(StrategyConfig):
 
     instrument_id: str
     max_trade_size: Decimal
-    trigger_min_size: float = 100.0
-    trigger_imbalance_ratio: float = 0.20
+    trigger_min_size: float = 0.5
+    trigger_imbalance_ratio: float = 0.4
     book_type: str = "L2_MBP"
     use_quote_ticks: bool = False
     subscribe_ticker: bool = False
@@ -168,7 +168,7 @@ def check_trigger(self):
         larger = max(bid_size, ask_size)
         ratio = smaller / larger
         self.log.info(
-            f"Book: {self._book.best_bid_price()} @ {self._book.best_ask_price()} ({ratio=:0.2f})",
+            f"Book: {self._book.best_bid_price()} @ {self._book.best_ask_price()} ({ratio=:0.4f})",  # ratio was 0.2 initially
         )
         if larger > self.trigger_min_size and ratio < self.trigger_imbalance_ratio:
             if len(self.cache.orders_inflight(strategy_id=self.id)) > 0:
diff --git a/nautilus_trader/test_kit/providers.py b/nautilus_trader/test_kit/providers.py
index aa4b4a616..8c9fd7fb4 100644
--- a/nautilus_trader/test_kit/providers.py
+++ b/nautilus_trader/test_kit/providers.py
@@ -395,6 +395,53 @@ def default_fx_ccy(symbol: str, venue: Venue = None) -> CurrencyPair:
         )
 
     @staticmethod
+    def btcusdt_future_OKX(expiry: Optional[date] = None, maker: Decimal = 0.00001,
+                           taker: Decimal = 0.0000143) -> CryptoFuture:
+        """
+        Return the OKX BTCUSDT instrument for backtesting.
+
+        Parameters
+        ----------
+        expiry : date, optional
+            The expiry date for the contract.
+        maker : Decimal,`optional`, maker transaction fee
+        taker : Decimal,`optional`, taker transaction fee
+
+        Returns
+        -------
+        CryptoFuture
+
+        """
+        if expiry is None:
+            expiry = date(2022, 3, 25)
+        return CryptoFuture(
+            instrument_id=InstrumentId(
+                symbol=Symbol(f"BTCUSDT_{expiry.strftime('%y%m%d')}"),
+                venue=Venue("OKX"),
+            ),
+            native_symbol=Symbol("BTCUSDT"),
+            underlying=BTC,
+            quote_currency=USDT,
+            settlement_currency=USDT,
+            expiry_date=expiry,
+            price_precision=2,
+            size_precision=6,
+            price_increment=Price(1e-02, precision=2),
+            size_increment=Quantity(1e-06, precision=6),
+            max_quantity=Quantity(9000, precision=6),
+            min_quantity=Quantity(1e-06, precision=6),
+            max_notional=None,
+            min_notional=Money(10.00000000, USDT),
+            max_price=Price(1000000, precision=2),
+            min_price=Price(0.01, precision=2),
+            margin_init=Decimal(0),
+            margin_maint=Decimal(0),
+            maker_fee=maker,
+            taker_fee=taker,
+            ts_event=0,
+            ts_init=0,
+        )
+    @staticmethod
     def equity(symbol: str = "AAPL", venue: str = "NASDAQ"):
         return Equity(
             instrument_id=InstrumentId(symbol=Symbol(symbol), venue=Venue(venue)),