feat: adding CoW helper MVP

src/contracts/BCoWHelper.sol

@@ -104,7 +104,7 @@ contract BCoWHelper is ICOWAMMPoolHelper, BMath {
   }
 
   /// @inheritdoc ICOWAMMPoolHelper
-  function tokens(address pool) public view returns (address[] memory tokens_) {
+  function tokens(address pool) public view virtual returns (address[] memory tokens_) {
     // reverts in case pool is not deployed by the helper's factory
     if (!IBCoWFactory(factory).isBPool(pool)) {
       revert PoolDoesNotExist();

test/integration/BCoWHelper.t.sol

@@ -20,7 +20,7 @@ import {GPv2TradeEncoder} from '@composable-cow/test/vendored/GPv2TradeEncoder.s
 import {BCoWFactory} from 'contracts/BCoWFactory.sol';
 import {BCoWHelper} from 'contracts/BCoWHelper.sol';
 
-contract ConstantProductHelperForkedTest is Test {
+contract BCoWHelperIntegrationTest is Test {
   using GPv2Order for GPv2Order.Data;
 
   BCoWHelper private helper;
@@ -46,6 +46,9 @@ contract ConstantProductHelperForkedTest is Test {
   uint256 constant INITIAL_WETH_BALANCE = 1 ether;
   uint256 constant INITIAL_SPOT_PRICE = 0.001e18;
 
+  uint256 constant SKEWENESS_RATIO = 95; // -5% skewness
+  uint256 constant EXPECTED_FINAL_SPOT_PRICE = INITIAL_SPOT_PRICE * 100 / SKEWENESS_RATIO;
+
   function setUp() public {
     vm.createSelectFork('mainnet', 20_012_063);
 
@@ -88,29 +91,18 @@ contract ConstantProductHelperForkedTest is Test {
     _executeHelperOrder(pool);
 
     uint256 postSpotPrice = pool.getSpotPriceSansFee(address(WETH), address(DAI));
-    assertEq(postSpotPrice, 1_052_631_578_947_368);
+    assertEq(postSpotPrice, EXPECTED_FINAL_SPOT_PRICE);
   }
 
   // NOTE: reverting test, weighted pools are not supported
   function testWeightedOrder() public {
     IBCoWPool pool = IBCoWPool(address(weightedPool));
 
-    uint256 ammWethInitialBalance = 1 ether;
-    uint256 ammDaiInitialBalance = 1000 ether;
-
-    deal(address(WETH), address(pool), ammWethInitialBalance);
-    deal(address(DAI), address(pool), 4 * ammDaiInitialBalance);
-
     uint256 spotPrice = pool.getSpotPriceSansFee(address(WETH), address(DAI));
     assertEq(spotPrice, INITIAL_SPOT_PRICE);
 
     vm.expectRevert(ICOWAMMPoolHelper.PoolDoesNotExist.selector);
     helper.order(address(pool), new uint256[](2));
-
-    // NOTE: not supported
-    // _executeHelperOrder(pool, ammWethInitialBalance, ammDaiInitialBalance);
-    // uint256 postSpotPrice = pool.getSpotPriceSansFee(address(WETH), address(DAI));
-    // assertEq(postSpotPrice, 1_052_631_578_947_368);
   }
 
   function _executeHelperOrder(IBPool pool) internal {
@@ -131,7 +123,7 @@ contract ConstantProductHelperForkedTest is Test {
     // DAI per WETH means a price vector of [1, 3000] (if the decimals are
     // different, as in WETH/USDC, then the atom amount is what counts).
     prices[daiIndex] = INITIAL_WETH_BALANCE;
-    prices[wethIndex] = INITIAL_DAI_BALANCE * 95 / 100;
+    prices[wethIndex] = INITIAL_DAI_BALANCE * SKEWENESS_RATIO / 100;
 
     // The helper generates the AMM order
     GPv2Order.Data memory ammOrder;

test/manual-smock/MockBCoWHelper.sol

@@ -20,6 +20,19 @@ contract MockBCoWHelper is BCoWHelper, Test {
     return _APP_DATA;
   }
 
+  // NOTE: manually added method (public overrides not supported in smock)
+  function tokens(address pool) public view override returns (address[] memory tokens_) {
+    (bool _success, bytes memory _data) = address(this).staticcall(abi.encodeWithSignature('tokens(address)', pool));
+
+    if (_success) return abi.decode(_data, (address[]));
+    else return super.tokens(pool);
+  }
+
+  // NOTE: manually added method (public overrides not supported in smock)
+  function expectCall_tokens(address pool) public {
+    vm.expectCall(address(this), abi.encodeWithSignature('tokens(address)', pool));
+  }
+
   // BCoWHelper methods
   constructor(address factory_) BCoWHelper(factory_) {}
 

test/unit/BCoWHelper.t.sol

@@ -120,6 +120,10 @@ contract BCoWHelperTest is Test {
   }
 
   function test_OrderWhenThePoolIsSupported(bytes32 domainSeparator) external {
+    // it should call tokens
+    helper.mock_call_tokens(address(pool), tokens);
+    helper.expectCall_tokens(address(pool));
+
     // it should query the domain separator from the pool
     pool.expectCall_SOLUTION_SETTLER_DOMAIN_SEPARATOR();
     pool.mock_call_SOLUTION_SETTLER_DOMAIN_SEPARATOR(domainSeparator);
@@ -157,8 +161,9 @@ contract BCoWHelperTest is Test {
 
   function test_OrderGivenAPriceVector(uint256 priceSkewness, uint256 balanceToken0, uint256 balanceToken1) external {
     // skew the price by max 50% (more could result in reverts bc of max swap ratio)
-    priceSkewness = bound(priceSkewness, 5000, 15_000);
-    vm.assume(priceSkewness != 10_000); // avoids no-skewness revert
+    uint256 base = 1e18;
+    priceSkewness = bound(priceSkewness, 0.5e18, 1.5e18);
+    vm.assume(priceSkewness != base); // avoids no-skewness revert
 
     balanceToken0 = bound(balanceToken0, 1e18, 1e36);
     balanceToken1 = bound(balanceToken1, 1e18, 1e36);
@@ -167,12 +172,12 @@ contract BCoWHelperTest is Test {
 
     uint256[] memory prices = new uint256[](2);
     prices[0] = balanceToken1;
-    prices[1] = balanceToken0 * priceSkewness / 10_000;
+    prices[1] = balanceToken0 * priceSkewness / base;
 
     // it should return a valid pool order
     (GPv2Order.Data memory ammOrder,,,) = helper.order(address(pool), prices);
 
-    assertEq(address(ammOrder.buyToken), priceSkewness > 10_000 ? tokens[0] : tokens[1]);
+    assertEq(address(ammOrder.buyToken), priceSkewness > 1e18 ? tokens[0] : tokens[1]);
 
     // this call should not revert
     pool.verify(ammOrder);

test/unit/BCoWHelper.tree

@@ -19,6 +19,7 @@ BCoWHelperTest::order
 ├── when the pool is not supported
 │   └── it should revert
 ├── when the pool is supported
+│   ├── it should call tokens
 │   ├── it should query the domain separator from the pool
 │   ├── it should return a valid pool order
 │   ├── it should return a commit pre-interaction