Contract 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e52 1

Contract Overview

Balance:
0 BNB
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xdea174b11ba65d4885403472b6234fcf065bf0580df2dd3ab04d5be1690a715f0x6080604071041812021-03-15 8:40:32188 days 17 hrs ago0x815e1cf12985574d067000e469e96cc30072cfbf IN  Contract Creation0 BNB0.00760077
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x040059700b4114bb1b4f3523e41e9a60f6fdfbf49477fb2cdd36ed8dd8b24d7e117507892021-08-24 6:32:5226 days 19 hrs ago 0xbeb4609cc2a34ec46fc285507cc99778f417c6af 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xc41417c31aa0c052d4988df776f54bcf41e5dcea847a5684ee96178b4634a76f114099722021-08-12 8:23:3338 days 17 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xb6282c04bd203fa7b2283c5fb9d1c2cd3f01c6184c7edbd25a52393fc88a8e5d114099302021-08-12 8:21:2738 days 17 hrs ago 0x27ba86cbfa67980ba72c492906db04fb4cfdf8e8 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x6aadac467076396d08ac1e9e70bbeed5e68002f44ceed69d3f53217d277bc19f114098052021-08-12 8:15:1238 days 17 hrs ago 0x27ba86cbfa67980ba72c492906db04fb4cfdf8e8 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x3ee21b6ac68c372d41575a9354089051b48f47410e3dddc2a7b4726437faedd3114095562021-08-12 8:02:4538 days 18 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x96adec44a6d9902f65b1b77cf5f3a7bc6ccadc6dd994497db27371ba1a4accde114092842021-08-12 7:49:0938 days 18 hrs ago 0xbeb4609cc2a34ec46fc285507cc99778f417c6af 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x3d7201b7ced054e13074f917419bd9eed93bd5045de9161b85a35ac1406e6094114027092021-08-12 2:20:2438 days 23 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xe21ddfda527580fa23ab05b5dd59429e1222f4fbe7b88b0e84cd5879d486a36098051902021-06-17 6:55:1094 days 19 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x46c0b611f394a1450e33174f06e27b14522a57139249ab24548838bda9a5ebbc98051312021-06-17 6:52:1394 days 19 hrs ago 0xbeb4609cc2a34ec46fc285507cc99778f417c6af 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xd5a55f503d79afdf1959b68e26118b023d8e2dfcee1554b7291df9ad60c8f96798051212021-06-17 6:51:4394 days 19 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xc8ddaf0324b1e3703511d95072b2d03e973511ad622e264f20ad40e83cfc9a0398051052021-06-17 6:50:5594 days 19 hrs ago 0x27ba86cbfa67980ba72c492906db04fb4cfdf8e8 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x0d9327e77e8879c556866b6776a924b9cfcc9b0f74de27fdd4fa7f91d9faf62298048752021-06-17 6:39:2594 days 19 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x76ff4f15d4b4935297da47f949da6c3de747fdbdaa9a6794d2cc81a6c7b7eded89681152021-05-19 4:00:13123 days 22 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xc737362131fc317328aa2f3e82df94343e270e723a791c4dc55dffa371e4f06a89623922021-05-18 23:11:29124 days 2 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x46afc47969af42c4b76d3d027673a0dd0243b5967a069bfa563d71afcd1ceab589509882021-05-18 13:41:17124 days 12 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x93a0325b388208ec58bbc4be8d2fd258d1e8d86a12a437809b7424faec9f450089451992021-05-18 8:51:50124 days 17 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x1bb2fe67502ef86bd4fd11dd832a50c0fbf2e4c8be58f73f6f58c4e4854a14d989384782021-05-18 3:15:47124 days 22 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x84a74c761132325b7671daa8edb4c945af3820148592b4964e5870f401df08c289382082021-05-18 3:02:17124 days 23 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x6c470c307ae98b8ee2870a78b495420307ae7b260d80c1f9b50f1be321fbc47a89186902021-05-17 10:46:17125 days 15 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xaf57b50a61077c75ec43c88c8e8c9b309ca799fcd73804e7c193bbd81c91383c89185772021-05-17 10:40:38125 days 15 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xbb5c01cedf09cabf3daa02a02dc9f00829011975931b1f01ea61b387ec96a93189181592021-05-17 10:19:44125 days 15 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x72a4521c2714d591c1194d37bbaa8bc06a8845e5df535991d096f66529f464ab89110452021-05-17 4:24:02125 days 21 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x0be76509ae8b1467254b46f0e82946fec12fa60c04e173233c2f264a5ae2c1b589108092021-05-17 4:12:14125 days 21 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0x645ec5c8772033ad99dc2eb49a4f06d105dd0c44c9189f7b0d9006cb19797f6f89107582021-05-17 4:09:41125 days 21 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
0xb0d14121eb1a378f092d94b16f05506f8e5ab33e9345b81d30cdff66de88f1e789107222021-05-17 4:07:53125 days 21 hrs ago 0xfd92377e20cbc5f92f7b12a74e09f009144d2af2 0x4630a19af7b8a5b82aca6cc0a0eb4eb6ab6c2e520 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
JumpRateModel

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-24
*/

