Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
pragma solidity 0.8.17;

import "lib/solmate/src/utils/SignedWadMath.sol";

library CalculationHelpers {
    int256 private constant _YEAR_WAD = 365 days * 1e18;
    uint256 private constant _LIQUIDATION_THRESHOLD = 100_000;
    uint256 private constant _BASIS_POINTS = 10_000;

    /**
     * @dev Computes the current debt of a borrow given the last time it was touched and the last computed debt.
     * @param amount Principal in ETH
     * @param startTime Start time of the loan
     * @param rate Interest rate (in bips)
     * @dev Formula: https://www.desmos.com/calculator/l6omp0rwnh
     */
    function computeCurrentDebt(
        uint256 amount,
        uint256 rate,
        uint256 startTime
    ) external view returns (uint256) {
        uint256 loanTime = block.timestamp - startTime;
        int256 yearsWad = wadDiv(int256(loanTime) * 1e18, _YEAR_WAD);
        return uint256(wadMul(int256(amount), wadExp(wadMul(yearsWad, bipsToSignedWads(rate)))));
    }

    /**
     * @dev Calculates the current maximum interest rate a specific refinancing
     * auction could settle at currently given the auction's start block and duration.
     * @param startBlock The block the auction started at
     * @param oldRate Previous interest rate (in bips)
     * @dev Formula: https://www.desmos.com/calculator/urasr71dhb
     */
    function calcRefinancingAuctionRate(
        uint256 startBlock,
        uint256 auctionDuration,
        uint256 oldRate
    ) external view returns (uint256) {
        uint256 currentAuctionBlock = block.number - startBlock;
        int256 oldRateWads = bipsToSignedWads(oldRate);

        uint256 auctionT1 = auctionDuration / 5;
        uint256 auctionT2 = (4 * auctionDuration) / 5;

        int256 maxRateWads;
        {
            int256 aInverse = -bipsToSignedWads(15000);
            int256 b = 2;
            int256 maxMinRateWads = bipsToSignedWads(500);

            if (oldRateWads < -((b * aInverse) / 2)) {
                maxRateWads = maxMinRateWads + (oldRateWads ** 2) / aInverse + b * oldRateWads;
            } else {
                maxRateWads = maxMinRateWads - ((b ** 2) * aInverse) / 4;
            }
        }

        int256 startSlope = maxRateWads / int256(auctionT1); // wad-bips per block

        int256 middleSlope = bipsToSignedWads(9000) / int256(3 * auctionDuration / 5) + 1; // wad-bips per block (add one to account for rounding)
        int256 middleB = maxRateWads - int256(auctionT1) * middleSlope;

        if (currentAuctionBlock < auctionT1) {
            return signedWadsToBips(startSlope * int256(currentAuctionBlock));
        } else if (currentAuctionBlock < auctionT2) {
            return signedWadsToBips(middleSlope * int256(currentAuctionBlock) + middleB);
        } else if (currentAuctionBlock < auctionDuration) {
            int256 endSlope;
            int256 endB;
            {
                endSlope =
                    (bipsToSignedWads(_LIQUIDATION_THRESHOLD) -
                        ((int256(auctionT2) * middleSlope) + middleB)) /
                    int256(auctionDuration - auctionT2); // wad-bips per block
                endB =
                    bipsToSignedWads(_LIQUIDATION_THRESHOLD) -
                    int256(auctionDuration) *
                    endSlope;
            }

            return signedWadsToBips(endSlope * int256(currentAuctionBlock) + endB);
        } else {
            return _LIQUIDATION_THRESHOLD;
        }
    }

    /**
     * @dev Converts an integer bips value to a signed wad value.
     */
    function bipsToSignedWads(uint256 bips) public pure returns (int256) {
        return int256((bips * 1e18) / _BASIS_POINTS);
    }

    /**
     * @dev Converts a signed wad value to an integer bips value.
     */
    function signedWadsToBips(int256 wads) public pure returns (uint256) {
        return uint256((wads * int256(_BASIS_POINTS)) / 1e18);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @notice Signed 18 decimal fixed point (wad) arithmetic library.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SignedWadMath.sol)
/// @author Modified from Remco Bloemen (https://xn--2-umb.com/22/exp-ln/index.html)

/// @dev Will not revert on overflow, only use where overflow is not possible.
function toWadUnsafe(uint256 x) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Multiply x by 1e18.
        r := mul(x, 1000000000000000000)
    }
}

