From e4d4ca262ab8c916b56bc7af0cea0d920cdb7943 Mon Sep 17 00:00:00 2001
From: Trent McConaghy <gtrent@gmail.com>
Date: Mon, 26 Feb 2024 23:58:38 +0100
Subject: [PATCH] Fix #599: [Pdr bot, sim] Implement two-sided prediction  (PR
 #670)

Fix #599:
- Make Aimodel do classification (not regression), where classifier outputs probabilities of up vs down
- In sim_engine predictoor: model two-sided prediction
- In sim_engine trader: use up/down confidence level to decide amt of $ to put in
- In sim_engine trader: sell when predict down, then buy back
- In sim_engine: add contour plots to visualize models, when 2 input vars (and hide plot when not 2 vars)
- In predictoor_agent approach 1: stake up/down as 50/50
- In predictoor_agent approach 3: stake up=prob_up*stake_amt, down=(1-prob_up)*stake_amt
- rename predictoor approach 3 --> approach 2
- predictoor.md README updated
---
 README.md                                     |   1 +
 READMEs/predictoor.md                         |  45 +-
 READMEs/trader.md                             |  10 +-
 pdr_backend/aimodel/aimodel.py                |  49 +++
 pdr_backend/aimodel/aimodel_data_factory.py   |  27 +-
 pdr_backend/aimodel/aimodel_factory.py        |  52 ++-
 pdr_backend/aimodel/plot_model.py             |  91 ++++
 pdr_backend/aimodel/test/conftest.py          |   2 +-
 pdr_backend/aimodel/test/test_aimodel.py      |   1 +
 .../aimodel/test/test_aimodel_data_factory.py |  63 ++-
 .../aimodel/test/test_aimodel_factory.py      | 133 +++---
 pdr_backend/aimodel/test/test_plot_model.py   |   1 +
 pdr_backend/cli/cli_module.py                 |  15 +-
 pdr_backend/cli/test/test_cli_module.py       |  10 +-
 pdr_backend/contract/base_contract.py         |   5 +-
 .../contract/test/test_erc721_factory.py      |   5 -
 pdr_backend/lake/test/resources.py            |  32 +-
 pdr_backend/ppss/aimodel_ss.py                |   4 +-
 pdr_backend/ppss/ppss.py                      |  26 +-
 pdr_backend/ppss/predictoor_ss.py             |  66 ++-
 pdr_backend/ppss/test/test_aimodel_ss.py      |   6 +-
 pdr_backend/ppss/test/test_ppss.py            |  10 +-
 pdr_backend/ppss/test/test_predictoor_ss.py   |  87 +++-
 pdr_backend/ppss/web3_pp.py                   |   4 +-
 .../predictoor/approach1/predictoor_agent1.py |  36 --
 .../predictoor/approach1/test/conftest.py     |   1 -
 .../approach1/test/test_predictoor_agent1.py  |  61 ---
 .../predictoor/approach3/predictoor_agent3.py |  57 ---
 .../predictoor/approach3/test/conftest.py     |   1 -
 .../approach3/test/test_predictoor_agent3.py  | 187 --------
 .../predictoor/base_predictoor_agent.py       | 164 -------
 pdr_backend/predictoor/predictoor_agent.py    | 302 +++++++++++++
 ...predictoor_agent_runner.py => mockutil.py} |  88 +---
 .../predictoor/test/test_predictoor_agent.py  | 234 ++++++++++
 pdr_backend/sim/sim_engine.py                 | 404 +++++++++++-------
 pdr_backend/sim/test/test_sim_engine.py       |  85 ++--
 pdr_backend/util/mathutil.py                  |  49 +--
 pdr_backend/util/strutil.py                   |   4 +-
 .../util/test_noganache/test_mathutil.py      |  19 +-
 .../util/test_noganache/test_strutil.py       |   4 +-
 ppss.yaml                                     |  26 +-
 system_tests/conftest.py                      |   1 +
 system_tests/test_predictoor_system.py        |  31 +-
 43 files changed, 1412 insertions(+), 1087 deletions(-)
 create mode 100644 pdr_backend/aimodel/aimodel.py
 create mode 100644 pdr_backend/aimodel/plot_model.py
 create mode 100644 pdr_backend/aimodel/test/test_aimodel.py
 create mode 100644 pdr_backend/aimodel/test/test_plot_model.py
 delete mode 100644 pdr_backend/predictoor/approach1/predictoor_agent1.py
 delete mode 100644 pdr_backend/predictoor/approach1/test/conftest.py
 delete mode 100644 pdr_backend/predictoor/approach1/test/test_predictoor_agent1.py
 delete mode 100644 pdr_backend/predictoor/approach3/predictoor_agent3.py
 delete mode 100644 pdr_backend/predictoor/approach3/test/conftest.py
 delete mode 100644 pdr_backend/predictoor/approach3/test/test_predictoor_agent3.py
 delete mode 100644 pdr_backend/predictoor/base_predictoor_agent.py
 create mode 100644 pdr_backend/predictoor/predictoor_agent.py
 rename pdr_backend/predictoor/test/{predictoor_agent_runner.py => mockutil.py} (50%)
 create mode 100644 pdr_backend/predictoor/test/test_predictoor_agent.py

diff --git a/README.md b/README.md
index 6c7ef979b..cfb5319d2 100644
--- a/README.md
+++ b/README.md
@@ -81,6 +81,7 @@ OPF-run bots & higher-level tools:
 - `publisher` - publish pdr data feeds
 - `analytics` - analytics tools
 - `payout` - OCEAN & ROSE payout
+- `deployer` - deployer tool
 - `accuracy` - calculates % correct, for display in predictoor.ai webapp
 
 Mid-level building blocks:
diff --git a/READMEs/predictoor.md b/READMEs/predictoor.md
index a07cd53b5..def03b964 100644
--- a/READMEs/predictoor.md
+++ b/READMEs/predictoor.md
@@ -65,12 +65,14 @@ What it does:
 1. Grab historical price data from exchanges and stores in `parquet_data/` dir. It re-uses any previously saved data.
 1. Run through many 5min epochs. At each epoch:
    - Build a model
-   - Predict up/down
+   - Predict
    - Trade
-   - Plot total profit versus time, and more
-   - Log to console, and to `logs/out_<time>.txt`
+   - Plot profit versus time, more
+   - Log to console and `logs/out_<time>.txt`
+   
+"Predict" actions are _two-sided_: it does one "up" prediction tx, and one "down" tx, with more stake to the higher-confidence direction. Two-sided is more profitable than one-sided prediction.
 
-The baseline settings use a linear model inputting prices of the previous 10 epochs as inputs (autoregressive_n = 10), just BTC close price as input, a simulated 0% trading fee, and a trading strategy of "buy if predict up; sell 5min later". You can play with different values in `my_ppss.yaml`.
+By default, simulation uses a linear model inputting prices of the previous 2-10 epochs as inputs (autoregressive_n), just BTC close price as input, a simulated 0% trading fee, and a trading strategy of "buy if predict up; sell 5min later". You can play with different values in `my_ppss.yaml`.
 
 Profit isn't guaranteed: fees, slippage and more eats into them. Model accuracy makes a big difference too.
 
