Updated the vortex to perform BNT -> vBNT trades through v3

Author: yudilevi

components/Contracts.ts

@@ -19,6 +19,7 @@ import {
     LiquidityProtectionStats__factory,
     LiquidityProtectionStore__factory,
     LiquidityProtectionSystemStore__factory,
+    MockVortexBurner__factory,
     NetworkSettings__factory,
     Owned__factory,
     StakingRewards__factory,
@@ -156,6 +157,7 @@ const getContracts = (signer?: Signer) => {
             LiquidityProtectionSystemStore__factory,
             signer
         ),
+        MockVortexBurner: deployOrAttach('MockVortexBurner', MockVortexBurner__factory, signer),
         NetworkSettings: deployOrAttach('NetworkSettings', NetworkSettings__factory, signer),
         Owned: deployOrAttach('Owned', Owned__factory, signer),
         StakingRewards: deployOrAttach('StakingRewards', StakingRewards__factory, signer),

contracts/helpers/MockVortexBurner.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity 0.6.12;
+
+contract MockVortexBurner {
+    uint256 _total = 1000;
+
+    function totalBurnedAmount() external view returns (uint256) {
+        return _total;
+    }
+}

contracts/helpers/TestBancorNetworkV3.sol

@@ -42,4 +42,24 @@ contract TestBancorNetworkV3 is BancorNetwork {
             reserveToken.safeTransferFrom(msg.sender, _bancorVault, availableAmount);
         }
     }
+
+    function tradeBySourceAmount(
+        IERC20 sourceToken,
+        IERC20 targetToken,
+        uint256 sourceAmount,
+        uint256 minReturnAmount,
+        uint256 deadline,
+        address /* beneficiary */
+    ) external payable returns (uint256) {
+        require(sourceToken != targetToken);
+        require(sourceAmount > 0);
+        require(minReturnAmount > 0);
+        require(deadline >= block.timestamp);
+
+        // transfer the source tokens from the caller
+        sourceToken.safeTransferFrom(msg.sender, address(this), sourceAmount);
+
+        // requires that the contract hold sufficient target tokens
+        targetToken.transfer(msg.sender, sourceAmount * 2);
+    }
 }

contracts/vortex/VortexBurner.sol

@@ -20,6 +20,21 @@ import "../token/ReserveToken.sol";
 import "../INetworkSettings.sol";
 import "../IBancorNetwork.sol";
 
+interface IVortexBurner {
+    function totalBurnedAmount() external view returns (uint256);
+}
+
+interface IBancorNetworkV3 {
+    function tradeBySourceAmount(
+        IERC20 sourceToken,
+        IERC20 targetToken,
+        uint256 sourceAmount,
+        uint256 minReturnAmount,
+        uint256 deadline,
+        address beneficiary
+    ) external payable returns (uint256);
+}
+
 /**
  * @dev This contract provides any user to trigger a network fee burning event
  */