/// @dev Takes an integer amount of seconds and converts it to a wad amount of days.
/// @dev Will not revert on overflow, only use where overflow is not possible.
/// @dev Not meant for negative second amounts, it assumes x is positive.
function toDaysWadUnsafe(uint256 x) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Multiply x by 1e18 and then divide it by 86400.
        r := div(mul(x, 1000000000000000000), 86400)
    }
}

/// @dev Takes a wad amount of days and converts it to an integer amount of seconds.
/// @dev Will not revert on overflow, only use where overflow is not possible.
/// @dev Not meant for negative day amounts, it assumes x is positive.
function fromDaysWadUnsafe(int256 x) pure returns (uint256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Multiply x by 86400 and then divide it by 1e18.
        r := div(mul(x, 86400), 1000000000000000000)
    }
}

/// @dev Will not revert on overflow, only use where overflow is not possible.
function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Multiply x by y and divide by 1e18.
        r := sdiv(mul(x, y), 1000000000000000000)
    }
}

/// @dev Will return 0 instead of reverting if y is zero and will
/// not revert on overflow, only use where overflow is not possible.
function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Multiply x by 1e18 and divide it by y.
        r := sdiv(mul(x, 1000000000000000000), y)
    }
}

function wadMul(int256 x, int256 y) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Store x * y in r for now.
        r := mul(x, y)

        // Equivalent to require(x == 0 || (x * y) / x == y)
        if iszero(or(iszero(x), eq(sdiv(r, x), y))) {
            revert(0, 0)
        }

        // Scale the result down by 1e18.
        r := sdiv(r, 1000000000000000000)
    }
}

function wadDiv(int256 x, int256 y) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Store x * 1e18 in r for now.
        r := mul(x, 1000000000000000000)

        // Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x))
        if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) {
            revert(0, 0)
        }

        // Divide r by y.
        r := sdiv(r, y)
    }
}

/// @dev Will not work with negative bases, only use when x is positive.
function wadPow(int256 x, int256 y) pure returns (int256) {
    // Equivalent to x to the power of y because x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)
    return wadExp((wadLn(x) * y) / 1e18); // Using ln(x) means x must be greater than 0.
}

function wadExp(int256 x) pure returns (int256 r) {
    unchecked {
        // When the result is < 0.5 we return zero. This happens when
        // x <= floor(log(0.5e18) * 1e18) ~ -42e18
        if (x <= -42139678854452767551) return 0;

        // When the result is > (2**255 - 1) / 1e18 we can not represent it as an
        // int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135.
        if (x >= 135305999368893231589) revert("EXP_OVERFLOW");

        // x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96
        // for more intermediate precision and a binary basis. This base conversion
        // is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
        x = (x << 78) / 5**18;

        // Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers
        // of two such that exp(x) = exp(x') * 2**k, where k is an integer.
        // Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
        int256 k = ((x << 96) / 54916777467707473351141471128 + 2**95) >> 96;
        x = x - k * 54916777467707473351141471128;

        // k is in the range [-61, 195].

        // Evaluate using a (6, 7)-term rational approximation.
        // p is made monic, we'll multiply by a scale factor later.
        int256 y = x + 1346386616545796478920950773328;
        y = ((y * x) >> 96) + 57155421227552351082224309758442;
        int256 p = y + x - 94201549194550492254356042504812;
        p = ((p * y) >> 96) + 28719021644029726153956944680412240;
        p = p * x + (4385272521454847904659076985693276 << 96);

        // We leave p in 2**192 basis so we don't need to scale it back up for the division.
        int256 q = x - 2855989394907223263936484059900;
        q = ((q * x) >> 96) + 50020603652535783019961831881945;
        q = ((q * x) >> 96) - 533845033583426703283633433725380;
        q = ((q * x) >> 96) + 3604857256930695427073651918091429;
        q = ((q * x) >> 96) - 14423608567350463180887372962807573;
        q = ((q * x) >> 96) + 26449188498355588339934803723976023;

        /// @solidity memory-safe-assembly
        assembly {
            // Div in assembly because solidity adds a zero check despite the unchecked.
            // The q polynomial won't have zeros in the domain as all its roots are complex.
            // No scaling is necessary because p is already 2**96 too large.
            r := sdiv(p, q)
        }

        // r should be in the range (0.09, 0.25) * 2**96.

        // We now need to multiply r by:
        // * the scale factor s = ~6.031367120.
        // * the 2**k factor from the range reduction.
        // * the 1e18 / 2**96 factor for base conversion.
        // We do this all at once, with an intermediate result in 2**213
        // basis, so the final right shift is always by a positive amount.
        r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k));
    }
}