@@ -80,27 +82,30 @@ Simulation uses Python [logging](https://docs.python.org/3/howto/logging.html) f
 
 ## 3. Run Predictoor Bot on Sapphire Testnet
 
-Predictoor contracts run on [Oasis Sapphire](https://docs.oasis.io/dapp/sapphire/) testnet and mainnet. Sapphire is a privacy-preserving EVM-compatible L1 chain.
+Predictoor contracts run on [Oasis Sapphire](https://docs.oasis.io/dapp/sapphire/) testnet and mainnet. Sapphire is a privacy-preserving EVM-compatible L1 chain. 
 
-Let's get our bot running on testnet first.
+Let's get our predictoor bot running on testnet first.
 
-First, tokens! You need (fake) ROSE to pay for gas, and (fake) OCEAN to stake and earn. [Get them here](testnet-faucet.md).
+The bot does two-sided predictions, like in simulation. This also means it needs two Ethereum accounts, with keys PRIVATE_KEY and PRIVATE_KEY2.
 
-Then, copy & paste your private key as an envvar. In console:
+First, tokens! You need (fake) ROSE to pay for gas, and (fake) OCEAN to stake and earn, for both accounts. [Get them here](testnet-faucet.md).
+
+Then, copy & paste your private keys as envvars. In console:
 ```console
-export PRIVATE_KEY=<YOUR_PRIVATE_KEY>
+export PRIVATE_KEY=<YOUR_PRIVATE_KEY 1>
+export PRIVATE_KEY2=<YOUR_PRIVATE_KEY 2>
 ```
 
 Update `my_ppss.yaml` as desired.
 
-Then, run a bot with modeling-on-the fly (approach 3). In console:
+Then, run a bot with modeling-on-the fly (approach 2). In console:
 ```console
-pdr predictoor 3 my_ppss.yaml sapphire-testnet
+pdr predictoor 2 my_ppss.yaml sapphire-testnet
 ```
 
 Your bot is running, congrats! Sit back and watch it in action. It will loop continuously.
 
-At every 5m/1h epoch, it builds & submits >1 times, to maximize accuracy without missing submission deadlines. Specifically: 60 s before predictions are due, it builds a model then submits a prediction. It repeats this until the deadline.
+At every 5m/1h epoch, it builds & submits >1 times, to maximize accuracy without missing submission deadlines. Specifically: 60 s before predictions are due, it builds a model then prediction txs for up and for down (with stake for each). It repeats this until the deadline.
 
 It logs to console, and to `logs/out_<time>.txt`. Like simulation, it uses Python logging framework, configurable in `logging.yaml`.
 
@@ -111,25 +116,26 @@ The CLI has support tools too. Learn about each via:
 - `pdr get_predictions_info -h`
 - and more yet; type `pdr -h` to see
 
-You can track behavior at finer resolution by writing more logs to the [code](../pdr_backend/predictoor/approach3/predictoor_agent3.py), or [querying Predictoor subgraph](subgraph.md).
+You can track behavior at finer resolution by writing more logs to the [code](../pdr_backend/predictoor/predictoor_agent.py), or [querying Predictoor subgraph](subgraph.md).
 
 
 ## 4. Run Predictoor Bot on Sapphire Mainnet
 
 Time to make it real: let's get our bot running on Sapphire _mainnet_.
 
-First, real tokens! Get [ROSE via this guide](get-rose-on-sapphire.md) and [OCEAN via this guide](get-ocean-on-sapphire.md).
+First, real tokens! Get [ROSE via this guide](get-rose-on-sapphire.md) and [OCEAN via this guide](get-ocean-on-sapphire.md), for each of your two accounts.
 
-Then, copy & paste your private key as an envvar. (You can skip this if it's same as testnet.) In console:
+Then, copy & paste your private keys as envvars. (You can skip this if keys are same as testnet.) In console:
 ```console
-export PRIVATE_KEY=<YOUR_PRIVATE_KEY>
+export PRIVATE_KEY=<YOUR_PRIVATE_KEY 1>
+export PRIVATE_KEY2=<YOUR_PRIVATE_KEY 2>
 ```
 
 Update `my_ppss.yaml` as desired.
 
 Then, run the bot. In console:
 ```console
-pdr predictoor 3 my_ppss.yaml sapphire-mainnet
+pdr predictoor 2 my_ppss.yaml sapphire-mainnet
 ```
 
 This is where there's real $ at stake. Good luck!
@@ -142,7 +148,6 @@ When running predictoors on mainnet, you have the potential to earn $.
 
 **[Here](payout.md)** are instructions to claim your earnings.
 
-
 Congrats! You've gone through all the essential steps to earn $ by running a predictoor bot on mainnet.
 
 The next sections describe how to go beyond, by optimizing the model and more.
@@ -151,7 +156,7 @@ The next sections describe how to go beyond, by optimizing the model and more.
 
 The idea: make your own model, tuned for accuracy, which in turn will optimize it for $. Here's how:
 1. Fork `pdr-backend` repo.
-1. Change predictoor approach3 modeling code as you wish, while iterating with simulation.
+1. Change predictoor approach 2 modeling code as you wish, while iterating with simulation.
 1. Bring your model as a Predictoor bot to testnet then mainnet.
 
 # Right-size staking
@@ -186,7 +191,7 @@ deployment_configs:
     memory: '512Mi'
     source: "binance"
     type: "predictoor"
-    approach: 3
+    approach: 2
     network: "sapphire-testnet"
     s_until_epoch_end: 20
     pdr_backend_image_source: "oceanprotocol/pdr-backend:latest"
diff --git a/READMEs/trader.md b/READMEs/trader.md
index 8f6252b5c..4fbea314f 100644
--- a/READMEs/trader.md
+++ b/READMEs/trader.md
@@ -58,12 +58,14 @@ What it does:
 1. Grab historical price data from exchanges and stores in `parquet_data/` dir. It re-uses any previously saved data.
 1. Run through many 5min epochs. At each epoch:
    - Build a model
-   - Predict up/down
+   - Predict
    - Trade
-   - Plot total profit versus time, and more
-   - Log to console, and to `logs/out_<time>.txt`
+   - Plot profit versus time, more
+   - Log to console and `logs/out_<time>.txt`
+   
+"Predict" actions are _two-sided_: it does one "up" prediction tx, and one "down" tx, with more stake to the higher-confidence direction. Two-sided is more profitable than one-sided prediction.
 
-The baseline settings use a linear model inputting prices of the previous 10 epochs as inputs, a simulated 0% trading fee, and a trading strategy of "buy if predict up; sell 5min later". You can play with different values in `my_ppss.yaml`.
+By default, simulation uses a linear model inputting prices of the previous 2-10 epochs as inputs (autoregressive_n), just BTC close price as input, a simulated 0% trading fee, and a trading strategy of "buy if predict up; sell 5min later". You can play with different values in `my_ppss.yaml`.
 
 Profit isn't guaranteed: fees, slippage and more eats into them. Model accuracy makes a big difference too.
 
diff --git a/pdr_backend/aimodel/aimodel.py b/pdr_backend/aimodel/aimodel.py
new file mode 100644
index 000000000..55b7e7ea1
--- /dev/null
+++ b/pdr_backend/aimodel/aimodel.py
@@ -0,0 +1,49 @@
+from typing import Tuple
+
+from enforce_typing import enforce_types
+import numpy as np
+
+
+@enforce_types
+class Aimodel:
+
+    def __init__(self, skm, scaler):
+        self._skm = skm  # sklearn model
+        self._scaler = scaler
+
+    def predict_true(self, X):
+        """
+        @description
+          Classify each input sample, with lower fidelity: just True vs False
+
+        @arguments
+          X -- 2d array of [sample_i, var_i]:cont_value -- model inputs
+
+        @return
+          ytrue -- 1d array of [sample_i]:bool_value -- classifier model outputs
+        """
+        # We explicitly don't call skm.predict() here, because it's
+        #   inconsistent with predict_proba() for svc and maybe others.
+        # Rather, draw on the probability output to guarantee consistency.
+        yptrue = self.predict_ptrue(X)
+        print(f"in predict_true(); yptrue[:10] = {yptrue[:10]}")
+        ytrue = yptrue > 0.5
+        return ytrue
+
+    def predict_ptrue(self, X: np.ndarray) -> np.ndarray:
+        """
+        @description
+          Classify each input sample, with higher fidelity: prob of being True
+
+        @arguments
+          X -- 2d array of [sample_i, var_i]:cont_value -- model inputs
+
+        @return
+          yptrue - 1d array of [sample_i]: prob_of_being_true -- model outputs
+        """
+        X = self._scaler.transform(X)
+        T = self._skm.predict_proba(X)  # [sample_i][class_i]
+        N = T.shape[0]
+        class_i = 1  # this is the class for "True"
+        yptrue = np.array([T[i, class_i] for i in range(N)])
+        return yptrue
diff --git a/pdr_backend/aimodel/aimodel_data_factory.py b/pdr_backend/aimodel/aimodel_data_factory.py
index f89360e44..ca53d63e9 100644
--- a/pdr_backend/aimodel/aimodel_data_factory.py
+++ b/pdr_backend/aimodel/aimodel_data_factory.py
@@ -45,6 +45,22 @@ class AimodelDataFactory:
     def __init__(self, ss: PredictoorSS):
         self.ss = ss
 
+    @staticmethod
+    def ycont_to_ytrue(ycont: np.ndarray, y_thr: float) -> np.ndarray:
+        """
+        @description
+          Convert regression y (ycont) to classifier y (ybool).
+
+        @arguments
+          ycont -- 1d array of [sample_i]:cont_value -- regression model outputs
+          y_thr -- classify to True if ycont >= this threshold
+
+        @return
+          ybool -- 1d array of [sample_i]:bool_value -- classifier model outputs
+        """
+        ybool = np.array([ycont_val >= y_thr for ycont_val in ycont])
+        return ybool
+
     def create_xy(
         self,
         mergedohlcv_df: pl.DataFrame,
@@ -52,6 +68,10 @@ def create_xy(
         do_fill_nans: bool = True,
     ) -> Tuple[np.ndarray, np.ndarray, pd.DataFrame, np.ndarray]:
         """
+        @description
+          Create X, y data for a regression setting
+          For y in a classification setting, call ycont_to_ytrue() after.
+
         @arguments
           mergedohlcv_df -- *polars* DataFrame. See class docstring
           testshift -- to simulate across historical test data
@@ -59,8 +79,8 @@ def create_xy(
             If you turn this off and mergedohlcv_df has nans, then X/y/etc gets nans
 
         @return
-          X -- 2d array of [sample_i, var_i]:value -- inputs for model
-          y -- 1d array of [sample_i]:value -- target outputs for model
+          X -- 2d array of [sample_i, var_i]:cont_value -- model inputs
+          ycont -- 1d array of [sample_i]:cont_value -- regression model outputs
           x_df -- *pandas* DataFrame. See class docstring.
           xrecent -- [var_i]:value -- most recent X value. Bots use to predict
         """
@@ -132,7 +152,8 @@ def create_xy(
         assert "datetime" not in x_df.columns
 
         # return
-        return X, y, x_df, xrecent
+        ycont = y
+        return X, ycont, x_df, xrecent
 
 
 @enforce_types
diff --git a/pdr_backend/aimodel/aimodel_factory.py b/pdr_backend/aimodel/aimodel_factory.py
index c0e230fab..2cff74006 100644
--- a/pdr_backend/aimodel/aimodel_factory.py
+++ b/pdr_backend/aimodel/aimodel_factory.py
@@ -1,8 +1,10 @@
 from enforce_typing import enforce_types
-from sklearn import linear_model, svm
-from sklearn.gaussian_process import GaussianProcessRegressor
-from sklearn.gaussian_process.kernels import RBF
+from sklearn.linear_model import LogisticRegression
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import SVC
 
+from pdr_backend.aimodel.aimodel import Aimodel
 from pdr_backend.ppss.aimodel_ss import AimodelSS
 
 
@@ -11,23 +13,31 @@ class AimodelFactory:
     def __init__(self, aimodel_ss: AimodelSS):
         self.aimodel_ss = aimodel_ss
 
-    def build(self, X_train, y_train):
-        model = self._model()
-        model.fit(X_train, y_train)
-        return model
+    def build(self, X: np.ndarray, ybool: np.ndarray) -> Aimodel:
+        """
+        @description
+          Train the model
+
+        @arguments
+          X -- 2d array of [sample_i, var_i]:cont_value -- model inputs
+          ybool -- 1d array of [sample_i]:bool_value -- classifier model outputs
 
-    def _model(self):
+        @return
+          model -- Aimodel
+        """
         a = self.aimodel_ss.approach
-        if a == "LIN":
-            return linear_model.LinearRegression()
-        if a == "GPR":
-            kernel = 1.0 * RBF(length_scale=1e1, length_scale_bounds=(1e-2, 1e3))
-            return GaussianProcessRegressor(kernel=kernel, alpha=0.0)
-        if a == "SVR":
-            return svm.SVR()
-        if a == "NuSVR":
-            return svm.NuSVR()
-        if a == "LinearSVR":
-            return svm.LinearSVR()
-
-        raise ValueError(a)
+        if a == "LinearLogistic":
+            skm = LogisticRegression()
+        elif a == "LinearSVC":
+            skm = SVC(kernel="linear", probability=True, C=0.025)
+        else:
+            raise ValueError(a)
+
+        scaler = StandardScaler()
+        scaler.fit(X)
+
+        X = scaler.transform(X)
+        skm.fit(X, ybool)
+
+        model = Aimodel(skm, scaler)
+        return model
diff --git a/pdr_backend/aimodel/plot_model.py b/pdr_backend/aimodel/plot_model.py
new file mode 100644
index 000000000..10ac1266a
--- /dev/null
+++ b/pdr_backend/aimodel/plot_model.py
@@ -0,0 +1,91 @@
+from typing import Tuple
+
+from enforce_typing import enforce_types
+import matplotlib.pyplot as plt
+from matplotlib import cm
+import numpy as np
+
+from pdr_backend.aimodel.aimodel import Aimodel
+from pdr_backend.util.mathutil import classif_acc
+
+
+@enforce_types
+def plot_model(
+    model: Aimodel,
+    X: np.ndarray,
+    ytrue: np.ndarray,
+    labels: Tuple[str, str],
+    fig_ax=None,
+    xranges=None,
+    fancy_title: bool = False,
+    legend_loc: str = "lower right",
+):
+    """
+    @description
+      Plot the model response in a contour plot.
+      And overlay X-data. (Training data or otherwise.)
+      Only relevant when the model has 2-d input.
+
+    @arguments
+      model
+      X -- [sample_i][dim_i]:floatval -- training model inputs (or other)
+      ytrue -- [sample_i]:boolval -- training model outputs (or other)
+      labels -- (x0 axis label, x1 axis label)
+      fig_ax -- None or (fig, ax) to easily embed into existing plot
+      xranges -- None or (x0_min, x0_max, x1_min, x1_max) -- plot boundaries
+      fancy_title -- should title have model accuracy info?
+      legend_loc -- eg "upper left"
+    """
+    assert X.shape[1] == 2, "only relevant for 2-d input"
+    N = X.shape[1]
+
+    x0_label, x1_labels = labels
+
+    if xranges is None:
+        x0_min, x0_max = min(X[:, 0]), max(X[:, 0])
+        x1_min, x1_max = min(X[:, 1]), max(X[:, 1])
+    else:
+        x0_min, x0_max, x1_min, x1_max = xranges
+
+    if fig_ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = fig_ax
+        ax.cla()  # clear axis
+
+    feature_x = np.linspace(x0_min, x0_max, 200)
+    feature_y = np.linspace(x1_min, x1_max, 200)
+    dim0, dim1 = np.meshgrid(feature_x, feature_y)
+    mesh_df0, mesh_df1 = dim0.ravel(), dim1.ravel()
+    mesh_df = np.array([mesh_df0, mesh_df1]).T
+    Z = model.predict_ptrue(mesh_df).reshape(dim1.shape)
+    ax.contourf(dim0, dim1, Z, levels=25, cmap=cm.RdBu)  # type: ignore[attr-defined]
+
+    ytrue_hat = model.predict_true(X)
+    correct = ytrue_hat == ytrue
+    wrong = np.invert(correct)
+    ax.scatter(X[:, 0][wrong], X[:, 1][wrong], s=40, c="yellow", label="wrong")
+
+    yfalse = np.invert(ytrue)
+    ax.scatter(X[:, 0][ytrue], X[:, 1][ytrue], s=5, c="c", label="true")
+    ax.scatter(X[:, 0][yfalse], X[:, 1][yfalse], s=5, c="r", label="false")
+
+    n, n_correct, n_wrong = len(correct), sum(correct), sum(wrong)
+    if fancy_title:
+        ax.set_title(
+            "Contours = model response. "
+            f" {n_correct}/{n} = {n_correct/n*100:.2f}% correct"
+            f", ie {n_wrong}/{n} = {n_wrong/n*100:.2f}% wrong"
+        )
+    else:
+        ax.set_title("Contours = model response")
+
+    ax.set_xlabel(labels[0])
+    ax.set_ylabel(labels[1])
+
+    HEIGHT = 9  # magic number
+    WIDTH = HEIGHT
+    fig.set_size_inches(WIDTH, HEIGHT)
+
+    ax.legend(loc=legend_loc)
+    plt.show()
diff --git a/pdr_backend/aimodel/test/conftest.py b/pdr_backend/aimodel/test/conftest.py
index ea8fb19c1..56ecdf787 100644
--- a/pdr_backend/aimodel/test/conftest.py
+++ b/pdr_backend/aimodel/test/conftest.py
@@ -10,7 +10,7 @@
 def aimodel_factory():
     aimodel_ss = AimodelSS(
         {
-            "approach": "LIN",
+            "approach": "LinearLogistic",
             "max_n_train": 7,
             "autoregressive_n": 3,
             "input_feeds": ["binance BTC/USDT c"],
diff --git a/pdr_backend/aimodel/test/test_aimodel.py b/pdr_backend/aimodel/test/test_aimodel.py
new file mode 100644
index 000000000..64bad319b
--- /dev/null
+++ b/pdr_backend/aimodel/test/test_aimodel.py
@@ -0,0 +1 @@
+# nothing here: put all the testing in test_aimodel_factory.py
diff --git a/pdr_backend/aimodel/test/test_aimodel_data_factory.py b/pdr_backend/aimodel/test/test_aimodel_data_factory.py
index b81e1e3ba..933b073a0 100644
--- a/pdr_backend/aimodel/test/test_aimodel_data_factory.py
+++ b/pdr_backend/aimodel/test/test_aimodel_data_factory.py
@@ -13,27 +13,42 @@
     ETHUSDT_RAWOHLCV_DFS,
     KRAKEN_BTC_DATA,
     KRAKEN_ETH_DATA,
-    _predictoor_ss,
-    _predictoor_ss_1feed,
     _df_from_raw_data,
     _mergedohlcv_df_ETHUSDT,
 )
 from pdr_backend.ppss.aimodel_ss import AimodelSS
-from pdr_backend.ppss.predictoor_ss import PredictoorSS
+from pdr_backend.ppss.predictoor_ss import PredictoorSS, predictoor_ss_test_dict
 from pdr_backend.util.mathutil import fill_nans, has_nan
 
 
+@enforce_types
+def test_ycont_to_ytrue(tmpdir):
+    ycont = np.array([8.3, 6.4, 7.5, 8.6, 5.0])
+    y_thr = 7.0
+    target_ybool = np.array([True, False, True, True, False])
+
+    ybool = AimodelDataFactory.ycont_to_ytrue(ycont, y_thr)
+    assert_array_equal(ybool, target_ybool)
+
+
+@enforce_types
 def test_create_xy__0():
     predictoor_ss = PredictoorSS(
         {
             "predict_feed": "binanceus ETH/USDT c 5m",
+            "approach": 1,
+            "stake_amount": 1,
             "bot_only": {
                 "s_until_epoch_end": 60,
-                "stake_amount": 1,
+            },
+            "sim_only": {
+                "others_stake": 3,
+                "others_accuracy": 0.51,
+                "revenue": 0.93,
             },
             "aimodel_ss": {
                 "input_feeds": ["binanceus ETH/USDT oc"],
-                "approach": "LIN",
+                "approach": "LinearLogistic",
                 "max_n_train": 4,
                 "autoregressive_n": 2,
             },
@@ -58,7 +73,6 @@ def test_create_xy__0():
             [0.1, 0.1, 7.5, 8.6],  # newest
         ]
     )
-    target_y = np.array([5.3, 6.4, 7.5, 8.6, 9.7])  # oldest to newest
     target_x_df = pd.DataFrame(
         {
             "binanceus:ETH/USDT:open:t-3": [0.1, 0.1, 0.1, 0.1, 0.1],
@@ -70,8 +84,9 @@ def test_create_xy__0():
     target_xrecent = np.array([0.1, 0.1, 8.6, 9.7])
 
     factory = AimodelDataFactory(predictoor_ss)
-    X, y, x_df, xrecent = factory.create_xy(mergedohlcv_df, testshift=0)
 
+    target_y = np.array([5.3, 6.4, 7.5, 8.6, 9.7])  # oldest to newest
+    X, y, x_df, xrecent = factory.create_xy(mergedohlcv_df, testshift=0)
     _assert_pd_df_shape(predictoor_ss.aimodel_ss, X, y, x_df)
     assert_array_equal(X, target_X)
     assert_array_equal(y, target_y)
@@ -80,10 +95,10 @@ def test_create_xy__0():
 
 
 @enforce_types
-def test_create_xy__1exchange_1coin_1signal(tmpdir):
-    ss, _, aimodel_data_factory = _predictoor_ss_1feed(
-        tmpdir, "binanceus ETH/USDT h 5m"
-    )
+def test_create_xy_reg__1exchange_1coin_1signal(tmpdir):
+    d = predictoor_ss_test_dict("binanceus ETH/USDT h 5m")
+    ss = PredictoorSS(d)
+    aimodel_data_factory = AimodelDataFactory(ss)
     mergedohlcv_df = merge_rawohlcv_dfs(ETHUSDT_RAWOHLCV_DFS)
 
     # =========== have testshift = 0
@@ -203,7 +218,7 @@ def test_create_xy__1exchange_1coin_1signal(tmpdir):
 
 
 @enforce_types
-def test_create_xy__2exchanges_2coins_2signals():
+def test_create_xy_reg__2exchanges_2coins_2signals():
     rawohlcv_dfs = {
         "binanceus": {
             "BTC/USDT": _df_from_raw_data(BINANCE_BTC_DATA),
@@ -215,10 +230,16 @@ def test_create_xy__2exchanges_2coins_2signals():
         },
     }
 
-    ss = _predictoor_ss(
-        "binanceus ETH/USDT h 5m",
-        ["binanceus BTC/USDT,ETH/USDT hl", "kraken BTC/USDT,ETH/USDT hl"],
-    )
+    d = predictoor_ss_test_dict()
+    assert "predict_feed" in d
+    assert "input_feeds" in d["aimodel_ss"]
+    d["predict_feed"] = "binanceus ETH/USDT h 5m"
+    d["aimodel_ss"]["input_feeds"] = [
+        "binanceus BTC/USDT,ETH/USDT hl",
+        "kraken BTC/USDT,ETH/USDT hl",
+    ]
+    ss = PredictoorSS(d)
+
     assert ss.aimodel_ss.autoregressive_n == 3
     assert ss.aimodel_ss.n == (4 + 4) * 3
 
@@ -286,7 +307,7 @@ def test_create_xy__2exchanges_2coins_2signals():
 
 
 @enforce_types
-def test_create_xy__check_timestamp_order(tmpdir):
+def test_create_xy_reg__check_timestamp_order(tmpdir):
     mergedohlcv_df, factory = _mergedohlcv_df_ETHUSDT(tmpdir)
 
     # timestamps should be descending order
@@ -304,7 +325,7 @@ def test_create_xy__check_timestamp_order(tmpdir):
 
 
 @enforce_types
-def test_create_xy__input_type(tmpdir):
+def test_create_xy_reg__input_type(tmpdir):
     mergedohlcv_df, aimodel_data_factory = _mergedohlcv_df_ETHUSDT(tmpdir)
 
     assert isinstance(mergedohlcv_df, pl.DataFrame)
@@ -319,9 +340,11 @@ def test_create_xy__input_type(tmpdir):
 
 
 @enforce_types
-def test_create_xy__handle_nan(tmpdir):
+def test_create_xy_reg__handle_nan(tmpdir):
     # create mergedohlcv_df
-    _, _, aimodel_data_factory = _predictoor_ss_1feed(tmpdir, "binanceus ETH/USDT h 5m")
+    d = predictoor_ss_test_dict("binanceus ETH/USDT h 5m")
+    ss = PredictoorSS(d)
+    aimodel_data_factory = AimodelDataFactory(ss)
     mergedohlcv_df = merge_rawohlcv_dfs(ETHUSDT_RAWOHLCV_DFS)
 
     # initial mergedohlcv_df should be ok
diff --git a/pdr_backend/aimodel/test/test_aimodel_factory.py b/pdr_backend/aimodel/test/test_aimodel_factory.py
index 6081c07d1..d93cbd67c 100644
--- a/pdr_backend/aimodel/test/test_aimodel_factory.py
+++ b/pdr_backend/aimodel/test/test_aimodel_factory.py
@@ -1,67 +1,89 @@
 import warnings
-from unittest.mock import Mock
 
 import numpy as np
+from numpy.testing import assert_array_equal
 import pytest
 from enforce_typing import enforce_types
 
+from pdr_backend.aimodel.plot_model import plot_model
+from pdr_backend.aimodel.aimodel_data_factory import AimodelDataFactory
 from pdr_backend.aimodel.aimodel_factory import AimodelFactory
 from pdr_backend.ppss.aimodel_ss import APPROACHES, AimodelSS
+from pdr_backend.util.mathutil import classif_acc
 
-
-@enforce_types
-def test_aimodel_factory_basic():
-    for approach in APPROACHES:
-        aimodel_ss = AimodelSS(
-            {
-                "approach": approach,
-                "max_n_train": 7,
-                "autoregressive_n": 3,
-                "input_feeds": ["binance BTC/USDT c"],
-            }
-        )
-        factory = AimodelFactory(aimodel_ss)
-        assert isinstance(factory.aimodel_ss, AimodelSS)
-
-        (X_train, y_train, X_test, y_test) = _data()
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")  # ignore ConvergenceWarning, more
-            model = factory.build(X_train, y_train)
-
-        y_test_hat = model.predict(X_test)
-        assert y_test_hat.shape == y_test.shape
+PLOT = False  # only turn on for manual testing
 
 
 @enforce_types
-def test_aimodel_accuracy_from_xy(aimodel_factory):
-    (X_train, y_train, X_test, y_test) = _data()
+def test_aimodel_factory_LinearLogistic():
+    _test_aimodel_factory(approach="LinearLogistic")
 
-    aimodel = aimodel_factory.build(X_train, y_train)
 
-    y_train_hat = aimodel.predict(X_train)
-    assert sum(abs(y_train - y_train_hat)) < 1e-10  # near-perfect since linear
-
-    y_test_hat = aimodel.predict(X_test)
-    assert sum(abs(y_test - y_test_hat)) < 1e-10
+@enforce_types
+def test_aimodel_factory_LinearSVC():
+    _test_aimodel_factory(approach="LinearSVC")
 
 
 @enforce_types
-def _data() -> tuple:
-    X_train = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
-    y_train = f(X_train)
+def _test_aimodel_factory(approach):
+    # settings
+    aimodel_ss = AimodelSS(
+        {
+            "approach": approach,
+            "max_n_train": 7,
+            "autoregressive_n": 3,
+            "input_feeds": ["binance BTC/USDT c"],
+        }
+    )
+
+    # factory
+    factory = AimodelFactory(aimodel_ss)
+
+    # data
+    y_thr = 2.0
+
+    N = 1000
+    mn, mx = -10.0, +10.0
+    X = np.random.uniform(mn, mx, (N, 2))
+    ycont = 3.0 + 1.0 * X[:, 0] + 2.0 * X[:, 1]  # ycont = 3 + 1*x0 + 2*x1
+    ytrue = ycont > y_thr
+
+    # build model
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")  # ignore ConvergenceWarning, more
+        model = factory.build(X, ytrue)
+
+    # plot
+    if PLOT:
+        labels = ("x0", "x1")
+        fancy_title = True
+        leg_loc = "upper right"
+        fig_ax = None
+        xranges = (mn, mx, mn, mx)
+        plot_model(
+            model,
+            X,
+            ytrue,
+            labels,
+            fig_ax=None,
+            xranges=(mn, mx, mn, mx),
+            fancy_title=True,
+            legend_loc="upper right",
+        )
 
-    X_test = np.array([[3, 5]])
-    y_test = f(X_test)
+    # test predict_true() & predict_ptrue()
+    ytrue_hat = model.predict_true(X)
+    yptrue_hat = model.predict_ptrue(X)
 
-    return (X_train, y_train, X_test, y_test)
+    assert ytrue_hat.shape == yptrue_hat.shape == (N,)
+    assert ytrue_hat.dtype == bool
+    assert yptrue_hat.dtype == float
 
+    assert classif_acc(ytrue_hat, ytrue) > 0.8
+    assert 0 < min(yptrue_hat) < max(yptrue_hat) < 1.0
+    assert_array_equal(yptrue_hat > 0.5, ytrue_hat)
 
-@enforce_types
-def f(X: np.ndarray) -> np.ndarray:
-    # y = 3 * x0 + 2 * x1
-    y = 3.0 + 1.0 * X[:, 0] + 2.0 * X[:, 1]
-    return y
+    assert not PLOT
 
 
 @enforce_types
@@ -69,7 +91,7 @@ def test_aimodel_accuracy_from_create_xy(aimodel_factory):
     # This is from a test function in test_model_data_factory.py
 
     # The underlying AR process is: close[t] = close[t-1] + open[t-1]
-    X_train = np.array(
+    X_trn = np.array(
         [
             [0.1, 0.1, 3.1, 4.2],  # oldest
             [0.1, 0.1, 4.2, 5.3],
@@ -78,22 +100,15 @@ def test_aimodel_accuracy_from_create_xy(aimodel_factory):
             [0.1, 0.1, 7.5, 8.6],
         ]
     )  # newest
-    y_train = np.array([5.3, 6.4, 7.5, 8.6, 9.7])  # oldest  # newest
+    ycont_trn = np.array([5.3, 6.4, 7.5, 8.6, 9.7])  # oldest  # newest
 
-    aimodel = aimodel_factory.build(X_train, y_train)
+    y_thr = 7.0
+    ytrue_trn = AimodelDataFactory.ycont_to_ytrue(ycont_trn, y_thr)
 
-    y_train_hat = aimodel.predict(X_train)
-    assert sum(abs(y_train - y_train_hat)) < 1e-10  # near-perfect since linear
-
-
-@enforce_types
-def test_aimodel_factory_bad_approach():
-    aimodel_ss = Mock(spec=AimodelSS)
-    aimodel_ss.approach = "BAD"
-    factory = AimodelFactory(aimodel_ss)
+    model = aimodel_factory.build(X_trn, ytrue_trn)
 
-    X_train, y_train, _, _ = _data()
+    ytrue_trn_hat = model.predict_true(X_trn)
+    assert_array_equal(ytrue_trn, ytrue_trn_hat)  # expect zero error
 
-    # forcefully change the model
-    with pytest.raises(ValueError):
-        factory.build(X_train, y_train)
+    yptrue_trn_hat = model.predict_ptrue(X_trn)
+    assert_array_equal(yptrue_trn_hat > 0.5, ytrue_trn_hat)
diff --git a/pdr_backend/aimodel/test/test_plot_model.py b/pdr_backend/aimodel/test/test_plot_model.py
new file mode 100644
index 000000000..64bad319b
--- /dev/null
+++ b/pdr_backend/aimodel/test/test_plot_model.py
@@ -0,0 +1 @@
+# nothing here: put all the testing in test_aimodel_factory.py
diff --git a/pdr_backend/cli/cli_module.py b/pdr_backend/cli/cli_module.py
index 37751c335..813656bf4 100644
--- a/pdr_backend/cli/cli_module.py
+++ b/pdr_backend/cli/cli_module.py
@@ -18,8 +18,7 @@
 from pdr_backend.lake.ohlcv_data_factory import OhlcvDataFactory
 from pdr_backend.payout.payout import do_ocean_payout, do_rose_payout
 from pdr_backend.ppss.ppss import PPSS
-from pdr_backend.predictoor.approach1.predictoor_agent1 import PredictoorAgent1
-from pdr_backend.predictoor.approach3.predictoor_agent3 import PredictoorAgent3
+from pdr_backend.predictoor.predictoor_agent import PredictoorAgent
 from pdr_backend.publisher.publish_assets import publish_assets
 from pdr_backend.sim.sim_engine import SimEngine
 from pdr_backend.trader.approach1.trader_agent1 import TraderAgent1
@@ -75,17 +74,7 @@ def do_predictoor(args, nested_args=None):
         network=args.NETWORK,
         nested_override_args=nested_args,
     )
-
-    approach = args.APPROACH
-    if approach == 1:
-        agent = PredictoorAgent1(ppss)
-
-    elif approach == 3:
-        agent = PredictoorAgent3(ppss)
-
-    else:
-        raise ValueError(f"Unknown predictoor approach {approach}")
-
+    agent = PredictoorAgent(ppss)
     agent.run()
 
 
diff --git a/pdr_backend/cli/test/test_cli_module.py b/pdr_backend/cli/test/test_cli_module.py
index 3030ecc4e..92c879f2b 100644
--- a/pdr_backend/cli/test/test_cli_module.py
+++ b/pdr_backend/cli/test/test_cli_module.py
@@ -280,19 +280,11 @@ def test_do_get_traction_info(monkeypatch):
 
 @enforce_types
 def test_do_predictoor(monkeypatch):
-    monkeypatch.setattr(f"{_CLI_PATH}.PredictoorAgent1", MockAgent)
+    monkeypatch.setattr(f"{_CLI_PATH}.PredictoorAgent", MockAgent)
 
     do_predictoor(MockArgParser_APPROACH_PPSS_NETWORK().parse_args())
     assert MockAgent.was_run
 
-    monkeypatch.setattr(f"{_CLI_PATH}.PredictoorAgent3", MockAgent)
-
-    do_predictoor(MockArgParser_APPROACH_PPSS_NETWORK(_APPROACH3).parse_args())
-    assert MockAgent.was_run
-
-    with pytest.raises(ValueError):
-        do_predictoor(MockArgParser_APPROACH_PPSS_NETWORK(_APPROACH_BAD).parse_args())
-
 
 @enforce_types
 def test_do_publisher(monkeypatch):
diff --git a/pdr_backend/contract/base_contract.py b/pdr_backend/contract/base_contract.py
index ad75b7548..79a612f04 100644
--- a/pdr_backend/contract/base_contract.py
+++ b/pdr_backend/contract/base_contract.py
@@ -14,7 +14,6 @@ def __init__(self, web3_pp, address: str, contract_name: str):
         if not isinstance(web3_pp, Web3PP):
             raise ValueError(f"web3_pp is {web3_pp.__class__}, not Web3PP")
         self.web3_pp = web3_pp
-        self.config = web3_pp.web3_config  # for convenience
         self.contract_address = self.config.w3.to_checksum_address(address)
         self.contract_instance = self.config.w3.eth.contract(
             address=self.config.w3.to_checksum_address(address),
@@ -22,6 +21,10 @@ def __init__(self, web3_pp, address: str, contract_name: str):
         )
         self.contract_name = contract_name
 
+    @property
+    def config(self):
+        return self.web3_pp.web3_config
+
     @property
     def name(self):
         return self.contract_name
diff --git a/pdr_backend/contract/test/test_erc721_factory.py b/pdr_backend/contract/test/test_erc721_factory.py
index e9bba3db0..5037d6fb0 100644
--- a/pdr_backend/contract/test/test_erc721_factory.py
+++ b/pdr_backend/contract/test/test_erc721_factory.py
@@ -60,11 +60,6 @@ def test_Erc721Factory(web3_pp, web3_config):
     receipt = {"status": 0}
     config.w3.eth.wait_for_transaction_receipt.return_value = receipt
 
-    with patch.object(factory, "config") as mock_config:
-        mock_config.return_value = config
-        with pytest.raises(ValueError):
-            factory.createNftWithErc20WithFixedRate(nft_data, erc_data, fre_data)
-
 
 @enforce_types
 def test_Erc721Factory_no_address(web3_pp):
diff --git a/pdr_backend/lake/test/resources.py b/pdr_backend/lake/test/resources.py
index 7b5fbeb77..a57255b2d 100644
--- a/pdr_backend/lake/test/resources.py
+++ b/pdr_backend/lake/test/resources.py
@@ -10,7 +10,7 @@
 from pdr_backend.lake.merge_df import merge_rawohlcv_dfs
 from pdr_backend.lake.ohlcv_data_factory import OhlcvDataFactory
 from pdr_backend.lake.plutil import concat_next_df, initialize_rawohlcv_df, text_to_df
-from pdr_backend.ppss.predictoor_ss import PredictoorSS
+from pdr_backend.ppss.predictoor_ss import PredictoorSS, predictoor_ss_test_dict
 from pdr_backend.ppss.lake_ss import LakeSS
 from pdr_backend.ppss.ppss import mock_ppss
 from pdr_backend.ppss.web3_pp import mock_web3_pp
@@ -18,20 +18,13 @@
 
 @enforce_types
 def _mergedohlcv_df_ETHUSDT(tmpdir):
-    _, _, aimodel_data_factory = _predictoor_ss_1feed(tmpdir, "binanceus ETH/USDT h 5m")
+    d = predictoor_ss_test_dict("binanceus ETH/USDT h 5m")
+    predictoor_ss = PredictoorSS(d)
+    aimodel_data_factory = AimodelDataFactory(predictoor_ss)
     mergedohlcv_df = merge_rawohlcv_dfs(ETHUSDT_RAWOHLCV_DFS)
     return mergedohlcv_df, aimodel_data_factory
 
 
-@enforce_types
-def _predictoor_ss_1feed(tmpdir, feed):
-    predictoor_ss = _predictoor_ss(feed, [feed])
-    lake_ss = _lake_ss(tmpdir, [feed])
-    ohlcv_data_factory = OhlcvDataFactory(lake_ss)
-    aimodel_data_factory = AimodelDataFactory(predictoor_ss)
-    return predictoor_ss, ohlcv_data_factory, aimodel_data_factory
-
-
 @enforce_types
 def _lake_ss_1feed(tmpdir, feed, st_timestr=None, fin_timestr=None):
     parquet_dir = str(tmpdir)
@@ -60,23 +53,6 @@ def _filter_gql_tables_config(record_config: Dict, record_filter: str) -> Dict:
     return {k: v for k, v in record_config["tables"].items() if k == record_filter}
 
 
-@enforce_types
-def _predictoor_ss(feed, feeds):
-    return PredictoorSS(
-        {
-            "predict_feed": feed,
-            "timeframe": "5m",
-            "bot_only": {"s_until_epoch_end": 60, "stake_amount": 1},
-            "aimodel_ss": {
-                "input_feeds": feeds,
-                "approach": "LIN",
-                "max_n_train": 7,
-                "autoregressive_n": 3,
-            },
-        }
-    )
-
-
 @enforce_types
 def _lake_ss(parquet_dir, feeds, st_timestr=None, fin_timestr=None):
     return LakeSS(
diff --git a/pdr_backend/ppss/aimodel_ss.py b/pdr_backend/ppss/aimodel_ss.py
index a55fd1dd5..342c7d350 100644
--- a/pdr_backend/ppss/aimodel_ss.py
+++ b/pdr_backend/ppss/aimodel_ss.py
@@ -6,7 +6,7 @@
 from pdr_backend.ppss.base_ss import MultiFeedMixin
 from pdr_backend.util.strutil import StrMixin
 
-APPROACHES = ["LIN", "GPR", "SVR", "NuSVR", "LinearSVR"]
+APPROACHES = ["LinearLogistic", "LinearSVC"]
 
 
 @enforce_types
@@ -31,7 +31,7 @@ def __init__(self, d: dict):
 
     @property
     def approach(self) -> str:
-        return self.d["approach"]  # eg "LIN"
+        return self.d["approach"]  # eg "LinearLogistic"
 
     @property
     def max_n_train(self) -> int:
diff --git a/pdr_backend/ppss/ppss.py b/pdr_backend/ppss/ppss.py
index 207e4b663..87be1469b 100644
--- a/pdr_backend/ppss/ppss.py
+++ b/pdr_backend/ppss/ppss.py
@@ -9,7 +9,7 @@
 from pdr_backend.ppss.dfbuyer_ss import DFBuyerSS
 from pdr_backend.ppss.lake_ss import LakeSS
 from pdr_backend.ppss.payout_ss import PayoutSS
-from pdr_backend.ppss.predictoor_ss import PredictoorSS
+from pdr_backend.ppss.predictoor_ss import PredictoorSS, predictoor_ss_test_dict
 from pdr_backend.ppss.publisher_ss import PublisherSS
 from pdr_backend.ppss.sim_ss import SimSS
 from pdr_backend.ppss.topup_ss import TopupSS
@@ -169,26 +169,10 @@ def mock_ppss(
     )
 
     assert hasattr(ppss, "predictoor_ss")
-    ppss.predictoor_ss = PredictoorSS(
-        {
-            "predict_feed": onefeed,
-            "stake_amount": 1,
-            "bot_only": {
-                "s_until_epoch_end": 60,
-            },
-            "sim_only": {
-                "others_stake": 3,
-                "others_accuracy": 0.51,
-                "revenue": 0.93,
-            },
-            "aimodel_ss": {
-                "input_feeds": feeds,
-                "approach": "LIN",
-                "max_n_train": 7,
-                "autoregressive_n": 3,
-            },
-        }
-    )
+    d = predictoor_ss_test_dict()
+    d["predict_feed"] = onefeed
+    d["aimodel_ss"]["input_feeds"] = feeds
+    ppss.predictoor_ss = PredictoorSS(d)
 
     assert hasattr(ppss, "trader_ss")
     ppss.trader_ss = TraderSS(
diff --git a/pdr_backend/ppss/predictoor_ss.py b/pdr_backend/ppss/predictoor_ss.py
index 4c3bfb6c8..c9231d26b 100644
--- a/pdr_backend/ppss/predictoor_ss.py
+++ b/pdr_backend/ppss/predictoor_ss.py
@@ -1,9 +1,16 @@
+from typing import Optional
+
 from enforce_typing import enforce_types
 
 from pdr_backend.ppss.base_ss import SingleFeedMixin
 from pdr_backend.ppss.aimodel_ss import AimodelSS
 from pdr_backend.util.strutil import StrMixin
 
+# Approaches:
+#  1: Allocate up-vs-down stake equally (50-50). Baseline.
+#  2: Allocate up-vs-down stake on model prediction confidence.
+CAND_APPROACHES = [1, 2]
+
 
 class PredictoorSS(SingleFeedMixin, StrMixin):
     __STR_OBJDIR__ = ["d"]
@@ -13,17 +20,24 @@ class PredictoorSS(SingleFeedMixin, StrMixin):
     def __init__(self, d: dict):
         super().__init__(d, assert_feed_attributes=["timeframe"])
         self.aimodel_ss = AimodelSS(d["aimodel_ss"])
+        if self.approach not in CAND_APPROACHES:
+            s = f"Allowed approaches={CAND_APPROACHES}, got {self.approach}"
+            raise ValueError(s)
 
     # --------------------------------
     # yaml properties
 
     # (predict_feed defined in base)
 
+    @property
+    def approach(self) -> int:
+        return self.d["approach"]
+
     @property
     def stake_amount(self) -> int:
         """
         @description
-          How much your bot stakes. In OCEAN per epoch, per feed
+          Total bot stake amount, per epoch, per feed. In OCEAN.
         """
         return self.d["stake_amount"]
 
@@ -31,8 +45,8 @@ def stake_amount(self) -> int:
     def others_stake(self) -> int:
         """
         @description
-          How much all others' bots stake.
-          In OCEAN per epoch, per feed. Simulation only.
+          How much all others' bots stake. Per epoch, per feed. In OCEAN.
+          Simulation only.
         """
         return self.d["sim_only"]["others_stake"]
 
@@ -40,8 +54,7 @@ def others_stake(self) -> int:
     def others_accuracy(self) -> float:
         """
         @description
-          What % of others' bots stake is correct?
-          Returns a value in range [0.0, 1.0]
+          What % of others' bots stake is correct? Return val in range [0.0,1.0]
           Simulation only.
         """
         return self.d["sim_only"]["others_accuracy"]
@@ -50,8 +63,8 @@ def others_accuracy(self) -> float:
     def revenue(self) -> float:
         """
         @description
-          Sales revenue going towards predictoors.
-          In OCEAN per epoch, per feed. Simulation only.
+          Sales revenue going towards predictoors. Per epoch, per feed. OCEAN.
+          Simulation only.
         """
         return self.d["sim_only"]["revenue"]
 
@@ -60,4 +73,41 @@ def s_until_epoch_end(self) -> int:
         return self.d["bot_only"]["s_until_epoch_end"]
 
     # --------------------------------
-    # derivative properties
+    # setters (add as needed)
+    @enforce_types
+    def set_approach(self, approach: int):
+        if approach not in CAND_APPROACHES:
+            s = f"Allowed approaches={CAND_APPROACHES}, got {self.approach}"
+            raise ValueError(s)
+        self.d["approach"] = approach
+
+
+# =========================================================================
+# utilities for testing
+
+
+@enforce_types
+def predictoor_ss_test_dict(predict_feed: Optional[str] = None) -> dict:
+    """Use this function's return dict 'd' to construct PredictoorSS(d)"""
+    predict_feed = predict_feed or "binance BTC/USDT c 5m"
+    input_feeds = [predict_feed]
+    d = {
+        "predict_feed": predict_feed,
+        "approach": 1,
+        "stake_amount": 1,
+        "sim_only": {
+            "others_stake": 2313,
+            "others_accuracy": 0.50001,
+            "revenue": 0.93007,
+        },
+        "bot_only": {
+            "s_until_epoch_end": 60,
+        },
+        "aimodel_ss": {
+            "input_feeds": input_feeds,
+            "approach": "LinearLogistic",
+            "max_n_train": 7,
+            "autoregressive_n": 3,
+        },
+    }
+    return d
diff --git a/pdr_backend/ppss/test/test_aimodel_ss.py b/pdr_backend/ppss/test/test_aimodel_ss.py
index 9f37b13ce..9c04d9dc9 100644
--- a/pdr_backend/ppss/test/test_aimodel_ss.py
+++ b/pdr_backend/ppss/test/test_aimodel_ss.py
@@ -11,7 +11,7 @@
 @enforce_types
 def test_aimodel_ss_happy1():
     d = {
-        "approach": "LIN",
+        "approach": "LinearLogistic",
         "max_n_train": 7,
         "autoregressive_n": 3,
         "input_feeds": ["kraken ETH/USDT hc", "binanceus ETH/USDT,TRX/DAI h"],
@@ -20,7 +20,7 @@ def test_aimodel_ss_happy1():
 
     # yaml properties
     assert ss.feeds_strs == ["kraken ETH/USDT hc", "binanceus ETH/USDT,TRX/DAI h"]
-    assert ss.approach == "LIN"
+    assert ss.approach == "LinearLogistic"
     assert ss.max_n_train == 7
     assert ss.autoregressive_n == 3
 
@@ -66,7 +66,7 @@ def test_aimodel_ss_happy2():
 @enforce_types
 def test_aimodel_ss_unhappy1():
     d = {
-        "approach": "LIN",
+        "approach": "LinearLogistic",
         "max_n_train": 7,
         "autoregressive_n": 3,
         "input_feeds": ["kraken ETH/USDT"],  # missing a signal like "c"
diff --git a/pdr_backend/ppss/test/test_ppss.py b/pdr_backend/ppss/test/test_ppss.py
index 29674fad7..3e7ef1717 100644
--- a/pdr_backend/ppss/test/test_ppss.py
+++ b/pdr_backend/ppss/test/test_ppss.py
@@ -33,7 +33,7 @@ def _test_ppss(yaml_filename=None, yaml_str=None, network=None):
     assert ppss.trader_ss.timeframe_str in ["5m", "1h"]
     assert isinstance(ppss.lake_ss.st_timestr, str)
     assert ppss.dfbuyer_ss.weekly_spending_limit >= 0
-    assert ppss.predictoor_ss.aimodel_ss.approach == "LIN"
+    assert ppss.predictoor_ss.aimodel_ss.approach == "LinearLogistic"
     assert ppss.payout_ss.batch_size >= 0
     assert 1 <= ppss.predictoor_ss.s_until_epoch_end <= 120
     assert isinstance(ppss.sim_ss.do_plot, bool)
@@ -92,7 +92,13 @@ def test_mock_ppss_default_network_development():
     ],
 )
 def test_mock_ppss_onefeed1(feed_str):
-    """Thorough test that the 1-feed arg is used everywhere"""
+    """
+    @description
+      Thorough test that the 1-feed arg is used everywhere
+
+    @arguments
+      feed_str -- eg "binance BTC/USDT c 5m"
+    """
 
     ppss = mock_ppss([feed_str], "sapphire-mainnet")
 
diff --git a/pdr_backend/ppss/test/test_predictoor_ss.py b/pdr_backend/ppss/test/test_predictoor_ss.py
index f0c0fff4e..e559510c9 100644
--- a/pdr_backend/ppss/test/test_predictoor_ss.py
+++ b/pdr_backend/ppss/test/test_predictoor_ss.py
@@ -1,37 +1,82 @@
+from typing import Optional
+
 from enforce_typing import enforce_types
 import pytest
 
-from pdr_backend.ppss.predictoor_ss import PredictoorSS
+from pdr_backend.cli.arg_feed import ArgFeed
+from pdr_backend.ppss.predictoor_ss import PredictoorSS, predictoor_ss_test_dict
 
 
 @enforce_types
 def test_predictoor_ss():
-    d = {
-        "predict_feed": "binance BTC/USDT c 5m",
-        "stake_amount": 1,
-        "sim_only": {
-            "others_stake": 2313,
-            "others_accuracy": 0.50001,
-            "revenue": 0.93007,
-        },
-        "bot_only": {
-            "s_until_epoch_end": 60,
-        },
-        "aimodel_ss": {
-            "input_feeds": ["binance BTC/USDT c"],
-            "approach": "LIN",
-            "max_n_train": 7,
-            "autoregressive_n": 3,
-        },
-    }
+    # build PredictoorSS
+    d = predictoor_ss_test_dict()
+
+    assert "predict_feed" in d
+    d["predict_feed"] = "binance BTC/USDT c 5m"
+
+    assert "input_feeds" in d["aimodel_ss"]
+    d["aimodel_ss"]["input_feeds"] = [
+        "binance BTC/USDT c 5m",
+        "kraken ETH/USDT o 1h",
+    ]
     ss = PredictoorSS(d)
 
-    # yaml properties
+    # test yaml properties
+    assert ss.feed == ArgFeed("binance", "close", "BTC/USDT", "5m")
+    assert ss.aimodel_ss.feeds == [
+        ArgFeed("binance", "close", "BTC/USDT", "5m"),
+        ArgFeed("kraken", "open", "ETH/USDT", "1h"),
+    ]
+
+    assert ss.approach == 1
     assert ss.stake_amount == 1
     assert ss.others_stake == 2313
     assert ss.others_accuracy == pytest.approx(0.50001, abs=0.000001)
     assert ss.revenue == pytest.approx(0.93007, abs=0.000001)
     assert ss.s_until_epoch_end == 60
 
-    # str
+    # test str
     assert "PredictoorSS" in str(ss)
+
+    # test setters
+    ss.set_approach(2)
+    assert ss.approach == 2
+
+
+@enforce_types
+def test_predictoor_ss_test_dict():
+    # test - reasoonable defaults when nothing passed in
+    d = predictoor_ss_test_dict()
+    f = d["predict_feed"]
+    assert "binance" in f or "kraken" in f
+    assert "BTC" in f or "ETH" in f
+    assert "5m" in f or "1h" in f
+    assert d["aimodel_ss"]["input_feeds"] == [f]
+
+    # test 5m
+    d = predictoor_ss_test_dict("binance ETH/USDT c 5m")
+    assert d["predict_feed"] == "binance ETH/USDT c 5m"
+    assert d["aimodel_ss"]["input_feeds"] == ["binance ETH/USDT c 5m"]
+
+    # test 1h
+    d = predictoor_ss_test_dict("binance ETH/USDT c 1h")
+    assert d["predict_feed"] == "binance ETH/USDT c 1h"
+    assert d["aimodel_ss"]["input_feeds"] == ["binance ETH/USDT c 1h"]
+
+
+@enforce_types
+def test_predictoor_ss_bad_approach():
+    # catch bad approach in __init__()
+    for bad_approach in [0, 3]:
+        d = predictoor_ss_test_dict()
+        d["approach"] = bad_approach
+        with pytest.raises(ValueError):
+            PredictoorSS(d)
+
+    # catch bad approach in set_approach()
+    for bad_approach in [0, 3]:
+        d = predictoor_ss_test_dict()
+        ss = PredictoorSS(d)
+        with pytest.raises(ValueError):
+            ss.set_approach(bad_approach)
diff --git a/pdr_backend/ppss/web3_pp.py b/pdr_backend/ppss/web3_pp.py
index 47190da9d..ad47572e2 100644
--- a/pdr_backend/ppss/web3_pp.py
+++ b/pdr_backend/ppss/web3_pp.py
@@ -320,7 +320,8 @@ def get_block(
 
 @enforce_types
 class _MockPredictoorContractWithTracking:
-    def __init__(self, w3, s_per_epoch: int, contract_address: str):
+    def __init__(self, web3_pp, w3, s_per_epoch: int, contract_address: str):
+        self.web3_pp = web3_pp
         self._w3 = w3
         self.s_per_epoch = s_per_epoch
         self.contract_address: str = contract_address
@@ -367,6 +368,7 @@ def inplace_mock_w3_and_contract_with_tracking(
     mock_w3 = Mock()  # pylint: disable=not-callable
     mock_w3.eth = _MockEthWithTracking(init_timestamp, init_block_number)
     _mock_pdr_contract = _MockPredictoorContractWithTracking(
+        web3_pp,
         mock_w3,
         timeframe_s,
         feed_address,
diff --git a/pdr_backend/predictoor/approach1/predictoor_agent1.py b/pdr_backend/predictoor/approach1/predictoor_agent1.py
deleted file mode 100644
index 9e31fab4b..000000000
--- a/pdr_backend/predictoor/approach1/predictoor_agent1.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import random
-from typing import Tuple
-
-from enforce_typing import enforce_types
-
-from pdr_backend.predictoor.base_predictoor_agent import BasePredictoorAgent
-from pdr_backend.util.time_types import UnixTimeS
-
-
-@enforce_types
-class PredictoorAgent1(BasePredictoorAgent):
-    def get_prediction(
-        self, timestamp: UnixTimeS  # pylint: disable=unused-argument
-    ) -> Tuple[bool, float]:
-        """
-        @description
-          Predict for a given timestamp.
-
-        @arguments
-          timestamp -- UnixTimeSeonds -- when to make prediction for (unix time)
-
-        @return
-          predval -- bool -- if True, it's predicting 'up'. If False, 'down'
-          stake -- int -- amount to stake, in units of Eth
-
-        @notes
-          Below is the default implementation, giving random predictions.
-          You need to customize it to implement your own strategy.
-        """
-        # Pick random prediction & random stake. You need to customize this.
-        predval = bool(random.getrandbits(1))
-
-        # Stake amount is in ETH
-        stake = random.randint(1, 30) / 10000
-
-        return (predval, stake)
diff --git a/pdr_backend/predictoor/approach1/test/conftest.py b/pdr_backend/predictoor/approach1/test/conftest.py
deleted file mode 100644
index fc9ed034c..000000000
--- a/pdr_backend/predictoor/approach1/test/conftest.py
+++ /dev/null
@@ -1 +0,0 @@
-from pdr_backend.conftest_ganache import *  # pylint: disable=wildcard-import
diff --git a/pdr_backend/predictoor/approach1/test/test_predictoor_agent1.py b/pdr_backend/predictoor/approach1/test/test_predictoor_agent1.py
deleted file mode 100644
index 78081707d..000000000
--- a/pdr_backend/predictoor/approach1/test/test_predictoor_agent1.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from unittest.mock import MagicMock
-
-import pytest
-from enforce_typing import enforce_types
-
-from pdr_backend.ppss.ppss import PPSS
-from pdr_backend.ppss.predictoor_ss import PredictoorSS
-from pdr_backend.ppss.web3_pp import Web3PP
-from pdr_backend.predictoor.approach1.predictoor_agent1 import PredictoorAgent1
-from pdr_backend.predictoor.test.predictoor_agent_runner import run_agent_test
-
-
-# ===========================================================================
-# test main loop
-
-
-@enforce_types
-def test_predictoor_agent1_main(tmpdir, monkeypatch):
-    """
-    @description
-      Main end-to-end test of running agent 1.
-
-      Runs the agent for a while, and then does some basic sanity checks.
-    """
-    run_agent_test(str(tmpdir), monkeypatch, PredictoorAgent1)
-
-
-@enforce_types
-def test_predictoor_agent1_run():
-    """
-    @description
-      Another end-to-end test of running agent 1.
-
-      Runs the agent for 1 iteration, then stops because envvar TEST == true.
-    """
-    mock_predictoor_agent1 = MagicMock(spec=PredictoorAgent1)
-    take_step = mock_predictoor_agent1.take_step
-    take_step.return_value = None
-
-    mock_predictoor_agent1.run()
-
-
-# ===========================================================================
-# test __init__()
-
-
-@enforce_types
-def test_agent_init_empty():
-    """
-    @description
-      Basic test: when there's no feeds, does it complain?
-    """
-    # test with no feeds
-    mock_ppss_empty = MagicMock(spec=PPSS)
-    mock_ppss_empty.predictoor_ss = MagicMock(spec=PredictoorSS)
-    mock_ppss_empty.predictoor_ss.get_feed_from_candidates.return_value = None
-    mock_ppss_empty.web3_pp = MagicMock(spec=Web3PP)
-    mock_ppss_empty.web3_pp.query_feed_contracts.return_value = {}
-
-    with pytest.raises(ValueError, match="No feeds found"):
-        PredictoorAgent1(mock_ppss_empty)
diff --git a/pdr_backend/predictoor/approach3/predictoor_agent3.py b/pdr_backend/predictoor/approach3/predictoor_agent3.py
deleted file mode 100644
index a73d4a0e0..000000000
--- a/pdr_backend/predictoor/approach3/predictoor_agent3.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from typing import Tuple
-
-from enforce_typing import enforce_types
-
-from pdr_backend.aimodel.aimodel_data_factory import AimodelDataFactory
-from pdr_backend.aimodel.aimodel_factory import AimodelFactory
-from pdr_backend.lake.ohlcv_data_factory import OhlcvDataFactory
-from pdr_backend.predictoor.base_predictoor_agent import BasePredictoorAgent
-from pdr_backend.util.time_types import UnixTimeS
-
-
-@enforce_types
-class PredictoorAgent3(BasePredictoorAgent):
-    def __init__(self, ppss):
-        super().__init__(ppss)
-        self.get_data_components()
-
-    @enforce_types
-    def get_data_components(self):
-        ohlcv_data_factory = OhlcvDataFactory(self.ppss.lake_ss)
-        mergedohlcv_df = ohlcv_data_factory.get_mergedohlcv_df()
-        return mergedohlcv_df
-
-    @enforce_types
-    def get_prediction(
-        self, timestamp: UnixTimeS  # pylint: disable=unused-argument
-    ) -> Tuple[bool, float]:
-        """
-        @description
-          Predict for a given timestamp.
-
-        @arguments
-          timestamp -- UnixTimeS -- when to make prediction for (unix time)
-
-        @return
-          predval -- bool -- if True, it's predicting 'up'. If False, 'down'
-          stake -- int -- amount to stake, in units of Eth
-        """
-        mergedohlcv_df = self.get_data_components()
-
-        model_data_factory = AimodelDataFactory(self.ppss.predictoor_ss)
-        X, y, _, xrecent = model_data_factory.create_xy(mergedohlcv_df, testshift=0)
-
-        # Compute the model
-        aimodel_factory = AimodelFactory(self.ppss.predictoor_ss.aimodel_ss)
-        model = aimodel_factory.build(X, y)
-
-        # Predict next y
-        X_test = xrecent.reshape((1, len(xrecent)))
-        predprice = model.predict(X_test)[0]
-        curprice = y[-1]
-        predval = predprice > curprice
-
-        # Stake amount
-        stake = self.ppss.predictoor_ss.stake_amount
-
-        return (bool(predval), stake)
diff --git a/pdr_backend/predictoor/approach3/test/conftest.py b/pdr_backend/predictoor/approach3/test/conftest.py
deleted file mode 100644
index fc9ed034c..000000000
--- a/pdr_backend/predictoor/approach3/test/conftest.py
+++ /dev/null
@@ -1 +0,0 @@
-from pdr_backend.conftest_ganache import *  # pylint: disable=wildcard-import
diff --git a/pdr_backend/predictoor/approach3/test/test_predictoor_agent3.py b/pdr_backend/predictoor/approach3/test/test_predictoor_agent3.py
deleted file mode 100644
index f2a10c229..000000000
--- a/pdr_backend/predictoor/approach3/test/test_predictoor_agent3.py
+++ /dev/null
@@ -1,187 +0,0 @@
-from unittest.mock import patch
-
-from enforce_typing import enforce_types
-import numpy as np
-from numpy.testing import assert_array_equal
-import polars as pl
-
-from pdr_backend.predictoor.approach3.predictoor_agent3 import PredictoorAgent3
-from pdr_backend.predictoor.test.predictoor_agent_runner import (
-    run_agent_test,
-    get_agent_1feed,
-    get_agent_2feeds,
-)
-from pdr_backend.util.time_types import UnixTimeS
-
-
-# ===========================================================================
-# test main loop
-
-
-@enforce_types
-def test_predictoor_agent3_main(tmpdir, monkeypatch):
-    """
-    @description
-      Main end-to-end test of running agent 3.
-
-      Runs the agent for a while, and then does some basic sanity checks.
-    """
-    run_agent_test(str(tmpdir), monkeypatch, PredictoorAgent3)
-
-
-# ===========================================================================
-# test __init__()
-
-
-@enforce_types
-@patch(
-    "pdr_backend.predictoor.approach3.predictoor_agent3.PredictoorAgent3.get_data_components"
-)
-def test_predictoor_agent3_init(mock_get_data_components, tmpdir, monkeypatch):
-    """
-    @description
-      Basic tests: is get_data_components() called? Is feed.name sane?
-    """
-    # initialize agent
-    feed, _, _, _ = get_agent_1feed(str(tmpdir), monkeypatch, PredictoorAgent3)
-
-    # assert get_data_components() is called once during init
-    mock_get_data_components.assert_called_once()
-
-    # assert agent was initialized with development feed
-    assert "BTC/USDT|binanceus|5m" in feed.name
-
-
-# ===========================================================================
-# test get_prediction()
-
-BTC_CLOSE_VALS = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0]
-ETH_CLOSE_VALS = [30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0]
-
-
-def mock_get_data_components2(*args, **kwargs):  # pylint: disable=unused-argument
-    d = {
-        "timestamp": [100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
-        "binanceus:BTC/USDT:open": [1.0] * 10,
-        "binanceus:BTC/USDT:high": [1.0] * 10,
-        "binanceus:BTC/USDT:low": [1.0] * 10,
-        "binanceus:BTC/USDT:close": BTC_CLOSE_VALS,
-        "binanceus:BTC/USDT:volume": [1.0] * 10,
-        "binanceus:ETH/USDT:open": [1.0] * 10,
-        "binanceus:ETH/USDT:high": [1.0] * 10,
-        "binanceus:ETH/USDT:low": [1.0] * 10,
-        "binanceus:ETH/USDT:close": ETH_CLOSE_VALS,
-        "binanceus:ETH/USDT:volume": [1.0] * 10,
-    }
-    mergedohlcv_df = pl.DataFrame(d)
-    return mergedohlcv_df
-
-
-class MockModel:
-    """scikit-learn style model"""
-
-    def __init__(self):
-        self.aimodel_ss = None  # fill this in later, after patch applied
-        self.last_X = None  # for tracking test results
-        self.last_y = None  # ""
-
-    def predict(self, X: np.ndarray) -> np.ndarray:
-        ar_n = self.aimodel_ss.autoregressive_n
-        n_feeds = self.aimodel_ss.n_feeds
-        (n_points, n_vars) = X.shape
-        assert n_points == 1  # this mock can only handle 1 input point
-        assert n_vars == self.aimodel_ss.n == ar_n * n_feeds
-        yval: float = np.sum(X)
-        y: np.ndarray = np.array([yval])
-        self.last_X, self.last_y = X, y  # cache for testing
-        return y
-
-
-@enforce_types
-def test_predictoor_agent3_get_prediction_1feed(tmpdir, monkeypatch):
-    """
-    @description
-      Test get_prediction(), when X has only 1 input feed
-
-      Approach:
-      - mergedohlcv_df has simple pre-set values: CLOSE_VALS
-      - predprice = model.predict(X) is a simple sum of X-values
-      - then, test that sum(CLOSE_VALS[-ar_n:]) == predprice
-        where ar_n = autoregressive_n = 3
-    """
-    mock_model = MockModel()
-
-    def mock_build(*args, **kwargs):  # pylint: disable=unused-argument
-        return mock_model
-
-    with patch(
-        "pdr_backend.predictoor.approach3.predictoor_agent3.PredictoorAgent3.get_data_components",
-        mock_get_data_components2,
-    ), patch(
-        "pdr_backend.predictoor.approach3.predictoor_agent3.AimodelFactory.build",
-        mock_build,
-    ):
-
-        # initialize agent
-        _, ppss, agent, _ = get_agent_1feed(str(tmpdir), monkeypatch, PredictoorAgent3)
-        aimodel_ss = ppss.predictoor_ss.aimodel_ss
-        assert aimodel_ss.n_feeds == 1
-
-        # do prediction
-        mock_model.aimodel_ss = aimodel_ss
-        agent.get_prediction(timestamp=UnixTimeS(5))  # arbitrary timestamp
-
-        ar_n = aimodel_ss.autoregressive_n
-        assert ar_n == 3
-
-        assert mock_model.last_X.shape == (1, 3) == (1, ar_n * 1)
-        expected_X = np.array([BTC_CLOSE_VALS[-ar_n:]])  # [17.0, 18.0, 19.0]
-        expected_yval = sum(BTC_CLOSE_VALS[-ar_n:])
-        expected_y = np.array([expected_yval])
-
-        assert_array_equal(expected_X, mock_model.last_X)
-        assert_array_equal(expected_y, mock_model.last_y)
-
-
-@enforce_types
-def test_predictoor_agent3_get_prediction_2feeds(tmpdir, monkeypatch):
-    """
-    @description
-      Test get_prediction(), when X has >1 input feed
-    """
-    mock_model = MockModel()
-
-    def mock_build(*args, **kwargs):  # pylint: disable=unused-argument
-        return mock_model
-
-    with patch(
-        "pdr_backend.predictoor.approach3.predictoor_agent3.PredictoorAgent3.get_data_components",
-        mock_get_data_components2,
-    ), patch(
-        "pdr_backend.predictoor.approach3.predictoor_agent3.AimodelFactory.build",
-        mock_build,
-    ):
-
-        # initialize agent
-        feeds, ppss, agent = get_agent_2feeds(
-            str(tmpdir), monkeypatch, PredictoorAgent3
-        )
-        assert len(feeds) == 2
-        aimodel_ss = ppss.predictoor_ss.aimodel_ss
-        assert aimodel_ss.n_feeds == 2
-
-        # do prediction
-        mock_model.aimodel_ss = aimodel_ss
-        agent.get_prediction(timestamp=UnixTimeS(5))  # arbitrary timestamp
-
-        ar_n = aimodel_ss.autoregressive_n
-        assert ar_n == 3
-
-        assert mock_model.last_X.shape == (1, 6) == (1, ar_n * 2)
-        # [17.0, 18.0, 19.0, 37.0, 38.0, 39.0]
-        expected_X = np.array([BTC_CLOSE_VALS[-ar_n:] + ETH_CLOSE_VALS[-ar_n:]])
-        expected_yval = sum(BTC_CLOSE_VALS[-ar_n:] + ETH_CLOSE_VALS[-ar_n:])
-        expected_y = np.array([expected_yval])
-
-        assert_array_equal(expected_X, mock_model.last_X)
-        assert_array_equal(expected_y, mock_model.last_y)
diff --git a/pdr_backend/predictoor/base_predictoor_agent.py b/pdr_backend/predictoor/base_predictoor_agent.py
deleted file mode 100644
index ae6ceacfb..000000000
--- a/pdr_backend/predictoor/base_predictoor_agent.py
+++ /dev/null
@@ -1,164 +0,0 @@
-import logging
-import os
-import time
-from abc import ABC, abstractmethod
-from typing import List, Tuple
-
-from enforce_typing import enforce_types
-
-from pdr_backend.ppss.ppss import PPSS
-from pdr_backend.subgraph.subgraph_feed import print_feeds
-from pdr_backend.util.logutil import logging_has_stdout
-from pdr_backend.util.time_types import UnixTimeS
-
-logger = logging.getLogger("predictoor_agent")
-
-
-class BasePredictoorAgent(ABC):
-    """
-    What it does
-    - Fetches Predictoor contracts from subgraph, and filters them
-    - Monitors each contract for epoch changes.
-    - When a value can be predicted, call get_prediction()
-    """
-
-    @enforce_types
-    def __init__(self, ppss: PPSS):
-        # ppss
-        self.ppss = ppss
-        logger.info(self.ppss)
-
-        # set self.feeds
-        cand_feeds = ppss.web3_pp.query_feed_contracts()
-        print_feeds(cand_feeds, f"cand feeds, owner={ppss.web3_pp.owner_addrs}")
-
-        feed = ppss.predictoor_ss.get_feed_from_candidates(cand_feeds)
-        if not feed:
-            raise ValueError("No feeds found.")
-
-        print_feeds({feed.address: feed}, "filtered feed")
-        self.feed = feed
-
-        self.feed_contract = ppss.web3_pp.get_single_contract(feed.address)
-
-        # set attribs to track block
-        self.prev_block_timestamp: UnixTimeS = UnixTimeS(0)
-        self.prev_block_number: UnixTimeS = UnixTimeS(0)
-        self.prev_submit_epochs: List[int] = []
-
-    @enforce_types
-    def run(self):
-        logger.info("Starting main loop.")
-        logger.info(self.status_str())
-        logger.info("Waiting...")
-        while True:
-            self.take_step()
-            if os.getenv("TEST") == "true":
-                break
-
-    @enforce_types
-    def take_step(self):
-        # at new block number yet?
-        if self.cur_block_number <= self.prev_block_number:
-            if logging_has_stdout():
-                print(".", end="", flush=True)
-            time.sleep(1)
-            return
-
-        # is new block ready yet?
-        if not self.cur_block:
-            return
-        self.prev_block_number = UnixTimeS(self.cur_block_number)
-        self.prev_block_timestamp = UnixTimeS(self.cur_timestamp)
-
-        # within the time window to predict?
-        if self.cur_epoch_s_left > self.epoch_s_thr:
-            return
-
-        logger.info(self.status_str())
-
-        # compute prediction; exit if no good
-        submit_epoch, target_slot = self.cur_epoch, self.target_slot
-        logger.info("Predict for time slot = %s...", self.target_slot)
-
-        predval, stake = self.get_prediction(target_slot)
-        logger.info("-> Predict result: predval=%s, stake=%s", predval, stake)
-        if predval is None or stake <= 0:
-            logger.warning("Done: can't use predval/stake")
-            return
-
-        # submit prediction to chain
-        logger.info("Submit predict tx to chain...")
-        self.feed_contract.submit_prediction(
-            predval,
-            stake,
-            target_slot,
-            wait_for_receipt=True,
-        )
-        self.prev_submit_epochs.append(submit_epoch)
-        logger.info("-> Submit predict tx result: success.")
-
-        if logging_has_stdout():
-            print("" + "=" * 180)
-
-        # start printing for next round
-        logger.info(self.status_str())
-        logger.info("Waiting...")
-
-    @property
-    def cur_epoch(self) -> int:
-        return self.feed_contract.get_current_epoch()
-
-    @property
-    def cur_block(self):
-        return self.ppss.web3_pp.web3_config.get_block(
-            self.cur_block_number, full_transactions=False
-        )
-
-    @property
-    def cur_block_number(self) -> int:
-        return self.ppss.web3_pp.w3.eth.block_number
-
-    @property
-    def cur_timestamp(self) -> UnixTimeS:
-        return UnixTimeS(self.cur_block["timestamp"])
-
-    @property
-    def epoch_s_thr(self):
-        """Start predicting if there's > this time left"""
-        return self.ppss.predictoor_ss.s_until_epoch_end
-
-    @property
-    def s_per_epoch(self) -> int:
-        return self.feed.seconds_per_epoch
-
-    @property
-    def next_slot(self) -> UnixTimeS:  # a timestamp
-        return UnixTimeS((self.cur_epoch + 1) * self.s_per_epoch)
-
-    @property
-    def target_slot(self) -> int:  # a timestamp
-        return UnixTimeS((self.cur_epoch + 2) * self.s_per_epoch)
-
-    @property
-    def cur_epoch_s_left(self) -> int:
-        return self.next_slot - self.cur_timestamp
-
-    def status_str(self) -> str:
-        s = ""
-        s += f"cur_epoch={self.cur_epoch}"
-        s += f", cur_block_number={self.cur_block_number}"
-        s += f", cur_timestamp={self.cur_timestamp}"
-        s += f", next_slot={self.next_slot}"
-        s += f", target_slot={self.target_slot}"
-        s += f". {self.cur_epoch_s_left} s left in epoch"
-        s += f" (predict if <= {self.epoch_s_thr} s left)"
-        s += f". s_per_epoch={self.s_per_epoch}"
-        return s
-
-    @abstractmethod
-    def get_prediction(
-        self,
-        timestamp: UnixTimeS,  # pylint: disable=unused-argument
-    ) -> Tuple[bool, float]:
-        pass
diff --git a/pdr_backend/predictoor/predictoor_agent.py b/pdr_backend/predictoor/predictoor_agent.py
new file mode 100644
index 000000000..6c6e2e3f2
--- /dev/null
+++ b/pdr_backend/predictoor/predictoor_agent.py
@@ -0,0 +1,302 @@
+import copy
+import logging
+import os
+import time
+from typing import Dict, List, Optional, Tuple
+
+from enforce_typing import enforce_types
+
+from pdr_backend.aimodel.aimodel_data_factory import AimodelDataFactory
+from pdr_backend.aimodel.aimodel_factory import AimodelFactory
+from pdr_backend.contract.predictoor_contract import PredictoorContract
+from pdr_backend.lake.ohlcv_data_factory import OhlcvDataFactory
+from pdr_backend.ppss.ppss import PPSS
+from pdr_backend.subgraph.subgraph_feed import print_feeds, SubgraphFeed
+from pdr_backend.util.logutil import logging_has_stdout
+from pdr_backend.util.time_types import UnixTimeS
+from pdr_backend.util.web3_config import Web3Config
+
+logger = logging.getLogger("predictoor_agent")
+
+
+class PredictoorAgent:
+    """
+    What it does
+    - Fetches Predictoor contracts from subgraph, and filters them
+    - Monitors each contract for epoch changes.
+    - When a value can be predicted, call calc_stakes()
+    """
+
+    @enforce_types
+    def __init__(self, ppss: PPSS):
+        # ppss
+        self.ppss = ppss
+        logger.info(self.ppss)
+
+        # set self.feed
+        cand_feeds: Dict[str, SubgraphFeed] = ppss.web3_pp.query_feed_contracts()
+        print_feeds(cand_feeds, f"cand feeds, owner={ppss.web3_pp.owner_addrs}")
+
+        feed: SubgraphFeed = ppss.predictoor_ss.get_feed_from_candidates(cand_feeds)
+        if not feed:
+            raise ValueError("No feeds found.")
+
+        print_feeds({feed.address: feed}, "filtered feed")
+        self.feed: SubgraphFeed = feed
+
+        # set self.feed_contract, self.feed_contract2
+        self.feed_contract: PredictoorContract = ppss.web3_pp.get_single_contract(
+            feed.address
+        )
+
+        pk2: Optional[str] = os.getenv("PRIVATE_KEY2")
+        assert pk2 is not None, "Need PRIVATE_KEY2 envvar"
+        rpc_url: str = self.ppss.web3_pp.rpc_url
+        web3_config2 = Web3Config(rpc_url, pk2)
+        self.feed_contract2 = copy.deepcopy(self.feed_contract)
+        self.feed_contract2.web3_pp.set_web3_config(web3_config2)
+
+        # ensure ohlcv data cache is up to date
+        if self.use_ohlcv_data():
+            _ = self.get_ohlcv_data()
+
+        # set attribs to track block
+        self.prev_block_timestamp: UnixTimeS = UnixTimeS(0)
+        self.prev_block_number: UnixTimeS = UnixTimeS(0)
+        self.prev_submit_epochs: List[int] = []
+
+    @enforce_types
+    def run(self):
+        logger.info("Starting main loop.")
+        logger.info(self.status_str())
+        logger.info("Waiting...")
+        while True:
+            self.take_step()
+            if os.getenv("TEST") == "true":
+                break
+
+    @enforce_types
+    def take_step(self):
+        # at new block number yet?
+        if self.cur_block_number <= self.prev_block_number:
+            if logging_has_stdout():
+                print(".", end="", flush=True)
+            time.sleep(1)
+            return
+
+        # is new block ready yet?
+        if not self.cur_block:
+            return
+        self.prev_block_number = UnixTimeS(self.cur_block_number)
+        self.prev_block_timestamp = UnixTimeS(self.cur_timestamp)
+
+        # within the time window to predict?
+        if self.cur_epoch_s_left > self.epoch_s_thr:
+            return
+
+        logger.info(self.status_str())
+
+        # compute prediction; exit if no good
+        submit_epoch, target_slot = self.cur_epoch, self.target_slot
+        logger.info("Predict for time slot = %s...", self.target_slot)
+
+        stake_up, stake_down = self.calc_stakes()
+        s = f"-> Predict result: stake_up={stake_up}, stake_down={stake_down}"
+        logger.info(s)
+        if stake_up == 0 and stake_down == 0:
+            logger.warning("Done: can't use predval/stake")
+            return
+
+        # submit prediction to chain
+        self.submit_prediction_txs(stake_up, stake_down, target_slot)
+        self.prev_submit_epochs.append(submit_epoch)
+
+        # start printing for next round
+        if logging_has_stdout():
+            print("" + "=" * 180)
+        logger.info(self.status_str())
+        logger.info("Waiting...")
+
+    @property
+    def cur_epoch(self) -> int:
+        return self.feed_contract.get_current_epoch()
+
+    @property
+    def cur_block(self):
+        return self.ppss.web3_pp.web3_config.get_block(
+            self.cur_block_number, full_transactions=False
+        )
+
+    @property
+    def cur_block_number(self) -> int:
+        return self.ppss.web3_pp.w3.eth.block_number
+
+    @property
+    def cur_timestamp(self) -> UnixTimeS:
+        return UnixTimeS(self.cur_block["timestamp"])
+
+    @property
+    def epoch_s_thr(self):
+        """Start predicting if there's > this time left"""
+        return self.ppss.predictoor_ss.s_until_epoch_end
+
+    @property
+    def s_per_epoch(self) -> int:
+        return self.feed.seconds_per_epoch
+
+    @property
+    def next_slot(self) -> UnixTimeS:  # a timestamp
+        return UnixTimeS((self.cur_epoch + 1) * self.s_per_epoch)
+
+    @property
+    def target_slot(self) -> UnixTimeS:  # a timestamp
+        return UnixTimeS((self.cur_epoch + 2) * self.s_per_epoch)
+
+    @property
+    def cur_epoch_s_left(self) -> int:
+        return self.next_slot - self.cur_timestamp
+
+    def status_str(self) -> str:
+        s = ""
+        s += f"cur_epoch={self.cur_epoch}"
+        s += f", cur_block_number={self.cur_block_number}"
+        s += f", cur_timestamp={self.cur_timestamp}"
+        s += f", next_slot={self.next_slot}"
+        s += f", target_slot={self.target_slot}"
+        s += f". {self.cur_epoch_s_left} s left in epoch"
+        s += f" (predict if <= {self.epoch_s_thr} s left)"
+        s += f". s_per_epoch={self.s_per_epoch}"
+        return s
+
+    @enforce_types
+    def submit_prediction_txs(
+        self,
+        stake_up: float,  # in units of Eth
+        stake_down: float,  # ""
+        target_slot: UnixTimeS,  # a timestamp
+    ):
+        logger.info("Submit 'up' prediction tx to chain...")
+        tx1 = self.feed_contract.submit_prediction(
+            True,
+            stake_up,
+            target_slot,
+            wait_for_receipt=True,
+        )
+
+        logger.info("Submit 'down' prediction tx to chain...")
+        tx2 = self.feed_contract2.submit_prediction(
+            False,
+            stake_down,
+            target_slot,
+            wait_for_receipt=True,
+        )
+
+        # handle errors
+        if _tx_failed(tx1) or _tx_failed(tx2):
+            s = "One or both txs failed. So, resubmit both with zero stake."
+            s += f"\ntx1={tx1}\ntx2={tx2}"
+            logger.warning(s)
+
+            logger.info("Re-submit 'up' prediction tx to chain... (stake=0)")
+            self.feed_contract.submit_prediction(
+                True,
+                1e-10,
+                target_slot,
+                wait_for_receipt=True,
+            )
+
+            logger.info("Re-submit 'down' prediction tx to chain... (stake=0)")
+            self.feed_contract2.submit_prediction(
+                False,
+                1e-10,
+                target_slot,
+                wait_for_receipt=True,
+            )
+
+        return True
+
+    @enforce_types
+    def calc_stakes(self) -> Tuple[float, float]:
+        """
+        @return
+          stake_up -- amt to stake up, in units of Eth
+          stake_down -- amt to stake down, ""
+        """
+        approach = self.ppss.predictoor_ss.approach
+        if approach == 1:
+            return self.calc_stakes1()
+        if approach == 2:
+            return self.calc_stakes2()
+        raise ValueError(approach)
+
+    @enforce_types
+    def calc_stakes1(self) -> Tuple[float, float]:
+        """
+        @description
+          Calculate up-vs-down stake according to approach 1.
+          How: allocate equally (50-50)
+
+        @return
+          stake_up -- amt to stake up, in units of Eth
+          stake_down -- amt to stake down, ""
+        """
+        assert self.ppss.predictoor_ss.approach == 1
+        tot_amt = self.ppss.predictoor_ss.stake_amount
+        stake_up, stake_down = 0.50 * tot_amt, 0.50 * tot_amt
+        return (stake_up, stake_down)
+
+    @enforce_types
+    def calc_stakes2(self) -> Tuple[float, float]:
+        """
+        @description
+          Calculate up-vs-down stake according to approach 2.
+          How: use classifier model's confidence
+
+        @return
+          stake_up -- amt to stake up, in units of Eth
+          stake_down -- amt to stake down, ""
+        """
+        assert self.ppss.predictoor_ss.approach == 2
+
+        mergedohlcv_df = self.get_ohlcv_data()
+
+        data_f = AimodelDataFactory(self.ppss.predictoor_ss)
+        X, ycont, _, xrecent = data_f.create_xy(mergedohlcv_df, testshift=0)
+
+        curprice = ycont[-1]
+        y_thr = curprice
+        ybool = data_f.ycont_to_ytrue(ycont, y_thr)
+
+        # build model
+        model_f = AimodelFactory(self.ppss.predictoor_ss.aimodel_ss)
+        model = model_f.build(X, ybool)
+
+        # predict
+        X_test = xrecent.reshape((1, len(xrecent)))
+        prob_up = model.predict_ptrue(X_test)[0]
+
+        # calc stake amounts
+        tot_amt = self.ppss.predictoor_ss.stake_amount
+        stake_up = prob_up * tot_amt
+        stake_down = (1.0 - prob_up) * tot_amt
+
+        return (stake_up, stake_down)
+
+    @enforce_types
+    def use_ohlcv_data(self) -> bool:
+        """Do we use ohlcv data?"""
+        return self.ppss.predictoor_ss.approach == 2
+
+    @enforce_types
+    def get_ohlcv_data(self):
+        """Update local lake's ohlcv data; return the data frame that results"""
+        if not self.use_ohlcv_data():
+            raise ValueError("only call if we need ohlcv data")
+        f = OhlcvDataFactory(self.ppss.lake_ss)
+        mergedohlcv_df = f.get_mergedohlcv_df()
+        return mergedohlcv_df
+
+
+@enforce_types
+def _tx_failed(tx) -> bool:
+    return tx is None or tx["status"] != 1
diff --git a/pdr_backend/predictoor/test/predictoor_agent_runner.py b/pdr_backend/predictoor/test/mockutil.py
similarity index 50%
rename from pdr_backend/predictoor/test/predictoor_agent_runner.py
rename to pdr_backend/predictoor/test/mockutil.py
index 79e2b15ba..295ea08e9 100644
--- a/pdr_backend/predictoor/test/predictoor_agent_runner.py
+++ b/pdr_backend/predictoor/test/mockutil.py
@@ -1,29 +1,27 @@
-"""
-This file exposes run_agent_test()
-which is used by test_predictoor_agent{1,3}.py
-"""
-
 import os
+from typing import List
 from unittest.mock import Mock
 
 from enforce_typing import enforce_types
+import pytest
 
 from pdr_backend.ppss.ppss import mock_feed_ppss, mock_ppss
 from pdr_backend.ppss.web3_pp import (
     inplace_mock_query_feed_contracts,
     inplace_mock_w3_and_contract_with_tracking,
 )
-from pdr_backend.subgraph.subgraph_feed import mock_feed
+from pdr_backend.subgraph.subgraph_feed import mock_feed, SubgraphFeed
 from pdr_backend.util.time_types import UnixTimeS
 
-PRIV_KEY = os.getenv("PRIVATE_KEY")
+PRIV_KEY = str(os.getenv("PRIVATE_KEY"))
+PRIV_KEY2 = PRIV_KEY[:-4] + "0000"
 OWNER_ADDR = "0xowner"
 INIT_TIMESTAMP = UnixTimeS(107)
 INIT_BLOCK_NUMBER = 13
 
 
 @enforce_types
-def get_agent_1feed(tmpdir: str, monkeypatch, predictoor_agent_class):
+def mock_ppss_1feed(approach: int, tmpdir: str, monkeypatch):
     """
     @description
       Initialize the agent, and return it along with related info
@@ -32,15 +30,20 @@ def get_agent_1feed(tmpdir: str, monkeypatch, predictoor_agent_class):
     @return
       feed -- SubgraphFeed, eg for binance BTC/USDT 5m
       ppss -- PPSS
-      agent -- PredictoorAgent{1,3,..}
       pdr_contract -- PredictoorContract corresponding to the feed
     """
+    # mock ppss, feed
     monkeypatch.setenv("PRIVATE_KEY", PRIV_KEY)
+    monkeypatch.setenv("PRIVATE_KEY2", PRIV_KEY2)
     feed, ppss = mock_feed_ppss(
         "5m", "binanceus", "BTC/USDT", network="development", tmpdir=tmpdir
     )
+    ppss.predictoor_ss.set_approach(approach)
+
+    # mock ppss.web3_pp.query_feed_contracts()
     inplace_mock_query_feed_contracts(ppss.web3_pp, feed)
 
+    # mock w3, pdr contract
     pdr_contract = inplace_mock_w3_and_contract_with_tracking(
         ppss.web3_pp,
         INIT_TIMESTAMP,
@@ -50,16 +53,11 @@ def get_agent_1feed(tmpdir: str, monkeypatch, predictoor_agent_class):
         monkeypatch,
     )
 
-    # now we're done the mocking, time for the real work!!
-
-    # real work: initialize
-    agent = predictoor_agent_class(ppss)
-
-    return (feed, ppss, agent, pdr_contract)
+    return (feed, ppss, pdr_contract)
 
 
 @enforce_types
-def get_agent_2feeds(tmpdir: str, monkeypatch, predictoor_agent_class):
+def mock_ppss_2feeds(approach: int, tmpdir: str, monkeypatch):
     """
     @description
       Initialize the agent, and return it along with related info
@@ -68,19 +66,24 @@ def get_agent_2feeds(tmpdir: str, monkeypatch, predictoor_agent_class):
     @return
       feeds -- list of SubgraphFeed, eg for binance {BTC,ETH}/USDT 5m
       ppss -- PPSS
-      agent -- PredictoorAgent{1,3,..}
     """
     monkeypatch.setenv("PRIVATE_KEY", PRIV_KEY)
+    monkeypatch.setenv("PRIVATE_KEY2", PRIV_KEY2)
 
+    # mock ppss, feeds
     exchange, timescale, quote = "binanceus", "5m", "USDT"
     coins = ["BTC", "ETH"]
-    feeds = [mock_feed(timescale, exchange, f"{c}/{quote}") for c in coins]
+    feeds: List[SubgraphFeed] = [
+        mock_feed(timescale, exchange, f"{c}/{quote}") for c in coins
+    ]
     ppss = mock_ppss(
         [f"{exchange} {c}/{quote} c {timescale}" for c in coins],
         network="development",
         tmpdir=tmpdir,
     )
+    ppss.predictoor_ss.set_approach(approach)
 
+    # mock ppss.web3_pp.query_feed_contracts()
     ppss.web3_pp.query_feed_contracts = Mock()
     ppss.web3_pp.query_feed_contracts.return_value = {
         feed.address: feed for feed in feeds
@@ -100,51 +103,4 @@ def get_agent_2feeds(tmpdir: str, monkeypatch, predictoor_agent_class):
         contract_func,
     )
 
-    # now we're done the mocking, time for the real work!!
-
-    # real work: initialize
-    agent = predictoor_agent_class(ppss)
-
-    return (feeds, ppss, agent)
-
-
-@enforce_types
-def run_agent_test(tmpdir: str, monkeypatch, predictoor_agent_class):
-    """
-    @description
-        Run the agent for a while, and then do some basic sanity checks.
-
-        Uses get_agent_1feed (not 2feeds)
-    """
-    _, ppss, agent, _mock_pdr_contract = get_agent_1feed(
-        tmpdir, monkeypatch, predictoor_agent_class
-    )
-    # now we're done the mocking, time for the real work!!
-
-    # real work: main iterations
-    for _ in range(500):
-        agent.take_step()
-
-    # log some final results for debubbing / inspection
-    mock_w3 = ppss.web3_pp.web3_config.w3
-    print("\n" + "/" * 160)
-    print("Done iterations")
-    print(
-        f"init block_number = {INIT_BLOCK_NUMBER}"
-        f", final = {mock_w3.eth.block_number}"
-    )
-    print()
-    print(f"init timestamp = {INIT_TIMESTAMP}, final = {mock_w3.eth.timestamp}")
-    print(f"all timestamps seen = {mock_w3.eth._timestamps_seen}")
-    print()
-    print(
-        "unique prediction_slots = "
-        f"{sorted(set(_mock_pdr_contract._prediction_slots))}"
-    )
-    print(f"all prediction_slots = {_mock_pdr_contract._prediction_slots}")
-
-    # relatively basic sanity tests
-    assert _mock_pdr_contract._prediction_slots
-    assert (mock_w3.eth.timestamp + 2 * ppss.predictoor_ss.timeframe_s) >= max(
-        _mock_pdr_contract._prediction_slots
-    )
+    return (feeds, ppss)
diff --git a/pdr_backend/predictoor/test/test_predictoor_agent.py b/pdr_backend/predictoor/test/test_predictoor_agent.py
new file mode 100644
index 000000000..9e34ef043
--- /dev/null
+++ b/pdr_backend/predictoor/test/test_predictoor_agent.py
@@ -0,0 +1,234 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from enforce_typing import enforce_types
+import numpy as np
+from numpy.testing import assert_array_equal
+import polars as pl
+
+from pdr_backend.ppss.ppss import PPSS
+from pdr_backend.ppss.predictoor_ss import PredictoorSS
+from pdr_backend.ppss.web3_pp import Web3PP
+from pdr_backend.predictoor.predictoor_agent import PredictoorAgent
+from pdr_backend.predictoor.test.mockutil import (
+    INIT_TIMESTAMP,
+    INIT_BLOCK_NUMBER,
+    mock_ppss_1feed,
+    mock_ppss_2feeds,
+)
+
+
+# ===========================================================================
+# test approach 1 & 2 - main loop
+
+
+@enforce_types
+def test_predictoor_agent_main1(tmpdir, monkeypatch):
+    _test_predictoor_agent_main(1, str(tmpdir), monkeypatch)
+
+
+@enforce_types
+def test_predictoor_agent_main2(tmpdir, monkeypatch):
+    _test_predictoor_agent_main(2, str(tmpdir), monkeypatch)
+
+
+@enforce_types
+def _test_predictoor_agent_main(approach: int, tmpdir: str, monkeypatch):
+    """
+    @description
+        Run the agent for a while, and then do some basic sanity checks.
+        Uses get_agent_1feed, *not* 2feeds.
+    """
+    assert approach in [1, 2]
+
+    _, ppss, _mock_pdr_contract = mock_ppss_1feed(approach, tmpdir, monkeypatch)
+    assert ppss.predictoor_ss.approach == approach
+    # now we're done the mocking, time for the real work!!
+
+    # real work: main iterations
+    agent = PredictoorAgent(ppss)
+    for _ in range(500):
+        agent.take_step()
+
+    # log some final results for debubbing / inspection
+    mock_w3 = ppss.web3_pp.web3_config.w3
+    print("\n" + "/" * 160)
+    print("Done iterations")
+    print(
+        f"init block_number = {INIT_BLOCK_NUMBER}"
+        f", final = {mock_w3.eth.block_number}"
+    )
+    print()
+    print(f"init timestamp = {INIT_TIMESTAMP}, final = {mock_w3.eth.timestamp}")
+    print(f"all timestamps seen = {mock_w3.eth._timestamps_seen}")
+    print()
+    print(
+        "unique prediction_slots = "
+        f"{sorted(set(_mock_pdr_contract._prediction_slots))}"
+    )
+    print(f"all prediction_slots = {_mock_pdr_contract._prediction_slots}")
+
+    # relatively basic sanity tests
+    assert _mock_pdr_contract._prediction_slots
+    assert (mock_w3.eth.timestamp + 2 * ppss.predictoor_ss.timeframe_s) >= max(
+        _mock_pdr_contract._prediction_slots
+    )
+
+
+# ===========================================================================
+# test constructor
+
+
+@enforce_types
+def test_predictoor_agent_init_empty():
+    """
+    @description
+      Basic test: when there's no feeds, does it complain?
+    """
+    # test with no feeds
+    mock_ppss_empty = MagicMock(spec=PPSS)
+    mock_ppss_empty.predictoor_ss = MagicMock(spec=PredictoorSS)
+    mock_ppss_empty.predictoor_ss.get_feed_from_candidates.return_value = None
+    mock_ppss_empty.web3_pp = MagicMock(spec=Web3PP)
+    mock_ppss_empty.web3_pp.query_feed_contracts.return_value = {}
+
+    with pytest.raises(ValueError, match="No feeds found"):
+        PredictoorAgent(mock_ppss_empty)
+
+
+# ===========================================================================
+# test approach 3 - get_prediction()
+
+BTC_CLOSE_VALS = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0]
+ETH_CLOSE_VALS = [30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0]
+
+
+def mock_get_ohlcv_data2(*args, **kwargs):  # pylint: disable=unused-argument
+    d = {
+        "timestamp": [100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
+        "binanceus:BTC/USDT:open": [1.0] * 10,
+        "binanceus:BTC/USDT:high": [1.0] * 10,
+        "binanceus:BTC/USDT:low": [1.0] * 10,
+        "binanceus:BTC/USDT:close": BTC_CLOSE_VALS,
+        "binanceus:BTC/USDT:volume": [1.0] * 10,
+        "binanceus:ETH/USDT:open": [1.0] * 10,
+        "binanceus:ETH/USDT:high": [1.0] * 10,
+        "binanceus:ETH/USDT:low": [1.0] * 10,
+        "binanceus:ETH/USDT:close": ETH_CLOSE_VALS,
+        "binanceus:ETH/USDT:volume": [1.0] * 10,
+    }
+    mergedohlcv_df = pl.DataFrame(d)
+    return mergedohlcv_df
+
+
+class MockModel:
+    """scikit-learn style model"""
+
+    def __init__(self):
+        self.aimodel_ss = None  # fill this in later, after patch applied
+        self.last_X = None  # for tracking test results
+        self.last_yptrue = None  # ""
+
+    def predict_ptrue(self, X: np.ndarray) -> np.ndarray:
+        ar_n = self.aimodel_ss.autoregressive_n
+        n_feeds = self.aimodel_ss.n_feeds
+        (n_points, n_vars) = X.shape
+        assert n_points == 1  # this mock can only handle 1 input point
+        assert n_vars == self.aimodel_ss.n == ar_n * n_feeds
+
+        CLOSE_VALS = X
+        prob_up = np.sum(CLOSE_VALS) / 1e6
+        assert 0.0 <= prob_up <= 1.0
+        yptrue = np.array([prob_up])
+
+        self.last_X, self.last_yptrue = X, yptrue  # cache for testing
+        return yptrue
+
+
+@enforce_types
+def test_predictoor_agent_calc_stakes2_1feed(tmpdir, monkeypatch):
+    """
+    @description
+      Test calc_stakes2() on 1 feed.
+
+      Approach to test:
+      - mergedohlcv_df has simple pre-set values: CLOSE_VALS
+      - prob_up = model.predict_ptrue(X) is a simple sum of X-values
+      - then, test that sum(CLOSE_VALS[-ar_n:])/1e6 == prob_up
+        - where ar_n = autoregressive_n = 3
+        - where the /1e6 is so 0 <= prob_up <= 1.0 when summing BTC prices
+    """
+    mock_model = MockModel()
+
+    def mock_build(*args, **kwargs):  # pylint: disable=unused-argument
+        return mock_model
+
+    d = "pdr_backend.predictoor.predictoor_agent"
+    with patch(f"{d}.PredictoorAgent.get_ohlcv_data", mock_get_ohlcv_data2), patch(
+        f"{d}.AimodelFactory.build", mock_build
+    ):
+
+        # initialize agent
+        _, ppss, _ = mock_ppss_1feed(2, str(tmpdir), monkeypatch)
+        aimodel_ss = ppss.predictoor_ss.aimodel_ss
+        assert aimodel_ss.n_feeds == 1
+
+        # do prediction
+        mock_model.aimodel_ss = aimodel_ss
+        agent = PredictoorAgent(ppss)
+        agent.calc_stakes2()
+
+        ar_n = aimodel_ss.autoregressive_n
+        assert ar_n == 3
+
+        assert mock_model.last_X.shape == (1, 3) == (1, ar_n * 1)
+        expected_X = np.array([BTC_CLOSE_VALS[-ar_n:]])  # [17.0, 18.0, 19.0]
+        expected_prob_up = sum(BTC_CLOSE_VALS[-ar_n:]) / 1e6
+        expected_yptrue = np.array([expected_prob_up])
+
+        assert_array_equal(expected_X, mock_model.last_X)
+        assert_array_equal(expected_yptrue, mock_model.last_yptrue)
+
+
+@enforce_types
+def test_predictoor_agent_calc_stakes2_2feeds(tmpdir, monkeypatch):
+    """
+    @description
+      Test calc_stakes2(), when X has >1 input feed
+    """
+    mock_model = MockModel()
+
+    def mock_build(*args, **kwargs):  # pylint: disable=unused-argument
+        return mock_model
+
+    d = "pdr_backend.predictoor.predictoor_agent"
+    with patch(f"{d}.PredictoorAgent.get_ohlcv_data", mock_get_ohlcv_data2), patch(
+        f"{d}.AimodelFactory.build", mock_build
+    ):
+
+        # initialize agent
+        feeds, ppss = mock_ppss_2feeds(2, str(tmpdir), monkeypatch)
+        assert ppss.predictoor_ss.approach == 2
+
+        assert len(feeds) == 2
+        aimodel_ss = ppss.predictoor_ss.aimodel_ss
+        assert aimodel_ss.n_feeds == 2
+
+        # do prediction
+        mock_model.aimodel_ss = aimodel_ss
+        agent = PredictoorAgent(ppss)
+        agent.calc_stakes2()
+
+        ar_n = aimodel_ss.autoregressive_n
+        assert ar_n == 3
+
+        assert mock_model.last_X.shape == (1, 6) == (1, ar_n * 2)
+
+        # [17.0, 18.0, 19.0, 37.0, 38.0, 39.0]
+        expected_X = np.array([BTC_CLOSE_VALS[-ar_n:] + ETH_CLOSE_VALS[-ar_n:]])
+
+        expected_prob_up = sum(BTC_CLOSE_VALS[-ar_n:] + ETH_CLOSE_VALS[-ar_n:]) / 1e6
+        expected_yptrue = np.array([expected_prob_up])
+
+        assert_array_equal(expected_X, mock_model.last_X)
+        assert_array_equal(expected_yptrue, mock_model.last_yptrue)
diff --git a/pdr_backend/sim/sim_engine.py b/pdr_backend/sim/sim_engine.py
index 38fb56778..758b7a5e9 100644
--- a/pdr_backend/sim/sim_engine.py
+++ b/pdr_backend/sim/sim_engine.py
@@ -1,19 +1,21 @@
 import copy
 import logging
 import os
-from typing import List
+from typing import Dict, List, Union
 
 import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
 import numpy as np
 import polars as pl
 from enforce_typing import enforce_types
 from statsmodels.stats.proportion import proportion_confint
 
+from pdr_backend.aimodel.plot_model import plot_model
 from pdr_backend.aimodel.aimodel_data_factory import AimodelDataFactory
 from pdr_backend.aimodel.aimodel_factory import AimodelFactory
 from pdr_backend.lake.ohlcv_data_factory import OhlcvDataFactory
 from pdr_backend.ppss.ppss import PPSS
-from pdr_backend.util.mathutil import nmse
+from pdr_backend.util.mathutil import classif_acc
 from pdr_backend.util.time_types import UnixTimeMs
 
 logger = logging.getLogger("sim_engine")
@@ -22,17 +24,18 @@
 
 # pylint: disable=too-many-instance-attributes
 class SimEngineState:
-    def __init__(self, init_holdings: dict):
+    def __init__(self, init_holdings: Dict[str, Union[int, float]]):
         self.holdings: dict = init_holdings
-        self.nmses_train: List[float] = []
-        self.ys_test: List[float] = []
-        self.ys_testhat: List[float] = []
+        self.init_loop_attributes()
+
+    def init_loop_attributes(self):
+        self.accs_train: List[float] = []
+        self.ybools_test: List[float] = []
+        self.ybools_testhat: List[float] = []
         self.corrects: List[bool] = []
         self.trader_profits_USD: List[float] = []
         self.predictoor_profits_OCEAN: List[float] = []
 
-        self.y2: List[float] = []
-
 
 # pylint: disable=too-many-instance-attributes
 class SimEngine:
@@ -55,7 +58,9 @@ def __init__(self, ppss: PPSS):
 
         self.plot_state = None
         if self.ppss.sim_ss.do_plot:
-            self.plot_state = PlotState()
+            n = self.ppss.predictoor_ss.aimodel_ss.n  # num input vars
+            include_contour = n == 2
+            self.plot_state = PlotState(include_contour)
 
         self.logfile = ""
 
@@ -83,14 +88,7 @@ def _init_loop_attributes(self):
         fh.setLevel(logging.INFO)
         logger.addHandler(fh)
 
-        self.st.nmses_train, self.st.ys_test, self.st.ys_testhat, self.st.corrects = (
-            [],
-            [],
-            [],
-            [],
-        )
-        self.st.trader_profits_USD = []  # profit per epoch
-        self.st.predictoor_profits_OCEAN = []  # profit per epoch
+        self.st.init_loop_attributes()
 
     @enforce_types
     def run(self):
@@ -98,86 +96,117 @@ def run(self):
         logger.info("Start run")
 
         # main loop!
-        pq_data_factory = OhlcvDataFactory(self.ppss.lake_ss)
-        mergedohlcv_df: pl.DataFrame = pq_data_factory.get_mergedohlcv_df()
+        f = OhlcvDataFactory(self.ppss.lake_ss)
+        mergedohlcv_df = f.get_mergedohlcv_df()
         for test_i in range(self.ppss.sim_ss.test_n):
             self.run_one_iter(test_i, mergedohlcv_df)
-            self._plot(test_i, self.ppss.sim_ss.test_n)
 
         logger.info("Done all iters.")
 
-        nmse_train = np.average(self.st.nmses_train)
-        nmse_test = nmse(self.st.ys_testhat, self.st.ys_test)
-        logger.info("Final nmse_train=%.5f, nmse_test=%.5f", nmse_train, nmse_test)
+        acc_train = np.average(self.st.accs_train)
+        acc_test = classif_acc(self.st.ybools_testhat, self.st.ybools_test)
+        logger.info("Final acc_train=%.5f, acc_test=%.5f", acc_train, acc_test)
 
+    # pylint: disable=too-many-statements# pylint: disable=too-many-statements
     @enforce_types
     def run_one_iter(self, test_i: int, mergedohlcv_df: pl.DataFrame):
-        # pylint: disable=too-many-statements
         ppss, pdr_ss = self.ppss, self.ppss.predictoor_ss
+
         testshift = ppss.sim_ss.test_n - test_i - 1  # eg [99, 98, .., 2, 1, 0]
-        model_data_factory = AimodelDataFactory(pdr_ss)
-        X, y, _, _ = model_data_factory.create_xy(mergedohlcv_df, testshift)
+        data_f = AimodelDataFactory(pdr_ss)
+        X, ycont, x_df, _ = data_f.create_xy(
+            mergedohlcv_df,
+            testshift,
+        )
+        colnames = [col for col in x_df.columns]
 
         st, fin = 0, X.shape[0] - 1
         X_train, X_test = X[st:fin, :], X[fin : fin + 1]
-        y_train, y_test = y[st:fin], y[fin : fin + 1]
+        ycont_train, ycont_test = ycont[st:fin], ycont[fin : fin + 1]
 
-        aimodel_factory = AimodelFactory(pdr_ss.aimodel_ss)
-        model = aimodel_factory.build(X_train, y_train)
+        curprice = ycont_train[-1]
+        trueprice = ycont_test[-1]
 
-        y_trainhat = model.predict(X_train)  # eg yhat=zhat[y-5]
+        y_thr = curprice
+        ybool = data_f.ycont_to_ytrue(ycont, y_thr)
+        ybool_train, ybool_test = ybool[st:fin], ybool[fin : fin + 1]
 
-        nmse_train = nmse(y_train, y_trainhat, min(y), max(y))
-        self.st.nmses_train.append(nmse_train)
+        model_f = AimodelFactory(pdr_ss.aimodel_ss)
+        model = model_f.build(X_train, ybool_train)
+
+        ybool_trainhat = model.predict_true(X_train)  # eg yhat=zhat[y-5]
+        acc_train = classif_acc(ybool_train, ybool_trainhat)
+        self.st.accs_train.append(acc_train)
 
         # current time
         recent_ut = UnixTimeMs(int(mergedohlcv_df["timestamp"].to_list()[-1]))
-        ut = UnixTimeMs(recent_ut - testshift * self.ppss.predictoor_ss.timeframe_ms)
+        ut = UnixTimeMs(recent_ut - testshift * pdr_ss.timeframe_ms)
 
-        # current price
-        curprice = y_train[-1]
+        # predict price direction
+        prob_up: float = model.predict_ptrue(X_test)[0]  # in [0.0, 1.0]
+        pred_up: bool = model.predict_true(X_test)[0]  # True or False
+        self.st.ybools_testhat.append(pred_up)
 
-        # predict price
-        predprice = model.predict(X_test)[0]
-        self.st.ys_testhat.append(predprice)
+        # predictoor: (simulate) submit predictions with stake
+        acct_up_profit = acct_down_profit = 0.0
+        stake_up = prob_up * pdr_ss.stake_amount
+        stake_down = (1.0 - prob_up) * pdr_ss.stake_amount
+        acct_up_profit -= stake_up
+        acct_down_profit -= stake_down
 
-        # simulate buy. Buy 'amt_usd' worth of TOK if we think price going up
+        # trader: enter the trading position
         usdcoin_holdings_before = self.st.holdings[self.usdcoin]
-        if self._do_buy(predprice, curprice):
-            self._buy(curprice, ppss.trader_ss.buy_amt_usd)
+        if pred_up:  # buy; exit later by selling
+            conf_up = (prob_up - 0.5) * 2.0  # to range [0,1]
+            buy_amt_usd = conf_up * ppss.trader_ss.buy_amt_usd
+            usdcoin_amt_sent = buy_amt_usd
+            tokcoin_amt_recd = self._buy(curprice, usdcoin_amt_sent)
+        else:  # sell; exit later by buying
+            prob_down = 1.0 - prob_up
+            conf_down = (prob_down - 0.5) * 2.0  # to range [0,1]
+            sell_amt_usd = conf_down * ppss.trader_ss.buy_amt_usd
+            p = self.ppss.trader_ss.fee_percent
+            tokcoin_amt_sent = sell_amt_usd / curprice / (1 - p)
+            usdcoin_amt_recd = self._sell(curprice, tokcoin_amt_sent)
 
         # observe true price
-        trueprice = y_test[0]
-        self.st.ys_test.append(trueprice)
-
-        # simulate sell. Update trader_profits_USD
-        tokcoin_amt_sell = self.st.holdings[self.tokcoin]
-        if tokcoin_amt_sell > 0:
-            self._sell(trueprice, tokcoin_amt_sell)
+        true_up = trueprice > curprice
+        self.st.ybools_test.append(true_up)
+
+        # trader: exit the trading position
+        if pred_up:  # we'd bought; so now sell
+            self._sell(trueprice, tokcoin_amt_sell=tokcoin_amt_recd)
+        else:  # we'd sold, so now buy back
+            self._buy(trueprice, usdcoin_amt_spend=usdcoin_amt_recd)
         usdcoin_holdings_after = self.st.holdings[self.usdcoin]
 
-        trader_profit_USD = usdcoin_holdings_after - usdcoin_holdings_before
-        self.st.trader_profits_USD.append(trader_profit_USD)
-
-        # err = abs(predprice - trueprice)
-        pred_dir = "UP" if predprice > curprice else "DN"
-        true_dir = "UP" if trueprice > curprice else "DN"
+        # track prediction
+        pred_dir = "UP" if pred_up else "DN"
+        true_dir = "UP" if true_up else "DN"
         correct = pred_dir == true_dir
         correct_s = "Y" if correct else "N"
         self.st.corrects.append(correct)
 
-        # Update predictoor_profits_OCEAN
-        if correct:
-            others_stake_correct = pdr_ss.others_accuracy * pdr_ss.others_stake
-            tot_stake_correct = others_stake_correct + pdr_ss.stake_amount
-            percent_to_me = pdr_ss.stake_amount / tot_stake_correct
-            predictoor_profit_OCEAN = percent_to_me * pdr_ss.revenue
+        # track predictoor profit
+        tot_stake = pdr_ss.others_stake + pdr_ss.stake_amount
+        others_stake_correct = pdr_ss.others_accuracy * pdr_ss.others_stake
+        others_stake_wrong = (1 - pdr_ss.others_accuracy) * pdr_ss.others_stake
+        if true_up:
+            tot_stake_correct = others_stake_correct + stake_up
+            percent_to_me = stake_up / tot_stake_correct
+            acct_up_profit += percent_to_me * (pdr_ss.revenue + tot_stake)
         else:
-            percent_to_me = 0
-            predictoor_profit_OCEAN = -pdr_ss.stake_amount
+            tot_stake_correct = others_stake_correct + stake_down
+            percent_to_me = stake_down / tot_stake_correct
+            acct_down_profit += percent_to_me * (pdr_ss.revenue + tot_stake)
+        predictoor_profit_OCEAN = acct_up_profit + acct_down_profit
         self.st.predictoor_profits_OCEAN.append(predictoor_profit_OCEAN)
 
-        # Log
+        # track trading profit
+        trader_profit_USD = usdcoin_holdings_after - usdcoin_holdings_before
+        self.st.trader_profits_USD.append(trader_profit_USD)
+
+        # log
         n_correct, n_trials = sum(self.st.corrects), len(self.st.corrects)
         acc_est = float(n_correct) / n_trials
         acc_l, acc_u = proportion_confint(count=n_correct, nobs=n_trials)
@@ -185,31 +214,33 @@ def run_one_iter(self, test_i: int, mergedohlcv_df: pl.DataFrame):
         s = f"Iter #{test_i+1}/{ppss.sim_ss.test_n}: "
         s += f"ut={ut.pretty_timestr()[9:][:-10]}"
 
-        s += f". pred={pred_dir}, true={true_dir}, correct={correct_s}"
-        s += f", %_rev_to_pdr={percent_to_me*100.0:7.4f}%"
-        s += f" -> {predictoor_profit_OCEAN:8.5f} OCEAN profit"
+        s += f" prob_up={prob_up:.2f}"
+        s += " predictoor profit = "
+        s += f"{acct_up_profit:8.5f} up"
+        s += f" + {acct_down_profit:8.5f} down"
+        s += f" = {predictoor_profit_OCEAN:8.5f} OCEAN"
         s += f" (cumulative {sum(self.st.predictoor_profits_OCEAN):7.2f} OCEAN)"
 
         s += f". Correct: {n_correct:4d}/{n_trials:4d} "
         s += f"= {acc_est*100:.2f}%"
         s += f" [{acc_l*100:.2f}%, {acc_u*100:.2f}%]"
 
-        s += f". trading made ${trader_profit_USD:9.4f}"
+        s += f". trader profit = ${trader_profit_USD:9.4f}"
         s += f" (cumulative ${sum(self.st.trader_profits_USD):9.4f})"
         logger.info(s)
 
-    def _do_buy(self, predprice: float, curprice: float) -> bool:
-        """
-        @arguments
-          predprice -- predicted price (5 min from now)
-          curprice -- current price (now)
-
-        @return
-          bool -- buy y/n?
-        """
-        return predprice > curprice
+        # plot
+        if self.do_plot(test_i, self.ppss.sim_ss.test_n):
+            self.plot_state.make_plot(  # type: ignore[union-attr]
+                self.st,
+                model,
+                X_train,
+                ybool_train,
+                colnames,
+            )
 
-    def _buy(self, price: float, usdcoin_amt_spend: float):
+    @enforce_types
+    def _buy(self, price: float, usdcoin_amt_spend: float) -> float:
         """
         @description
           Buy tokcoin with usdcoin
@@ -217,6 +248,8 @@ def _buy(self, price: float, usdcoin_amt_spend: float):
         @arguments
           price -- amt of usdcoin per token
           usdcoin_amt_spend -- amount to spend, in usdcoin; spend less if have less
+        @return
+          tokcoin_amt_recd --
         """
         # simulate buy
         usdcoin_amt_sent = min(usdcoin_amt_spend, self.st.holdings[self.usdcoin])
@@ -241,7 +274,10 @@ def _buy(self, price: float, usdcoin_amt_spend: float):
             self.usdcoin,
         )
 
-    def _sell(self, price: float, tokcoin_amt_sell: float):
+        return tokcoin_amt_recd
+
+    @enforce_types
+    def _sell(self, price: float, tokcoin_amt_sell: float) -> float:
         """
         @description
           Sell tokcoin for usdcoin
@@ -249,6 +285,9 @@ def _sell(self, price: float, tokcoin_amt_sell: float):
         @arguments
           price -- amt of usdcoin per token
           tokcoin_amt_sell -- how much of coin to sell, in tokcoin
+
+        @return
+          usdcoin_amt_recd -- usdcoin amt received
         """
         tokcoin_amt_sent = tokcoin_amt_sell
         self.st.holdings[self.tokcoin] -= tokcoin_amt_sent
@@ -272,119 +311,174 @@ def _sell(self, price: float, tokcoin_amt_sell: float):
             self.usdcoin,
         )
 
-    def _plot(self, i: int, N: int):
+        return usdcoin_amt_recd
+
+    @enforce_types
+    def do_plot(self, i: int, N: int):
+        "Plot on this iteration Y/N?"
         if not self.ppss.sim_ss.do_plot:
-            return
+            return False
 
         # don't plot first 5 iters -> not interesting
         # then plot the next 5 -> "stuff's happening!"
         # then plot every 5th iter, to balance "stuff's happening" w/ speed
         do_update = i >= 5 and (i < 10 or i % 5 == 0 or (i + 1) == N)
         if not do_update:
-            return
+            return False
 
-        self.plot_state.do_plot(self.st)  # type: ignore[union-attr]
+        return True
 
 
 @enforce_types
 class PlotState:
-    def __init__(self):
-        self.fig, self.axs = plt.subplots(2, 2, gridspec_kw={"width_ratios": [3, 1]})
-        self.x = []
-        self.y0 = []
-        self.y1_est, self.y1_l, self.y1_u = [], [], []
-        self.jitter = []
-        self.plotted_before = False
-        self.y2 = []
+    def __init__(self, include_contour: bool):
+        self.include_contour = include_contour
+
+        fig = plt.figure()
+        self.fig = fig
+
+        if include_contour:
+            gs = gridspec.GridSpec(2, 4, width_ratios=[5, 1, 1, 5])
+        else:
+            gs = gridspec.GridSpec(2, 3, width_ratios=[5, 1, 1])
+
+        self.ax00 = fig.add_subplot(gs[0, 0])
+        self.ax01 = fig.add_subplot(gs[0, 1:3])
+        self.ax10 = fig.add_subplot(gs[1, 0])
+        self.ax11 = fig.add_subplot(gs[1, 1])
+        self.ax12 = fig.add_subplot(gs[1, 2])
+        if include_contour:
+            self.ax03 = fig.add_subplot(gs[:, 3])
+
+        self.x: List[float] = []
+        self.y01_est: List[float] = []
+        self.y01_l: List[float] = []
+        self.y01_u: List[float] = []
+        self.jitter: List[float] = []
+        self.plotted_before: bool = False
         plt.ion()
         plt.show()
 
     # pylint: disable=too-many-statements
-    def do_plot(self, st: SimEngineState):
-        fig, ((ax0, ax1), (ax2, ax3)) = self.fig, self.axs
+    def make_plot(self, st, model, X_train, ybool_train, colnames):
+        fig = self.fig
+        ax00, ax01 = self.ax00, self.ax01
+        ax10, ax11, ax12 = self.ax10, self.ax11, self.ax12
 
         N = len(st.predictoor_profits_OCEAN)
-        N_done = len(self.x)
+        N_done = len(self.x)  # what # points have been plotted previously
 
         # set x
         self.x = list(range(0, N))
         next_x = _slice(self.x, N_done, N)
         next_hx = [next_x[0], next_x[-1]]  # horizontal x
 
-        # plot 0: predictoor profit vs time
-        self.y0 = list(np.cumsum(st.predictoor_profits_OCEAN))
-        next_y0 = _slice(self.y0, N_done, N)
-        ax0.plot(next_x, next_y0, color="green")
-        ax0.plot(next_hx, [0, 0], color="0.2", linestyle="dashed", linewidth=1)
-        _set_title(ax0, f"Predictoor profit vs time. Current:{self.y0[-1]:.2f} OCEAN")
+        # plot row 0, col 0: predictoor profit vs time
+        y00 = list(np.cumsum(st.predictoor_profits_OCEAN))
+        next_y00 = _slice(y00, N_done, N)
+        ax00.plot(next_x, next_y00, c="g")
+        ax00.plot(next_hx, [0, 0], c="0.2", ls="--", lw=1)
+        s = f"Predictoor profit vs time. Current:{y00[-1]:.2f} OCEAN"
+        _set_title(ax00, s)
         if not self.plotted_before:
-            ax0.set_ylabel("predictoor profit (OCEAN)", fontsize=FONTSIZE)
-            ax0.set_xlabel("time", fontsize=FONTSIZE)
-            _label_on_right(ax0)
-            ax0.margins(0.005, 0.05)
-
-        # plot 1: % correct vs time
-        for i_ in range(N_done, N):
-            n_correct = sum(st.corrects[: i_ + 1])
-            n_trials = len(st.corrects[: i_ + 1])
+            ax00.set_ylabel("predictoor profit (OCEAN)", fontsize=FONTSIZE)
+            ax00.set_xlabel("time", fontsize=FONTSIZE)
+            _label_on_right(ax00)
+            ax00.margins(0.005, 0.05)
+
+        # plot row 0, col 1: % correct vs time
+        for i in range(N_done, N):
+            n_correct = sum(st.corrects[: i + 1])
+            n_trials = len(st.corrects[: i + 1])
             l, u = proportion_confint(count=n_correct, nobs=n_trials)
-            self.y1_est.append(n_correct / n_trials * 100)
-            self.y1_l.append(l * 100)
-            self.y1_u.append(u * 100)
-        next_y1_est = _slice(self.y1_est, N_done, N)
-        next_y1_l = _slice(self.y1_l, N_done, N)
-        next_y1_u = _slice(self.y1_u, N_done, N)
-
-        ax1.plot(next_x, next_y1_est, "green")
-        _ = ax1.fill_between(next_x, next_y1_l, next_y1_u, color="0.9")
-        ax1.plot(next_hx, [50, 50], color="0.2", linestyle="dashed", linewidth=1)
-        ax1.set_ylim(bottom=40, top=60)
-        now_s = f"{self.y1_est[-1]:.2f}% [{self.y1_l[-1]:.2f}%, {self.y1_u[-1]:.2f}%]"
-        _set_title(ax1, f"% correct vs time. Current: {now_s}")
-        if not self.plotted_before:
-            ax1.set_xlabel("time", fontsize=FONTSIZE)
-            ax1.set_ylabel("% correct", fontsize=FONTSIZE)
-            _label_on_right(ax1)
-            ax1.margins(0.01, 0.01)
-
-        # plot 2: trader profit vs time
-        self.y2 = list(np.cumsum(st.trader_profits_USD))
-        next_y2 = _slice(self.y2, N_done, N)
-        ax2.plot(next_x, next_y2, color="blue")
-        ax2.plot(next_hx, [0, 0], color="0.2", linestyle="dashed", linewidth=1)
-        _set_title(ax2, f"Trader profit vs time. Current: ${self.y2[-1]:.2f}")
+            self.y01_est.append(n_correct / n_trials * 100)
+            self.y01_l.append(l * 100)
+            self.y01_u.append(u * 100)
+        next_y01_est = _slice(self.y01_est, N_done, N)
+        next_y01_l = _slice(self.y01_l, N_done, N)
+        next_y01_u = _slice(self.y01_u, N_done, N)
+
+        ax01.plot(next_x, next_y01_est, "green")
+        ax01.fill_between(next_x, next_y01_l, next_y01_u, color="0.9")
+        ax01.plot(next_hx, [50, 50], c="0.2", ls="--", lw=1)
+        ax01.set_ylim(bottom=40, top=60)
+        now_s = f"{self.y01_est[-1]:.2f}% "
+        now_s += f"[{self.y01_l[-1]:.2f}%, {self.y01_u[-1]:.2f}%]"
+        _set_title(ax01, f"% correct vs time. Current: {now_s}")
         if not self.plotted_before:
-            ax2.set_xlabel("time", fontsize=FONTSIZE)
-            ax2.set_ylabel("trader profit (USD)", fontsize=FONTSIZE)
-            _label_on_right(ax2)
-            ax2.margins(0.005, 0.05)
-
-        # plot 3: 1d scatter of profits
-        while len(self.jitter) < N:
-            self.jitter.append(np.random.uniform())
-        next_jitter = _slice(self.jitter, N_done, N)
-        next_profits = _slice(st.trader_profits_USD, N_done, N)
-        ax3.scatter(next_jitter, next_profits, color="blue", s=1)
-        avg = np.average(st.trader_profits_USD)
-        _set_title(ax3, f"Trader profit distribution. avg=${avg:.2f}")
+            ax01.set_xlabel("time", fontsize=FONTSIZE)
+            ax01.set_ylabel("% correct", fontsize=FONTSIZE)
+            _label_on_right(ax01)
+            ax01.margins(0.01, 0.01)
+
+        # plot row 0, col 2: model contour
+        if self.include_contour:
+            ax03 = self.ax03
+            labels = tuple([_shift_one_earlier(colname) for colname in colnames])
+            plot_model(model, X_train, ybool_train, labels, (fig, ax03))
+            if not self.plotted_before:
+                ax03.margins(0.01, 0.01)
+
+        # plot row 1, col 0: trader profit vs time
+        y10 = list(np.cumsum(st.trader_profits_USD))
+        next_y10 = _slice(y10, N_done, N)
+        ax10.plot(next_x, next_y10, c="b")
+        ax10.plot(next_hx, [0, 0], c="0.2", ls="--", lw=1)
+        _set_title(ax10, f"Trader profit vs time. Current: ${y10[-1]:.2f}")
         if not self.plotted_before:
-            ax3.plot(
-                [0 - 1, 1 + 1], [0, 0], color="0.2", linestyle="dashed", linewidth=1
-            )
-            ax3.set_ylabel("trader profit (USD)", fontsize=FONTSIZE)
-            _label_on_right(ax3)
-            plt.tick_params(bottom=False, labelbottom=False)
-            ax3.margins(0.05, 0.05)
+            ax10.set_xlabel("time", fontsize=FONTSIZE)
+            ax10.set_ylabel("trader profit (USD)", fontsize=FONTSIZE)
+            _label_on_right(ax10)
+            ax10.margins(0.005, 0.05)
+
+        # reusable profits scatterplot
+        def _scatter_profits(ax, actor_name: str, denomin, st_profits):
+            while len(self.jitter) < N:
+                self.jitter.append(np.random.uniform())
+            next_jitter = _slice(self.jitter, N_done, N)
+            next_profits = _slice(st_profits, N_done, N)
+            ax.scatter(next_jitter, next_profits, c="b", s=1)
+            avg = np.average(st_profits)
+            s = f"{actor_name} profit distr'n. avg={avg:.2f} {denomin}"
+            _set_title(ax, s)
+            if not self.plotted_before:
+                buf = 1.0
+                ax.plot([0 - buf, 1 + buf], [0, 0], c="0.2", ls="--", lw=1)
+                _set_ylabel(ax, f"{actor_name} profit ({denomin})")
+                _label_on_right(ax)
+                plt.tick_params(bottom=False, labelbottom=False)
+                ax.margins(0.05, 0.05)
+
+        # plot row 1, col 1: 1d scatter of predictoor profits
+        _scatter_profits(
+            ax11,
+            "pdr",
+            "OCEAN",
+            st.predictoor_profits_OCEAN,
+        )
+
+        # plot row 1, col 2: 1d scatter of trader profits
+        _scatter_profits(ax12, "trader", "USD", st.trader_profits_USD)
 
         # final pieces
         HEIGHT = 7.5  # magic number
-        WIDTH = int(HEIGHT * 3)  # magic number
+        WIDTH = int(HEIGHT * 3.2)  # magic number
         fig.set_size_inches(WIDTH, HEIGHT)
         fig.tight_layout(pad=0.5, h_pad=1.0, w_pad=1.0)
         plt.pause(0.001)
         self.plotted_before = True
 
 
+def _shift_one_earlier(s: str):
+    """eg 'binance:BTC/USDT:close:t-3' -> 'binance:BTC/USDT:close:t-2'"""
+    val = int(s[-1])
+    return s[:-1] + str(val - 1)
+
+
+def _set_ylabel(ax, s: str):
+    ax.set_ylabel(s, fontsize=FONTSIZE)
+
+
 def _set_title(ax, s: str):
     ax.set_title(s, fontsize=FONTSIZE, fontweight="bold")
 
diff --git a/pdr_backend/sim/test/test_sim_engine.py b/pdr_backend/sim/test/test_sim_engine.py
index 4b501f0ad..a1b751064 100644
--- a/pdr_backend/sim/test/test_sim_engine.py
+++ b/pdr_backend/sim/test/test_sim_engine.py
@@ -5,7 +5,7 @@
 
 from pdr_backend.ppss.lake_ss import LakeSS
 from pdr_backend.ppss.ppss import PPSS, fast_test_yaml_str
-from pdr_backend.ppss.predictoor_ss import PredictoorSS
+from pdr_backend.ppss.predictoor_ss import PredictoorSS, predictoor_ss_test_dict
 from pdr_backend.ppss.sim_ss import SimSS
 from pdr_backend.sim.sim_engine import SimEngine
 
@@ -14,54 +14,45 @@
 def test_sim_engine(tmpdir):
     s = fast_test_yaml_str(tmpdir)
     ppss = PPSS(yaml_str=s, network="development")
-
-    ppss.predictoor_ss = PredictoorSS(
-        {
-            "predict_feed": "binanceus BTC/USDT c 5m",
-            "stake_amount": 1,
-            "bot_only": {
-                "s_until_epoch_end": 60,
-            },
-            "sim_only": {
-                "others_stake": 3,
-                "others_accuracy": 0.51,
-                "revenue": 0.93,
-            },
-            "aimodel_ss": {
-                "input_feeds": ["binanceus BTC/USDT ETH/USDT oc"],
-                "approach": "LIN",
-                "max_n_train": 100,
-                "autoregressive_n": 3,
-            },
-        }
-    )
-
-    ppss.lake_ss = LakeSS(
-        {
-            "feeds": ["binanceus BTC/USDT ETH/USDT oc 5m"],
-            "parquet_dir": os.path.join(tmpdir, "parquet_data"),
-            "st_timestr": "2023-06-18",
-            "fin_timestr": "2023-06-30",
-            "timeframe": "5m",
-        }
-    )
-
-    assert hasattr(ppss, "sim_ss")
-    ppss.sim_ss = SimSS(
-        {
-            "do_plot": True,
-            "log_dir": os.path.join(tmpdir, "logs"),
-            "test_n": 10,
-            "exchange_only": {
-                "timeout": 30000,
-                "options": {
-                    "createMarketBuyOrderRequiresPrice": False,
-                    "defaultType": "spot",
-                },
+    input_feeds = ["binanceus BTC/USDT ETH/USDT oc 5m"]
+
+    # predictoor ss
+    d = predictoor_ss_test_dict()
+    d["predict_feed"] = "binanceus BTC/USDT c 5m"
+    d["aimodel_ss"] = {
+        "input_feeds": input_feeds,
+        "approach": "LinearLogistic",
+        "max_n_train": 100,
+        "autoregressive_n": 3,
+    }
+    ppss.predictoor_ss = PredictoorSS(d)
+
+    # lake ss
+    d = {
+        "feeds": input_feeds,
+        "parquet_dir": os.path.join(tmpdir, "parquet_data"),
+        "st_timestr": "2023-06-18",
+        "fin_timestr": "2023-06-30",
+        "timeframe": "5m",
+    }
+    ppss.lake_ss = LakeSS(d)
+
+    # sim ss
+    d = {
+        "do_plot": True,
+        "log_dir": os.path.join(tmpdir, "logs"),
+        "test_n": 10,
+        "exchange_only": {
+            "timeout": 30000,
+            "options": {
+                "createMarketBuyOrderRequiresPrice": False,
+                "defaultType": "spot",
             },
-        }
-    )
+        },
+    }
+    ppss.sim_ss = SimSS(d)
 
+    # go
     with mock.patch("pdr_backend.sim.sim_engine.plt.show"):
         sim_engine = SimEngine(ppss)
         sim_engine.run()
diff --git a/pdr_backend/util/mathutil.py b/pdr_backend/util/mathutil.py
index 705a35fe2..7f92b1b11 100644
--- a/pdr_backend/util/mathutil.py
+++ b/pdr_backend/util/mathutil.py
@@ -89,50 +89,11 @@ def fill_nans(
 
 
 @enforce_types
-def nmse(yhat, y, ymin=None, ymax=None) -> float:
-    """
-    @description
-        Calculates the normalized mean-squared error.
-    @arguments
-        yhat -- 1d array or list of floats -- estimated values of y
-        y -- 1d array or list of floats -- true values
-        ymin, ymax -- float, float -- roughly the min and max; they
-          do not have to be the perfect values of min and max, because
-          they're just here to scale the output into a roughly [0,1] range
-    @return
-        nmse -- float -- normalized mean-squared error
-    """
-    assert len(y) == len(yhat)
-    y, yhat = np.asarray(y), np.asarray(yhat)
-
-    # base case: no entries
-    if len(yhat) == 0:
-        return 0.0
-
-    # condition ymin, ymax
-    if ymin is None and ymax is None:
-        ymin, ymax = min(y), max(y)
-    assert ymin is not None
-    assert ymax is not None
-
-    # base case: both yhat and y are constant, and same values
-    if (ymax == ymin) and (max(yhat) == min(yhat) == max(y) == min(y)):
-        return 0.0
-
-    # yrange
-    yrange = ymax - ymin
-
-    # First, scale true values and predicted values such that:
-    # - true values are in range [0.0, 1.0]
-    # - predicted values follow the same scaling factors
-    y01 = (y - ymin) / yrange
-    yhat01 = (yhat - ymin) / yrange
-
-    mse_xy = np.sum(np.square(y01 - yhat01))
-    mse_x = np.sum(np.square(y01))
-    nmse_result = mse_xy / mse_x
-
-    return nmse_result
+def classif_acc(ytrue_hat, ytrue) -> float:
+    ytrue_hat, ytrue = np.array(ytrue_hat), np.array(ytrue)
+    n_correct = sum(ytrue_hat == ytrue)
+    acc = n_correct / len(ytrue)
+    return acc
 
 
 @enforce_types
diff --git a/pdr_backend/util/strutil.py b/pdr_backend/util/strutil.py
index 7c519ebcf..82702f82b 100644
--- a/pdr_backend/util/strutil.py
+++ b/pdr_backend/util/strutil.py
@@ -9,8 +9,8 @@ def longstr(self) -> str:
         class_name = self.__class__.__name__
 
         newline = False
-        if hasattr(self, "__STR_GIVES_NEWLINE__"):
-            newline = self.__STR_GIVES_NEWLINE__  # type: ignore
+        if hasattr(self, "__STR_GIVES_NEWLinearLogisticE__"):
+            newline = self.__STR_GIVES_NEWLinearLogisticE__  # type: ignore
 
         s = []
         s += [f"{class_name}={{"]
diff --git a/pdr_backend/util/test_noganache/test_mathutil.py b/pdr_backend/util/test_noganache/test_mathutil.py
index bab0dc593..7e9e75832 100644
--- a/pdr_backend/util/test_noganache/test_mathutil.py
+++ b/pdr_backend/util/test_noganache/test_mathutil.py
@@ -9,7 +9,7 @@
     fill_nans,
     from_wei,
     has_nan,
-    nmse,
+    classif_acc,
     round_sig,
     str_with_wei,
     string_to_bytes32,
@@ -171,12 +171,17 @@ def _test_fill_nans(pdl):
 
 
 @enforce_types
-def test_nmse():
-    y = np.array([10.0, 12.0, 13.0, 20.0])
-    yhat = np.array([9.0, 11.0, 14.0, 21.0])
-    ymin, ymax = 10.0, 20.0
-    e = nmse(yhat, y, ymin, ymax)
-    assert 0.035 <= e <= 0.036
+def test_classif_acc():
+    ybool = np.array([True, True, False, True])
+
+    ybool_hat = np.array([True, True, False, True])
+    assert classif_acc(ybool_hat, ybool) == 1.0
+
+    ybool_hat = np.array([False, False, True, False])
+    assert classif_acc(ybool_hat, ybool) == 0.0
+
+    ybool_hat = np.array([True, False, False, True])
+    assert classif_acc(ybool_hat, ybool) == 0.75
 
 
 @enforce_types
diff --git a/pdr_backend/util/test_noganache/test_strutil.py b/pdr_backend/util/test_noganache/test_strutil.py
index 6e1d14b7a..cd1bed75c 100644
--- a/pdr_backend/util/test_noganache/test_strutil.py
+++ b/pdr_backend/util/test_noganache/test_strutil.py
@@ -33,10 +33,10 @@ def ignoreMethod(self):
     s3 = f.longstr()
     assert s3 == s
 
-    f.__class__.__STR_GIVES_NEWLINE__ = True
+    f.__class__.__STR_GIVES_NEWLinearLogisticE__ = True
     s4 = f.longstr()
     assert "\n" in s4
-    f.__class__.__STR_GIVES_NEWLINE__ = False
+    f.__class__.__STR_GIVES_NEWLinearLogisticE__ = False
 
 
 def testStrMixin2():
diff --git a/ppss.yaml b/ppss.yaml
index 11f446f48..972267f94 100644
--- a/ppss.yaml
+++ b/ppss.yaml
@@ -2,7 +2,7 @@
 lake_ss:
   parquet_dir: parquet_data
   feeds:
-    - binance BTC/USDT 5m
+    - binance BTC/USDT ETH/USDT 5m
 #    - binance BTC/USDT ETH/USDT BNB/USDT XRP/USDT ADA/USDT DOGE/USDT SOL/USDT LTC/USDT TRX/USDT DOT/USDT 5m
 #    - kraken BTC/USDT 5m
   st_timestr: 2023-06-01_00:00 # starting date for data
@@ -10,10 +10,11 @@ lake_ss:
 
 predictoor_ss:
   predict_feed: binance BTC/USDT c 5m
-  stake_amount: 1 # How much your bot stakes. In OCEAN per epoch, per feed
+  approach: 2 # 1->50/50; 2->model-based
+  stake_amount: 100 # How much your bot stakes. In OCEAN per epoch, per feed
   
   sim_only:
-    others_stake: 5 # How much all others' bots stake. In OCEAN per epoch, per feed. Calcs: stake volume = 10e6 $/day/20_feeds = 34700 $/epoch/20_feeds (bc 288 5m epochs/day) = 1735 $/epoch/feed = 2313 OCEAN/epoch/feed (at 1 OCEAN=$0.75)
+    others_stake: 10000 # How much all others' bots stake. In OCEAN per epoch, per feed. Calcs: stake volume = 10e6 $/day/20_feeds = 34700 $/epoch/20_feeds (bc 288 5m epochs/day) = 1735 $/epoch/feed = 2313 OCEAN/epoch/feed (at 1 OCEAN=$0.75)
     others_accuracy: 0.50001 # What percent of others' bots stake is correct. Value in range 0.0-1.0. 0.50001 means mostly 50-50 stake and some small fry predicting a bit accurately
     revenue: 0.93006 # Sales revenue going towards predictoors. In OCEAN per epoch, per feed. Calcs: 37500 OCEAN/week/20_feeds (Predictoor DF rewards) = 18.6012 OCEAN/epoch/20_feeds (bc 2016 5m epochs/week) = 0.93006 OCEAN/epoch/feed
 
@@ -22,17 +23,15 @@ predictoor_ss:
     
   aimodel_ss:
     input_feeds:
-      - binance BTC/USDT c 5m
-#      - binance BTC/USDT ETH/USDT BNB/USDT XRP/USDT ADA/USDT DOGE/USDT SOL/USDT LTC/USDT TRX/USDT DOT/USDT ohlcv 5m
-#    - kraken BTC/USDT 5m
+      - binance BTC/USDT ETH/USDT c 5m
     max_n_train: 5000 # no. epochs to train model on
-    autoregressive_n : 10 # no. epochs that model looks back, to predict next
-    approach: LIN
+    autoregressive_n : 1 # no. epochs that model looks back, to predict next
+    approach: LinearLogistic
 
 trader_ss:
   feed: binance BTC/USDT c 5m
   sim_only:
-    buy_amt: 10 USD # buy this amount in each epoch
+    buy_amt: 1000 USD # buy this amount in each epoch
     fee_percent: 0.0 # simulated % fee
     init_holdings:
       - 100000 USDT
@@ -50,7 +49,7 @@ trader_ss:
 sim_ss: # sim only
   do_plot: True
   log_dir: logs
-  test_n : 200 # number of epochs to simulate
+  test_n : 2000 # number of epochs to simulate
   exchange_only:
     timeout: 30000
     options:
@@ -125,6 +124,13 @@ web3_pp:
     subgraph_url: http://localhost:9000/subgraphs/name/oceanprotocol/ocean-subgraph
     owner_addrs: "0xe2DD09d719Da89e5a3D0F2549c7E24566e947260" # OPF deployer address. Taken from ocean.py setup-local.md FACTORY_DEPLOYER_PRIVATE_KEY
 
+  development2:
+    address_file: "~/barge-pytest.address.json"
+    private_key: "0xc594c6e5def4bab63ac29eed19a134c130388f74f019bc74b8f4389df2837a58"
+    rpc_url: http://74.234.16.165:8545
+    subgraph_url: http://74.234.16.165:9000/subgraphs/name/oceanprotocol/ocean-subgraph
+    owner_addrs: "0xe2DD09d719Da89e5a3D0F2549c7E24566e947260" # OPF deployer address. Taken from ocean.py setup-local.md FACTORY_DEPLOYER_PRIVATE_KEY
+
   barge-predictoor-bot:
     address_file: "~/barge-predictoor-bot.address.json"
     private_key: "0xc594c6e5def4bab63ac29eed19a134c130388f74f019bc74b8f4389df2837a58" # address is 0xe2DD...
diff --git a/system_tests/conftest.py b/system_tests/conftest.py
index 66eeb5068..4f19f8056 100644
--- a/system_tests/conftest.py
+++ b/system_tests/conftest.py
@@ -43,4 +43,5 @@ def mock_predictoor_contract():
     mock_contract.payout_multiple.return_value = None
     mock_contract.get_agg_predval.return_value = (12, 23)
     mock_contract.get_current_epoch.return_value = 100
+    mock_contract.web3_pp = Mock()
     return mock_contract
diff --git a/system_tests/test_predictoor_system.py b/system_tests/test_predictoor_system.py
index 683efd8d5..8c5a9d0d2 100644
--- a/system_tests/test_predictoor_system.py
+++ b/system_tests/test_predictoor_system.py
@@ -1,5 +1,7 @@
+import os
 import sys
 from unittest.mock import Mock, patch, MagicMock
+
 from pdr_backend.cli import cli_module
 from pdr_backend.ppss.web3_pp import Web3PP
 from pdr_backend.util.web3_config import Web3Config
@@ -8,6 +10,7 @@
 def setup_mock_web3_pp(mock_feeds, mock_predictoor_contract):
     mock_web3_pp = MagicMock(spec=Web3PP)
     mock_web3_pp.network = "development"
+    mock_web3_pp.rpc_url = "http://example.com/rpc"
     mock_web3_pp.subgraph_url = (
         "http://localhost:8000/subgraphs/name/oceanprotocol/ocean-subgraph"
     )
@@ -26,7 +29,13 @@ def setup_mock_web3_pp(mock_feeds, mock_predictoor_contract):
     return mock_web3_pp, mock_predictoor_ss
 
 
-def _test_predictoor_system(mock_feeds, mock_predictoor_contract, approach, caplog):
+def _test_predictoor_system(
+    mock_feeds, mock_predictoor_contract, approach, caplog, monkeypatch
+):
+    PRIV_KEY = str(os.getenv("PRIVATE_KEY"))
+    PRIV_KEY2 = str(PRIV_KEY[:-4] + "0000")
+    monkeypatch.setenv("PRIVATE_KEY2", PRIV_KEY2)
+
     mock_web3_pp, mock_predictoor_ss = setup_mock_web3_pp(
         mock_feeds, mock_predictoor_contract
     )
@@ -61,15 +70,27 @@ def _test_predictoor_system(mock_feeds, mock_predictoor_contract, approach, capl
 
 @patch("pdr_backend.ppss.ppss.PPSS.verify_feed_dependencies")
 def test_predictoor_approach_1_system(
-    mock_verify_feed_dependencies, mock_feeds, mock_predictoor_contract, caplog
+    mock_verify_feed_dependencies,
+    mock_feeds,
+    mock_predictoor_contract,
+    caplog,
+    monkeypatch,
 ):
     _ = mock_verify_feed_dependencies
-    _test_predictoor_system(mock_feeds, mock_predictoor_contract, 1, caplog)
+    _test_predictoor_system(
+        mock_feeds, mock_predictoor_contract, 1, caplog, monkeypatch
+    )
 
 
 @patch("pdr_backend.ppss.ppss.PPSS.verify_feed_dependencies")
 def test_predictoor_approach_3_system(
-    mock_verify_feed_dependencies, mock_feeds, mock_predictoor_contract, caplog
+    mock_verify_feed_dependencies,
+    mock_feeds,
+    mock_predictoor_contract,
+    caplog,
+    monkeypatch,
 ):
     _ = mock_verify_feed_dependencies
-    _test_predictoor_system(mock_feeds, mock_predictoor_contract, 3, caplog)
+    _test_predictoor_system(
+        mock_feeds, mock_predictoor_contract, 3, caplog, monkeypatch
+    )