@@ -51,6 +66,9 @@ contract VortexBurner is Owned, Utils, ReentrancyGuard, ContractRegistryClient {
     // the address of the governance token security module
     ITokenGovernance private immutable _govTokenGovernance;
 
+    // the address of the v3 network
+    IBancorNetworkV3 private immutable _networkV3;
+
     // the percentage of the converted network tokens to be sent to the caller of the burning event (in units of PPM)
     uint32 private _burnReward;
 
@@ -86,16 +104,24 @@ contract VortexBurner is Owned, Utils, ReentrancyGuard, ContractRegistryClient {
     constructor(
         IERC20 networkToken,
         ITokenGovernance govTokenGovernance,
-        IContractRegistry registry
+        IContractRegistry registry,
+        IVortexBurner prevBurner,
+        IBancorNetworkV3 networkV3
     )
         public
         ContractRegistryClient(registry)
         validAddress(address(networkToken))
         validAddress(address(govTokenGovernance))
+        validAddress(address(networkV3))
     {
         _networkToken = networkToken;
         _govTokenGovernance = govTokenGovernance;
         _govToken = govTokenGovernance.token();
+        _networkV3 = networkV3;
+
+        if (address(prevBurner) != address(0x0)) {
+            _totalBurnedAmount = prevBurner.totalBurnedAmount();
+        }
     }
 
     /**
@@ -186,11 +212,11 @@ contract VortexBurner is Owned, Utils, ReentrancyGuard, ContractRegistryClient {
 
         // in case there are network tokens to burn, convert them to the governance token
         if (sourceAmount > 0) {
-            // approve the network to withdraw the network token amount
-            _networkToken.ensureApprove(address(network), sourceAmount);
+            // allow BancorNetwork v3 to transfer the BNT from this contract
+            _networkToken.ensureApprove(address(_networkV3), sourceAmount);
 
-            // convert the entire network token amount to the governance token
-            network.convertByPath(strategy.govPath, sourceAmount, 1, address(this), address(0), 0);
+            // trade BNT to vBNT on BancorNetwork v3
+            _networkV3.tradeBySourceAmount(_networkToken, _govToken, sourceAmount, 1, block.timestamp + 100, address(this));
         }
 
         // get the governance token balance

test/vortex/VortexBurner.js

@@ -1,6 +1,6 @@
 const { expect } = require('chai');
 const { BigNumber } = require('ethers');
-const { ethers } = require('hardhat');
+const { ethers, network } = require('hardhat');
 
 const { NATIVE_TOKEN_ADDRESS, registry, ZERO_ADDRESS } = require('../helpers/Constants');
 const Contracts = require('../../components/Contracts').default;
@@ -14,6 +14,8 @@ const STANDARD_CONVERTER_WEIGHTS = [500_000, 500_000];
 const TOTAL_SUPPLY = BigNumber.from(1_000_000_000).mul(TKN);
 
 let contractRegistry;
+let prevBurner;
+let networkV3;
 let bancorNetwork;
 let networkToken;
 let govToken;
@@ -44,6 +46,9 @@ describe('VortexBurner', () => {
 
         networkSettings = await Contracts.NetworkSettings.deploy(owner.address, BigNumber.from(0));
         await contractRegistry.registerAddress(registry.NETWORK_SETTINGS, networkSettings.address);
+
+        prevBurner = await Contracts.MockVortexBurner.deploy();
+        networkV3 = await Contracts.TestBancorNetworkV3.deploy(contractRegistry.address);
     });
 
     beforeEach(async () => {
@@ -65,6 +70,7 @@ describe('VortexBurner', () => {
 
         govToken = await Contracts.DSToken.deploy('vBNT', 'vBNT', 18);
         await govToken.issue(owner.address, TOTAL_SUPPLY);
+        await govToken.transfer(networkV3.address, TOTAL_SUPPLY.div(10));
 
         govTokenGovernance = await Contracts.TestTokenGovernance.deploy(govToken.address);
         await govToken.transferOwnership(govTokenGovernance.address);
@@ -75,7 +81,9 @@ describe('VortexBurner', () => {
         vortex = await Contracts.VortexBurner.deploy(
             networkToken.address,
             govTokenGovernance.address,
-            contractRegistry.address
+            contractRegistry.address,
+            ZERO_ADDRESS,
+            networkV3.address
         );
 
         await networkFeeWallet.transferOwnership(vortex.address);
@@ -93,21 +101,59 @@ describe('VortexBurner', () => {
             expect(await vortex.totalBurnedAmount()).to.equal(BigNumber.from(0));
         });
 
+        it('should allow initializing with a previous burner address', async () => {
+            vortex = await Contracts.VortexBurner.deploy(
+                networkToken.address,
+                govTokenGovernance.address,
+                contractRegistry.address,
+                prevBurner.address,
+                networkV3.address
+            );
+
+            expect(await vortex.totalBurnedAmount()).to.equal(BigNumber.from(1000));
+        });
+
         it('should revert if initialized with an invalid network token address', async () => {
             await expect(
-                Contracts.VortexBurner.deploy(ZERO_ADDRESS, govTokenGovernance.address, contractRegistry.address)
+                Contracts.VortexBurner.deploy(
+                    ZERO_ADDRESS,
+                    govTokenGovernance.address,
+                    contractRegistry.address,
+                    prevBurner.address,
+                    networkV3.address)
             ).to.be.revertedWith('ERR_INVALID_ADDRESS');
         });
 
         it('should revert if initialized with an invalid governance token governance address', async () => {
             await expect(
-                Contracts.VortexBurner.deploy(networkToken.address, ZERO_ADDRESS, contractRegistry.address)
+                Contracts.VortexBurner.deploy(
+                    networkToken.address,
+                    ZERO_ADDRESS,
+                    contractRegistry.address,
+                    prevBurner.address,
+                    networkV3.address)
             ).to.be.revertedWith('ERR_INVALID_ADDRESS');
         });
 
         it('should revert if initialized with an invalid contract registry address', async () => {
             await expect(
-                Contracts.VortexBurner.deploy(networkToken.address, govTokenGovernance.address, ZERO_ADDRESS)
+                Contracts.VortexBurner.deploy(
+                    networkToken.address,
+                    govTokenGovernance.address,
+                    ZERO_ADDRESS,
+                    prevBurner.address,
+                    networkV3.address)
+            ).to.be.revertedWith('ERR_INVALID_ADDRESS');
+        });
+
+        it('should revert if initialized with an invalid contract network v3 address', async () => {
+            await expect(
+                Contracts.VortexBurner.deploy(
+                    networkToken.address,
+                    govTokenGovernance.address,
+                    contractRegistry.address,
+                    prevBurner.address,
+                    ZERO_ADDRESS)
             ).to.be.revertedWith('ERR_INVALID_ADDRESS');
         });
     });
@@ -139,7 +185,9 @@ describe('VortexBurner', () => {
             const newVortex = await Contracts.VortexBurner.deploy(
                 networkToken.address,
                 govTokenGovernance.address,
-                contractRegistry.address
+                contractRegistry.address,
+                ZERO_ADDRESS,
+                networkV3.address
             );
 
             await vortex.transferNetworkFeeWalletOwnership(newVortex.address);
@@ -392,19 +440,9 @@ describe('VortexBurner', () => {
                                                     netNetworkTokenConversionAmount.sub(burnRewardAmount);
                                             }
 
-                                            // take into account that if one of the source tokens is the governance token -
-                                            // we won't be able to use rateByPath explicitly, since it wouldn't take into
-                                            // account a previous conversion.
-                                            totalBurnedAmount = totalBurnedAmount.add(
-                                                await bancorNetwork.rateByPath(
-                                                    [
-                                                        networkToken.address,
-                                                        data.GOV.poolToken.address,
-                                                        govToken.address
-                                                    ],
-                                                    netNetworkTokenConversionAmount
-                                                )
-                                            );
+                                            // assuming the BNT -> vBNT trade on Bancor v3 returns double the source amount,
+                                            // since a mock network is used
+                                            totalBurnedAmount = totalBurnedAmount.add(netNetworkTokenConversionAmount.mul(2));
 
                                             return {
                                                 convertibleTokens,