New liquidator + additional config

.gitmodules

@@ -54,3 +54,6 @@
 [submodule "lib/pt-v5-prize-pool-fee-burner"]
 	path = lib/pt-v5-prize-pool-fee-burner
 	url = https://github.com/GenerationSoftware/pt-v5-prize-pool-fee-burner
+[submodule "lib/fixed-liquidator"]
+	path = lib/fixed-liquidator
+	url = https://github.com/generationsoftware/fixed-liquidator

config/optimism.json

@@ -1,32 +1,17 @@
 {
     "simulation": {
-        "num_users": "128",
+        "num_users": "2",
         "time_step": "1800",
-        "tvl_usd": "10000000",
+        "tvl_usd": "5000000",
         "verbosity": "1",
+        "duration_draws": "6",
+
+        "eth_price_usd_per_draw" : [
+            "30"
+        ],
 
-        "duration_draws": "5",
         "apr_for_each_draw" : [
-            "25000000000000000",
-            "30000000000000000",
-            "35000000000000000",
-            "40000000000000000",
-            "45000000000000000",
-            "50000000000000000",
-            "55000000000000000",
-            "60000000000000000",
-            "65000000000000000",
-            "70000000000000000",
-            "60000000000000000",
-            "50000000000000000",
-            "30000000000000000",
-            "20000000000000000",
-            "10000000000000000",
-            "10000000000000000",
-            "10000000000000000",
-            "10000000000000000",
-            "10000000000000000",
-            "10000000000000000"
+            "30000000000000000"
         ]
     },
 
@@ -35,9 +20,9 @@
         "draw_timeout": "30",
         "grand_prize_period_draws": "365",
         "number_of_tiers": "4",
-        "tier_shares": "100",
+        "tier_shares": "200",
         "canary_shares": "5",
-        "reserve_shares": "20",
+        "reserve_shares": "40",
         "tier_liquidity_utilization_rate": "500000000000000000"
     },
 
@@ -53,14 +38,14 @@
     },
 
     "claimer": {
-        "claimer_min_fee": "100000000000",
-        "claimer_max_fee": "1000000000000000000"
+        "claimer_min_fee": "100",
+        "claimer_max_fee": "10000000"
     },
 
     "gas": {
-        "start_draw_cost_in_eth": "40000000000000",
-        "award_draw_cost_in_eth": "100000000000000",
-        "claim_cost_in_eth": "60000000000000",
-        "liquidation_cost_in_eth": "100000000000000"
+        "start_draw_cost_in_usd":   "10",
+        "award_draw_cost_in_usd":   "10",
+        "claim_cost_in_usd":        "10",
+        "liquidation_cost_in_usd":  "10"
     }
 }

remappings.txt

@@ -22,3 +22,4 @@ pt-v5-prize-pool/=lib/pt-v5-prize-pool/src/
 pt-v5-twab-controller/=lib/pt-v5-twab-controller/src/
 pt-v5-vault/=lib/pt-v5-vault/src/
 pt-v5-vault-test/=lib/pt-v5-vault/test/
+fixed-liquidator/=lib/fixed-liquidator/src/

scripts/ethereum.sh

@@ -1,3 +1,3 @@
-#! /usr/local/bin/bash
+#!/usr/bin/env bash
 rm config/output/ethereum-output.csv
 CONFIG=config/ethereum.json OUTPUT=config/output/ethereum-output.csv forge test -vvv --mt testSingleChain

scripts/optimism.sh

@@ -1,3 +1,3 @@
-#! /usr/local/bin/bash
+#!/usr/bin/env bash
 rm config/output/optimism-output.csv
 CONFIG=config/optimism.json OUTPUT=config/output/optimism-output.csv forge test -vvv --mt testSingleChain

src/agent/ClaimerAgent.sol