function wadLn(int256 x) pure returns (int256 r) {
    unchecked {
        require(x > 0, "UNDEFINED");

        // We want to convert x from 10**18 fixed point to 2**96 fixed point.
        // We do this by multiplying by 2**96 / 10**18. But since
        // ln(x * C) = ln(x) + ln(C), we can simply do nothing here
        // and add ln(2**96 / 10**18) at the end.

        /// @solidity memory-safe-assembly
        assembly {
            r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            r := or(r, shl(2, lt(0xf, shr(r, x))))
            r := or(r, shl(1, lt(0x3, shr(r, x))))
            r := or(r, lt(0x1, shr(r, x)))
        }

        // Reduce range of x to (1, 2) * 2**96
        // ln(2^k * x) = k * ln(2) + ln(x)
        int256 k = r - 96;
        x <<= uint256(159 - k);
        x = int256(uint256(x) >> 159);

        // Evaluate using a (8, 8)-term rational approximation.
        // p is made monic, we will multiply by a scale factor later.
        int256 p = x + 3273285459638523848632254066296;
        p = ((p * x) >> 96) + 24828157081833163892658089445524;
        p = ((p * x) >> 96) + 43456485725739037958740375743393;
        p = ((p * x) >> 96) - 11111509109440967052023855526967;
        p = ((p * x) >> 96) - 45023709667254063763336534515857;
        p = ((p * x) >> 96) - 14706773417378608786704636184526;
        p = p * x - (795164235651350426258249787498 << 96);

        // We leave p in 2**192 basis so we don't need to scale it back up for the division.
        // q is monic by convention.
        int256 q = x + 5573035233440673466300451813936;
        q = ((q * x) >> 96) + 71694874799317883764090561454958;
        q = ((q * x) >> 96) + 283447036172924575727196451306956;
        q = ((q * x) >> 96) + 401686690394027663651624208769553;
        q = ((q * x) >> 96) + 204048457590392012362485061816622;
        q = ((q * x) >> 96) + 31853899698501571402653359427138;
        q = ((q * x) >> 96) + 909429971244387300277376558375;
        /// @solidity memory-safe-assembly
        assembly {
            // Div in assembly because solidity adds a zero check despite the unchecked.
            // The q polynomial is known not to have zeros in the domain.
            // No scaling required because p is already 2**96 too large.
            r := sdiv(p, q)
        }

        // r is in the range (0, 0.125) * 2**96

        // Finalization, we need to:
        // * multiply by the scale factor s = 5.549…
        // * add ln(2**96 / 10**18)
        // * add k * ln(2)
        // * multiply by 10**18 / 2**96 = 5**18 >> 78

        // mul s * 5e18 * 2**96, base is now 5**18 * 2**192
        r *= 1677202110996718588342820967067443963516166;
        // add ln(2) * k * 5e18 * 2**192
        r += 16597577552685614221487285958193947469193820559219878177908093499208371 * k;
        // add ln(2**96 / 10**18) * 5e18 * 2**192
        r += 600920179829731861736702779321621459595472258049074101567377883020018308;
        // base conversion: mul 2**18 / 2**192
        r >>= 174;
    }
}

/// @dev Will return 0 instead of reverting if y is zero.
function unsafeDiv(int256 x, int256 y) pure returns (int256 r) {
    /// @solidity memory-safe-assembly
    assembly {
        // Divide x by y.
        r := sdiv(x, y)
    }
}

{
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {},
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "solmate/=lib/solmate/src/"
  ]
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"bips","type":"uint256"}],"name":"bipsToSignedWads","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"startBlock","type":"uint256"},{"internalType":"uint256","name":"auctionDuration","type":"uint256"},{"internalType":"uint256","name":"oldRate","type":"uint256"}],"name":"calcRefinancingAuctionRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rate","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"computeCurrentDebt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"wads","type":"int256"}],"name":"signedWadsToBips","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}]

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