Contract

0x6474cf672153a4EdCE26F788ed8820605d1F7125

Feature Tip: Add private address tag to any address under My Name Tag !

Source Code

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

Add

ContractCreator

0x49598E2F...97CE8f0bb at txn 0xacf69cd3ccf32fd7e1e918d0dd1855632594e41956feaa319272f0ac71ff1dbe

Multichain Info

$0 (Multichain Portfolio)

	Transaction Hash	Method	Block		From		To
There are no matching entries Please try again later

View more zero value Internal Transactions in Advanced View mode

Advanced mode:

Contract Source Code Verified (Exact Match)

Contract Name:

OptimizedReserveInterestRateStrategy

Compiler Version

v0.5.14+commit.01f1aaa4

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-10-21
*/

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.0;

/**
 * @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, 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");
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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-solidity/pull/522
        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. Reverts 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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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;
    }
}

// File: contracts/libraries/WadRayMath.sol

pragma solidity ^0.5.0;


/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/

library WadRayMath {
    using SafeMath for uint256;

    uint256 internal constant WAD = 1e18;
    uint256 internal constant halfWAD = WAD / 2;

    uint256 internal constant RAY = 1e27;
    uint256 internal constant halfRAY = RAY / 2;

    uint256 internal constant WAD_RAY_RATIO = 1e9;

    /**
    * @return one ray, 1e27
    **/
    function ray() internal pure returns (uint256) {
        return RAY;
    }

    /**
    * @return one wad, 1e18
    **/

    function wad() internal pure returns (uint256) {
        return WAD;
    }

    /**
    * @return half ray, 1e27/2
    **/
    function halfRay() internal pure returns (uint256) {
        return halfRAY;
    }

    /**
    * @return half ray, 1e18/2
    **/
    function halfWad() internal pure returns (uint256) {
        return halfWAD;
    }

    /**
    * @dev multiplies two wad, rounding half up to the nearest wad
    * @param a wad
    * @param b wad
    * @return the result of a*b, in wad
    **/
    function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
        return halfWAD.add(a.mul(b)).div(WAD);
    }

    /**
    * @dev divides two wad, rounding half up to the nearest wad
    * @param a wad
    * @param b wad
    * @return the result of a/b, in wad
    **/
    function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 halfB = b / 2;

        return halfB.add(a.mul(WAD)).div(b);
    }

    /**
    * @dev multiplies two ray, rounding half up to the nearest ray
    * @param a ray
    * @param b ray
    * @return the result of a*b, in ray
    **/
    function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
        return halfRAY.add(a.mul(b)).div(RAY);
    }

    /**
    * @dev divides two ray, rounding half up to the nearest ray
    * @param a ray
    * @param b ray
    * @return the result of a/b, in ray
    **/
    function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 halfB = b / 2;

        return halfB.add(a.mul(RAY)).div(b);
    }

    /**
    * @dev casts ray down to wad
    * @param a ray
    * @return a casted to wad, rounded half up to the nearest wad
    **/
    function rayToWad(uint256 a) internal pure returns (uint256) {
        uint256 halfRatio = WAD_RAY_RATIO / 2;

        return halfRatio.add(a).div(WAD_RAY_RATIO);
    }

    /**
    * @dev convert wad up to ray
    * @param a wad
    * @return a converted in ray
    **/
    function wadToRay(uint256 a) internal pure returns (uint256) {
        return a.mul(WAD_RAY_RATIO);
    }

    /**
    * @dev calculates base^exp. The code uses the ModExp precompile
    * @return base^exp, in ray
    */
    //solium-disable-next-line
    function rayPow(uint256 x, uint256 n) internal pure returns (uint256 z) {

        z = n % 2 != 0 ? x : RAY;

        for (n /= 2; n != 0; n /= 2) {
            x = rayMul(x, x);

            if (n % 2 != 0) {
                z = rayMul(z, x);
            }
        }
    }

}

// File: contracts/interfaces/IReserveInterestRateStrategy.sol

pragma solidity ^0.5.0;

/**
@title IReserveInterestRateStrategyInterface interface
@notice Interface for the calculation of the interest rates.
*/

interface IReserveInterestRateStrategy {

