Rebase LinearPool

pkg/pool-linear/test/LinearPool.test.ts

@@ -201,11 +201,13 @@ describe('LinearPool', function () {
   describe('set targets', () => {
     const originalLowerTarget = fp(1000);
     const originalUpperTarget = fp(5000);
+    const originalSwapFee = fp(0.057);
 
     sharedBeforeEach('deploy pool and set initial targets', async () => {
       await deployPool({ mainToken, wrappedToken, upperTarget: originalUpperTarget }, true);
       await setBalances(pool, { mainBalance: originalLowerTarget.add(originalUpperTarget).div(2) });
       await pool.setTargets(originalLowerTarget, originalUpperTarget);
+      await pool.setSwapFeePercentage(originalSwapFee);
     });
 
     const setBalances = async (
@@ -329,6 +331,15 @@ describe('LinearPool', function () {
           });
         });
 
+        it('does not overwrite other state', async () => {
+          const newLowerTarget = originalLowerTarget.div(2);
+          const newUpperTarget = originalUpperTarget.mul(2);
+
+          await pool.setTargets(newLowerTarget, newUpperTarget);
+
+          expect(await pool.getSwapFeePercentage()).to.equal(originalSwapFee);
+        });
+
         it('reverts if the lower target is fractional', async () => {
           const newLowerTarget = originalLowerTarget.add(1);
           const newUpperTarget = originalUpperTarget;

pkg/pool-utils/contracts/NewBasePool.sol

@@ -113,7 +113,7 @@ abstract contract NewBasePool is
      * This is useful to make sure Pool initialization happens only once, but derived Pools can change this value (even
      * to zero) by overriding this function.
      */
-    function _getMinimumBpt() internal pure returns (uint256) {
+    function _getMinimumBpt() internal pure virtual returns (uint256) {
         return _DEFAULT_MINIMUM_BPT;
     }
 
@@ -214,13 +214,15 @@ abstract contract NewBasePool is
 
         _ensureNotPaused();
         if (totalSupply() == 0) {
-            (bptAmountOut, amountsIn) = _onInitializePool(sender, userData);
+            (bptAmountOut, amountsIn) = _onInitializePool(sender, recipient, userData);
 
             // On initialization, we lock _getMinimumBpt() by minting it for the zero address. This BPT acts as a
             // minimum as it will never be burned, which reduces potential issues with rounding, and also prevents the
             // Pool from ever being fully drained.
+            // Some pool types do not require this mechanism, and the minimum BPT might be zero.
             _require(bptAmountOut >= _getMinimumBpt(), Errors.MINIMUM_BPT);
             _mintPoolTokens(address(0), _getMinimumBpt());
+
             _mintPoolTokens(recipient, bptAmountOut - _getMinimumBpt());
         } else {
             (bptAmountOut, amountsIn) = _onJoinPool(sender, balances, userData);
@@ -347,10 +349,11 @@ abstract contract NewBasePool is
      * The tokens granted to the Pool will be transferred from `sender`. These amounts are considered upscaled and will
      * be downscaled (rounding up) before being returned to the Vault.
      */
-    function _onInitializePool(address sender, bytes memory userData)
-        internal
-        virtual
-        returns (uint256 bptAmountOut, uint256[] memory amountsIn);
+    function _onInitializePool(
+        address sender,
+        address recipient,
+        bytes memory userData
+    ) internal virtual returns (uint256 bptAmountOut, uint256[] memory amountsIn);
 
     /**
      * @dev Called whenever the Pool is joined after the first initialization join (see `_onInitializePool`).

pkg/pool-utils/contracts/test/MockNewBasePool.sol

@@ -60,7 +60,7 @@ contract MockNewBasePool is NewBasePool {
         )
     {}
 
-    function _onInitializePool(address, bytes memory userData) internal override returns (uint256, uint256[] memory) {
+    function _onInitializePool(address, address, bytes memory userData) internal override returns (uint256, uint256[] memory) {
         emit InnerOnInitializePoolCalled(userData);
 
         uint256[] memory amountsIn = userData.initialAmountsIn();

pkg/pool-weighted/contracts/managed/ManagedPool.sol

@@ -438,11 +438,11 @@ contract ManagedPool is ManagedPoolSettings {
 
     // Initialize
 
-    function _onInitializePool(address sender, bytes memory userData)
-        internal
-        override
-        returns (uint256 bptAmountOut, uint256[] memory amountsIn)
-    {
+    function _onInitializePool(
+        address sender,
+        address,
+        bytes memory userData
+    ) internal override returns (uint256 bptAmountOut, uint256[] memory amountsIn) {
         // Check allowlist for LPs, if applicable
         _require(_isAllowedAddress(_getPoolState(), sender), Errors.ADDRESS_NOT_ALLOWLISTED);
 

pkg/pool-weighted/contracts/test/MockManagedPoolSettings.sol

@@ -55,7 +55,7 @@ contract MockManagedPoolSettings is ManagedPoolSettings {
         return _getVirtualSupply();
     }
 
-    function _onInitializePool(address, bytes memory userData) internal override returns (uint256, uint256[] memory) {
+    function _onInitializePool(address, address, bytes memory userData) internal override returns (uint256, uint256[] memory) {
         WeightedPoolUserData.JoinKind kind = userData.joinKind();
         _require(kind == WeightedPoolUserData.JoinKind.INIT, Errors.UNINITIALIZED);
 

pkg/solidity-utils/contracts/helpers/ERC20Helpers.sol

@@ -29,14 +29,15 @@ function _asIAsset(IERC20[] memory tokens) pure returns (IAsset[] memory assets)
 
 function _sortTokens(
     IERC20 tokenA,
-    IERC20 tokenB,
-    IERC20 tokenC
+    IERC20 tokenB
 ) pure returns (IERC20[] memory tokens) {
-    (uint256 indexTokenA, uint256 indexTokenB, uint256 indexTokenC) = _getSortedTokenIndexes(tokenA, tokenB, tokenC);
-    tokens = new IERC20[](3);
-    tokens[indexTokenA] = tokenA;
-    tokens[indexTokenB] = tokenB;
-    tokens[indexTokenC] = tokenC;
+    bool aFirst = tokenA < tokenB;
+    IERC20[] memory sortedTokens = new IERC20[](2);
+
+    sortedTokens[0] = aFirst ? tokenA : tokenB;
+    sortedTokens[1] = aFirst ? tokenB : tokenA;
+
+    return sortedTokens;
 }
 
 function _insertSorted(IERC20[] memory tokens, IERC20 token) pure returns (IERC20[] memory sorted) {
@@ -65,41 +66,3 @@ function _findTokenIndex(IERC20[] memory tokens, IERC20 token) pure returns (uin
 
     _revert(Errors.INVALID_TOKEN);
 }
-
-function _getSortedTokenIndexes(
-    IERC20 tokenA,
-    IERC20 tokenB,
-    IERC20 tokenC
-)
-    pure
-    returns (
-        uint256 indexTokenA,
-        uint256 indexTokenB,
-        uint256 indexTokenC
-    )
-{
-    if (tokenA < tokenB) {
-        if (tokenB < tokenC) {
-            // (tokenA, tokenB, tokenC)
-            return (0, 1, 2);
-        } else if (tokenA < tokenC) {
-            // (tokenA, tokenC, tokenB)
-            return (0, 2, 1);
-        } else {
-            // (tokenC, tokenA, tokenB)
-            return (1, 2, 0);
-        }
-    } else {
-        // tokenB < tokenA
-        if (tokenC < tokenB) {
-            // (tokenC, tokenB, tokenA)
-            return (2, 1, 0);
-        } else if (tokenC < tokenA) {
-            // (tokenB, tokenC, tokenA)
-            return (2, 0, 1);
-        } else {
-            // (tokenB, tokenA, tokenC)
-            return (1, 0, 2);
-        }
-    }
-}

pkg/solidity-utils/contracts/helpers/ScalingHelpers.sol

@@ -15,6 +15,8 @@
 pragma solidity ^0.7.0;
 
 import "../math/FixedPoint.sol";
+import "../math/Math.sol";
+import "../openzeppelin/ERC20.sol";
 import "./InputHelpers.sol";
 
 // solhint-disable
@@ -93,3 +95,12 @@ function _downscaleUpArray(uint256[] memory amounts, uint256[] memory scalingFac
         amounts[i] = FixedPoint.divUp(amounts[i], scalingFactors[i]);
     }
 }
+
+function _computeScalingFactor(IERC20 token) view returns (uint256) {
+    // Tokens that don't implement the `decimals` method are not supported.
+    uint256 tokenDecimals = ERC20(address(token)).decimals();
+
+    // Tokens with more than 18 decimals are not supported.
+    uint256 decimalsDifference = Math.sub(18, tokenDecimals);
+    return FixedPoint.ONE * 10**decimalsDifference;
+}

pvt/helpers/src/models/pools/linear/LinearPool.ts

@@ -56,6 +56,17 @@ export default class LinearPool extends BasePool {
     );
   }
 
+  // Order the tokens the same way the Vault will
+  static getTokenList(mainToken: Token, wrappedToken: Token, bptToken: Token): TokenList {
+    const tokens: Token[] = [];
+
+    tokens.push(bptToken);
+    tokens.push(mainToken.address < wrappedToken.address ? mainToken : wrappedToken);
+    tokens.push(mainToken.address < wrappedToken.address ? wrappedToken : mainToken);
+
+    return new TokenList(tokens);
+  }
+
   constructor(
     instance: Contract,
     poolId: string,
@@ -69,7 +80,14 @@ export default class LinearPool extends BasePool {
     swapFeePercentage: BigNumberish,
     owner?: SignerWithAddress
   ) {
-    super(instance, poolId, vault, new TokenList([wrappedToken, mainToken, bptToken]).sort(), swapFeePercentage, owner);
+    super(
+      instance,
+      poolId,
+      vault,
+      LinearPool.getTokenList(mainToken, wrappedToken, bptToken),
+      swapFeePercentage,
+      owner
+    );
     this.mainToken = mainToken;
     this.wrappedToken = wrappedToken;
     this.bptToken = bptToken;
@@ -83,7 +101,7 @@ export default class LinearPool extends BasePool {
   }
 
   get getLinearTokens(): TokenList {
-    return new TokenList([this.wrappedToken, this.mainToken, this.bptToken]).sort();
+    return LinearPool.getTokenList(this.mainToken, this.wrappedToken, this.bptToken);
   }
 
   get mainIndex(): number {