{
    "Function": "slitherConstructorConstantVariables",
    "File": "contracts/implementations/recovery/StrategyControllerPaused.sol",
    "Parent Contracts": [
        "node_modules/@openzeppelin/contracts/proxy/Initializable.sol",
        "contracts/StrategyControllerStorage.sol",
        "contracts/interfaces/IStrategyController.sol",
        "contracts/helpers/StrategyTypes.sol"
    ],
    "High-Level Calls": [],
    "Internal Calls": [],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "contract StrategyControllerPaused is IStrategyController, StrategyControllerStorage, Initializable {\n    using SignedSafeMath for int256;\n\n    uint256 private constant DIVISOR = 1000;\n    int256 private constant PERCENTAGE_BOUND = 10000; // Max 10x leverage\n\n    address public immutable factory;\n\n    // Initialize constructor to disable implementation\n    constructor(address factory_) public initializer {\n        factory = factory_;\n    }\n\n    /**\n     * @dev Called to initialize proxy\n     */\n    function initialize() external initializer {\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @dev Called during the creation of a new Strategy proxy (see: StrategyProxyFactory.createStrategy())\n     * @param manager_ The address that is set as manager\n     * @param strategy_ The address of the strategy\n     * @param state_ The initial strategy state\n     * @param router_ The router in charge of swapping items for this strategy\n     * @param data_ Optional bytes data to be passed if using GenericRouter\n     */\n    function setupStrategy(\n        address manager_,\n        address strategy_,\n        InitialState memory state_,\n        address router_,\n        bytes memory data_\n    ) external payable override {\n        (manager_, strategy_, state_, router_, data_); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Deposit ETH, which is traded for the underlying assets, and mint strategy tokens\n     * @param strategy The address of the strategy being deposited into\n     * @param router The address of the router that will be doing the handling the trading logic\n     * @param amount The deposit amount as valued in ETH (not used if msg.value > 0)\n     * @param data Optional bytes data to be passed if using GenericRouter\n     */\n    function deposit(\n        IStrategy strategy,\n        IStrategyRouter router,\n        uint256 amount,\n        uint256 slippage,\n        bytes memory data\n    ) external payable override {\n        (strategy, router, amount, slippage, data); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Withdraw ETH by trading underling assets for ETH\n     * @param strategy The address of the strategy being withdrawn from\n     * @param router The address of the router that will be doing the handling the trading logic\n     * @param amount The amount of strategy tokens that are being redeemed\n     * @param data Optional bytes data to be passed if using GenericRouter\n     */\n    function withdrawETH(\n        IStrategy strategy,\n        IStrategyRouter router,\n        uint256 amount,\n        uint256 slippage,\n        bytes memory data\n    ) external override {\n        (strategy, router, amount, slippage, data); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Withdraw WETH by trading underling assets for WETH\n     * @param strategy The address of the strategy being withdrawn from\n     * @param router The address of the router that will be doing the handling the trading logic\n     * @param amount The amount of strategy tokens that are being redeemed\n     * @param data Optional bytes data to be passed if using GenericRouter\n     */\n    function withdrawWETH(\n        IStrategy strategy,\n        IStrategyRouter router,\n        uint256 amount,\n        uint256 slippage,\n        bytes memory data\n    ) external override {\n        (strategy, router, amount, slippage, data); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Rebalance the strategy to match the current structure\n     * @param router The address of the router that will be doing the handling the trading logic\n     * @param data Optional bytes data to be passed if using GenericRouter\n     */\n    function rebalance(\n        IStrategy strategy,\n        IStrategyRouter router,\n        bytes memory data\n    ) external override {\n        (strategy, router, data); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Exchange all Synths into or out of sUSD to facilitate rebalancing of the rest of the strategy.\n     *         In order to rebalance the strategy, all Synths must first be converted into sUSD\n     * @param strategy The address of the strategy being withdrawn from\n     * @param adapter The address of the synthetix adapter to handle the exchanging of all synths\n     * @param token The token being positioned into. Either sUSD or address(-1) which represents all of the strategy's Synth positions\n     */\n    function repositionSynths(IStrategy strategy, address adapter, address token) external {\n        (strategy, adapter, token); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Initiate a restructure of the strategy items. This gives users a chance to withdraw before restructure\n     * @dev The strategyItems array is encoded and temporarily stored while the timelock is active\n     * @param strategyItems An array of Item structs that will comprise the strategy\n     */\n    function restructure(\n        IStrategy strategy,\n        StrategyItem[] memory strategyItems\n    ) external override {\n        (strategy, strategyItems); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Finalize a restructure by setting the new values and trading the strategyItems\n     * @dev The strategyItems are decoded and the new structure is set into the strategy\n     * @param router The address of the router that will be doing the handling the trading logic\n     * @param data Optional bytes data to be sent if using GenericRouter\n     */\n    function finalizeStructure(\n        IStrategy strategy,\n        IStrategyRouter router,\n        bytes memory data\n    ) external override {\n        (strategy, router, data); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Initiate an update of a StrategyState value. This gives users a chance to withdraw before changes are finalized\n     * @param category The TimelockCategory of the value we want to change\n     * @param newValue The new value that we are updating the state to\n     */\n    function updateValue(\n        IStrategy strategy,\n        TimelockCategory category,\n        uint256 newValue\n    ) external override {\n        (strategy, category, newValue); // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Finalize the value that was set in the timelock\n     * @param strategy The address of the strategy that is being updated\n     */\n    function finalizeValue(IStrategy strategy) external override {\n        strategy; // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Change strategy to 'social'. Cannot be undone.\n     * @dev A social profile allows other users to deposit into the strategy\n     */\n    function openStrategy(IStrategy strategy) external override {\n        strategy; // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    /**\n     * @notice Change strategy to 'set'. Cannot be undone.\n     * @dev A set strategy cannot be restructured\n     */\n    function setStrategy(IStrategy strategy) external override {\n        strategy; // shh compiler\n        revert(\"StrategyControllerPaused.\");\n    }\n\n    // @notice Initialized getter\n    function initialized(address strategy) public view override returns (bool) {\n        return _initialized[strategy] > 0;\n    }\n\n    // @notice StrategyState getter\n    function strategyState(address strategy) external view override returns (StrategyState memory) {\n        return _strategyStates[strategy];\n    }\n\n    /**\n     * @notice This function verifies that the structure passed in parameters is valid\n     * @dev We check that the array lengths match, that the percentages add 100%,\n     *      no zero addresses, and no duplicates\n     * @dev Token addresses must be passed in, according to increasing byte value\n     */\n    function verifyStructure(address strategy, StrategyItem[] memory newItems)\n        public\n        view\n        override\n        returns (bool)\n    {\n        require(newItems.length > 0, \"Cannot set empty structure\");\n        require(newItems[0].item != address(0), \"Invalid item addr\"); //Everything else will caught by the ordering requirement below\n        require(newItems[newItems.length-1].item != address(-1), \"Invalid item addr\"); //Reserved space for virtual item\n\n        ITokenRegistry registry = oracle().tokenRegistry();\n\n        int256 total = 0;\n        for (uint256 i = 0; i < newItems.length; i++) {\n            address item = newItems[i].item;\n            require(i == 0 || newItems[i].item > newItems[i - 1].item, \"Item ordering\");\n            int256 percentage = newItems[i].percentage;\n            if (registry.itemCategories(item) == uint256(ItemCategory.DEBT)) {\n              require(percentage <= 0, \"Debt cannot be positive\");\n              require(percentage >= -PERCENTAGE_BOUND, \"Out of bounds\");\n            } else {\n              require(percentage >= 0, \"Token cannot be negative\");\n              require(percentage <= PERCENTAGE_BOUND, \"Out of bounds\");\n            }\n            uint256 category = registry.estimatorCategories(item);\n            require(category != uint256(EstimatorCategory.BLOCKED), \"Token blocked\");\n            if (category == uint256(EstimatorCategory.STRATEGY))\n                _checkCyclicDependency(strategy, IStrategy(item), registry);\n            total = total.add(percentage);\n        }\n        require(total == int256(DIVISOR), \"Total percentage wrong\");\n        return true;\n    }\n\n    /**\n        @notice Refresh StrategyController's addresses\n     */\n    function updateAddresses() public {\n        IStrategyProxyFactory f = IStrategyProxyFactory(factory);\n        _whitelist = f.whitelist();\n        address o = f.oracle();\n        if (o != _oracle) {\n          IOracle ensoOracle = IOracle(o);\n          _oracle = o;\n          _weth = ensoOracle.weth();\n          _susd = ensoOracle.susd();\n        }\n    }\n\n    function oracle() public view override returns (IOracle) {\n        return IOracle(_oracle);\n    }\n\n    function whitelist() public view override returns (IWhitelist) {\n        return IWhitelist(_whitelist);\n    }\n\n    // Internal Strategy Functions\n    /**\n     * @notice Deposit eth or weth into strategy\n     * @dev Calldata is only needed for the GenericRouter\n     */\n\n    function _checkCyclicDependency(address test, IStrategy strategy, ITokenRegistry registry) private view {\n        require(address(strategy) != test, \"Cyclic dependency\");\n        require(!strategy.supportsSynths(), \"Synths not supported\");\n        address[] memory strategyItems = strategy.items();\n        for (uint256 i = 0; i < strategyItems.length; i++) {\n          if (registry.estimatorCategories(strategyItems[i]) == uint256(EstimatorCategory.STRATEGY))\n              _checkCyclicDependency(test, IStrategy(strategyItems[i]), registry);\n        }\n    }\n\n    receive() external payable {\n        revert(\"StrategyControllerPaused.\");\n    }\n}"
}