Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {WadRayMath} from '@aave/core-v3/contracts/protocol/libraries/math/WadRayMath.sol';
import {IGhoDiscountRateStrategy} from './interfaces/IGhoDiscountRateStrategy.sol';

/**
 * @title GhoDiscountRateStrategy contract
 * @author Aave
 * @notice Implements the calculation of the discount rate depending on the current strategy
 */
contract GhoDiscountRateStrategy is IGhoDiscountRateStrategy {
  using WadRayMath for uint256;

  /**
   * @dev Amount of debt that is entitled to get a discount per unit of discount token
   * Expressed with the number of decimals of the discounted token
   */
  uint256 public constant GHO_DISCOUNTED_PER_DISCOUNT_TOKEN = 100e18;

  /**
   * @dev Percentage of discount to apply to the part of the debt that is entitled to get a discount
   * Expressed in bps, a value of 3000 results in 30.00%
   */
  uint256 public constant DISCOUNT_RATE = 0.3e4;

  /**
   * @dev Minimum balance amount of discount token to be entitled to a discount
   * Expressed with the number of decimals of the discount token
   */
  uint256 public constant MIN_DISCOUNT_TOKEN_BALANCE = 1e15;

  /**
   * @dev Minimum balance amount of debt token to be entitled to a discount
   * Expressed with the number of decimals of the debt token
   */
  uint256 public constant MIN_DEBT_TOKEN_BALANCE = 1e18;

  /// @inheritdoc IGhoDiscountRateStrategy
  function calculateDiscountRate(
    uint256 debtBalance,
    uint256 discountTokenBalance
  ) external pure override returns (uint256) {
    if (discountTokenBalance < MIN_DISCOUNT_TOKEN_BALANCE || debtBalance < MIN_DEBT_TOKEN_BALANCE) {
      return 0;
    } else {
      uint256 discountedBalance = discountTokenBalance.wadMul(GHO_DISCOUNTED_PER_DISCOUNT_TOKEN);
      if (discountedBalance >= debtBalance) {
        return DISCOUNT_RATE;
      } else {
        return (discountedBalance * DISCOUNT_RATE) / debtBalance;
      }
    }
  }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

/**
 * @title WadRayMath library
 * @author Aave
 * @notice Provides functions to perform calculations with Wad and Ray units
 * @dev Provides mul and div function for wads (decimal numbers with 18 digits of precision) and rays (decimal numbers
 * with 27 digits of precision)
 * @dev Operations are rounded. If a value is >=.5, will be rounded up, otherwise rounded down.
 */
library WadRayMath {
  // HALF_WAD and HALF_RAY expressed with extended notation as constant with operations are not supported in Yul assembly
  uint256 internal constant WAD = 1e18;
  uint256 internal constant HALF_WAD = 0.5e18;

  uint256 internal constant RAY = 1e27;
  uint256 internal constant HALF_RAY = 0.5e27;

  uint256 internal constant WAD_RAY_RATIO = 1e9;

  /**
   * @dev Multiplies two wad, rounding half up to the nearest wad
   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
   * @param a Wad
   * @param b Wad
   * @return c = a*b, in wad
   */
  function wadMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // to avoid overflow, a <= (type(uint256).max - HALF_WAD) / b
    assembly {
      if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_WAD), b))))) {
        revert(0, 0)
      }

      c := div(add(mul(a, b), HALF_WAD), WAD)
    }
  }

  /**
   * @dev Divides two wad, rounding half up to the nearest wad
   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
   * @param a Wad
   * @param b Wad
   * @return c = a/b, in wad
   */
  function wadDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // to avoid overflow, a <= (type(uint256).max - halfB) / WAD
    assembly {
      if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), WAD))))) {
        revert(0, 0)
      }

      c := div(add(mul(a, WAD), div(b, 2)), b)
    }
  }

  /**
   * @notice Multiplies two ray, rounding half up to the nearest ray
   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
   * @param a Ray
   * @param b Ray
   * @return c = a raymul b
   */
  function rayMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // to avoid overflow, a <= (type(uint256).max - HALF_RAY) / b
    assembly {
      if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_RAY), b))))) {
        revert(0, 0)
      }

      c := div(add(mul(a, b), HALF_RAY), RAY)
    }
  }

  /**
   * @notice Divides two ray, rounding half up to the nearest ray
   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
   * @param a Ray
   * @param b Ray
   * @return c = a raydiv b
   */
  function rayDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // to avoid overflow, a <= (type(uint256).max - halfB) / RAY
    assembly {
      if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), RAY))))) {
        revert(0, 0)
      }

      c := div(add(mul(a, RAY), div(b, 2)), b)
    }
  }

  /**
   * @dev Casts ray down to wad
   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
   * @param a Ray
   * @return b = a converted to wad, rounded half up to the nearest wad
   */
  function rayToWad(uint256 a) internal pure returns (uint256 b) {
    assembly {
      b := div(a, WAD_RAY_RATIO)
      let remainder := mod(a, WAD_RAY_RATIO)
      if iszero(lt(remainder, div(WAD_RAY_RATIO, 2))) {
        b := add(b, 1)
      }
    }
  }

  /**
   * @dev Converts wad up to ray
   * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
   * @param a Wad
   * @return b = a converted in ray
   */
  function wadToRay(uint256 a) internal pure returns (uint256 b) {
    // to avoid overflow, b/WAD_RAY_RATIO == a
    assembly {
      b := mul(a, WAD_RAY_RATIO)

      if iszero(eq(div(b, WAD_RAY_RATIO), a)) {
        revert(0, 0)
      }
    }
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title IGhoDiscountRateStrategy
 * @author Aave
 * @notice Defines the basic interface of the GhoDiscountRateStrategy
 */
interface IGhoDiscountRateStrategy {
  /**
   * @notice Calculates the discount rate depending on the debt and discount token balances
   * @param debtBalance The debt balance of the user
   * @param discountTokenBalance The discount token balance of the user
   * @return The discount rate, as a percentage - the maximum can be 10000 = 100.00%
   */
  function calculateDiscountRate(
    uint256 debtBalance,
    uint256 discountTokenBalance
  ) external view returns (uint256);
}

{
  "remappings": [
    "@aave/=node_modules/@aave/",
    "@aave/core-v3/=node_modules/@aave/core-v3/",
    "@aave/periphery-v3/=node_modules/@aave/periphery-v3/",
    "@openzeppelin/=node_modules/@openzeppelin/",
    "aave-stk-v1-5/=lib/aave-stk-v1-5/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "eth-gas-reporter/=node_modules/eth-gas-reporter/",
    "forge-std/=lib/forge-std/src/",
    "hardhat-deploy/=node_modules/hardhat-deploy/",
    "hardhat/=node_modules/hardhat/",
    "aave-address-book/=lib/aave-stk-v1-5/lib/aave-address-book/src/",
    "aave-helpers/=lib/aave-stk-v1-5/lib/aave-helpers/",
    "aave-v3-core/=lib/aave-stk-v1-5/lib/aave-address-book/lib/aave-v3-core/",
    "aave-v3-periphery/=lib/aave-stk-v1-5/lib/aave-address-book/lib/aave-v3-periphery/",
    "erc4626-tests/=lib/aave-stk-v1-5/lib/openzeppelin-contracts/lib/erc4626-tests/",
    "openzeppelin-contracts/=lib/aave-stk-v1-5/lib/openzeppelin-contracts/",
    "solidity-utils/=lib/aave-stk-v1-5/lib/aave-helpers/lib/solidity-utils/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

[{"inputs":[],"name":"DISCOUNT_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GHO_DISCOUNTED_PER_DISCOUNT_TOKEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_DEBT_TOKEN_BALANCE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_DISCOUNT_TOKEN_BALANCE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"debtBalance","type":"uint256"},{"internalType":"uint256","name":"discountTokenBalance","type":"uint256"}],"name":"calculateDiscountRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}]

608060405234801561001057600080fd5b50610282806100206000396000f3fe608060405234801561001057600080fd5b50600436106100675760003560e01c806393adbec51161005057806393adbec51461009c57806398c4f438146100af578063b510c589146100be57600080fd5b80633454274e1461006c578063771a73af1461008c575b600080fd5b61007a66038d7ea4c6800081565b60405190815260200160405180910390f35b61007a68056bc75e2d6310000081565b61007a6100aa36600461018b565b6100c7565b61007a670de0b6b3a764000081565b61007a610bb881565b600066038d7ea4c680008210806100e55750670de0b6b3a764000083105b156100f257506000610136565b60006101078368056bc75e2d6310000061013c565b905083811061011b57610bb8915050610136565b83610128610bb8836101ad565b6101329190610211565b9150505b92915050565b600081157ffffffffffffffffffffffffffffffffffffffffffffffffff90fa4a62c4dffff8390048411151761017157600080fd5b50670de0b6b3a764000091026706f05b59d3b20000010490565b6000806040838503121561019e57600080fd5b50508035926020909101359150565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561020c577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b500290565b600082610247577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b50049056fea2646970667358221220eade037b99500476a13ba91bd66c2969099700609e7e892435b2c1e1b4b3883764736f6c634300080a0033

0x608060405234801561001057600080fd5b50600436106100675760003560e01c806393adbec51161005057806393adbec51461009c57806398c4f438146100af578063b510c589146100be57600080fd5b80633454274e1461006c578063771a73af1461008c575b600080fd5b61007a66038d7ea4c6800081565b60405190815260200160405180910390f35b61007a68056bc75e2d6310000081565b61007a6100aa36600461018b565b6100c7565b61007a670de0b6b3a764000081565b61007a610bb881565b600066038d7ea4c680008210806100e55750670de0b6b3a764000083105b156100f257506000610136565b60006101078368056bc75e2d6310000061013c565b905083811061011b57610bb8915050610136565b83610128610bb8836101ad565b6101329190610211565b9150505b92915050565b600081157ffffffffffffffffffffffffffffffffffffffffffffffffff90fa4a62c4dffff8390048411151761017157600080fd5b50670de0b6b3a764000091026706f05b59d3b20000010490565b6000806040838503121561019e57600080fd5b50508035926020909101359150565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561020c577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b500290565b600082610247577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b50049056fea2646970667358221220eade037b99500476a13ba91bd66c2969099700609e7e892435b2c1e1b4b3883764736f6c634300080a0033