pragma solidity ^0.6.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.
 */

// SPDX-License-Identifier: MIT
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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * 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);
        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 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;
    }
}

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract ContextUpgradeSafe is Initializable {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {


    }


    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }

    uint256[50] private __gap;
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */

    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {


        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);

    }


    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    uint256[49] private __gap;
}

// https://github.com/compound-finance/compound-protocol/blob/master/contracts/InterestRateModel.sol
//Copyright 2020 Compound Labs, Inc.
//Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
//1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
//2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
//3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

/**
  * @title wepiggy's IInterestRateModel Interface
  * @author wepiggy
  */
interface IInterestRateModel {
    /**
      * @notice Calculates the current borrow interest rate per block
      * @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 block (as a percentage, and scaled by 1e18)
      */
    function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint);

    /**
      * @notice Calculates the current supply interest rate per block
      * @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 block (as a percentage, and scaled by 1e18)
      */
    function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external view returns (uint);

}

// COPIED FROM https://github.com/compound-finance/compound-protocol/blob/master/contracts/BaseJumpRateModelV2.sol
//Copyright 2020 Compound Labs, Inc.
//Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
//1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
//2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
//3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

/**
  * @title Logic for Compound's JumpRateModel Contract V2.
  * @author Compound (modified by Dharma Labs, refactored by Arr00)
  * @notice Version 2 modifies Version 1 by enabling updateable parameters.
  */
contract BaseJumpRateModel is IInterestRateModel, OwnableUpgradeSafe {
    using SafeMath for uint;

    event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock, uint jumpMultiplierPerBlock, uint kink);

    /**
     * @notice The approximate number of blocks per year that is assumed by the interest rate model
     */
    uint public constant blocksPerYear = 10512000;

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

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

    /**
     * @notice The multiplierPerBlock after hitting a specified utilization point
     */
    uint public jumpMultiplierPerBlock;

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

    /**
     * @notice Update the parameters of the interest rate model (only callable by owner, i.e. Timelock)
     * @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 multiplierPerBlock after hitting a specified utilization point
     * @param kink_ The utilization point at which the jump multiplier is applied
     */
    function updateJumpRateModel(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) external {
        updateJumpRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, 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 block, 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 block as a mantissa (scaled by 1e18)
     */
    function getBorrowRateInternal(uint cash, uint borrows, uint reserves) internal view returns (uint) {
        uint util = utilizationRate(cash, borrows, reserves);

        if (util <= kink) {
            return util.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
        } else {
            uint normalRate = kink.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
            uint excessUtil = util.sub(kink);
            return excessUtil.mul(jumpMultiplierPerBlock).div(1e18).add(normalRate);
        }
    }

    /**
     * @notice Calculates the current borrow rate per block
     * @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 block as a mantissa (scaled by 1e18)
     */
    function getBorrowRate(uint cash, uint borrows, uint reserves) external virtual override view returns (uint) {
        return getBorrowRateInternal(cash, borrows, reserves);
    }


    function getSupplyRateInternal(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) internal view returns (uint) {
        uint oneMinusReserveFactor = uint(1e18).sub(reserveFactorMantissa);
        uint borrowRate = getBorrowRateInternal(cash, borrows, reserves);
        uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(1e18);
        return utilizationRate(cash, borrows, reserves).mul(rateToPool).div(1e18);
    }
    /**
     * @notice Calculates the current supply rate per block
     * @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 block as a mantissa (scaled by 1e18)
     */
    function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external virtual override view returns (uint) {
        return getSupplyRateInternal(cash, borrows, reserves, reserveFactorMantissa);
    }

    /**
     * @notice Internal function to update the parameters of the 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 multiplierPerBlock after hitting a specified utilization point
     * @param kink_ The utilization point at which the jump multiplier is applied
     */
    function updateJumpRateModelInternal(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) internal onlyOwner {
        baseRatePerBlock = baseRatePerYear.div(blocksPerYear);
        multiplierPerBlock = (multiplierPerYear.mul(1e18)).div(blocksPerYear.mul(kink_));
        jumpMultiplierPerBlock = jumpMultiplierPerYear.div(blocksPerYear);
        kink = kink_;

        emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink);
    }
}


