Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IExpectedOutCalculator
•    - function getExpectedOut(
• interface IPriceChecker
•    - function checkPrice(
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
•  contract DynamicSlippageChecker is ... *
•    - function checkPrice(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-04-21
*/

// SPDX-License-Identifier: LGPL-3.0-or-later
pragma solidity ^0.7.6;
pragma abicoder v2;

// File: IExpectedOutCalculator.sol

interface IExpectedOutCalculator {
    function getExpectedOut(
        uint256 _amountIn,
        address _fromToken,
        address _toToken,
        bytes calldata _data
    ) external view returns (uint256);
}

// File: IPriceChecker.sol

interface IPriceChecker {
    function checkPrice(
        uint256 _amountIn,
        address _fromToken,
        address _toToken,
        uint256 _feeAmount,
        uint256 _minOut,
        bytes calldata _data
    ) external view returns (bool);
}

// File: SafeMath.sol

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: DynamicSlippageChecker.sol

// Like the `FixedSlippageChecker` except the user can pass in their desired
// allowed slippage % dynamically in the _data field. The rest of the _data
// is passed to the price checker.
contract DynamicSlippageChecker is IPriceChecker {
    using SafeMath for uint256;

    string public NAME;
    IExpectedOutCalculator public immutable EXPECTED_OUT_CALCULATOR;

    uint256 internal constant MAX_BPS = 10_000;

    constructor(string memory _name, address _expectedOutCalculator) {
        NAME = _name;
        EXPECTED_OUT_CALCULATOR = IExpectedOutCalculator(
            _expectedOutCalculator
        );
    }

    function checkPrice(
        uint256 _amountIn,
        address _fromToken,
        address _toToken,
        uint256,
        uint256 _minOut,
        bytes calldata _data
    ) external view override returns (bool) {
        (uint256 _allowedSlippageInBps, bytes memory _data) = abi.decode(
            _data,
            (uint256, bytes)
        );

        uint256 _expectedOut = EXPECTED_OUT_CALCULATOR.getExpectedOut(
            _amountIn,
            _fromToken,
            _toToken,
            _data
        );

        return
            _minOut >
            _expectedOut.mul(MAX_BPS.sub(_allowedSlippageInBps)).div(MAX_BPS);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"address","name":"_expectedOutCalculator","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"EXPECTED_OUT_CALCULATOR","outputs":[{"internalType":"contract IExpectedOutCalculator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"address","name":"_fromToken","type":"address"},{"internalType":"address","name":"_toToken","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"_minOut","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"checkPrice","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

60a060405234801561001057600080fd5b506040516107fd3803806107fd83398101604081905261002f91610116565b8151610042906000906020850190610059565b5060601b6001600160601b031916608052506101df565b828054600181600116156101000203166002900490600052602060002090601f01602090048101928261008f57600085556100d5565b82601f106100a857805160ff19168380011785556100d5565b828001600101855582156100d5579182015b828111156100d55782518255916020019190600101906100ba565b506100e19291506100e5565b5090565b5b808211156100e157600081556001016100e6565b80516001600160a01b038116811461011157600080fd5b919050565b60008060408385031215610128578182fd5b82516001600160401b038082111561013e578384fd5b818501915085601f830112610151578384fd5b81518181111561015d57fe5b6040516020601f8301601f191682018101848111838210171561017c57fe5b6040528282528483018101891015610192578687fd5b8693505b828410156101b35784840181015182850182015292830192610196565b828411156101c357868184840101525b8196506101d18189016100fa565b955050505050509250929050565b60805160601c6105fe6101ff60003980609b528060d552506105fe6000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80633a0b987c146100465780639e2f2b5c14610064578063a3f4df7e14610084575b600080fd5b61004e610099565b60405161005b91906104b6565b60405180910390f35b610077610072366004610313565b6100bd565b60405161005b91906104ab565b61008c6101a8565b60405161005b91906104ca565b7f000000000000000000000000000000000000000000000000000000000000000081565b600080806100cd848601866103bf565b9150915060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316630d1003ee8c8c8c866040518563ffffffff1660e01b8152600401610125949392919061058c565b60206040518083038186803b15801561013d57600080fd5b505afa158015610151573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061017591906102fb565b905061019761271061019161018a8287610236565b849061026c565b906102ad565b9096119a9950505050505050505050565b6000805460408051602060026001851615610100026000190190941693909304601f8101849004840282018401909252818152929183018282801561022e5780601f106102035761010080835404028352916020019161022e565b820191906000526020600020905b81548152906001019060200180831161021157829003601f168201915b505050505081565b6000828211156102615760405162461bcd60e51b8152600401610258906104dd565b60405180910390fd5b508082035b92915050565b60008261027b57506000610266565b8282028284828161028857fe5b04146102a65760405162461bcd60e51b81526004016102589061054b565b9392505050565b60008082116102ce5760405162461bcd60e51b815260040161025890610514565b8183816102d757fe5b049392505050565b80356001600160a01b03811681146102f657600080fd5b919050565b60006020828403121561030c578081fd5b5051919050565b600080600080600080600060c0888a03121561032d578283fd5b8735965061033d602089016102df565b955061034b604089016102df565b9450606088013593506080880135925060a088013567ffffffffffffffff80821115610375578384fd5b818a0191508a601f830112610388578384fd5b813581811115610396578485fd5b8b60208285010111156103a7578485fd5b60208301945080935050505092959891949750929550565b600080604083850312156103d1578182fd5b8235915060208084013567ffffffffffffffff808211156103f0578384fd5b818601915086601f830112610403578384fd5b81358181111561040f57fe5b604051601f8201601f191681018501838111828210171561042c57fe5b6040528181528382018501891015610442578586fd5b81858501868301378585838301015280955050505050509250929050565b60008151808452815b8181101561048557602081850181015186830182015201610469565b818111156104965782602083870101525b50601f01601f19169290920160200192915050565b901515815260200190565b6001600160a01b0391909116815260200190565b6000602082526102a66020830184610460565b6020808252601e908201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604082015260600190565b6020808252601a908201527f536166654d6174683a206469766973696f6e206279207a65726f000000000000604082015260600190565b60208082526021908201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6040820152607760f81b606082015260800190565b8481526001600160a01b038481166020830152831660408201526080606082018190526000906105be90830184610460565b969550505050505056fea2646970667358221220b9a64c1b0d17ae0cacf7ada43d7769ca5a0ae7f26add57f4a3c7db1637bd39a064736f6c634300070600330000000000000000000000000000000000000000000000000000000000000040000000000000000000000000cecb1bf380d4536039f55c0def8e20d1a84e2af7000000000000000000000000000000000000000000000000000000000000002b5353425f42414c5f574554485f44594e414d49435f534c4950504147455f50524943455f434845434b4552000000000000000000000000000000000000000000

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

0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000cecb1bf380d4536039f55c0def8e20d1a84e2af7000000000000000000000000000000000000000000000000000000000000002b5353425f42414c5f574554485f44594e414d49435f534c4950504147455f50524943455f434845434b4552000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): SSB_BAL_WETH_DYNAMIC_SLIPPAGE_PRICE_CHECKER
Arg [1] : _expectedOutCalculator (address): 0xcECB1BF380D4536039f55c0DEF8e20D1A84E2af7

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 000000000000000000000000cecb1bf380d4536039f55c0def8e20d1a84e2af7
Arg [2] : 000000000000000000000000000000000000000000000000000000000000002b
Arg [3] : 5353425f42414c5f574554485f44594e414d49435f534c4950504147455f5052
Arg [4] : 4943455f434845434b4552000000000000000000000000000000000000000000

8279:1120:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8395:63;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8729:667;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8370:18::-;;;:::i;:::-;;;;;;;:::i;8395:63::-;;;:::o;8729:667::-;8947:4;;;9018:72;;;;9043:5;9018:72;:::i;:::-;8964:126;;;;9103:20;9126:23;-1:-1:-1;;;;;9126:38:0;;9179:9;9203:10;9228:8;9251:5;9126:141;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9103:164;-1:-1:-1;9323:65:0;8503:6;9323:52;9340:34;8503:6;9352:21;9340:11;:34::i;:::-;9323:12;;:16;:52::i;:::-;:56;;:65::i;:::-;9300:88;;;;8729:667;-1:-1:-1;;;;;;;;;;8729:667:0:o;8370:18::-;;;;;;;;;;;;;;;-1:-1:-1;;8370:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3844:158::-;3902:7;3935:1;3930;:6;;3922:49;;;;-1:-1:-1;;;3922:49:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;3989:5:0;;;3844:158;;;;;:::o;4261:220::-;4319:7;4343:6;4339:20;;-1:-1:-1;4358:1:0;4351:8;;4339:20;4382:5;;;4386:1;4382;:5;:1;4406:5;;;;;:10;4398:56;;;;-1:-1:-1;;;4398:56:0;;;;;;;:::i;:::-;4472:1;4261:220;-1:-1:-1;;;4261:220:0:o;4959:153::-;5017:7;5049:1;5045;:5;5037:44;;;;-1:-1:-1;;;5037:44:0;;;;;;;:::i;:::-;5103:1;5099;:5;;;;;;;4959:153;-1:-1:-1;;;4959:153:0:o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;113:2;65:124;;;:::o;194:194::-;;317:2;305:9;296:7;292:23;288:32;285:2;;;338:6;330;323:22;285:2;-1:-1:-1;366:16:1;;275:113;-1:-1:-1;275:113:1:o;393:1000::-;;;;;;;;609:3;597:9;588:7;584:23;580:33;577:2;;;631:6;623;616:22;577:2;672:9;659:23;649:33;;701:40;737:2;726:9;722:18;701:40;:::i;:::-;691:50;;760:40;796:2;785:9;781:18;760:40;:::i;:::-;750:50;;847:2;836:9;832:18;819:32;809:42;;898:3;887:9;883:19;870:33;860:43;;954:3;943:9;939:19;926:33;978:18;1019:2;1011:6;1008:14;1005:2;;;1040:6;1032;1025:22;1005:2;1083:6;1072:9;1068:22;1058:32;;1128:7;1121:4;1117:2;1113:13;1109:27;1099:2;;1155:6;1147;1140:22;1099:2;1200;1187:16;1226:2;1218:6;1215:14;1212:2;;;1247:6;1239;1232:22;1212:2;1297:7;1292:2;1283:6;1279:2;1275:15;1271:24;1268:37;1265:2;;;1323:6;1315;1308:22;1265:2;1359;1355;1351:11;1341:21;;1381:6;1371:16;;;;;567:826;;;;;;;;;;:::o;1398:1007::-;;;1536:2;1524:9;1515:7;1511:23;1507:32;1504:2;;;1557:6;1549;1542:22;1504:2;1598:9;1585:23;1575:33;;1627:2;1680;1669:9;1665:18;1652:32;1703:18;1744:2;1736:6;1733:14;1730:2;;;1765:6;1757;1750:22;1730:2;1808:6;1797:9;1793:22;1783:32;;1853:7;1846:4;1842:2;1838:13;1834:27;1824:2;;1880:6;1872;1865:22;1824:2;1921;1908:16;1943:2;1939;1936:10;1933:2;;;1949:9;1933:2;1989;1983:9;2058:2;2039:13;;-1:-1:-1;;2035:27:1;2023:40;;2019:49;;2083:18;;;2103:22;;;2080:46;2077:2;;;2129:9;2077:2;2156;2149:22;2180:18;;;2217:11;;;2213:20;;2210:33;-1:-1:-1;2207:2:1;;;2261:6;2253;2246:22;2207:2;2322;2317;2313;2309:11;2304:2;2296:6;2292:15;2279:46;2367:6;2362:2;2357;2349:6;2345:15;2341:24;2334:40;2393:6;2383:16;;;;;;;1494:911;;;;;:::o;2410:477::-;;2491:5;2485:12;2518:6;2513:3;2506:19;2543:3;2555:162;2569:6;2566:1;2563:13;2555:162;;;2631:4;2687:13;;;2683:22;;2677:29;2659:11;;;2655:20;;2648:59;2584:12;2555:162;;;2735:6;2732:1;2729:13;2726:2;;;2801:3;2794:4;2785:6;2780:3;2776:16;2772:27;2765:40;2726:2;-1:-1:-1;2869:2:1;2848:15;-1:-1:-1;;2844:29:1;2835:39;;;;2876:4;2831:50;;2461:426;-1:-1:-1;;2461:426:1:o;2892:187::-;3057:14;;3050:22;3032:41;;3020:2;3005:18;;2987:92::o;3084:232::-;-1:-1:-1;;;;;3277:32:1;;;;3259:51;;3247:2;3232:18;;3214:102::o;3321:221::-;;3470:2;3459:9;3452:21;3490:46;3532:2;3521:9;3517:18;3509:6;3490:46;:::i;3547:354::-;3749:2;3731:21;;;3788:2;3768:18;;;3761:30;3827:32;3822:2;3807:18;;3800:60;3892:2;3877:18;;3721:180::o;3906:350::-;4108:2;4090:21;;;4147:2;4127:18;;;4120:30;4186:28;4181:2;4166:18;;4159:56;4247:2;4232:18;;4080:176::o;4261:397::-;4463:2;4445:21;;;4502:2;4482:18;;;4475:30;4541:34;4536:2;4521:18;;4514:62;-1:-1:-1;;;4607:2:1;4592:18;;4585:31;4648:3;4633:19;;4435:223::o;4663:490::-;4876:25;;;-1:-1:-1;;;;;4975:15:1;;;4970:2;4955:18;;4948:43;5027:15;;5022:2;5007:18;;5000:43;5079:3;5074:2;5059:18;;5052:31;;;4663:490;;5100:47;;5127:19;;5119:6;5100:47;:::i;:::-;5092:55;4866:287;-1:-1:-1;;;;;;4866:287:1:o

ipfs://b9a64c1b0d17ae0cacf7ada43d7769ca5a0ae7f26add57f4a3c7db1637bd39a0