Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.19;

import "./InterestRateModel.sol";
import "../SafeMath.sol";

/**
 * @title Moonwell's JumpRateModel Contract
 * @author Compound
 * @author Moonwell
 */
contract JumpRateModel is InterestRateModel {
    using SafeMath for uint;

    event NewInterestParams(
        uint baseRatePerTimestamp,
        uint multiplierPerTimestamp,
        uint jumpMultiplierPerTimestamp,
        uint kink
    );

    /**
     * @notice The approximate number of timestamps per year that is assumed by the interest rate model
     */
    uint public constant timestampsPerYear = 60 * 60 * 24 * 365;

    /**
     * @notice The multiplier of utilization rate that gives the slope of the interest rate
     */
    uint public multiplierPerTimestamp;

    /**
     * @notice The base interest rate which is the y-intercept when utilization rate is 0
     */
    uint public baseRatePerTimestamp;

    /**
     * @notice The multiplierPerTimestamp after hitting a specified utilization point
     */
    uint public jumpMultiplierPerTimestamp;

    /**
     * @notice The utilization point at which the jump multiplier is applied
     */
    uint public kink;

    /// @dev we know that we do not need to use safemath, however safemath is still used for safety
    /// and to not modify existing code.

    /**
     * @notice Construct an interest rate model
     * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by 1e18)
     * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by 1e18)
     * @param jumpMultiplierPerYear The multiplierPerTimestamp after hitting a specified utilization point
     * @param kink_ The utilization point at which the jump multiplier is applied
     */
    constructor(
        uint baseRatePerYear,
        uint multiplierPerYear,
        uint jumpMultiplierPerYear,
        uint kink_
    ) {
        baseRatePerTimestamp = baseRatePerYear
            .mul(1e18)
            .div(timestampsPerYear)
            .div(1e18);
        multiplierPerTimestamp = multiplierPerYear
            .mul(1e18)
            .div(timestampsPerYear)
            .div(1e18);
        jumpMultiplierPerTimestamp = jumpMultiplierPerYear
            .mul(1e18)
            .div(timestampsPerYear)
            .div(1e18);
        kink = kink_;

        emit NewInterestParams(
            baseRatePerTimestamp,
            multiplierPerTimestamp,
            jumpMultiplierPerTimestamp,
            kink
        );
    }

    /**
     * @notice Calculates the utilization rate of the market: `borrows / (cash + borrows - reserves)`
     * @param cash The amount of cash in the market
     * @param borrows The amount of borrows in the market
     * @param reserves The amount of reserves in the market (currently unused)
     * @return The utilization rate as a mantissa between [0, 1e18]
     */
    function utilizationRate(
        uint cash,
        uint borrows,
        uint reserves
    ) public pure returns (uint) {
        // Utilization rate is 0 when there are no borrows
        if (borrows == 0) {
            return 0;
        }

        return borrows.mul(1e18).div(cash.add(borrows).sub(reserves));
    }

    /**
     * @notice Calculates the current borrow rate per timestamp, with the error code expected by the market
     * @param cash The amount of cash in the market
     * @param borrows The amount of borrows in the market
     * @param reserves The amount of reserves in the market
     * @return The borrow rate percentage per timestamp as a mantissa (scaled by 1e18)
     */
    function getBorrowRate(
        uint cash,
        uint borrows,
        uint reserves
    ) public view override returns (uint) {
        uint util = utilizationRate(cash, borrows, reserves);

        if (util <= kink) {
            return
                util.mul(multiplierPerTimestamp).div(1e18).add(
                    baseRatePerTimestamp
                );
        } else {
            uint normalRate = kink.mul(multiplierPerTimestamp).div(1e18).add(
                baseRatePerTimestamp
            );
            uint excessUtil = util.sub(kink);
            return
                excessUtil.mul(jumpMultiplierPerTimestamp).div(1e18).add(
                    normalRate
                );
        }
    }

    /**
     * @notice Calculates the current supply rate per timestamp
     * @param cash The amount of cash in the market
     * @param borrows The amount of borrows in the market
     * @param reserves The amount of reserves in the market
     * @param reserveFactorMantissa The current reserve factor for the market
     * @return The supply rate percentage per timestamp as a mantissa (scaled by 1e18)
     */
    function getSupplyRate(
        uint cash,
        uint borrows,
        uint reserves,
        uint reserveFactorMantissa
    ) public view override returns (uint) {
        uint oneMinusReserveFactor = uint(1e18).sub(reserveFactorMantissa);
        uint borrowRate = getBorrowRate(cash, borrows, reserves);
        uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(1e18);
        return
            utilizationRate(cash, borrows, reserves).mul(rateToPool).div(1e18);
    }
}

// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.19;

/**
 * @title Moonwell's InterestRateModel Interface
 * @author Moonwell
 */
abstract contract InterestRateModel {
    /// @notice Indicator that this is an InterestRateModel contract (for inspection)
    bool public constant isInterestRateModel = true;

    /**
     * @notice Calculates the current borrow interest rate per timestamp
     * @param cash The total amount of cash the market has
     * @param borrows The total amount of borrows the market has outstanding
     * @param reserves The total amount of reserves the market has
     * @return The borrow rate per timestamp (as a percentage, and scaled by 1e18)
     */
    function getBorrowRate(
        uint cash,
        uint borrows,
        uint reserves
    ) external view virtual returns (uint);

    /**
     * @notice Calculates the current supply interest rate per timestamp
     * @param cash The total amount of cash the market has
     * @param borrows The total amount of borrows the market has outstanding
     * @param reserves The total amount of reserves the market has
     * @param reserveFactorMantissa The current reserve factor the market has
     * @return The supply rate per timestamp (as a percentage, and scaled by 1e18)
     */
    function getSupplyRate(
        uint cash,
        uint borrows,
        uint reserves,
        uint reserveFactorMantissa
    ) external view virtual returns (uint);
}

// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.19;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @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 addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        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-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        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,
        string memory errorMessage
    ) 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, errorMessage);

        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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers.
     * Reverts with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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;
    }

    /**
     * @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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

{
  "remappings": [
    "@forge-std/=lib/forge-std/src/",
    "@openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "@openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "@wormhole/=lib/wormhole/ethereum/contracts/",
    "@protocol/=src/",
    "@test/=test/",
    "@proposals/=src/proposals/",
    "@utils/=src/utils/",
    "@zelt/=lib/zelt/",
    "@zelt-src/=lib/zelt/src/",
    "@zelt-test/=lib/zelt/test/",
    "ds-test/=lib/solmate/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "solmate/=lib/solmate/src/",
    "wormhole/=lib/wormhole/",
    "zelt/=lib/zelt/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"baseRatePerYear","type":"uint256"},{"internalType":"uint256","name":"multiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"jumpMultiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"kink_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"baseRatePerTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"multiplierPerTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"jumpMultiplierPerTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"kink","type":"uint256"}],"name":"NewInterestParams","type":"event"},{"inputs":[],"name":"baseRatePerTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"borrows","type":"uint256"},{"internalType":"uint256","name":"reserves","type":"uint256"}],"name":"getBorrowRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"borrows","type":"uint256"},{"internalType":"uint256","name":"reserves","type":"uint256"},{"internalType":"uint256","name":"reserveFactorMantissa","type":"uint256"}],"name":"getSupplyRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isInterestRateModel","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jumpMultiplierPerTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kink","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiplierPerTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timestampsPerYear","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"borrows","type":"uint256"},{"internalType":"uint256","name":"reserves","type":"uint256"}],"name":"utilizationRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010a741a4627800000000000000000000000000000000000000000000000000022b1c8c1227a00000000000000000000000000000000000000000000000000000b1a2bc2ec500000

-----Decoded View---------------
Arg [0] : baseRatePerYear (uint256): 0
Arg [1] : multiplierPerYear (uint256): 75000000000000000
Arg [2] : jumpMultiplierPerYear (uint256): 2500000000000000000
Arg [3] : kink_ (uint256): 800000000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 000000000000000000000000000000000000000000000000010a741a46278000
Arg [2] : 00000000000000000000000000000000000000000000000022b1c8c1227a0000
Arg [3] : 0000000000000000000000000000000000000000000000000b1a2bc2ec500000