/**
  * @title Compound's JumpRateModel Contract V2 for V2 cTokens
  * @author Arr00
  * @notice Supports only for V2 cTokens
  */
contract JumpRateModel is BaseJumpRateModel {

    function initialize(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) public initializer {
        super.__Ownable_init();
        super.updateJumpRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
    }
}

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"baseRatePerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"multiplierPerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"jumpMultiplierPerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"kink","type":"uint256"}],"name":"NewInterestParams","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"baseRatePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"blocksPerYear","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":[{"internalType":"uint256","name":"baseRatePerYear","type":"uint256"},{"internalType":"uint256","name":"multiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"jumpMultiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"kink_","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"jumpMultiplierPerBlock","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":"multiplierPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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"}],"name":"updateJumpRateModel","outputs":[],"stateMutability":"nonpayable","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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

Deployed ByteCode Sourcemap

21838:332:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19396:181;;;;;;;;;;;;;;;;-1:-1:-1;19396:181:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;17202:236;;;;;;;;;;;;;;;;-1:-1:-1;17202:236:0;;;;;;;;;;;;;;;;;:::i;:::-;;21891:276;;;;;;;;;;;;;;;;-1:-1:-1;21891:276:0;;;;;;;;;;;;;;;;;:::i;17828:297::-;;;;;;;;;;;;;;;;-1:-1:-1;17828:297:0;;;;;;;;;;;;:::i;10562:148::-;;;:::i;16243:30::-;;;:::i;9920:79::-;;;:::i;:::-;;;;-1:-1:-1;;;;;9920:79:0;;;;;;;;;;;;;;16078:45;;;:::i;20456:232::-;;;;;;;;;;;;;;;;-1:-1:-1;20456:232:0;;;;;;;;;;;;;;;;;:::i;16529:34::-;;;:::i;16391:28::-;;;:::i;10865:244::-;;;;;;;;;;;;;;;;-1:-1:-1;10865:244:0;-1:-1:-1;;;;;10865:244:0;;:::i;16668:16::-;;;:::i;19396:181::-;19499:4;19523:46;19545:4;19551:7;19560:8;19523:21;:46::i;:::-;19516:53;;19396:181;;;;;;:::o;17202:236::-;17337:93;17365:15;17382:17;17401:21;17424:5;17337:27;:93::i;:::-;17202:236;;;;:::o;21891:276::-;6384:12;;;;;;;;:31;;;6400:15;:13;:15::i;:::-;6384:47;;;-1:-1:-1;6420:11:0;;;;6419:12;6384:47;6376:106;;;;-1:-1:-1;;;6376:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6491:19;6514:12;;;;;;6513:13;6533:83;;;;6562:12;:19;;-1:-1:-1;;;;6562:19:0;;;;;6590:18;6577:4;6590:18;;;6533:83;22027:22:::1;:20;:22::i;:::-;22060:99;22094:15;22111:17;22130:21;22153:5;22060:33;:99::i;:::-;6638:14:::0;6634:57;;;6678:5;6663:20;;-1:-1:-1;;6663:20:0;;;6634:57;21891:276;;;;;:::o;17828:297::-;17914:4;17995:12;17991:53;;-1:-1:-1;18031:1:0;18024:8;;17991:53;18063:54;18085:31;18107:8;18085:17;:4;18094:7;18085:8;:17::i;:::-;:21;;:31::i;:::-;18063:17;:7;18075:4;18063:11;:17::i;:::-;:21;;:54::i;10562:148::-;10142:12;:10;:12::i;:::-;10132:6;;-1:-1:-1;;;;;10132:6:0;;;:22;;;10124:67;;;;;-1:-1:-1;;;10124:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10653:6:::1;::::0;10632:40:::1;::::0;10669:1:::1;::::0;-1:-1:-1;;;;;10653:6:0::1;::::0;10632:40:::1;::::0;10669:1;;10632:40:::1;10683:6;:19:::0;;-1:-1:-1;;;;;;10683:19:0::1;::::0;;10562:148::o;16243:30::-;;;;:::o;9920:79::-;9985:6;;-1:-1:-1;;;;;9985:6:0;9920:79;:::o;16078:45::-;16115:8;16078:45;:::o;20456:232::-;20587:4;20611:69;20633:4;20639:7;20648:8;20658:21;20611;:69::i;:::-;20604:76;20456:232;-1:-1:-1;;;;;20456:232:0:o;16529:34::-;;;;:::o;16391:28::-;;;;:::o;10865:244::-;10142:12;:10;:12::i;:::-;10132:6;;-1:-1:-1;;;;;10132:6:0;;;:22;;;10124:67;;;;;-1:-1:-1;;;10124:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10954:22:0;::::1;10946:73;;;;-1:-1:-1::0;;;10946:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11056:6;::::0;11035:38:::1;::::0;-1:-1:-1;;;;;11035:38:0;;::::1;::::0;11056:6:::1;::::0;11035:38:::1;::::0;11056:6:::1;::::0;11035:38:::1;11084:6;:17:::0;;-1:-1:-1;;;;;;11084:17:0::1;-1:-1:-1::0;;;;;11084:17:0;;;::::1;::::0;;;::::1;::::0;;10865:244::o;16668:16::-;;;;:::o;18513:539::-;18607:4;18624:9;18636:40;18652:4;18658:7;18667:8;18636:15;:40::i;:::-;18624:52;;18701:4;;18693;:12;18689:356;;18729:60;18772:16;;18729:38;18762:4;18729:28;18738:18;;18729:4;:8;;:28;;;;:::i;:38::-;:42;;:60::i;:::-;18722:67;;;;;18689:356;18822:15;18840:60;18883:16;;18840:38;18873:4;18840:28;18849:18;;18840:4;;:8;;:28;;;;:::i;:60::-;18822:78;;18915:15;18933:14;18942:4;;18933;:8;;:14;;;;:::i;:::-;18915:32;;18969:64;19022:10;18969:48;19012:4;18969:38;18984:22;;18969:10;:14;;:38;;;;:::i;:64::-;18962:71;;;;;;;21186:507;10142:12;:10;:12::i;:::-;10132:6;;-1:-1:-1;;;;;10132:6:0;;;:22;;;10124:67;;;;;-1:-1:-1;;;10124:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21358:34:::1;:15:::0;16115:8:::1;21358:19;:34::i;:::-;21339:16;:53:::0;21424:59:::1;21458:24;16115:8;21476:5:::0;21458:17:::1;:24::i;21424:59::-;21403:18;:80:::0;21519:40:::1;:21:::0;16115:8:::1;21519:25;:40::i;:::-;21494:22;:65:::0;;;21570:4:::1;:12:::0;;;21618:16:::1;::::0;21636:18:::1;::::0;21600:85:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;;;;::::1;::::0;;;;;;;::::1;21186:507:::0;;;;:::o;6785:508::-;7202:4;7248:17;7280:7;6785:508;:::o;9498:129::-;6384:12;;;;;;;;:31;;;6400:15;:13;:15::i;:::-;6384:47;;;-1:-1:-1;6420:11:0;;;;6419:12;6384:47;6376:106;;;;-1:-1:-1;;;6376:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6491:19;6514:12;;;;;;6513:13;6533:83;;;;6562:12;:19;;-1:-1:-1;;;;6562:19:0;;;;;6590:18;6577:4;6590:18;;;6533:83;9556:26:::1;:24;:26::i;:::-;9593;:24;:26::i;:::-;6638:14:::0;6634:57;;;6678:5;6663:20;;-1:-1:-1;;6663:20:0;;;6634:57;9498:129;:::o;896:181::-;954:7;986:5;;;1010:6;;;;1002:46;;;;;-1:-1:-1;;;1002:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1068:1;-1:-1:-1;896:181:0;;;;;:::o;1352:136::-;1410:7;1437:43;1441:1;1444;1437:43;;;;;;;;;;;;;;;;;:3;:43::i;2226:471::-;2284:7;2529:6;2525:47;;-1:-1:-1;2559:1:0;2552:8;;2525:47;2596:5;;;2600:1;2596;:5;:1;2620:5;;;;;:10;2612:56;;;;-1:-1:-1;;;2612:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3165:132;3223:7;3250:39;3254:1;3257;3250:39;;;;;;;;;;;;;;;;;:3;:39::i;8307:106::-;8395:10;8307:106;:::o;19587:448::-;19709:4;;19755:37;19760:4;19770:21;19755:14;:37::i;:::-;19726:66;;19803:15;19821:46;19843:4;19849:7;19858:8;19821:21;:46::i;:::-;19803:64;-1:-1:-1;19878:15:0;19896:47;19938:4;19896:37;19803:64;19911:21;19896:14;:37::i;:47::-;19878:65;;19961:66;20022:4;19961:56;20006:10;19961:40;19977:4;19983:7;19992:8;19961:15;:40::i;:::-;:44;;:56::i;:66::-;19954:73;19587:448;-1:-1:-1;;;;;;;;19587:448:0:o;8228:69::-;6384:12;;;;;;;;:31;;;6400:15;:13;:15::i;:::-;6384:47;;;-1:-1:-1;6420:11:0;;;;6419:12;6384:47;6376:106;;;;-1:-1:-1;;;6376:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6491:19;6514:12;;;;;;6513:13;6533:83;;;;6562:12;:19;;-1:-1:-1;;;;6562:19:0;;;;;6590:18;6577:4;6590:18;;;6638:14;6634:57;;;6678:5;6663:20;;-1:-1:-1;;6663:20:0;;;8228:69;:::o;9635:202::-;6384:12;;;;;;;;:31;;;6400:15;:13;:15::i;:::-;6384:47;;;-1:-1:-1;6420:11:0;;;;6419:12;6384:47;6376:106;;;;-1:-1:-1;;;6376:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6491:19;6514:12;;;;;;6513:13;6533:83;;;;6562:12;:19;;-1:-1:-1;;;;6562:19:0;;;;;6590:18;6577:4;6590:18;;;6533:83;9707:17:::1;9727:12;:10;:12::i;:::-;9750:6;:18:::0;;-1:-1:-1;;;;;;9750:18:0::1;-1:-1:-1::0;;;;;9750:18:0;::::1;::::0;;::::1;::::0;;;9784:43:::1;::::0;9750:18;;-1:-1:-1;9750:18:0;-1:-1:-1;;9784:43:0::1;::::0;-1:-1:-1;;9784:43:0::1;6624:1;6638:14:::0;6634:57;;;6678:5;6663:20;;-1:-1:-1;;6663:20:0;;;9635:202;:::o;1783:192::-;1869:7;1905:12;1897:6;;;;1889:29;;;;-1:-1:-1;;;1889:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1941:5:0;;;1783:192::o;3785:345::-;3871:7;3973:12;3966:5;3958:28;;;;-1:-1:-1;;;3958:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3997:9;4013:1;4009;:5;;;;;;;3785:345;-1:-1:-1;;;;;3785:345:0:o

Swarm Source

ipfs://31a633a2e196744bc7115f972b2604ea786c098c83335d073761231cce68420c
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading