optipair.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

import {IERC20} from "./interfaces/IERC20.sol";
import {AggregatorV3Interface} from
    "../lib/chainlink-brownie-contracts/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";

/**
 * @title OptionAMM
 * @notice This contract implements an Automated Market Maker (AMM) for options trading.
 * @author Yug Agarwal
 * @dev This contract allows users to provide liquidity for options trading and earn profit.
 *
 *                          .            .                                   .#
 *                        +#####+---+###+#############+-                  -+###.
 *                        +###+++####+##-+++++##+++##++####+-.         -+###+++
 *                        +#########.-#+--+####++###- -########+---+++#####+++
 *                        +#######+#+++--+####+-..-+-.###+++########+-++###++.
 *                       +######.     +#-#####+-.-------+############+++####-
 *                      +####++...     ########-++-        +##########++++++.
 *                     -#######-+.    .########+++          -++######+++-
 *                     #++########--+-+####++++-- . ..    .-#++--+##+####.
 *                    -+++++++++#####---###---.----###+-+########..-+#++##-
 *                    ++###+++++#####-..---.. .+##++++#++#++-+--.   .-++++#
 *                   .###+.  .+#+-+###+ ..    +##+##+#++----...---.  .-+--+.
 *                   ###+---------+####+   -####+-.......    ...--++.  .---.
 *                  -#++++-----#######+-  .-+###+.... .....      .-+##-.  .
 *                  ##+++###++######++-.   .--+---++---........  ...---.  .
 *                 -####+-+#++###++-.        .--.--...-----.......--..... .
 *                 +######+++###+--..---.....  ...---------------.. .. .  .
 *                .-#########+#+++--++--------......----++--.--.  .--+---.
 *                 -+++########++--++++----------------------.--+++--+++--
 *            .######-.-++++###+----------------------..---++--++-+++---..
 *            -##########-------+-----------------------+-++-++----..----+----+#####++--..
 *            -#############+..  ..--..----------.....-+++++++++++++++++##################+.
 *            --+++++#########+-   . ....  ....... -+++++++++++++++++++############-.----+##-
 *            -----....-+#######+-             .. -+++++++++++++++++++++##+######+.       +++.
 *            --------.....---+#####+--......----.+++++++++++++++++++++##+-+++##+.        -++-
 *            -------...   .--++++++---.....-----.+++++++++++++++++++++++. -+++##-        .---
 *            #################+--.....-------.  .+++++++++++++++++++++-       -+-.       .---
 *            +#########++++-.. .......-+--..--++-++++++++++++++++++++-         .-... ....----
 *            -#####++---..   .--       -+++-.  ..+++++++++++++++++++--        .-+-......-+---
 *            +####+---...    -+#-   .  --++++-. .+++++++++++++++++++---        --        -+--
 *            ++++++++++--....-++.--++--.--+++++-.+++++++++++++++++++---. .......         ----
 *           .--++#########++-.--.+++++--++++###+-++++++++++++++++++++----   .-++-        ----
 *            .-+#############+-.++#+-+-++#######-++++++++++++++++++++----   -++++-      ..---
 *           .---+############+.+###++--++#####++-+++++++++++++++++++++-------++++-........-+-
 *            --+-+##########-+######+++++-++++++-++++++++++++++++++++++-----.----.......---+-
 *           .--+---#######..+#######+++++++--+++-+++++++++++++++++++++++-----------------+++-
 *           .++--..-+##-.-########+++++---++ .+-.+++++++++++++++++++++++++++++++++++---+++++-
 *           -+++. ..-..-+#########++-++--..--....+++++++++++++++++++++++++++++++++++++++++++-
 *           -++-......-+++############++++----- .+++++++++++++++++++++++++++++++++++++++++++-
 *           +##-.....---+#######+####+####+--++-.+++++++++++++++++++++++++++++++++++++++++++-
 *          .#+++-...-++######++-+-----..----++##-+++++++++++++++++++++++++++++++++++++++++++-
 *          .+++--------+##----+------+-..----+++-+++++++++++++++++++++++++++++++++++++++++++-
 *           ----.-----+++-+-...------++-----...--+++++++++++++++++++++++++++++++++++++++++++-
 *          .-..-.--.----..--.... ....++--.  ....-+++++++++++++++++++++++++++++++++++++++++++-
 *           -----------.---..--..   ..+.  . ... .+++++++++++++++++++++++++++++++++++++++++++-
 *         .+#+#+---####+-.    .....--...   .    .+++++++++++++++++++++++++++++++++++++++++++-
 *         -+++++#++++++++.    ..-...--.. ..     .+++++++++++++++++++++++++++++++++++++++++++-
 *         ++++++-------++--   . ....--.. . . .. .+++++++++++++++++++++++++-+----------...
 *         -++++--++++.------......-- ...  ..  . .---------------...
 *         -++-+####+++---..-.........
 *           .....
 */
