Contract 0xab1e4b72bc2f3890f052df111ee626c1c7229f26

/**
 *Submitted for verification at Arbiscan on 2022-05-17
*/

// SPDX-License-Identifier: MIT

pragma solidity =0.8.10;





abstract contract IDFSRegistry {
 
    function getAddr(bytes4 _id) public view virtual returns (address);

    function addNewContract(
        bytes32 _id,
        address _contractAddr,
        uint256 _waitPeriod
    ) public virtual;

    function startContractChange(bytes32 _id, address _newContractAddr) public virtual;

    function approveContractChange(bytes32 _id) public virtual;

    function cancelContractChange(bytes32 _id) public virtual;

    function changeWaitPeriod(bytes32 _id, uint256 _newWaitPeriod) public virtual;
}





interface IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint256 digits);
    function totalSupply() external view returns (uint256 supply);

    function balanceOf(address _owner) external view returns (uint256 balance);

    function transfer(address _to, uint256 _value) external returns (bool success);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool success);

    function approve(address _spender, uint256 _value) external returns (bool success);

    function allowance(address _owner, address _spender) external view returns (uint256 remaining);

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}





library Address {
    //insufficient balance
    error InsufficientBalance(uint256 available, uint256 required);
    //unable to send value, recipient may have reverted
    error SendingValueFail();
    //insufficient balance for call
    error InsufficientBalanceForCall(uint256 available, uint256 required);
    //call to non-contract
    error NonContractCall();
    
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        uint256 balance = address(this).balance;
        if (balance < amount){
            revert InsufficientBalance(balance, amount);
        }

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        if (!(success)){
            revert SendingValueFail();
        }
    }

    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        uint256 balance = address(this).balance;
        if (balance < value){
            revert InsufficientBalanceForCall(balance, value);
        }
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        if (!(isContract(target))){
            revert NonContractCall();
        }

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}




library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}







library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /// @dev Edited so it always first approves 0 and then the value, because of non standard tokens
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            "SafeERC20: decreased allowance below zero"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}





contract ArbitrumAuthAddresses {
    address internal constant ADMIN_VAULT_ADDR = 0xd47D8D97cAd12A866900eEc6Cde1962529F25351;
    address internal constant FACTORY_ADDRESS = 0x5261abC3a94a6475D0A1171daE94A5f84fbaEcD2;
    address internal constant ADMIN_ADDR = 0x6AFEA85cFAB61e3a55Ad2e4537252Ec05796BEfa;
}





contract AuthHelper is ArbitrumAuthAddresses {
}





contract AdminVault is AuthHelper {
    address public owner;
    address public admin;

    error SenderNotAdmin();

    constructor() {
        owner = msg.sender;
        admin = ADMIN_ADDR;
    }

    /// @notice Admin is able to change owner
    /// @param _owner Address of new owner
    function changeOwner(address _owner) public {
        if (admin != msg.sender){
            revert SenderNotAdmin();
        }
        owner = _owner;
    }

    /// @notice Admin is able to set new admin
    /// @param _admin Address of multisig that becomes new admin
    function changeAdmin(address _admin) public {
        if (admin != msg.sender){
            revert SenderNotAdmin();
        }
        admin = _admin;
    }

}








contract AdminAuth is AuthHelper {
    using SafeERC20 for IERC20;

    AdminVault public constant adminVault = AdminVault(ADMIN_VAULT_ADDR);

    error SenderNotOwner();
    error SenderNotAdmin();

    modifier onlyOwner() {
        if (adminVault.owner() != msg.sender){
            revert SenderNotOwner();
        }
        _;
    }

    modifier onlyAdmin() {
        if (adminVault.admin() != msg.sender){
            revert SenderNotAdmin();
        }
        _;
    }

    /// @notice withdraw stuck funds
    function withdrawStuckFunds(address _token, address _receiver, uint256 _amount) public onlyOwner {
        if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
            payable(_receiver).transfer(_amount);
        } else {
            IERC20(_token).safeTransfer(_receiver, _amount);
        }
    }

    /// @notice Destroy the contract
    function kill() public onlyAdmin {
        selfdestruct(payable(msg.sender));
    }
}




