Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import "@prb/math/contracts/PRBMathUD60x18.sol";

import "../interfaces/IThalesAMM.sol";
import "../interfaces/IPositionalMarket.sol";

/// @title An AMM using BlackScholes odds algorithm to provide liqudidity for traders of UP or DOWN positions
contract ThalesAMMUtils {
    using PRBMathUD60x18 for uint256;

    uint private constant ONE = 1e18;
    uint private constant ONE_PERCENT = 1e16;

    struct PriceImpactParams {
        uint amount;
        uint balanceOtherSide;
        uint balancePosition;
        uint balanceOtherSideAfter;
        uint balancePositionAfter;
        uint availableToBuyFromAMM;
        uint max_spread;
    }

    struct DiscountParams {
        uint balancePosition;
        uint balanceOtherSide;
        uint amount;
        uint availableToBuyFromAMM;
        uint max_spread;
    }

    // IThalesAMM public thalesAMM;

    // constructor(address _thalesAMM) {
    //     thalesAMM = IThalesAMM(_thalesAMM);
    // }

    /// @notice get the algorithmic odds of market being in the money, taken from JS code https://gist.github.com/aasmith/524788/208694a9c74bb7dfcb3295d7b5fa1ecd1d662311
    /// @param _price current price of the asset
    /// @param strike price of the asset
    /// @param timeLeftInDays when does the market mature
    /// @param volatility implied yearly volatility of the asset
    /// @return result odds of market being in the money
    function calculateOdds(
        uint _price,
        uint strike,
        uint timeLeftInDays,
        uint volatility
    ) public view returns (uint result) {
        uint vt = ((volatility / (100)) * (sqrt(timeLeftInDays / (365)))) / (1e9);
        bool direction = strike >= _price;
        uint lnBase = strike >= _price ? (strike * (ONE)) / (_price) : (_price * (ONE)) / (strike);
        uint d1 = (PRBMathUD60x18.ln(lnBase) * (ONE)) / (vt);
        uint y = (ONE * (ONE)) / (ONE + ((d1 * (2316419)) / (1e7)));
        uint d2 = (d1 * (d1)) / (2) / (ONE);
        if (d2 < 130 * ONE) {
            uint z = (_expneg(d2) * (3989423)) / (1e7);

            uint y5 = (powerInt(y, 5) * (1330274)) / (1e6);
            uint y4 = (powerInt(y, 4) * (1821256)) / (1e6);
            uint y3 = (powerInt(y, 3) * (1781478)) / (1e6);
            uint y2 = (powerInt(y, 2) * (356538)) / (1e6);
            uint y1 = (y * (3193815)) / (1e7);
            uint x1 = y5 + (y3) + (y1) - (y4) - (y2);
            uint x = ONE - ((z * (x1)) / (ONE));
            result = ONE * (1e2) - (x * (1e2));
            if (direction) {
                return result;
            } else {
                return ONE * (1e2) - result;
            }
        } else {
            result = direction ? 0 : ONE * 1e2;
        }
    }

    function _expneg(uint x) internal view returns (uint result) {
        result = (ONE * ONE) / _expNegPow(x);
    }

    function _expNegPow(uint x) internal view returns (uint result) {
        uint e = 2718280000000000000;
        result = PRBMathUD60x18.pow(e, x);
    }

    function powerInt(uint A, int8 B) internal pure returns (uint result) {
        result = ONE;
        for (int8 i = 0; i < B; i++) {
            result = (result * (A)) / (ONE);
        }
    }

    function sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }

    function calculateDiscount(DiscountParams memory params) public view returns (int) {
        uint currentBuyImpactOtherSide = buyPriceImpactImbalancedSkew(
            PriceImpactParams(
                params.amount,
                params.balancePosition,
                params.balanceOtherSide,
                params.balanceOtherSide > ONE
                    ? params.balancePosition
                    : params.balancePosition + (ONE - params.balanceOtherSide),
                params.balanceOtherSide > ONE ? params.balanceOtherSide - ONE : 0,
                params.availableToBuyFromAMM,
                params.max_spread
            )
        );

        uint startDiscount = currentBuyImpactOtherSide;
        uint tempMultiplier = params.balancePosition - params.amount;
        uint finalDiscount = ((startDiscount / 2) * ((tempMultiplier * ONE) / params.balancePosition + ONE)) / ONE;

        return -int(finalDiscount);
    }

    function buyPriceImpactImbalancedSkew(PriceImpactParams memory params) public view returns (uint) {
        uint maxPossibleSkew = params.balanceOtherSide + params.availableToBuyFromAMM - params.balancePosition;
        uint skew = params.balanceOtherSideAfter - (params.balancePositionAfter);
        uint newImpact = (params.max_spread * ((skew * ONE) / (maxPossibleSkew))) / ONE;
        if (params.balancePosition > 0 && params.amount > params.balancePosition) {
            uint newPriceForMintedOnes = newImpact / (2);
            uint tempMultiplier = (params.amount - params.balancePosition) * (newPriceForMintedOnes);
            return (tempMultiplier * ONE) / (params.amount) / ONE;
        } else {
            uint previousSkew = params.balanceOtherSide;
            uint previousImpact = (params.max_spread * ((previousSkew * ONE) / (maxPossibleSkew))) / ONE;
            return (newImpact + previousImpact) / (2);
        }
    }

    function sellPriceImpactImbalancedSkew(
        uint amount,
        uint balanceOtherSide,
        uint _balancePosition,
        uint balanceOtherSideAfter,
        uint balancePositionAfter,
        uint available,
        uint max_spread
    ) public view returns (uint _sellImpactReturned) {
        uint maxPossibleSkew = _balancePosition + (available) - (balanceOtherSide);
        uint skew = balancePositionAfter - (balanceOtherSideAfter);
        uint newImpact = (max_spread * ((skew * ONE) / (maxPossibleSkew))) / ONE;

        if (balanceOtherSide > 0 && amount > _balancePosition) {
            uint newPriceForMintedOnes = newImpact / (2);
            uint tempMultiplier = (amount - _balancePosition) * (newPriceForMintedOnes);
            _sellImpactReturned = tempMultiplier / (amount);
        } else {
            uint previousSkew = _balancePosition;
            uint previousImpact = (max_spread * ((previousSkew * ONE) / (maxPossibleSkew))) / ONE;
            _sellImpactReturned = (newImpact + previousImpact) / (2);
        }
    }

    function balanceOfPositionOnMarket(
        address market,
        IThalesAMM.Position position,
        address addressToCheck
    ) public view returns (uint balance) {
        (IPosition up, IPosition down) = IPositionalMarket(market).getOptions();
        balance = position == IThalesAMM.Position.Up ? up.getBalanceOf(addressToCheck) : down.getBalanceOf(addressToCheck);
    }

    function balanceOfPositionsOnMarket(
        address market,
        IThalesAMM.Position position,
        address addressToCheck
    ) public view returns (uint balance, uint balanceOtherSide) {
        (IPosition up, IPosition down) = IPositionalMarket(market).getOptions();
        balance = position == IThalesAMM.Position.Up ? up.getBalanceOf(addressToCheck) : down.getBalanceOf(addressToCheck);
        balanceOtherSide = position == IThalesAMM.Position.Up
            ? down.getBalanceOf(addressToCheck)
            : up.getBalanceOf(addressToCheck);
    }

    function getBalanceOfPositionsOnMarket(address market, address addressToCheck)
        public
        view
        returns (uint upBalance, uint downBalance)
    {
        (IPosition up, IPosition down) = IPositionalMarket(market).getOptions();
        upBalance = up.getBalanceOf(addressToCheck);
        downBalance = down.getBalanceOf(addressToCheck);
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;

import "./PRBMath.sol";

/// @title PRBMathUD60x18
/// @author Paul Razvan Berg
/// @notice Smart contract library for advanced fixed-point math that works with uint256 numbers considered to have 18
/// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60
/// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the
/// maximum values permitted by the Solidity type uint256.
library PRBMathUD60x18 {
    /// @dev Half the SCALE number.
    uint256 internal constant HALF_SCALE = 5e17;

    /// @dev log2(e) as an unsigned 60.18-decimal fixed-point number.
    uint256 internal constant LOG2_E = 1_442695040888963407;

    /// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_584007913129639935;

    /// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_WHOLE_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_000000000000000000;

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @notice Calculates the arithmetic average of x and y, rounding down.
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The arithmetic average as an unsigned 60.18-decimal fixed-point number.
    function avg(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // The operations can never overflow.
        unchecked {
            // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need
            // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice.
            result = (x >> 1) + (y >> 1) + (x & y & 1);
        }
    }

    /// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x.
    ///
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    ///
    /// Requirements:
    /// - x must be less than or equal to MAX_WHOLE_UD60x18.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number to ceil.
    /// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function ceil(uint256 x) internal pure returns (uint256 result) {
        if (x > MAX_WHOLE_UD60x18) {
            revert PRBMathUD60x18__CeilOverflow(x);
        }
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "SCALE - remainder" but faster.
            let delta := sub(SCALE, remainder)

            // Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster.
            result := add(x, mul(delta, gt(remainder, 0)))
        }
    }

    /// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number.
    ///
    /// @dev Uses mulDiv to enable overflow-safe multiplication and division.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    ///
    /// @param x The numerator as an unsigned 60.18-decimal fixed-point number.
    /// @param y The denominator as an unsigned 60.18-decimal fixed-point number.
    /// @param result The quotient as an unsigned 60.18-decimal fixed-point number.
    function div(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDiv(x, SCALE, y);
    }

    /// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number.
    /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant).
    function e() internal pure returns (uint256 result) {
        result = 2_718281828459045235;
    }

    /// @notice Calculates the natural exponent of x.
    ///
    /// @dev Based on the insight that e^x = 2^(x * log2(e)).
    ///
    /// Requirements:
    /// - All from "log2".
    /// - x must be less than 133.084258667509499441.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp(uint256 x) internal pure returns (uint256 result) {
        // Without this check, the value passed to "exp2" would be greater than 192.
        if (x >= 133_084258667509499441) {
            revert PRBMathUD60x18__ExpInputTooBig(x);
        }

        // Do the fixed-point multiplication inline to save gas.
        unchecked {
            uint256 doubleScaleProduct = x * LOG2_E;
            result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
        }
    }

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    ///
    /// @dev See https://ethereum.stackexchange.com/q/79903/24693.
    ///
    /// Requirements:
    /// - x must be 192 or less.
    /// - The result must fit within MAX_UD60x18.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        // 2^192 doesn't fit within the 192.64-bit format used internally in this function.
        if (x >= 192e18) {
            revert PRBMathUD60x18__Exp2InputTooBig(x);
        }

        unchecked {
            // Convert x to the 192.64-bit fixed-point format.
            uint256 x192x64 = (x << 64) / SCALE;

            // Pass x to the PRBMath.exp2 function, which uses the 192.64-bit fixed-point number representation.
            result = PRBMath.exp2(x192x64);
        }
    }

    /// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x.
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    /// @param x The unsigned 60.18-decimal fixed-point number to floor.
    /// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function floor(uint256 x) internal pure returns (uint256 result) {
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster.
            result := sub(x, mul(remainder, gt(remainder, 0)))
        }
    }

    /// @notice Yields the excess beyond the floor of x.
    /// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part.
    /// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of.
    /// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number.
    function frac(uint256 x) internal pure returns (uint256 result) {
        assembly {
            result := mod(x, SCALE)
        }
    }

    /// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation.
    ///
    /// @dev Requirements:
    /// - x must be less than or equal to MAX_UD60x18 divided by SCALE.
    ///
    /// @param x The basic integer to convert.
    /// @param result The same number in unsigned 60.18-decimal fixed-point representation.
    function fromUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__FromUintOverflow(x);
            }
            result = x * SCALE;
        }
    }

    /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down.
    ///
    /// @dev Requirements:
    /// - x * y must fit within MAX_UD60x18, lest it overflows.
    ///
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function gm(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        unchecked {
            // Checking for overflow this way is faster than letting Solidity do it.
            uint256 xy = x * y;
            if (xy / x != y) {
                revert PRBMathUD60x18__GmOverflow(x, y);
            }

            // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE
            // during multiplication. See the comments within the "sqrt" function.
            result = PRBMath.sqrt(xy);
        }
    }

    /// @notice Calculates 1 / x, rounding toward zero.
    ///
    /// @dev Requirements:
    /// - x cannot be zero.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse.
    /// @return result The inverse as an unsigned 60.18-decimal fixed-point number.
    function inv(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // 1e36 is SCALE * SCALE.
            result = 1e36 / x;
        }
    }

    /// @notice Calculates the natural logarithm of x.
    ///
    /// @dev Based on the insight that ln(x) = log2(x) / log2(e).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    /// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm.
    /// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number.
    function ln(uint256 x) internal pure returns (uint256 result) {
        // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x)
        // can return is 196205294292027477728.
        unchecked {
            result = (log2(x) * SCALE) / LOG2_E;
        }
    }

    /// @notice Calculates the common logarithm of x.
    ///
    /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common
    /// logarithm based on the insight that log10(x) = log2(x) / log2(10).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm.
    /// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number.
    function log10(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }

        // Note that the "mul" in this block is the assembly multiplication operation, not the "mul" function defined
        // in this contract.
        // prettier-ignore
        assembly {
            switch x
            case 1 { result := mul(SCALE, sub(0, 18)) }
            case 10 { result := mul(SCALE, sub(1, 18)) }
            case 100 { result := mul(SCALE, sub(2, 18)) }
            case 1000 { result := mul(SCALE, sub(3, 18)) }
            case 10000 { result := mul(SCALE, sub(4, 18)) }
            case 100000 { result := mul(SCALE, sub(5, 18)) }
            case 1000000 { result := mul(SCALE, sub(6, 18)) }
            case 10000000 { result := mul(SCALE, sub(7, 18)) }
            case 100000000 { result := mul(SCALE, sub(8, 18)) }
            case 1000000000 { result := mul(SCALE, sub(9, 18)) }
            case 10000000000 { result := mul(SCALE, sub(10, 18)) }
            case 100000000000 { result := mul(SCALE, sub(11, 18)) }
            case 1000000000000 { result := mul(SCALE, sub(12, 18)) }
            case 10000000000000 { result := mul(SCALE, sub(13, 18)) }
            case 100000000000000 { result := mul(SCALE, sub(14, 18)) }
            case 1000000000000000 { result := mul(SCALE, sub(15, 18)) }
            case 10000000000000000 { result := mul(SCALE, sub(16, 18)) }
            case 100000000000000000 { result := mul(SCALE, sub(17, 18)) }
            case 1000000000000000000 { result := 0 }
            case 10000000000000000000 { result := SCALE }
            case 100000000000000000000 { result := mul(SCALE, 2) }
            case 1000000000000000000000 { result := mul(SCALE, 3) }
            case 10000000000000000000000 { result := mul(SCALE, 4) }
            case 100000000000000000000000 { result := mul(SCALE, 5) }
            case 1000000000000000000000000 { result := mul(SCALE, 6) }
            case 10000000000000000000000000 { result := mul(SCALE, 7) }
            case 100000000000000000000000000 { result := mul(SCALE, 8) }
            case 1000000000000000000000000000 { result := mul(SCALE, 9) }
            case 10000000000000000000000000000 { result := mul(SCALE, 10) }
            case 100000000000000000000000000000 { result := mul(SCALE, 11) }
            case 1000000000000000000000000000000 { result := mul(SCALE, 12) }
            case 10000000000000000000000000000000 { result := mul(SCALE, 13) }
            case 100000000000000000000000000000000 { result := mul(SCALE, 14) }
            case 1000000000000000000000000000000000 { result := mul(SCALE, 15) }
            case 10000000000000000000000000000000000 { result := mul(SCALE, 16) }
            case 100000000000000000000000000000000000 { result := mul(SCALE, 17) }
            case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) }
            case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) }
            case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) }
            case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) }
            case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) }
            case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) }
            case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) }
            case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) }
            case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) }
            case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) }
            case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) }
            case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) }
            case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) }
            case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) }
            case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) }
            case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) }
            case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) }
            case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) }
            case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) }
            case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) }
            case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) }
            case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) }
            case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) }
            case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) }
            case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) }
            case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) }
            case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) }
            case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) }
            case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) }
            case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) }
            case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) }
            case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) }
            case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) }
            default {
                result := MAX_UD60x18
            }
        }

        if (result == MAX_UD60x18) {
            // Do the fixed-point division inline to save gas. The denominator is log2(10).
            unchecked {
                result = (log2(x) * SCALE) / 3_321928094887362347;
            }
        }
    }

    /// @notice Calculates the binary logarithm of x.
    ///
    /// @dev Based on the iterative approximation algorithm.
    /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
    ///
    /// Requirements:
    /// - x must be greater than or equal to SCALE, otherwise the result would be negative.
    ///
    /// Caveats:
    /// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm.
    /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number.
    function log2(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }
        unchecked {
            // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n).
            uint256 n = PRBMath.mostSignificantBit(x / SCALE);

            // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow
            // because n is maximum 255 and SCALE is 1e18.
            result = n * SCALE;

            // This is y = x * 2^(-n).
            uint256 y = x >> n;

            // If y = 1, the fractional part is zero.
            if (y == SCALE) {
                return result;
            }

            // Calculate the fractional part via the iterative approximation.
            // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster.
            for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) {
                y = (y * y) / SCALE;

                // Is y^2 > 2 and so in the range [2,4)?
                if (y >= 2 * SCALE) {
                    // Add the 2^(-m) factor to the logarithm.
                    result += delta;

                    // Corresponds to z/2 on Wikipedia.
                    y >>= 1;
                }
            }
        }
    }

    /// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal
    /// fixed-point number.
    /// @dev See the documentation for the "PRBMath.mulDivFixedPoint" function.
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The product as an unsigned 60.18-decimal fixed-point number.
    function mul(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDivFixedPoint(x, y);
    }

    /// @notice Returns PI as an unsigned 60.18-decimal fixed-point number.
    function pi() internal pure returns (uint256 result) {
        result = 3_141592653589793238;
    }

    /// @notice Raises x to the power of y.
    ///
    /// @dev Based on the insight that x^y = 2^(log2(x) * y).
    ///
    /// Requirements:
    /// - All from "exp2", "log2" and "mul".
    ///
    /// Caveats:
    /// - All from "exp2", "log2" and "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x Number to raise to given power y, as an unsigned 60.18-decimal fixed-point number.
    /// @param y Exponent to raise x to, as an unsigned 60.18-decimal fixed-point number.
    /// @return result x raised to power y, as an unsigned 60.18-decimal fixed-point number.
    function pow(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            result = y == 0 ? SCALE : uint256(0);
        } else {
            result = exp2(mul(log2(x), y));
        }
    }

    /// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the
    /// famous algorithm "exponentiation by squaring".
    ///
    /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring
    ///
    /// Requirements:
    /// - The result must fit within MAX_UD60x18.
    ///
    /// Caveats:
    /// - All from "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x The base as an unsigned 60.18-decimal fixed-point number.
    /// @param y The exponent as an uint256.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function powu(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // Calculate the first iteration of the loop in advance.
        result = y & 1 > 0 ? x : SCALE;

        // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster.
        for (y >>= 1; y > 0; y >>= 1) {
            x = PRBMath.mulDivFixedPoint(x, x);

            // Equivalent to "y % 2 == 1" but faster.
            if (y & 1 > 0) {
                result = PRBMath.mulDivFixedPoint(result, x);
            }
        }
    }

    /// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number.
    function scale() internal pure returns (uint256 result) {
        result = SCALE;
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Requirements:
    /// - x must be less than MAX_UD60x18 / SCALE.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root.
    /// @return result The result as an unsigned 60.18-decimal fixed-point .
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__SqrtOverflow(x);
            }
            // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned
            // 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root).
            result = PRBMath.sqrt(x * SCALE);
        }
    }

    /// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process.
    /// @param x The unsigned 60.18-decimal fixed-point number to convert.
    /// @return result The same number in basic integer form.
    function toUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            result = x / SCALE;
        }
    }
}

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