    /**
    * @dev returns the base variable borrow rate, in rays
    */
    function getBaseVariableBorrowRate() external view returns (uint256);

    /**
    * @dev calculates the liquidity, stable, and variable rates depending on the current utilization rate
    *      and the base parameters
    *
    */
    function calculateInterestRates(
        address _reserve,
        uint256 _utilizationRate,
        uint256 _totalBorrowsStable,
        uint256 _totalBorrowsVariable,
        uint256 _averageStableBorrowRate)
    external
    view
    returns (uint256 liquidityRate, uint256 stableBorrowRate, uint256 variableBorrowRate);
}

// File: contracts/interfaces/ILendingPoolAddressesProvider.sol

pragma solidity ^0.5.0;

/**
@title ILendingPoolAddressesProvider interface
@notice provides the interface to fetch the LendingPoolCore address
 */

contract ILendingPoolAddressesProvider {

    function getLendingPool() public view returns (address);
    function setLendingPoolImpl(address _pool) public;

    function getLendingPoolCore() public view returns (address payable);
    function setLendingPoolCoreImpl(address _lendingPoolCore) public;

    function getLendingPoolConfigurator() public view returns (address);
    function setLendingPoolConfiguratorImpl(address _configurator) public;

    function getLendingPoolDataProvider() public view returns (address);
    function setLendingPoolDataProviderImpl(address _provider) public;

    function getLendingPoolParametersProvider() public view returns (address);
    function setLendingPoolParametersProviderImpl(address _parametersProvider) public;

    function getTokenDistributor() public view returns (address);
    function setTokenDistributor(address _tokenDistributor) public;


    function getFeeProvider() public view returns (address);
    function setFeeProviderImpl(address _feeProvider) public;

    function getLendingPoolLiquidationManager() public view returns (address);
    function setLendingPoolLiquidationManager(address _manager) public;

    function getLendingPoolManager() public view returns (address);
    function setLendingPoolManager(address _lendingPoolManager) public;

    function getPriceOracle() public view returns (address);
    function setPriceOracle(address _priceOracle) public;

    function getLendingRateOracle() public view returns (address);
    function setLendingRateOracle(address _lendingRateOracle) public;

}

// File: contracts/interfaces/ILendingRateOracle.sol

pragma solidity ^0.5.0;

/**
* @title ILendingRateOracle interface
* @notice Interface for the Aave borrow rate oracle. Provides the average market borrow rate to be used as a base for the stable borrow rate calculations
**/

interface ILendingRateOracle {
    /**
    @dev returns the market borrow rate in ray
    **/
    function getMarketBorrowRate(address _asset) external view returns (uint256);

    /**
    @dev sets the market borrow rate. Rate value must be in ray
    **/
    function setMarketBorrowRate(address _asset, uint256 _rate) external;
}

// File: contracts/lendingpool/base/DoubleSlopeInterestRateStrategyBase.sol

pragma solidity ^0.5.0;