contract SaverExchangeRegistry is AdminAuth {

	mapping(address => bool) private wrappers;

	function addWrapper(address _wrapper) public onlyOwner {
		wrappers[_wrapper] = true;
	}

	function removeWrapper(address _wrapper) public onlyOwner {
		wrappers[_wrapper] = false;
	}

	function isWrapper(address _wrapper) public view returns(bool) {
		return wrappers[_wrapper];
	}
}

[{"inputs":[],"name":"NonContractCall","type":"error"},{"inputs":[],"name":"SenderNotAdmin","type":"error"},{"inputs":[],"name":"SenderNotOwner","type":"error"},{"inputs":[{"internalType":"address","name":"_wrapper","type":"address"}],"name":"addWrapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"adminVault","outputs":[{"internalType":"contract AdminVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wrapper","type":"address"}],"name":"isWrapper","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kill","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wrapper","type":"address"}],"name":"removeWrapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawStuckFunds","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

11568:392:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11665:90;;;;;;:::i;:::-;;:::i;:::-;;11470:85;;;:::i;10641:68::-;;9492:42;10641:68;;;;;-1:-1:-1;;;;;584:32:1;;;566:51;;554:2;539:18;10641:68:0;;;;;;;;11108:316;;;;;;:::i;:::-;;:::i;11859:98::-;;;;;;:::i;:::-;-1:-1:-1;;;;;11934:18:0;11916:4;11934:18;;;;;;;;;;;;;;11859:98;;;;1254:14:1;;1247:22;1229:41;;1217:2;1202:18;11859:98:0;1089:187:1;11760:94:0;;;;;;:::i;:::-;;:::i;11665:90::-;10836:10;-1:-1:-1;;;;;10814:32:0;9492:42;-1:-1:-1;;;;;10814:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10814:32:0;;10810:87;;10869:16;;-1:-1:-1;;;10869:16:0;;;;;;;;;;;10810:87;-1:-1:-1;;;;;11725:18:0::1;:8;:18:::0;;;::::1;::::0;;;;;;:25;;-1:-1:-1;;11725:25:0::1;11746:4;11725:25;::::0;;11665:90::o;11470:85::-;10982:10;-1:-1:-1;;;;;10960:32:0;9492:42;-1:-1:-1;;;;;10960:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10960:32:0;;10956:87;;11015:16;;-1:-1:-1;;;11015:16:0;;;;;;;;;;;10956:87;11535:10:::1;11514:33;11108:316:::0;10836:10;-1:-1:-1;;;;;10814:32:0;9492:42;-1:-1:-1;;;;;10814:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10814:32:0;;10810:87;;10869:16;;-1:-1:-1;;;10869:16:0;;;;;;;;;;;10810:87;11230:42:::1;-1:-1:-1::0;;;;;11220:52:0;::::1;;11216:201;;;11289:36;::::0;-1:-1:-1;;;;;11289:27:0;::::1;::::0;:36;::::1;;;::::0;11317:7;;11289:36:::1;::::0;;;11317:7;11289:27;:36;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;11108:316:::0;;;:::o;11216:201::-:1;11358:47;-1:-1:-1::0;;;;;11358:27:0;::::1;11386:9:::0;11397:7;11358:27:::1;:47::i;:::-;11108:316:::0;;;:::o;11760:94::-;10836:10;-1:-1:-1;;;;;10814:32:0;9492:42;-1:-1:-1;;;;;10814:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10814:32:0;;10810:87;;10869:16;;-1:-1:-1;;;10869:16:0;;;;;;;;;;;10810:87;-1:-1:-1;;;;;11823:18:0::1;11844:5;11823:18:::0;;;::::1;::::0;;;;;;:26;;-1:-1:-1;;11823:26:0::1;::::0;;11760:94::o;7176:211::-;7320:58;;;-1:-1:-1;;;;;1729:32:1;;;7320:58:0;;;1711:51:1;1778:18;;;;1771:34;;;7320:58:0;;;;;;;;;;1684:18:1;;;;7320:58:0;;;;;;;;-1:-1:-1;;;;;7320:58:0;-1:-1:-1;;;7320:58:0;;;9033:106;;;;;;;;;;;;;;;;7293:86;;7313:5;;7320:58;-1:-1:-1;;9033:106:0;;:27;;;7320:58;;9033:27;:106::i;:::-;9154:17;;9007:132;;-1:-1:-1;9154:21:0;9150:237;;9309:10;9298:30;;;;;;;;;;;;:::i;:::-;9290:85;;;;-1:-1:-1;;;9290:85:0;;2300:2:1;9290:85:0;;;2282:21:1;2339:2;2319:18;;;2312:30;2378:34;2358:18;;;2351:62;-1:-1:-1;;;2429:18:1;;;2422:40;2479:19;;9290:85:0;;;;;;;;3198:230;3335:12;3367:53;3390:6;3398:4;3404:1;3407:12;3367:22;:53::i;:::-;3360:60;3198:230;-1:-1:-1;;;;3198:230:0:o;4148:1036::-;4321:12;4352:18;4363:6;4352:10;:18::i;:::-;4346:77;;4394:17;;-1:-1:-1;;;4394:17:0;;;;;;;;;;;4346:77;4496:12;4510:23;4537:6;-1:-1:-1;;;;;4537:11:0;4556:8;4566:4;4537:34;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4495:76;;;;4586:7;4582:595;;;4617:10;-1:-1:-1;4610:17:0;;-1:-1:-1;4610:17:0;4582:595;4731:17;;:21;4727:439;;4994:10;4988:17;5055:15;5042:10;5038:2;5034:19;5027:44;4727:439;5137:12;5130:20;;-1:-1:-1;;;5130:20:0;;;;;;;;:::i;1908:641::-;1968:4;2449:20;;2279:66;2498:23;;;;;;:42;;-1:-1:-1;;2525:15:0;;;2490:51;-1:-1:-1;;1908:641:0:o;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:247::-;209:6;262:2;250:9;241:7;237:23;233:32;230:52;;;278:1;275;268:12;230:52;317:9;304:23;336:31;361:5;336:31;:::i;:::-;386:5;150:247;-1:-1:-1;;;150:247:1:o;628:456::-;705:6;713;721;774:2;762:9;753:7;749:23;745:32;742:52;;;790:1;787;780:12;742:52;829:9;816:23;848:31;873:5;848:31;:::i;:::-;898:5;-1:-1:-1;955:2:1;940:18;;927:32;968:33;927:32;968:33;:::i;:::-;628:456;;1020:7;;-1:-1:-1;;;1074:2:1;1059:18;;;;1046:32;;628:456::o;1281:251::-;1351:6;1404:2;1392:9;1383:7;1379:23;1375:32;1372:52;;;1420:1;1417;1410:12;1372:52;1452:9;1446:16;1471:31;1496:5;1471:31;:::i;1816:277::-;1883:6;1936:2;1924:9;1915:7;1911:23;1907:32;1904:52;;;1952:1;1949;1942:12;1904:52;1984:9;1978:16;2037:5;2030:13;2023:21;2016:5;2013:32;2003:60;;2059:1;2056;2049:12;2509:258;2581:1;2591:113;2605:6;2602:1;2599:13;2591:113;;;2681:11;;;2675:18;2662:11;;;2655:39;2627:2;2620:10;2591:113;;;2722:6;2719:1;2716:13;2713:48;;;-1:-1:-1;;2757:1:1;2739:16;;2732:27;2509:258::o;2772:274::-;2901:3;2939:6;2933:13;2955:53;3001:6;2996:3;2989:4;2981:6;2977:17;2955:53;:::i;:::-;3024:16;;;;;2772:274;-1:-1:-1;;2772:274:1:o;3051:383::-;3200:2;3189:9;3182:21;3163:4;3232:6;3226:13;3275:6;3270:2;3259:9;3255:18;3248:34;3291:66;3350:6;3345:2;3334:9;3330:18;3325:2;3317:6;3313:15;3291:66;:::i;:::-;3418:2;3397:15;-1:-1:-1;;3393:29:1;3378:45;;;;3425:2;3374:54;;3051:383;-1:-1:-1;;3051:383:1:o

d1ffe5521c5200cdf222ba79603fe488655b665eb36f26612bd9026a44173c27