import "./IPriceFeed.sol";

interface IThalesAMM {
    enum Position {
        Up,
        Down
    }

    function manager() external view returns (address);

    function availableToBuyFromAMM(address market, Position position) external view returns (uint);

    function impliedVolatilityPerAsset(bytes32 oracleKey) external view returns (uint);

    function buyFromAmmQuote(
        address market,
        Position position,
        uint amount
    ) external view returns (uint);

    function buyFromAMM(
        address market,
        Position position,
        uint amount,
        uint expectedPayout,
        uint additionalSlippage
    ) external returns (uint);

    function availableToSellToAMM(address market, Position position) external view returns (uint);

    function sellToAmmQuote(
        address market,
        Position position,
        uint amount
    ) external view returns (uint);

    function sellToAMM(
        address market,
        Position position,
        uint amount,
        uint expectedPayout,
        uint additionalSlippage
    ) external returns (uint);

    function isMarketInAMMTrading(address market) external view returns (bool);

    function price(address market, Position position) external view returns (uint);

    function buyPriceImpact(
        address market,
        Position position,
        uint amount
    ) external view returns (int);

    function sellPriceImpact(
        address market,
        Position position,
        uint amount
    ) external view returns (int);

    function priceFeed() external view returns (IPriceFeed);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.16;

import "../interfaces/IPositionalMarketManager.sol";
import "../interfaces/IPosition.sol";
import "../interfaces/IPriceFeed.sol";

interface IPositionalMarket {
    /* ========== TYPES ========== */