/**
* @title InterestRateStrategyBase contract
* @notice implements the base functions needed for the InterestRateStrategy contracts
* @author Aave
**/
contract DoubleSlopeInterestRateStrategyBase is IReserveInterestRateStrategy {
    using WadRayMath for uint256;
    using SafeMath for uint256;

    ILendingPoolAddressesProvider public addressesProvider;

    //base variable borrow rate when Utilization rate = 0. Expressed in ray
    uint256 internal baseVariableBorrowRate;

    //slope of the variable interest curve when utilization rate > 0 and <= OPTIMAL_UTILIZATION_RATE. Expressed in ray
    uint256 internal variableRateSlope1;

    //slope of the variable interest curve when utilization rate > OPTIMAL_UTILIZATION_RATE. Expressed in ray
    uint256 internal variableRateSlope2;

    //slope of the stable interest curve when utilization rate > 0 and <= OPTIMAL_UTILIZATION_RATE. Expressed in ray
    uint256 internal stableRateSlope1;

    //slope of the stable interest curve when utilization rate > OPTIMAL_UTILIZATION_RATE. Expressed in ray
    uint256 internal stableRateSlope2;

    constructor(
        ILendingPoolAddressesProvider _provider,
        uint256 _baseVariableBorrowRate,
        uint256 _variableRateSlope1,
        uint256 _variableRateSlope2,
        uint256 _stableRateSlope1,
        uint256 _stableRateSlope2
    ) public {
        addressesProvider = _provider;
        baseVariableBorrowRate = _baseVariableBorrowRate;
        variableRateSlope1 = _variableRateSlope1;
        variableRateSlope2 = _variableRateSlope2;
        stableRateSlope1 = _stableRateSlope1;
        stableRateSlope2 = _stableRateSlope2;
    }

    /**
    * @dev accessors
    */

    function getVariableRateSlope1() external view returns (uint256) {
        return variableRateSlope1;
    }

    function getVariableRateSlope2() external view returns (uint256) {
        return variableRateSlope2;
    }

    function getStableRateSlope1() external view returns (uint256) {
        return stableRateSlope1;
    }

    function getStableRateSlope2() external view returns (uint256) {
        return stableRateSlope2;
    }

    function getBaseVariableBorrowRate() external view returns (uint256) {
        return baseVariableBorrowRate;
    }

    /**
    * @dev calculates the liquidity, stable, and variable rates depending on the current utilization rate
    *      and the base parameters
    *
    */
    function calculateInterestRates(
        address _reserve,
        uint256 _utilizationRate,
        uint256 _totalBorrowsStable,
        uint256 _totalBorrowsVariable,
        uint256 _averageStableBorrowRate
    )
        external
        view
        returns (uint256 liquidityRate, uint256 stableBorrowRate, uint256 variableBorrowRate);

    /**
    * @dev calculates the interest rates depending on the available liquidity and the total borrowed.
    * @param _reserve the address of the reserve
    * @param _availableLiquidity the liquidity available in the reserve
    * @param _totalBorrowsStable the total borrowed from the reserve a stable rate
    * @param _totalBorrowsVariable the total borrowed from the reserve at a variable rate
    * @param _averageStableBorrowRate the weighted average of all the stable rate borrows
    * @param _optimalRatio the optimal target ratio after which slope 2 is used
    * @return the liquidity rate, stable borrow rate and variable borrow rate calculated from the input parameters
    **/
    function calculateInterestRatesInternal(
        address _reserve,
        uint256 _availableLiquidity,
        uint256 _totalBorrowsStable,
        uint256 _totalBorrowsVariable,
        uint256 _averageStableBorrowRate,
        uint256 _optimalRatio
    )
        internal
        view
        returns (
            uint256 currentLiquidityRate,
            uint256 currentStableBorrowRate,
            uint256 currentVariableBorrowRate
        )
    {
        uint256 excessRatio = WadRayMath.ray() - _optimalRatio;

        uint256 totalBorrows = _totalBorrowsStable.add(_totalBorrowsVariable);

        uint256 utilizationRate = (totalBorrows == 0 && _availableLiquidity == 0)
            ? 0
            : totalBorrows.rayDiv(_availableLiquidity.add(totalBorrows));

        currentStableBorrowRate = ILendingRateOracle(addressesProvider.getLendingRateOracle())
            .getMarketBorrowRate(_reserve);

        if (utilizationRate > _optimalRatio) {
            uint256 excessUtilizationRateRatio = utilizationRate.sub(_optimalRatio).rayDiv(
                excessRatio
            );

            currentStableBorrowRate = currentStableBorrowRate.add(stableRateSlope1).add(
                stableRateSlope2.rayMul(excessUtilizationRateRatio)
            );

            currentVariableBorrowRate = baseVariableBorrowRate.add(variableRateSlope1).add(
                variableRateSlope2.rayMul(excessUtilizationRateRatio)
            );
        } else {
            currentStableBorrowRate = currentStableBorrowRate.add(
                stableRateSlope1.rayMul(utilizationRate.rayDiv(_optimalRatio))
            );
            currentVariableBorrowRate = baseVariableBorrowRate.add(
                utilizationRate.rayDiv(_optimalRatio).rayMul(variableRateSlope1)
            );
        }

        currentLiquidityRate = getOverallBorrowRateInternal(
            _totalBorrowsStable,
            _totalBorrowsVariable,
            currentVariableBorrowRate,
            _averageStableBorrowRate
        )
            .rayMul(utilizationRate);

    }

    /**
    * @dev calculates the overall borrow rate as the weighted average between the total variable borrows and total stable borrows.
    * @param _totalBorrowsStable the total borrowed from the reserve a stable rate
    * @param _totalBorrowsVariable the total borrowed from the reserve at a variable rate
    * @param _currentVariableBorrowRate the current variable borrow rate
    * @param _currentAverageStableBorrowRate the weighted average of all the stable rate borrows
    * @return the weighted averaged borrow rate
    **/
    function getOverallBorrowRateInternal(
        uint256 _totalBorrowsStable,
        uint256 _totalBorrowsVariable,
        uint256 _currentVariableBorrowRate,
        uint256 _currentAverageStableBorrowRate
    ) internal pure returns (uint256) {
        uint256 totalBorrows = _totalBorrowsStable.add(_totalBorrowsVariable);

        if (totalBorrows == 0) return 0;

        uint256 weightedVariableRate = _totalBorrowsVariable.wadToRay().rayMul(
            _currentVariableBorrowRate
        );

        uint256 weightedStableRate = _totalBorrowsStable.wadToRay().rayMul(
            _currentAverageStableBorrowRate
        );

        uint256 overallBorrowRate = weightedVariableRate.add(weightedStableRate).rayDiv(
            totalBorrows.wadToRay()
        );

        return overallBorrowRate;
    }
}