contract OptionAMM {
    error Optipair__ZeroAmount();

    struct Option {
        uint256 strikePrice;
        uint256 lotSize; // x
        uint256 premium; // y
        uint256 expiry;
        bool isCall;
        address creator;
        bool purchased;
    }

    Option[] private options;
    IERC20 private immutable i_usdc; // USDC token contract interface
    AggregatorV3Interface private immutable i_priceFeed; // Chainlink price feed interface

    uint256 private constant DECIMAL_PRECISION = 18;
    uint256 private immutable i_usdcDecimals;

    // Mapping from option ID to user address to active status
    mapping(uint256 => mapping(address => bool)) private optionOwnership;

    // Liquidity tracking
    uint256 private totalLiquidity;
    uint256 private totalPremiumLiquidity;
    mapping(address => uint256) private liquidityContributions;
    uint16 private immutable i_minPremiumPercentage; // Minimum premium percentage for options
    mapping(address => uint256[]) private userOptions; // Mapping from user address to option IDs they own

    event OptionCreated(
        uint256 indexed optionId, uint256 strikePrice, uint256 lotSize, uint256 premium, uint256 expiry, bool isCall
    );
    event OptionPurchased(uint256 indexed optionId, address buyer, uint256 lotAmount, uint256 cost);
    event LiquidityAdded(address indexed provider, uint256 amount);
    event LiquidityRemoved(address indexed provider, uint256 amount);
    event OptionSettled(uint256 indexed optionId, address indexed holder, uint256 payout, bool inTheMoney);

    /**
     * @param _usdcAddress USDC token contract address
     * @param _priceFeedAddress The ETH/USD(for now) chainlink price feed contract address
     */
    constructor(address _usdcAddress, address _priceFeedAddress, uint16 _minPremiumPercentage) {
        require(_minPremiumPercentage > 0 && _minPremiumPercentage <= 10000, "Invalid min premium percentage");
        require(_usdcAddress != address(0), "USDC address cannot be zero");
        require(_priceFeedAddress != address(0), "Price feed address cannot be zero");

        i_usdc = IERC20(_usdcAddress);
        // ftso = FtsoV2Interface(_ftsoAddress);
        i_priceFeed = AggregatorV3Interface(_priceFeedAddress);

        i_usdcDecimals = IERC20(_usdcAddress).decimals();

        i_minPremiumPercentage = _minPremiumPercentage;
    }

    /**
     * @param _strikePrice strike price of the option in USD (18 decimals)
     * @param _lotSize lot size of the option (number of tokens in the option, in 18 decimals)
     * @param _premium premium price of the option (in USDC, 18 decimals)
     * @param _expiry expiry timestamp of the option (in seconds)
     * @param _isCall boolean indicating if the option is a call option (true) or a put option (false)
     */
    function createOption(uint256 _strikePrice, uint256 _lotSize, uint256 _premium, uint256 _expiry, bool _isCall)
        public
    {
        uint256 latestPrice = getLatestPrice();
        require(_isCall ? _strikePrice > latestPrice : _strikePrice < latestPrice, "Strike price not valid");
        require(_strikePrice > 0, "Strike price must be greater than 0");
        require(_lotSize > 0, "Lot size must be greater than 0");
        require(_premium >= _strikePrice * i_minPremiumPercentage / 10000, "Premium too low");
        require(_expiry > block.timestamp, "Expiry must be in the future");

        options.push(
            Option({
                strikePrice: _strikePrice,
                lotSize: _lotSize,
                premium: _premium,
                expiry: _expiry,
                isCall: _isCall,
                creator: msg.sender,
                purchased: false
            })
        );
        uint256 optionId = options.length - 1;
        emit OptionCreated(optionId, _strikePrice, _lotSize, _premium, _expiry, _isCall);
    }

    /**
     *
     * @param _optionId ID of the option to purchase
     */
    function purchaseOption(uint256 _optionId) public {
        require(_optionId < options.length, "Option does not exist");
        Option memory option = options[_optionId];
        require(block.timestamp < option.expiry, "Option has expired");

        // uint256 currentPremium = option.lotSize > 0 ? option.k / option.lotSize : 0;
        uint256 extraPenalty = getExtraPenalty(_optionId);

        uint256 cost = (option.premium + extraPenalty) * option.lotSize / 10 ** DECIMAL_PRECISION; // Adjust for decimals

        require(
            i_usdc.transferFrom(msg.sender, address(this), cost / 10 ** (DECIMAL_PRECISION - i_usdcDecimals)),
            "Failed to transfer USDC"
        );

        // option.lotSize -= _lotAmount; // Decrease lot size available
        // option.premium = option.lotSize > 0 ? option.k / option.lotSize : 0; // Update premium for next buyer
        optionOwnership[_optionId][msg.sender] = true; // Record the purchase
        totalLiquidity += cost; // Update total liquidity
        options[_optionId].purchased = true; // Mark option as purchased
        //options[_optionId].lotSize = 0;
        totalPremiumLiquidity += cost; // Update total premium liquidity
        userOptions[msg.sender].push(_optionId); // Add option ID to user's list

        emit OptionPurchased(_optionId, msg.sender, option.lotSize, cost);
    }

    /**
     *
     * @param _amount Amount of USDC to add as liquidity (in 18 decimals)
     */
    function addLiquidity(uint256 _amount) public {
        if (_amount == 0) revert Optipair__ZeroAmount();
        require(
            i_usdc.transferFrom(msg.sender, address(this), _amount / 10 ** (DECIMAL_PRECISION - i_usdcDecimals)),
            "Failed to transfer USDC"
        );
        liquidityContributions[msg.sender] += _amount;
        totalLiquidity += _amount;
        emit LiquidityAdded(msg.sender, _amount);
    }

    /**
     *
     * @param _amount Amount of USDC to remove as liquidity (in 18 decimals)
     */
    function removeLiquidity(uint256 _amount) public {
        if (_amount == 0) revert Optipair__ZeroAmount();
        require(liquidityContributions[msg.sender] >= _amount, "Insufficient liquidity");
        require(i_usdc.transfer(msg.sender, _amount / 10 ** (DECIMAL_PRECISION - i_usdcDecimals)), "Transfer failed");
        liquidityContributions[msg.sender] -= _amount;
        totalLiquidity -= _amount;
        emit LiquidityRemoved(msg.sender, _amount);
    }

    /**
     * @notice Settle an option after its expiry
     * @param optionId ID of the option to settle
     */
    function settleOption(uint256 optionId) public {
        require(optionId < options.length, "Option does not exist");
        Option memory option = options[optionId];
        require(block.timestamp >= option.expiry, "Option has not yet expired");
        require(optionOwnership[optionId][msg.sender], "You do not own this option");

        uint256 latestPrice = getLatestPrice();
        uint256 payout;
        bool inTheMoney;

        /*
            latest price = 1808.051 * 1e18 = 1808051 * 1e15
            strike price = 500 * 1e18 = 500000 * 1e15
            lot count = 1e18 = 1000 * 1e15
            price difference = 1808051 - 500000 = 13,08,051 * 1e15
            payout = 1308051000 * 1e12 * 1e18 / 1e30 = 1308051000 * 1e0 = 1308051000
        */

        if (option.isCall) {
            if (latestPrice > option.strikePrice) {
                inTheMoney = true;
                uint256 priceDifference = latestPrice - option.strikePrice;
                payout = priceDifference * option.lotSize / 10 ** DECIMAL_PRECISION;

                // Ensure there is enough liquidity to pay out
                require(totalLiquidity >= payout, "Insufficient liquidity for payout");
                require(
                    i_usdc.transfer(msg.sender, payout / 10 ** (DECIMAL_PRECISION - i_usdcDecimals)), "Payout failed"
                );
                totalLiquidity -= payout; // Update liquidity
            }
        } else {
            // Put option
            if (latestPrice < option.strikePrice) {
                inTheMoney = true;
                uint256 priceDifference = option.strikePrice - latestPrice;
                payout = priceDifference * option.lotSize / 10 ** DECIMAL_PRECISION;

                // Ensure there is enough liquidity to pay out
                require(totalLiquidity >= payout, "Insufficient liquidity for payout");
                require(
                    i_usdc.transfer(msg.sender, payout / 10 ** (DECIMAL_PRECISION - i_usdcDecimals)), "Payout failed"
                );
                totalLiquidity -= payout; // Update liquidity
            }
        }

        // if (
        //     (option.isCall && latestPrice > int256(option.strikePrice))
        //         || (option.isCall == false && latestPrice < int256(option.strikePrice))
        // ) {
        //     inTheMoney = true;
        //     uint256 priceDifference = uint256(abs(latestPrice - int256(option.strikePrice)));
        //     payout = priceDifference * lotCount;

        //     // Ensure there is enough liquidity to pay out
        //     require(totalLiquidity >= payout, "Insufficient liquidity for payout");
        //     require(usdc.transfer(msg.sender, payout), "Payout failed");
        //     totalLiquidity -= payout; // Update liquidity
        // }

        // Burn the settled options
        optionOwnership[optionId][msg.sender] = false;
        for (uint256 i = 0; i < userOptions[msg.sender].length; i++) {
            if (userOptions[msg.sender][i] == optionId) {
                userOptions[msg.sender][i] = userOptions[msg.sender][userOptions[msg.sender].length - 1];
                userOptions[msg.sender].pop();
                break;
            }
        }

        emit OptionSettled(optionId, msg.sender, payout, inTheMoney);
    }

    /**
     * @notice Get the latest price of ETH in USD from Chainlink
     * @return Latest price in 18 decimals
     */
    function getLatestPrice() public view returns (uint256) {
        (, int256 price,,,) = i_priceFeed.latestRoundData();
        uint8 decimals = i_priceFeed.decimals();

        return abs(price * int256(10 ** (18 - decimals))); // Convert to 18 decimals

        // bytes21[] memory feedIds = new bytes21[](1);
        // feedIds[0] = ETH_USD_FEED_ID;
        // (uint256[] memory values,,) = ftso.getFeedsById(feedIds);
        // return int256(values[0]);
    }

    /**
     * @notice Legacy payable function for backward compatibility (deprecated)
     * @dev Use getLatestPrice() instead - this function is gas inefficient
     * @return Latest price in 18 decimals
     */
    function getLatestPricePayable() public payable returns (uint256) {
        return getLatestPrice();
    }

    /**
     *
     * @param optionId ID of the option to get extra penalty for
     * @return Extra penalty amount in 18 decimals
     */
    function getExtraPenalty(uint256 optionId) public view returns (uint256) {
        require(optionId < options.length, "Option does not exist");
        Option memory option = options[optionId];
        uint256 latestPrice = getLatestPrice();
        uint256 extraPenalty = 0;

        if (option.isCall) {
            if (latestPrice > option.strikePrice) {
                extraPenalty = latestPrice - option.strikePrice;
            }
        } else {
            if (latestPrice < option.strikePrice) {
                extraPenalty = option.strikePrice - latestPrice;
            }
        }

        return extraPenalty;
    }

    /* Getter and Helper Functions */

    function abs(int256 x) private pure returns (uint256) {
        return x >= 0 ? uint256(x) : uint256(-x);
    }

    // Additional helper methods can be added here
    function getOptionsLength() public view returns (uint256) {
        return options.length;
    }

    function getUsersOptions(address user) public view returns (uint256[] memory) {
        return userOptions[user];
    }

    function getOptionsList() public view returns (Option[] memory) {
        return options;
    }

    function getMinPremiumPercentage() public view returns (uint16) {
        return i_minPremiumPercentage;
    }

    function getUsdcAddress() public view returns (address) {
        return address(i_usdc);
    }

    function getPriceFeedAddress() public view returns (address) {
        return address(i_priceFeed);
    }

    function getIsOwnerOfTheOption(uint256 optionId, address user) public view returns (bool) {
        return optionOwnership[optionId][user];
    }

    function getLiquidityContributionByAUser(address user) public view returns (uint256) {
        return liquidityContributions[user];
    }

    function getTotalLiquidity() public view returns (uint256) {
        return totalLiquidity;
    }

    function getOptionById(uint256 optionId) public view returns (Option memory) {
        require(optionId < options.length, "Option does not exist");
        return options[optionId];
    }

    function getOptionDetails(uint256 optionId) public view returns (Option memory) {
        require(optionId < options.length, "Option does not exist");
        return options[optionId];
    }

    function getTotalPremiumLiquidity() public view returns (uint256) {
        return totalPremiumLiquidity;
    }
}