@@ -92,7 +92,7 @@ contract ClaimerAgent is Utils {
         // see if any are worth claiming
         {
           uint claimFees = claimer.computeTotalFees(tier, tierPrizes);
-          uint cost = tierPrizes * env.config().gas().claimCostInEth;
+          uint cost = env.config().usdToWeth(tierPrizes * env.config().gas().claimCostInUsd);
           if (isLogging(3)) {
             console2.log(
               "\tclaimFees for drawId %s tier %s with prize size %e:",
@@ -312,7 +312,7 @@ contract ClaimerAgent is Utils {
     if (isLogging(2)) {
       console2.log(
         "+++++++++++++++++++++ Prize Claim Cost:",
-        env.config().gas().claimCostInEth
+        env.config().gas().claimCostInUsd
       );
       console2.log(
         "+++++++++++++++++++++ Draw",

src/agent/DrawAgent.sol

@@ -44,7 +44,7 @@ contract DrawAgent is StdCheats, Utils {
   }
 
   function willFinishDraw() public view returns (bool) {
-    uint256 finishDrawCost = env.config().gas().finishDrawCostInEth;
+    uint256 finishDrawCost = env.config().usdToWeth(env.config().gas().finishDrawCostInUsd);
     uint256 minimumFinishDrawProfit = getMinimumProfit(finishDrawCost);
     uint256 finishDrawProfit;
 
@@ -69,9 +69,7 @@ contract DrawAgent is StdCheats, Utils {
 
     if (drawManager.canStartDraw()) {
       uint fee = drawManager.startDrawReward();
-      // console2.log("fee %e", fee);
-      uint256 startDrawCost = env.config().gas().startDrawCostInEth;
-      // console2.log("cost %e", startDrawCost);
+      uint256 startDrawCost = env.config().usdToWeth(env.config().gas().startDrawCostInUsd);
       uint256 startDrawProfit = fee < startDrawCost ? 0 : fee - startDrawCost;
       if (startDrawProfit >= getMinimumProfit(startDrawCost)) {
         // console2.log("started draw", drawId);

src/agent/LiquidatorAgent.sol

@@ -7,8 +7,8 @@ import { SD59x18, wrap, convert, uMAX_SD59x18 } from "prb-math/SD59x18.sol";
 
 import { ERC20PermitMock } from "pt-v5-vault-test/contracts/mock/ERC20PermitMock.sol";
 import { ILiquidationPair } from "pt-v5-liquidator-interfaces/ILiquidationPair.sol";
-import { LiquidationPair } from "pt-v5-cgda-liquidator/LiquidationPair.sol";
-import { LiquidationRouter } from "pt-v5-cgda-liquidator/LiquidationRouter.sol";
+import { FixedLiquidationPair } from "fixed-liquidator/FixedLiquidationPair.sol";
+import { FixedLiquidationRouter } from "fixed-liquidator/FixedLiquidationRouter.sol";
 import { PrizePool } from "pt-v5-prize-pool/PrizePool.sol";
 
 import { SingleChainEnvironment } from "../environment/SingleChainEnvironment.sol";
@@ -25,13 +25,17 @@ contract LiquidatorAgent is Utils {
 
   PrizePool public prizePool;
   ERC20PermitMock public prizeToken;
-  LiquidationRouter public router;
+  FixedLiquidationRouter public router;
 
   string liquidatorCsv;
 
   uint public burnedPool;
 
   mapping(uint24 drawId => uint256 totalBurnedPool) public totalBurnedPoolPerDraw;
+  mapping(uint24 drawId => uint256 amountIn) public totalAmountInPerDraw;
+  mapping(uint24 drawId => uint256 amountOut) public totalAmountOutPerDraw;
+  mapping(uint24 drawId => uint256 amountIn) public feeBurnerAmountInPerDraw;
+  mapping(uint24 drawId => uint256 amountOut) public feeBurnerAmountOutPerDraw;
 
   constructor(SingleChainEnvironment _env) {
     env = _env;
@@ -51,11 +55,13 @@ contract LiquidatorAgent is Utils {
     uint24 openDrawId = prizePool.getOpenDrawId();
     (amountOut, amountIn, profit) = checkLiquidationPair(wethUsdValue, poolUsdValue, wethUsdValue, env.pair());
     if (profit.gt(wrap(0))) {
-      // console2.log("draw %s: liquidating %s for %s ", openDrawId, amountOut, amountIn);
+      totalAmountInPerDraw[openDrawId] += amountIn;
+      totalAmountOutPerDraw[openDrawId] += amountOut;
     }
     (amountOut, amountIn, profit) = checkLiquidationPair(poolUsdValue, wethUsdValue, wethUsdValue, env.feeBurnerPair());
     if (profit.gt(wrap(0))) {
-      totalBurnedPoolPerDraw[openDrawId] += amountIn;
+      feeBurnerAmountInPerDraw[openDrawId] += amountIn;
+      feeBurnerAmountOutPerDraw[openDrawId] += amountOut;
     }
   }
 
@@ -65,7 +71,6 @@ contract LiquidatorAgent is Utils {
     (amountOut, amountIn, profit) = _findBestProfit(tokenInValueUsd, tokenOutValueUsd, ethValueUsd, pair);
 
     // if (isFeeBurner(pair) && maxAmountOut > 0) {
-    //   console2.log("Available to burn: %e", maxAmountOut);
     // }
     // console2.log("checkLiquidationPair amountOut %e", amountOut);
     // console2.log("checkLiquidationPair amountIn %e", amountIn);
@@ -75,19 +80,21 @@ contract LiquidatorAgent is Utils {
       tokenIn.mint(address(this), amountIn);
       tokenIn.approve(address(router), amountIn);
       router.swapExactAmountOut(
-        LiquidationPair(address(pair)),
+        FixedLiquidationPair(address(pair)),
         address(this),
         amountOut,
         uint256(uMAX_SD59x18 / 1e18), // NOTE: uMAX_SD59x18/1e18 for DaLiquidator
         block.timestamp + 10
       );
-
       if (isFeeBurner(pair)) {
         burnedPool += amountIn;
       }
 
-      uint256 elapsedSinceDrawEnded = block.timestamp -
-        prizePool.drawClosesAt(prizePool.getLastAwardedDrawId());
+
+      uint256 elapsedSinceDrawEnded;
+      // uint256 elapsedSinceDrawEnded = block.timestamp -
+      //   prizePool.drawClosesAt(prizePool.getLastAwardedDrawId());
+
 
       // SD59x18 efficiency = convert(int256(amountIn)).div(convert(int256(amountOutInPrizeTokens)));
       // uint256 efficiencyPercent = uint256(convert(efficiency.mul(convert(100))));
@@ -106,6 +113,7 @@ contract LiquidatorAgent is Utils {
       logs[10] = 0;
       logs[11] = pair.maxAmountOut();
 
+
       logUint256ToCsv(liquidatorCsvFile, logs);
     }    
   }
@@ -143,7 +151,11 @@ contract LiquidatorAgent is Utils {
     uint256 amountOut
   ) public view returns (SD59x18) {
     SD59x18 amountOutInUsd = tokenOutValueUsd.mul(convert(int256(amountOut)));
-    SD59x18 cost = tokenInValueUsd.mul(convert(int256(amountIn))).add(computeGasCostInUsd(ethValueUsd, env.config().gas().liquidationCostInEth));
+    if (amountIn > 57896044618658097711785492504343953926634992332820282019728) {
+      return wrap(0);
+    }
+    SD59x18 capitalCost = tokenInValueUsd.mul(convert(int256(amountIn)));//.add(convert(int256(env.config().gas().liquidationCostInUsd)));
+    SD59x18 cost = capitalCost.add(convert(int256(env.config().gas().liquidationCostInUsd)));
     return cost.lt(amountOutInUsd) ? amountOutInUsd.sub(cost) : wrap(0);
   } 
 

src/environment/SingleChainEnvironment.sol

@@ -23,8 +23,10 @@ import { Claimer } from "pt-v5-claimer/Claimer.sol";
 import { ILiquidationSource } from "pt-v5-liquidator-interfaces/ILiquidationSource.sol";
 import { ILiquidationPair } from "pt-v5-liquidator-interfaces/ILiquidationPair.sol";
 
-import { LiquidationPairFactory } from "pt-v5-cgda-liquidator/LiquidationPairFactory.sol";
-import { LiquidationRouter } from "pt-v5-cgda-liquidator/LiquidationRouter.sol";
+// import { LiquidationPairFactory } from "pt-v5-cgda-liquidator/LiquidationPairFactory.sol";
+// import { LiquidationRouter } from "pt-v5-cgda-liquidator/LiquidationRouter.sol";
+import { FixedLiquidationPairFactory } from "fixed-liquidator/FixedLiquidationPairFactory.sol";
+import { FixedLiquidationRouter } from "fixed-liquidator/FixedLiquidationRouter.sol";
 
 import { YieldVaultMintRate } from "../YieldVaultMintRate.sol";
 
@@ -55,7 +57,7 @@ contract SingleChainEnvironment is Utils, StdCheats {
   YieldVaultMintRate public yieldVault;
   ILiquidationPair public pair;
   Claimer public claimer;
-  LiquidationRouter public router;
+  FixedLiquidationRouter public router;
   FeeBurner public feeBurner;
   ILiquidationPair public feeBurnerPair;
 
@@ -135,6 +137,7 @@ contract SingleChainEnvironment is Utils, StdCheats {
       claimerConfig.maxFeePortionOfPrize
     );
 
+    console2.log("Claimer DecayConstant ", claimer.decayConstant().unwrap());
     // console2.log("SingleChainEnvironment constructor 6");
 
     underlyingToken.mint(address(this), vaultFactory.YIELD_BUFFER());
@@ -162,10 +165,10 @@ contract SingleChainEnvironment is Utils, StdCheats {
     SD59x18 wethUsdValue = config.wethUsdValueOverTime().get(block.timestamp);
     SD59x18 poolUsdValue = config.poolUsdValueOverTime().get(block.timestamp);
 
-    LiquidationPairFactory pairFactory = new LiquidationPairFactory();
-    vm.label(address(pairFactory), "LiquidationPairFactory");
-    LiquidationRouter cgdaRouter = new LiquidationRouter(pairFactory);
-    vm.label(address(cgdaRouter), "LiquidationRouter");
+    FixedLiquidationPairFactory pairFactory = new FixedLiquidationPairFactory();
+    vm.label(address(pairFactory), "FixedLiquidationPairFactory");
+    FixedLiquidationRouter fixedRouter = new FixedLiquidationRouter(pairFactory);
+    vm.label(address(fixedRouter), "FixedLiquidationRouter");
     // console2.log(
     //   "initializeCgdaLiquidator _liquidatorConfig.exchangeRatePrizeTokenToUnderlying",
     //   _liquidatorConfig.exchangeRatePrizeTokenToUnderlying.unwrap()
@@ -187,19 +190,15 @@ contract SingleChainEnvironment is Utils, StdCheats {
           ILiquidationSource(address(vault)),
           address(prizeToken),
           address(vault),
-          config.prizePool().drawPeriodSeconds,
-          uint32(config.prizePool().firstDrawOpensAt),
-          config.getTargetFirstSaleTime(),
-          config.getDecayConstant(),
-          wethAmount, // weth is token in
-          poolAmount, // pool is token out
-          1e18 // min is 1 pool being sold
+          config.prizePool().drawPeriodSeconds / 3,
+          0.00001e18,
+          0 // no smoothing
         )
       )
     );
     vm.label(address(pair), "VaultLiquidationPair");
 
-    router = LiquidationRouter(address(cgdaRouter));
+    router = FixedLiquidationRouter(address(fixedRouter));
     vault.setLiquidationPair(address(pair));
 
     feeBurnerPair = ILiquidationPair(
@@ -208,13 +207,9 @@ contract SingleChainEnvironment is Utils, StdCheats {
           ILiquidationSource(address(feeBurner)),
           address(poolToken),
           address(prizeToken),
-          config.prizePool().drawPeriodSeconds,
-          uint32(config.prizePool().firstDrawOpensAt),
-          config.getTargetFirstSaleTime(),
-          config.getDecayConstant(),
-          poolAmount, // pool is token in (burn)
-          wethAmount, // weth is token out
-          wethAmount // 1 pool worth of weth being sold
+          config.prizePool().drawPeriodSeconds / 3,
+          1e18, // 1 POOL,
+          0.95e18 // very high smoothing
         )
       )
     );