    enum Phase {
        Trading,
        Maturity,
        Expiry
    }
    enum Side {
        Up,
        Down
    }

    /* ========== VIEWS / VARIABLES ========== */

    function getOptions() external view returns (IPosition up, IPosition down);

    function times() external view returns (uint maturity, uint destructino);

    function getOracleDetails()
        external
        view
        returns (
            bytes32 key,
            uint strikePrice,
            uint finalPrice
        );

    function fees() external view returns (uint poolFee, uint creatorFee);

    function deposited() external view returns (uint);

    function creator() external view returns (address);

    function resolved() external view returns (bool);

    function phase() external view returns (Phase);

    function oraclePrice() external view returns (uint);

    function oraclePriceAndTimestamp() external view returns (uint price, uint updatedAt);

    function canResolve() external view returns (bool);

    function result() external view returns (Side);

    function balancesOf(address account) external view returns (uint up, uint down);

    function totalSupplies() external view returns (uint up, uint down);

    function getMaximumBurnable(address account) external view returns (uint amount);

    /* ========== MUTATIVE FUNCTIONS ========== */

    function mint(uint value) external;

    function exerciseOptions() external returns (uint);

    function burnOptions(uint amount) external;

    function burnOptionsMaximum() external;
}

// SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivFixedPointOverflow(uint256 prod1);

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivOverflow(uint256 prod1, uint256 denominator);

/// @notice Emitted when one of the inputs is type(int256).min.
error PRBMath__MulDivSignedInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows int256.
error PRBMath__MulDivSignedOverflow(uint256 rAbs);

/// @notice Emitted when the input is MIN_SD59x18.
error PRBMathSD59x18__AbsInputTooSmall();

/// @notice Emitted when ceiling a number overflows SD59x18.
error PRBMathSD59x18__CeilOverflow(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__DivInputTooSmall();

/// @notice Emitted when one of the intermediary unsigned results overflows SD59x18.
error PRBMathSD59x18__DivOverflow(uint256 rAbs);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathSD59x18__ExpInputTooBig(int256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathSD59x18__Exp2InputTooBig(int256 x);

/// @notice Emitted when flooring a number underflows SD59x18.
error PRBMathSD59x18__FloorUnderflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format overflows SD59x18.
error PRBMathSD59x18__FromIntOverflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format underflows SD59x18.
error PRBMathSD59x18__FromIntUnderflow(int256 x);

/// @notice Emitted when the product of the inputs is negative.
error PRBMathSD59x18__GmNegativeProduct(int256 x, int256 y);

/// @notice Emitted when multiplying the inputs overflows SD59x18.
error PRBMathSD59x18__GmOverflow(int256 x, int256 y);

/// @notice Emitted when the input is less than or equal to zero.
error PRBMathSD59x18__LogInputTooSmall(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__MulInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__MulOverflow(uint256 rAbs);

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__PowuOverflow(uint256 rAbs);

/// @notice Emitted when the input is negative.
error PRBMathSD59x18__SqrtNegativeInput(int256 x);

/// @notice Emitted when the calculating the square root overflows SD59x18.
error PRBMathSD59x18__SqrtOverflow(int256 x);

/// @notice Emitted when addition overflows UD60x18.
error PRBMathUD60x18__AddOverflow(uint256 x, uint256 y);

/// @notice Emitted when ceiling a number overflows UD60x18.
error PRBMathUD60x18__CeilOverflow(uint256 x);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathUD60x18__ExpInputTooBig(uint256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathUD60x18__Exp2InputTooBig(uint256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format format overflows UD60x18.
error PRBMathUD60x18__FromUintOverflow(uint256 x);

/// @notice Emitted when multiplying the inputs overflows UD60x18.
error PRBMathUD60x18__GmOverflow(uint256 x, uint256 y);

/// @notice Emitted when the input is less than 1.
error PRBMathUD60x18__LogInputTooSmall(uint256 x);

/// @notice Emitted when the calculating the square root overflows UD60x18.
error PRBMathUD60x18__SqrtOverflow(uint256 x);

/// @notice Emitted when subtraction underflows UD60x18.
error PRBMathUD60x18__SubUnderflow(uint256 x, uint256 y);

/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library
/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point
/// representation. When it does not, it is explicitly mentioned in the NatSpec documentation.
library PRBMath {
    /// STRUCTS ///

    struct SD59x18 {
        int256 value;
    }

    struct UD60x18 {
        uint256 value;
    }

    /// STORAGE ///

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @dev Largest power of two divisor of SCALE.
    uint256 internal constant SCALE_LPOTD = 262144;

    /// @dev SCALE inverted mod 2^256.
    uint256 internal constant SCALE_INVERSE =
        78156646155174841979727994598816262306175212592076161876661_508869554232690281;

    /// FUNCTIONS ///

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    /// @dev Has to use 192.64-bit fixed-point numbers.
    /// See https://ethereum.stackexchange.com/a/96594/24693.
    /// @param x The exponent as an unsigned 192.64-bit fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // Start from 0.5 in the 192.64-bit fixed-point format.
            result = 0x800000000000000000000000000000000000000000000000;

            // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows
            // because the initial result is 2^191 and all magic factors are less than 2^65.
            if (x & 0x8000000000000000 > 0) {
                result = (result * 0x16A09E667F3BCC909) >> 64;
            }
            if (x & 0x4000000000000000 > 0) {
                result = (result * 0x1306FE0A31B7152DF) >> 64;
            }
            if (x & 0x2000000000000000 > 0) {
                result = (result * 0x1172B83C7D517ADCE) >> 64;
            }
            if (x & 0x1000000000000000 > 0) {
                result = (result * 0x10B5586CF9890F62A) >> 64;
            }
            if (x & 0x800000000000000 > 0) {
                result = (result * 0x1059B0D31585743AE) >> 64;
            }
            if (x & 0x400000000000000 > 0) {
                result = (result * 0x102C9A3E778060EE7) >> 64;
            }
            if (x & 0x200000000000000 > 0) {
                result = (result * 0x10163DA9FB33356D8) >> 64;
            }
            if (x & 0x100000000000000 > 0) {
                result = (result * 0x100B1AFA5ABCBED61) >> 64;
            }
            if (x & 0x80000000000000 > 0) {
                result = (result * 0x10058C86DA1C09EA2) >> 64;
            }
            if (x & 0x40000000000000 > 0) {
                result = (result * 0x1002C605E2E8CEC50) >> 64;
            }
            if (x & 0x20000000000000 > 0) {
                result = (result * 0x100162F3904051FA1) >> 64;
            }
            if (x & 0x10000000000000 > 0) {
                result = (result * 0x1000B175EFFDC76BA) >> 64;
            }
            if (x & 0x8000000000000 > 0) {
                result = (result * 0x100058BA01FB9F96D) >> 64;
            }
            if (x & 0x4000000000000 > 0) {
                result = (result * 0x10002C5CC37DA9492) >> 64;
            }
            if (x & 0x2000000000000 > 0) {
                result = (result * 0x1000162E525EE0547) >> 64;
            }
            if (x & 0x1000000000000 > 0) {
                result = (result * 0x10000B17255775C04) >> 64;
            }
            if (x & 0x800000000000 > 0) {
                result = (result * 0x1000058B91B5BC9AE) >> 64;
            }
            if (x & 0x400000000000 > 0) {
                result = (result * 0x100002C5C89D5EC6D) >> 64;
            }
            if (x & 0x200000000000 > 0) {
                result = (result * 0x10000162E43F4F831) >> 64;
            }
            if (x & 0x100000000000 > 0) {
                result = (result * 0x100000B1721BCFC9A) >> 64;
            }
            if (x & 0x80000000000 > 0) {
                result = (result * 0x10000058B90CF1E6E) >> 64;
            }
            if (x & 0x40000000000 > 0) {
                result = (result * 0x1000002C5C863B73F) >> 64;
            }
            if (x & 0x20000000000 > 0) {
                result = (result * 0x100000162E430E5A2) >> 64;
            }
            if (x & 0x10000000000 > 0) {
                result = (result * 0x1000000B172183551) >> 64;
            }
            if (x & 0x8000000000 > 0) {
                result = (result * 0x100000058B90C0B49) >> 64;
            }
            if (x & 0x4000000000 > 0) {
                result = (result * 0x10000002C5C8601CC) >> 64;
            }
            if (x & 0x2000000000 > 0) {
                result = (result * 0x1000000162E42FFF0) >> 64;
            }
            if (x & 0x1000000000 > 0) {
                result = (result * 0x10000000B17217FBB) >> 64;
            }
            if (x & 0x800000000 > 0) {
                result = (result * 0x1000000058B90BFCE) >> 64;
            }
            if (x & 0x400000000 > 0) {
                result = (result * 0x100000002C5C85FE3) >> 64;
            }
            if (x & 0x200000000 > 0) {
                result = (result * 0x10000000162E42FF1) >> 64;
            }
            if (x & 0x100000000 > 0) {
                result = (result * 0x100000000B17217F8) >> 64;
            }
            if (x & 0x80000000 > 0) {
                result = (result * 0x10000000058B90BFC) >> 64;
            }
            if (x & 0x40000000 > 0) {
                result = (result * 0x1000000002C5C85FE) >> 64;
            }
            if (x & 0x20000000 > 0) {
                result = (result * 0x100000000162E42FF) >> 64;
            }
            if (x & 0x10000000 > 0) {
                result = (result * 0x1000000000B17217F) >> 64;
            }
            if (x & 0x8000000 > 0) {
                result = (result * 0x100000000058B90C0) >> 64;
            }
            if (x & 0x4000000 > 0) {
                result = (result * 0x10000000002C5C860) >> 64;
            }
            if (x & 0x2000000 > 0) {
                result = (result * 0x1000000000162E430) >> 64;
            }
            if (x & 0x1000000 > 0) {
                result = (result * 0x10000000000B17218) >> 64;
            }
            if (x & 0x800000 > 0) {
                result = (result * 0x1000000000058B90C) >> 64;
            }
            if (x & 0x400000 > 0) {
                result = (result * 0x100000000002C5C86) >> 64;
            }
            if (x & 0x200000 > 0) {
                result = (result * 0x10000000000162E43) >> 64;
            }
            if (x & 0x100000 > 0) {
                result = (result * 0x100000000000B1721) >> 64;
            }
            if (x & 0x80000 > 0) {
                result = (result * 0x10000000000058B91) >> 64;
            }
            if (x & 0x40000 > 0) {
                result = (result * 0x1000000000002C5C8) >> 64;
            }
            if (x & 0x20000 > 0) {
                result = (result * 0x100000000000162E4) >> 64;
            }
            if (x & 0x10000 > 0) {
                result = (result * 0x1000000000000B172) >> 64;
            }
            if (x & 0x8000 > 0) {
                result = (result * 0x100000000000058B9) >> 64;
            }
            if (x & 0x4000 > 0) {
                result = (result * 0x10000000000002C5D) >> 64;
            }
            if (x & 0x2000 > 0) {
                result = (result * 0x1000000000000162E) >> 64;
            }
            if (x & 0x1000 > 0) {
                result = (result * 0x10000000000000B17) >> 64;
            }
            if (x & 0x800 > 0) {
                result = (result * 0x1000000000000058C) >> 64;
            }
            if (x & 0x400 > 0) {
                result = (result * 0x100000000000002C6) >> 64;
            }
            if (x & 0x200 > 0) {
                result = (result * 0x10000000000000163) >> 64;
            }
            if (x & 0x100 > 0) {
                result = (result * 0x100000000000000B1) >> 64;
            }
            if (x & 0x80 > 0) {
                result = (result * 0x10000000000000059) >> 64;
            }
            if (x & 0x40 > 0) {
                result = (result * 0x1000000000000002C) >> 64;
            }
            if (x & 0x20 > 0) {
                result = (result * 0x10000000000000016) >> 64;
            }
            if (x & 0x10 > 0) {
                result = (result * 0x1000000000000000B) >> 64;
            }
            if (x & 0x8 > 0) {
                result = (result * 0x10000000000000006) >> 64;
            }
            if (x & 0x4 > 0) {
                result = (result * 0x10000000000000003) >> 64;
            }
            if (x & 0x2 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }
            if (x & 0x1 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }

            // We're doing two things at the same time:
            //
            //   1. Multiply the result by 2^n + 1, where "2^n" is the integer part and the one is added to account for
            //      the fact that we initially set the result to 0.5. This is accomplished by subtracting from 191
            //      rather than 192.
            //   2. Convert the result to the unsigned 60.18-decimal fixed-point format.
            //
            // This works because 2^(191-ip) = 2^ip / 2^191, where "ip" is the integer part "2^n".
            result *= SCALE;
            result >>= (191 - (x >> 64));
        }
    }

    /// @notice Finds the zero-based index of the first one in the binary representation of x.
    /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set
    /// @param x The uint256 number for which to find the index of the most significant bit.
    /// @return msb The index of the most significant bit as an uint256.
    function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
        if (x >= 2**128) {
            x >>= 128;
            msb += 128;
        }
        if (x >= 2**64) {
            x >>= 64;
            msb += 64;
        }
        if (x >= 2**32) {
            x >>= 32;
            msb += 32;
        }
        if (x >= 2**16) {
            x >>= 16;
            msb += 16;
        }
        if (x >= 2**8) {
            x >>= 8;
            msb += 8;
        }
        if (x >= 2**4) {
            x >>= 4;
            msb += 4;
        }
        if (x >= 2**2) {
            x >>= 2;
            msb += 2;
        }
        if (x >= 2**1) {
            // No need to shift x any more.
            msb += 1;
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The multiplicand as an uint256.
    /// @param y The multiplier as an uint256.
    /// @param denominator The divisor as an uint256.
    /// @return result The result as an uint256.
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
        // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
        // variables such that product = prod1 * 2^256 + prod0.
        uint256 prod0; // Least significant 256 bits of the product
        uint256 prod1; // Most significant 256 bits of the product
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        // Handle non-overflow cases, 256 by 256 division.
        if (prod1 == 0) {
            unchecked {
                result = prod0 / denominator;
            }
            return result;
        }

        // Make sure the result is less than 2^256. Also prevents denominator == 0.
        if (prod1 >= denominator) {
            revert PRBMath__MulDivOverflow(prod1, denominator);
        }

        ///////////////////////////////////////////////
        // 512 by 256 division.
        ///////////////////////////////////////////////

        // Make division exact by subtracting the remainder from [prod1 prod0].
        uint256 remainder;
        assembly {
            // Compute remainder using mulmod.
            remainder := mulmod(x, y, denominator)

            // Subtract 256 bit number from 512 bit number.
            prod1 := sub(prod1, gt(remainder, prod0))
            prod0 := sub(prod0, remainder)
        }

        // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
        // See https://cs.stackexchange.com/q/138556/92363.
        unchecked {
            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 lpotdod = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by lpotdod.
                denominator := div(denominator, lpotdod)

                // Divide [prod1 prod0] by lpotdod.
                prod0 := div(prod0, lpotdod)

                // Flip lpotdod such that it is 2^256 / lpotdod. If lpotdod is zero, then it becomes one.
                lpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * lpotdod;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /// @notice Calculates floor(x*y÷1e18) with full precision.
    ///
    /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the
    /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of
    /// being rounded to 1e-18.  See "Listing 6" and text above it at https://accu.org/index.php/journals/1717.
    ///
    /// Requirements:
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works.
    /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations:
    ///     1. x * y = type(uint256).max * SCALE
    ///     2. (x * y) % SCALE >= SCALE / 2
    ///
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) {
        uint256 prod0;
        uint256 prod1;
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        if (prod1 >= SCALE) {
            revert PRBMath__MulDivFixedPointOverflow(prod1);
        }

        uint256 remainder;
        uint256 roundUpUnit;
        assembly {
            remainder := mulmod(x, y, SCALE)
            roundUpUnit := gt(remainder, 499999999999999999)
        }

        if (prod1 == 0) {
            unchecked {
                result = (prod0 / SCALE) + roundUpUnit;
                return result;
            }
        }

        assembly {
            result := add(
                mul(
                    or(
                        div(sub(prod0, remainder), SCALE_LPOTD),
                        mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
                    ),
                    SCALE_INVERSE
                ),
                roundUpUnit
            )
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately.
    ///
    /// Requirements:
    /// - None of the inputs can be type(int256).min.
    /// - The result must fit within int256.
    ///
    /// @param x The multiplicand as an int256.
    /// @param y The multiplier as an int256.
    /// @param denominator The divisor as an int256.
    /// @return result The result as an int256.
    function mulDivSigned(
        int256 x,
        int256 y,
        int256 denominator
    ) internal pure returns (int256 result) {
        if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
            revert PRBMath__MulDivSignedInputTooSmall();
        }

        // Get hold of the absolute values of x, y and the denominator.
        uint256 ax;
        uint256 ay;
        uint256 ad;
        unchecked {
            ax = x < 0 ? uint256(-x) : uint256(x);
            ay = y < 0 ? uint256(-y) : uint256(y);
            ad = denominator < 0 ? uint256(-denominator) : uint256(denominator);
        }

        // Compute the absolute value of (x*y)÷denominator. The result must fit within int256.
        uint256 rAbs = mulDiv(ax, ay, ad);
        if (rAbs > uint256(type(int256).max)) {
            revert PRBMath__MulDivSignedOverflow(rAbs);
        }

        // Get the signs of x, y and the denominator.
        uint256 sx;
        uint256 sy;
        uint256 sd;
        assembly {
            sx := sgt(x, sub(0, 1))
            sy := sgt(y, sub(0, 1))
            sd := sgt(denominator, sub(0, 1))
        }

        // XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs.
        // If yes, the result should be negative.
        result = sx ^ sy ^ sd == 0 ? -int256(rAbs) : int256(rAbs);
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The uint256 number for which to calculate the square root.
    /// @return result The result as an uint256.
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        // Set the initial guess to the least power of two that is greater than or equal to sqrt(x).
        uint256 xAux = uint256(x);
        result = 1;
        if (xAux >= 0x100000000000000000000000000000000) {
            xAux >>= 128;
            result <<= 64;
        }
        if (xAux >= 0x10000000000000000) {
            xAux >>= 64;
            result <<= 32;
        }
        if (xAux >= 0x100000000) {
            xAux >>= 32;
            result <<= 16;
        }
        if (xAux >= 0x10000) {
            xAux >>= 16;
            result <<= 8;
        }
        if (xAux >= 0x100) {
            xAux >>= 8;
            result <<= 4;
        }
        if (xAux >= 0x10) {
            xAux >>= 4;
            result <<= 2;
        }
        if (xAux >= 0x8) {
            result <<= 1;
        }

        // The operations can never overflow because the result is max 2^127 when it enters this block.
        unchecked {
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1; // Seven iterations should be enough
            uint256 roundedDownResult = x / result;
            return result >= roundedDownResult ? roundedDownResult : result;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.16;

interface IPriceFeed {
    // Structs
    struct RateAndUpdatedTime {
        uint216 rate;
        uint40 time;
    }

    // Mutative functions
    function addAggregator(bytes32 currencyKey, address aggregatorAddress) external;

    function removeAggregator(bytes32 currencyKey) external;

    // Views

    function rateForCurrency(bytes32 currencyKey) external view returns (uint);

    function rateAndUpdatedTime(bytes32 currencyKey) external view returns (uint rate, uint time);

    function getRates() external view returns (uint[] memory);

    function getCurrencies() external view returns (bytes32[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.16;

import "../interfaces/IPositionalMarket.sol";

interface IPositionalMarketManager {
    /* ========== VIEWS / VARIABLES ========== */

    function durations() external view returns (uint expiryDuration, uint maxTimeToMaturity);

    function capitalRequirement() external view returns (uint);

    function marketCreationEnabled() external view returns (bool);

    function onlyAMMMintingAndBurning() external view returns (bool);

    function transformCollateral(uint value) external view returns (uint);

    function reverseTransformCollateral(uint value) external view returns (uint);

    function totalDeposited() external view returns (uint);

    function numActiveMarkets() external view returns (uint);

    function activeMarkets(uint index, uint pageSize) external view returns (address[] memory);

    function numMaturedMarkets() external view returns (uint);

    function maturedMarkets(uint index, uint pageSize) external view returns (address[] memory);

    function isActiveMarket(address candidate) external view returns (bool);

    function isKnownMarket(address candidate) external view returns (bool);

    function getThalesAMM() external view returns (address);

    /* ========== MUTATIVE FUNCTIONS ========== */

    function createMarket(
        bytes32 oracleKey,
        uint strikePrice,
        uint maturity,
        uint initialMint // initial sUSD to mint options for,
    ) external returns (IPositionalMarket);

    function resolveMarket(address market) external;

    function expireMarkets(address[] calldata market) external;

    function transferSusdTo(
        address sender,
        address receiver,
        uint amount
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.16;

import "./IPositionalMarket.sol";

interface IPosition {
    /* ========== VIEWS / VARIABLES ========== */

    function getBalanceOf(address account) external view returns (uint);

    function getTotalSupply() external view returns (uint);

    function exerciseWithAmount(address claimant, uint amount) external;
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__Exp2InputTooBig","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__LogInputTooSmall","type":"error"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"}],"name":"PRBMath__MulDivFixedPointOverflow","type":"error"},{"inputs":[{"internalType":"address","name":"market","type":"address"},{"internalType":"enum IThalesAMM.Position","name":"position","type":"uint8"},{"internalType":"address","name":"addressToCheck","type":"address"}],"name":"balanceOfPositionOnMarket","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"market","type":"address"},{"internalType":"enum IThalesAMM.Position","name":"position","type":"uint8"},{"internalType":"address","name":"addressToCheck","type":"address"}],"name":"balanceOfPositionsOnMarket","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"balanceOtherSide","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"balanceOtherSide","type":"uint256"},{"internalType":"uint256","name":"balancePosition","type":"uint256"},{"internalType":"uint256","name":"balanceOtherSideAfter","type":"uint256"},{"internalType":"uint256","name":"balancePositionAfter","type":"uint256"},{"internalType":"uint256","name":"availableToBuyFromAMM","type":"uint256"},{"internalType":"uint256","name":"max_spread","type":"uint256"}],"internalType":"struct ThalesAMMUtils.PriceImpactParams","name":"params","type":"tuple"}],"name":"buyPriceImpactImbalancedSkew","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"balancePosition","type":"uint256"},{"internalType":"uint256","name":"balanceOtherSide","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"availableToBuyFromAMM","type":"uint256"},{"internalType":"uint256","name":"max_spread","type":"uint256"}],"internalType":"struct ThalesAMMUtils.DiscountParams","name":"params","type":"tuple"}],"name":"calculateDiscount","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"uint256","name":"strike","type":"uint256"},{"internalType":"uint256","name":"timeLeftInDays","type":"uint256"},{"internalType":"uint256","name":"volatility","type":"uint256"}],"name":"calculateOdds","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"market","type":"address"},{"internalType":"address","name":"addressToCheck","type":"address"}],"name":"getBalanceOfPositionsOnMarket","outputs":[{"internalType":"uint256","name":"upBalance","type":"uint256"},{"internalType":"uint256","name":"downBalance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"balanceOtherSide","type":"uint256"},{"internalType":"uint256","name":"_balancePosition","type":"uint256"},{"internalType":"uint256","name":"balanceOtherSideAfter","type":"uint256"},{"internalType":"uint256","name":"balancePositionAfter","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"max_spread","type":"uint256"}],"name":"sellPriceImpactImbalancedSkew","outputs":[{"internalType":"uint256","name":"_sellImpactReturned","type":"uint256"}],"stateMutability":"view","type":"function"}]

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