// File: contracts/lendingpool/OptimizedReserveInterestRateStrategy.sol

pragma solidity ^0.5.0;



/**
* @title OptimizedReserveInterestRateStrategy contract
* @notice implements a double slope interest rate model with 91% optimal threshold.
* @author Aave
**/
contract OptimizedReserveInterestRateStrategy is DoubleSlopeInterestRateStrategyBase {
    /**
    * @dev this constant represents the utilization rate at which the pool aims to obtain most competitive borrow rates
    * expressed in ray
    **/
    uint256 public constant OPTIMAL_UTILIZATION_RATE = 0.65 * 1e27;

    constructor(
        ILendingPoolAddressesProvider _provider,
        uint256 _baseVariableBorrowRate,
        uint256 _variableRateSlope1,
        uint256 _variableRateSlope2,
        uint256 _stableRateSlope1,
        uint256 _stableRateSlope2
    )
        public
        DoubleSlopeInterestRateStrategyBase(
            _provider,
            _baseVariableBorrowRate,
            _variableRateSlope1,
            _variableRateSlope2,
            _stableRateSlope1,
            _stableRateSlope2
        )
    {}

    /**
    * @dev calculates the interest rates depending on the available liquidity and the total borrowed.
    * @param _reserve the address of the reserve
    * @param _availableLiquidity the liquidity available in the reserve
    * @param _totalBorrowsStable the total borrowed from the reserve a stable rate
    * @param _totalBorrowsVariable the total borrowed from the reserve at a variable rate
    * @param _averageStableBorrowRate the weighted average of all the stable rate borrows
    * @return the liquidity rate, stable borrow rate and variable borrow rate calculated from the input parameters
    **/
    function calculateInterestRates(
        address _reserve,
        uint256 _availableLiquidity,
        uint256 _totalBorrowsStable,
        uint256 _totalBorrowsVariable,
        uint256 _averageStableBorrowRate
    )
        external
        view
        returns (
            uint256 currentLiquidityRate,
            uint256 currentStableBorrowRate,
            uint256 currentVariableBorrowRate
        )
    {
        return
            super.calculateInterestRatesInternal(
                _reserve,
                _availableLiquidity,
                _totalBorrowsStable,
                _totalBorrowsVariable,
                _averageStableBorrowRate,
                OPTIMAL_UTILIZATION_RATE
            );
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"contract ILendingPoolAddressesProvider","name":"_provider","type":"address"},{"internalType":"uint256","name":"_baseVariableBorrowRate","type":"uint256"},{"internalType":"uint256","name":"_variableRateSlope1","type":"uint256"},{"internalType":"uint256","name":"_variableRateSlope2","type":"uint256"},{"internalType":"uint256","name":"_stableRateSlope1","type":"uint256"},{"internalType":"uint256","name":"_stableRateSlope2","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"constant":true,"inputs":[],"name":"OPTIMAL_UTILIZATION_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"addressesProvider","outputs":[{"internalType":"contract ILendingPoolAddressesProvider","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_reserve","type":"address"},{"internalType":"uint256","name":"_availableLiquidity","type":"uint256"},{"internalType":"uint256","name":"_totalBorrowsStable","type":"uint256"},{"internalType":"uint256","name":"_totalBorrowsVariable","type":"uint256"},{"internalType":"uint256","name":"_averageStableBorrowRate","type":"uint256"}],"name":"calculateInterestRates","outputs":[{"internalType":"uint256","name":"currentLiquidityRate","type":"uint256"},{"internalType":"uint256","name":"currentStableBorrowRate","type":"uint256"},{"internalType":"uint256","name":"currentVariableBorrowRate","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getBaseVariableBorrowRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getStableRateSlope1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getStableRateSlope2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getVariableRateSlope1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getVariableRateSlope2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

608060405234801561001057600080fd5b506040516107bb3803806107bb833981810160405260c081101561003357600080fd5b508051602082015160408301516060840151608085015160a090950151600080546001600160a01b039096166001600160a01b031990961695909517909455600192909255600255600355600491909155600555610725806100966000396000f3fe608060405234801561001057600080fd5b50600436106100885760003560e01c8063a15f30ac1161005b578063a15f30ac14610113578063c72c4d101461011b578063d5cd73911461013f578063f42024091461014757610088565b80630b3429a21461008d57806314e32da4146100a757806334762ca5146100af57806357e37af0146100b7575b600080fd5b61009561014f565b60408051918252519081900360200190f35b610095610155565b61009561015b565b6100f5600480360360a08110156100cd57600080fd5b506001600160a01b038135169060208101359060408101359060608101359060800135610161565b60408051938452602084019290925282820152519081900360600190f35b610095610191565b6101236101a1565b604080516001600160a01b039092168252519081900360200190f35b6100956101b0565b6100956101b6565b60025490565b60055490565b60015490565b600080600061018088888888886b0219aada9b14535aca0000006101bc565b925092509250955095509592505050565b6b0219aada9b14535aca00000081565b6000546001600160a01b031681565b60045490565b60035490565b600080600080846101cb610439565b03905060006101e0898963ffffffff61044916565b90506000811580156101f057508a155b610219576102146102078c8463ffffffff61044916565b839063ffffffff6104ac16565b61021c565b60005b90506000809054906101000a90046001600160a01b03166001600160a01b0316633618abba6040518163ffffffff1660e01b815260040160206040518083038186803b15801561026b57600080fd5b505afa15801561027f573d6000803e3d6000fd5b505050506040513d602081101561029557600080fd5b50516040805163bb85c0bb60e01b81526001600160a01b038f811660048301529151919092169163bb85c0bb916024808301926020929190829003018186803b1580156102e157600080fd5b505afa1580156102f5573d6000803e3d6000fd5b505050506040513d602081101561030b57600080fd5b50519450868111156103aa5760006103398461032d848b63ffffffff6104f016565b9063ffffffff6104ac16565b90506103736103538260055461054d90919063ffffffff16565b60045461036790899063ffffffff61044916565b9063ffffffff61044916565b95506103a261038d8260035461054d90919063ffffffff16565b6002546001546103679163ffffffff61044916565b945050610418565b6103dc6103cf6103c0838a63ffffffff6104ac16565b6004549063ffffffff61054d16565b869063ffffffff61044916565b94506104156104066002546103fa8a856104ac90919063ffffffff16565b9063ffffffff61054d16565b6001549063ffffffff61044916565b93505b610428816103fa8c8c888d610585565b955050505096509650969350505050565b6b033b2e3c9fd0803ce800000090565b6000828201838110156104a3576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b90505b92915050565b6000600282046104e8836104dc6104cf876b033b2e3c9fd0803ce80000006105f6565b849063ffffffff61044916565b9063ffffffff61064f16565b949350505050565b600082821115610547576040805162461bcd60e51b815260206004820152601e60248201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604482015290519081900360640190fd5b50900390565b60006104a36b033b2e3c9fd0803ce80000006104dc610572868663ffffffff6105f616565b6b019d971e4fe8401e7400000090610449565b600080610598868663ffffffff61044916565b9050806105a95760009150506104e8565b60006105b8856103fa886106b9565b905060006105c9856103fa8a6106b9565b905060006105e96105d9856106b9565b61032d858563ffffffff61044916565b9998505050505050505050565b600082610605575060006104a6565b8282028284828161061257fe5b04146104a35760405162461bcd60e51b81526004018080602001828103825260218152602001806106d06021913960400191505060405180910390fd5b60008082116106a5576040805162461bcd60e51b815260206004820152601a60248201527f536166654d6174683a206469766973696f6e206279207a65726f000000000000604482015290519081900360640190fd5b60008284816106b057fe5b04949350505050565b60006104a682633b9aca0063ffffffff6105f61656fe536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77a265627a7a7231582049fbf8e627c5a782b1a2b2e4a9bd1a2092f4004ea9cb4bc710284be87eacce1664736f6c634300050e003200000000000000000000000024a42fd28c976a61df5d00d0599c34c4f90748c80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000422ca8b0a00a42500000000000000000000000000000000000000000000000033b2e3c9fd0803ce800000000000000000000000000000000000000000000000052b7d2dcc80cd2e40000000000000000000000000000000000000000000000033b2e3c9fd0803ce8000000

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000024a42fd28c976a61df5d00d0599c34c4f90748c80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000422ca8b0a00a42500000000000000000000000000000000000000000000000033b2e3c9fd0803ce800000000000000000000000000000000000000000000000052b7d2dcc80cd2e40000000000000000000000000000000000000000000000033b2e3c9fd0803ce8000000

-----Decoded View---------------
Arg [0] : _provider (address): 0x24a42fD28C976A61Df5D00D0599C34c4f90748c8
Arg [1] : _baseVariableBorrowRate (uint256): 0
Arg [2] : _variableRateSlope1 (uint256): 80000000000000000000000000
Arg [3] : _variableRateSlope2 (uint256): 1000000000000000000000000000
Arg [4] : _stableRateSlope1 (uint256): 100000000000000000000000000
Arg [5] : _stableRateSlope2 (uint256): 1000000000000000000000000000

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 00000000000000000000000024a42fd28c976a61df5d00d0599c34c4f90748c8
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 000000000000000000000000000000000000000000422ca8b0a00a4250000000
Arg [3] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Arg [4] : 00000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
Arg [5] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000

Deployed Bytecode Sourcemap

17915:2244:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17915:2244:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12320:109;;;:::i;:::-;;;;;;;;;;;;;;;;12667:105;;;:::i;12780:117::-;;;:::i;19407:747::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;19407:747:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18170:62;;;:::i;10884:54::-;;;:::i;:::-;;;;-1:-1:-1;;;;;10884:54:0;;;;;;;;;;;;;;12554:105;;;:::i;12437:109::-;;;:::i;12320:::-;12403:18;;12320:109;:::o;12667:105::-;12748:16;;12667:105;:::o;12780:117::-;12867:22;;12780:117;:::o;19407:747::-;19696:28;19739:31;19785:33;19866:280;19921:8;19948:19;19986;20024:21;20064:24;18221:11;19866:36;:280::i;:::-;19846:300;;;;;;19407:747;;;;;;;;;:::o;18170:62::-;18221:11;18170:62;:::o;10884:54::-;;;-1:-1:-1;;;;;10884:54:0;;:::o;12554:105::-;12635:16;;12554:105;:::o;12437:109::-;12520:18;;12437:109;:::o;14136:2114::-;14465:28;14508:31;14554:33;14615:19;14656:13;14637:16;:14;:16::i;:::-;:32;;-1:-1:-1;14682:20:0;14705:46;:19;14729:21;14705:46;:23;:46;:::i;:::-;14682:69;-1:-1:-1;14764:23:0;14791:17;;:45;;;;-1:-1:-1;14812:24:0;;14791:45;14790:138;;14870:58;14890:37;:19;14914:12;14890:37;:23;:37;:::i;:::-;14870:12;;:58;:19;:58;:::i;:::-;14790:138;;;14853:1;14790:138;14764:164;;14986:17;;;;;;;;;-1:-1:-1;;;;;14986:17:0;-1:-1:-1;;;;;14986:38:0;;:40;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14986:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14986:40:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14986:40:0;14967:104;;;-1:-1:-1;;;14967:104:0;;-1:-1:-1;;;;;14967:104:0;;;;;;;;;:94;;;;;;;:104;;;;;14986:40;;14967:104;;;;;;;:94;:104;;;5:2:-1;;;;30:1;27;20:12;5:2;14967:104:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14967:104:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14967:104:0;;-1:-1:-1;15088:31:0;;;15084:895;;;15136:34;15173:86;15233:11;15173:34;:15;15193:13;15173:34;:19;:34;:::i;:::-;:41;:86;:41;:86;:::i;:::-;15136:123;;15302:134;15370:51;15394:26;15370:16;;:23;;:51;;;;:::i;:::-;15330:16;;15302:45;;:23;;:45;:27;:45;:::i;:::-;:49;:134;:49;:134;:::i;:::-;15276:160;;15481:137;15550:53;15576:26;15550:18;;:25;;:53;;;;:::i;:::-;15508:18;;15481:22;;:46;;;:26;:46;:::i;:137::-;15453:165;;15084:895;;;;15677:123;15723:62;15747:37;:15;15770:13;15747:37;:22;:37;:::i;:::-;15723:16;;;:62;:23;:62;:::i;:::-;15677:23;;:123;:27;:123;:::i;:::-;15651:149;;15843:124;15888:64;15933:18;;15888:37;15911:13;15888:15;:22;;:37;;;;:::i;:::-;:44;:64;:44;:64;:::i;:::-;15843:22;;;:124;:26;:124;:::i;:::-;15815:152;;15084:895;16014:226;16224:15;16014:188;16057:19;16091:21;16127:25;16167:24;16014:28;:188::i;:226::-;15991:249;;14136:2114;;;;;;;;;;;;;:::o;4309:76::-;4145:4;4309:76;:::o;921:181::-;979:7;1011:5;;;1035:6;;;;1027:46;;;;;-1:-1:-1;;;1027:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1093:1;-1:-1:-1;921:181:0;;;;;:::o;5906:158::-;5967:7;6007:1;6003:5;;6028:28;6003:1;6028:21;6038:10;:1;4145:4;6038:5;:10::i;:::-;6028:5;;:21;:9;:21;:::i;:::-;:25;:28;:25;:28;:::i;:::-;6021:35;5906:158;-1:-1:-1;;;;5906:158:0:o;1377:184::-;1435:7;1468:1;1463;:6;;1455:49;;;;;-1:-1:-1;;;1455:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1527:5:0;;;1377:184::o;5608:126::-;5669:7;5696:30;4145:4;5696:21;5708:8;:1;5714;5708:8;:5;:8;:::i;:::-;4192:7;;5696:11;:21::i;16804:831::-;17045:7;;17088:46;:19;17112:21;17088:46;:23;:46;:::i;:::-;17065:69;-1:-1:-1;17151:17:0;17147:31;;17177:1;17170:8;;;;;17147:31;17191:28;17222:91;17276:26;17222:32;:21;:30;:32::i;:91::-;17191:122;;17326:26;17355:94;17407:31;17355:30;:19;:28;:30::i;:94::-;17326:123;;17462:25;17490:100;17556:23;:12;:21;:23::i;:::-;17490:44;:20;17515:18;17490:44;:24;:44;:::i;:100::-;17462:128;16804:831;-1:-1:-1;;;;;;;;;16804:831:0:o;1812:470::-;1870:7;2114:6;2110:47;;-1:-1:-1;2144:1:0;2137:8;;2110:47;2181:5;;;2185:1;2181;:5;:1;2205:5;;;;;:10;2197:56;;;;-1:-1:-1;;;2197:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2750:333;2808:7;2907:1;2903;:5;2895:44;;;;;-1:-1:-1;;;2895:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;2950:9;2966:1;2962;:5;;;;;;;2750:333;-1:-1:-1;;;;2750:333:0:o;6497:107::-;6549:7;6576:20;:1;4250:3;6576:20;:5;:20;:::i

Swarm Source

bzzr://49fbf8e627c5a782b1a2b2e4a9bd1a2092f4004ea9cb4bc710284be87eacce16

Block		Transaction	Difficulty	Gas Used	Reward

View All Blocks Produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 30 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.

Tools & Services