{
    "Function": "_repayPath",
    "File": "contracts/routers/FullRouter.sol",
    "Parent Contracts": [
        "contracts/routers/StrategyRouter.sol",
        "contracts/helpers/StrategyTypes.sol",
        "contracts/interfaces/IStrategyRouter.sol"
    ],
    "High-Level Calls": [
        "SafeMath",
        "IStrategyController",
        "SafeMath",
        "ILendingPool",
        "SafeMath",
        "SafeMath",
        "IERC20",
        "IERC20",
        "IERC20",
        "IERC20",
        "ILendingPoolAddressesProvider",
        "IOracle",
        "IOracle",
        "SafeMath",
        "SafeMath",
        "SafeMath"
    ],
    "Internal Calls": [
        "require(bool,string)",
        "_setTempEstimate",
        "_getLeverageRemaining",
        "_deleverage",
        "_delegateSwap",
        "abi.decode()",
        "_getLeverageRemaining",
        "assert(bool)"
    ],
    "Library Calls": [
        "sub",
        "mul",
        "div",
        "sub",
        "sub",
        "sub",
        "add"
    ],
    "Low-Level Calls": [],
    "Code": "function _repayPath(\n        TradeData memory data,\n        uint256 amount, // weth\n        uint256 total,\n        address strategy\n    ) internal {\n        if (amount == 0 && (data.path[data.path.length-1] != weth || data.cache.length == 0)) return; // Debt doesn't need to change and no leverage tokens to deleverage so return\n        // Debt trade paths should have path.length == adapters.length,\n        // since final token can differ from the debt token defined in the strategy\n        require(data.adapters.length == data.path.length, \"Incorrect trade data\");\n        ILendingPool lendingPool = ILendingPool(addressesProvider.getLendingPool());\n        IOracle oracle = controller.oracle();\n        LeverageItem[] memory leverageItems;\n        uint256[] memory leverageLiquidity;\n\n        if (data.path[data.path.length-1] != weth) {\n            // Convert amount into the first token's currency\n            amount = amount.mul(10**18).div(uint256(oracle.estimateItem(10**18, data.path[data.path.length-1])));\n        } else if (data.cache.length > 0) {\n            // Deleverage tokens\n            leverageItems = abi.decode(data.cache, (LeverageItem[]));\n            leverageLiquidity = new uint256[](leverageItems.length);\n            if (amount == 0) {\n                // Special case where debt doesn't need to change but the relative amounts of leverage tokens do. We must first deleverage our debt\n                for (uint256 i = 0; i < leverageItems.length; i++) {\n                    leverageLiquidity[i] = _getLeverageRemaining(oracle, strategy, leverageItems[i].token, total, false);\n                    amount = amount.add(leverageLiquidity[i]);\n                }\n            } else {\n                uint256 leverageAmount = amount; // amount is denominated in weth here\n                for (uint256 i = 0; i < leverageItems.length; i++) {\n                    address token = leverageItems[i].token;\n                    if (leverageItems.length > 1) { //If multiple leveraged items, some may have less liquidity than the total amount we need to sell\n                        uint256 liquidity = _getLeverageRemaining(oracle, strategy, token, total, false);\n                        leverageLiquidity[i] = leverageAmount > liquidity ? liquidity : leverageAmount;\n                    } else {\n                        leverageLiquidity[i] = leverageAmount;\n                        _setTempEstimate(strategy, token, oracle.estimateItem(\n                          IERC20(token).balanceOf(strategy),\n                          token\n                        ));\n                    }\n                    leverageAmount = leverageAmount.sub(leverageLiquidity[i]);\n                }\n                assert(leverageAmount == 0);\n            }\n        }\n\n        while (amount > 0) {\n            if (leverageItems.length > 0) {\n                // Leverage tokens: cache can contain an array of tokens that can be purchased with the WETH received from selling debt\n                ( , , uint256 availableBorrowsETH, , , ) = lendingPool.getUserAccountData(strategy);\n                bool isLiquidityRemaining = false;\n                for (uint256 i = 0; i < leverageItems.length; i++) {\n                    if (leverageLiquidity[i] > 0 && availableBorrowsETH > 0) {\n                        // Only deleverage token when there is a disparity between the expected value and the estimated value\n                        uint256 leverageAmount = _deleverage(oracle, strategy, leverageItems[i].token, leverageLiquidity[i], availableBorrowsETH);\n                        leverageLiquidity[i] = leverageLiquidity[i].sub(leverageAmount);\n                        availableBorrowsETH = availableBorrowsETH.sub(leverageAmount);\n                        if (leverageLiquidity[i] > 0) isLiquidityRemaining = true; // Liquidity still remaining\n                    }\n                }\n                if (!isLiquidityRemaining) {\n                    // In case of deleveraging slippage, once we've fully deleveraged we just want use the weth the we've received even if its less than original amount\n                    uint256 balance = IERC20(weth).balanceOf(strategy);\n                    if (amount > balance) amount = balance;\n                }\n            }\n            for (int256 i = int256(data.adapters.length-1); i >= 0; i--) { //this doesn't work with uint256?? wtf solidity\n                uint256 _amount;\n                address _tokenIn = data.path[uint256(i)];\n                address _tokenOut;\n                address _from;\n                address _to;\n\n                if (uint256(i) == data.adapters.length-1) {\n                    uint256 balance = IERC20(_tokenIn).balanceOf(strategy);\n                    _amount = balance > amount ? amount : balance;\n                    _from = strategy;\n                    //Update amounts\n                    amount = amount.sub(_amount);\n                } else {\n                    _from = address(this);\n                    _amount = IERC20(_tokenIn).balanceOf(_from);\n                }\n                if (_amount > 0) {\n                    if (uint256(i) == 0) {\n                        _tokenOut = address(0); //Since we're repaying to the lending pool we'll set tokenOut to zero, however amount is valued in weth\n                        _to = strategy;\n                    } else {\n                        _tokenOut = data.path[uint256(i-1)];\n                        _to = address(this);\n                    }\n                    _delegateSwap(\n                        data.adapters[uint256(i)],\n                        _amount,\n                        1,\n                        _tokenIn,\n                        _tokenOut,\n                        _from,\n                        _to\n                    );\n                }\n            }\n        }\n    }"
}