// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@primitive/interfaces/IPrimitiveFactory.sol";
import "@primitive/interfaces/IPrimitiveEngine.sol";
import "./interfaces/IPrimitiveCallback.sol";
import "./interfaces/IFractionalVaultFactory.sol";
import "./interfaces/IFractionalVault.sol";
import "@oz/token/ERC20/IERC20.sol";
import "@oz/token/ERC20/utils/SafeERC20.sol";
import "@oz/token/ERC721/IERC721Receiver.sol";
import "@oz/token/ERC721/IERC721.sol";

/**
 * @title Fractionalized ERC721 Options
 * @notice Options for ERC721 assets via fractionalizing into ERC20 tokens & depositing into Primitve
 * @author verumlotus
 */
contract FractionalizedOption {
    using SafeERC20 for IERC20;
    using SafeERC20 for IFractionalVault;

    /************************************************
     *  IMMUTABLES & CONSTANTS
     ***********************************************/

    /// @notice address of the factory contract for Primitive Finance
    IPrimitiveFactory constant primFactory =
        IPrimitiveFactory(0x5cA2D631a37B21E5de2BcB0CbB892D723A96b068);

    /// @notice address of the Primitive Engine for this asset/stable pair
    IPrimitiveEngine immutable engine;

    /// @notice address of the factory contract for Fractional Art
    IFractionalVaultFactory constant fractionalArtFactory =
        IFractionalVaultFactory(0x85Aa7f78BdB2DE8F3e0c0010d99AD5853fFcfC63);

    /// @notice address of the vault contract for fractional art
    /// also is address of the ERC20 token representing the fractionalized NFT (risky asset in context of RMM Pool)
    IFractionalVault immutable fractionalArtVault;

    /// @notice address of the ERC20 token representing the stable asset
    IERC20 immutable stable;

    /// @notice poolId of our specific asset/stable pair in the primitive engine
    bytes32 immutable poolId;

    /// @notice the creator of this contract, and thus the primitive pool
    address immutable owner;

    /************************************************
     *  STRUCTS
     ***********************************************/

    /// @notice parameters for fractionalizing NFT on fractional.art
    struct FractionalParams {
        // name of ERC20 token
        string name;
        // symbol of ERC20 token
        string symbol;
        // address of nftToken
        address nftToken;
        // tokenId
        uint256 tokenId;
        // reserve price at start of fractional ownership
        uint256 listPrice;
        // fee for curator
        uint256 fee;
    }

    /// @notice parameters for creating an RMM-01 pool
    struct PrimitivePoolParams {
        // asset amount to deposit as LP in RMM Pool
        uint256 assetAmt;
        // stable amount to deposit as LP in RMM Pool
        uint256 stableAmt;
        // Strike price of the pool to calibrate to, with the same decimals as the stable token
        uint128 strike;
        // Implied Volatility to calibrate to as an unsigned 32-bit integer w/ precision of 1e4, 10000 = 100%
        uint32 sigma;
        // Maturity timestamp of the pool, in seconds
        uint32 maturity;
        // Multiplied against swap in amounts to apply fee, equal to 1 - fee %, an unsigned 32-bit integer, w/ precision of 1e4, 10000 = 100%
        uint32 gamma;
        // Risky reserve per liq. with risky decimals, = 1 - N(d1), d1 = (ln(S/K)+(r*sigma^2/2))/sigma*sqrt(tau)
        uint256 riskyPerLp;
        // Amount of liquidity to allocate to the curve, wei value with 18 decimals of precision
        uint256 delLiquidity;
    }

    /************************************************
     *  EVENTS, ERRORS, MODIFIERS
     ***********************************************/

    modifier onlyEngine() {
        require(msg.sender == address(engine), "Caller must be engine");
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Caller must be owner");
        _;
    }

    /**
     * @notice Franctionalizes the NFT and creates a Primitive Pool with specified parameters
     * @dev User must approve this contract to control NFT, and the appropriate amount of stable token balance
     * @param _stable the ERC20 token representing the stable asset
     * @param _fractionalParams helper parameters if we fractionalize this NFT (if not, pass in uninitialized struct)
     * @param _primitivePoolParams helper parameters for creating the primitive engine & pool
     */
    constructor(
        address _stable,
        FractionalParams memory _fractionalParams,
        PrimitivePoolParams memory _primitivePoolParams
    ) {
        owner = msg.sender;
        stable = IERC20(_stable);

        // First, fractionalize the NFT
        // Cache on stack
        address _token = _fractionalParams.nftToken;
        uint256 _tokenId = _fractionalParams.tokenId;

        // Transfer NFT to this contract
        IERC721(_token).safeTransferFrom(msg.sender, address(this), _tokenId);
        IERC721(_token).approve(address(fractionalArtFactory), _tokenId);
        uint256 vaultId = fractionalArtFactory.mint(
            _fractionalParams.name,
            _fractionalParams.symbol,
            _token,
            _tokenId,
            1e36,
            _fractionalParams.listPrice,
            _fractionalParams.fee
        );

        fractionalArtVault = IFractionalVault(
            fractionalArtFactory.vaults(vaultId)
        );
        fractionalArtVault.updateCurator(msg.sender);

        // Primitive Finance Logic
        // Create the engine
        engine = IPrimitiveEngine(
            primFactory.deploy(address(fractionalArtVault), address(stable))
        );
        (poolId, , ) = engine.create(
            _primitivePoolParams.strike,
            _primitivePoolParams.sigma,
            _primitivePoolParams.maturity,
            _primitivePoolParams.gamma,
            _primitivePoolParams.riskyPerLp,
            _primitivePoolParams.delLiquidity,
            ""
        );

        // There's a chance there's a small number of tokens left over after engine creation
        fractionalArtVault.safeTransfer(
            msg.sender,
            fractionalArtVault.balanceOf(address(this))
        );
        stable.safeTransfer(msg.sender, stable.balanceOf(address(this)));
    }

    /**
     * @notice deposits liquidity on behalf of msg.sender into the correct Primitive Pool
     * @dev Users will need to withdraw straight from primitive (an EOA is fine since there is no callback on a withdraw action)
     * @param delRisky amount of risky (fractional NFT ERC20 token) to deposit
     * @param delStable amount of stable token to deposit
     */
    function depositLiquidity(uint256 delRisky, uint256 delStable) external {
        fractionalArtVault.safeTransferFrom(
            msg.sender,
            address(this),
            delRisky
        );
        stable.safeTransferFrom(msg.sender, address(this), delStable);
        engine.allocate(poolId, msg.sender, delRisky, delStable, false, "");
    }

    /**
     * @notice Allows the pool creator to withdraw the initial liquidity they provided in the constructor
     * @param delRisky amount of risky (fractional NFT ERC20 token) to withdraw
     * @param delStable amount of stable token to withdraw
     */
    function withdrawInitialLiquidity(uint256 delRisky, uint256 delStable)
        external
        onlyOwner
    {
        // Withdraws from this contract's account & sends to msg.sender
        engine.withdraw(msg.sender, delRisky, delStable);
    }

    /************************************************
     *  Primitive Callbacks
     ***********************************************/
    /**
     * @notice Triggered when creating a new pool for an Engine
     * @param  delRisky  Amount of risky tokens required to initialize risky reserve
     * @param  delStable Amount of stable tokens required to initialize stable reserve
     */
    function createCallback(
        uint256 delRisky,
        uint256 delStable,
        bytes calldata // data bytes passed in, unused
    ) external onlyEngine {
        // For the callback, we simply need to transfer the desired amount of assets to the engine
        fractionalArtVault.safeTransfer(address(engine), delRisky);
        IERC20(stable).safeTransfer(address(engine), delStable);
    }

    /**
     * @notice Triggered when depositing tokens to an Engine
     * @param  delRisky  Amount of risky tokens required to deposit to risky margin balance
     * @param  delStable Amount of stable tokens required to deposit to stable margin balance
     */
    function depositCallback(
        uint256 delRisky,
        uint256 delStable,
        bytes calldata // data bytes passed in, unused
    ) external onlyEngine {
        if (delRisky != 0) {
            fractionalArtVault.safeTransfer(address(engine), delRisky);
        }
        if (delStable != 0) {
            IERC20(stable).safeTransfer(address(engine), delStable);
        }
    }

    /**
     * @notice Triggered when providing liquidity to an Engine
     * @param  delRisky  Amount of risky tokens required to provide to risky reserve
     * @param  delStable Amount of stable tokens required to provide to stable reserve
     */
    function allocateCallback(
        uint256 delRisky,
        uint256 delStable,
        bytes calldata // data bytes passed in, unused
    ) external onlyEngine {
        fractionalArtVault.safeTransfer(address(engine), delRisky);
        IERC20(stable).safeTransfer(address(engine), delStable);
    }

    /**
     * @notice Receiver function for ERC721 assets
     */
    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public pure returns (bytes4) {
        return this.onERC721Received.selector;
    }
}


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

import "@primitive/interfaces/callback/IPrimitiveCreateCallback.sol";
import "@primitive/interfaces/callback/IPrimitiveDepositCallback.sol";
import "@primitive/interfaces/callback/IPrimitiveLiquidityCallback.sol";

// Utility interface so we don't have to list out all the Primitive Call back interfaces we support
interface IPrimitiveCallback is
    IPrimitiveCreateCallback,
    IPrimitiveDepositCallback,
    IPrimitiveLiquidityCallback
{

}


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

interface IFractionalVaultFactory {
    // returns vault ID
    function mint(
        string memory _name,
        string memory _symbol,
        address _token,
        uint256 _id,
        uint256 _supply,
        uint256 _listPrice,
        uint256 _fee
    ) external returns (uint256);

    function vaults(uint256 _vaultId) external returns (address);
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@oz/token/ERC20/IERC20.sol";

interface IFractionalVault is IERC20 {
    // returns vault ID
    function mint(
        string memory _name,
        string memory _symbol,
        address _token,
        uint256 _id,
        uint256 _supply,
        uint256 _listPrice,
        uint256 _fee
    ) external returns (uint256);

    function updateCurator(address _curator) external;
}


Options for ERC721 assets via fractionalizing into ERC20 tokens & depositing into Primitve

Fractionalized ERC721 Options

This function is used to allocate funds from the FractionalArtVault and a stablecoin to the Engine contract. It takes in two uint256 parameters (delRisky and delStable) which represent the amount of funds to be allocated from the FractionalArtVault and the stablecoin respectively. It also takes in a bytes calldata parameter which is used to pass in additional data to the function. The function then calls the safeTransfer function on both the FractionalArtVault and the stablecoin to transfer the specified amounts to the Engine contract. (autogenerated documentation)

This function is used to transfer a certain amount of tokens from the FractionalArtVault and a stablecoin to the Engine contract. The function takes three parameters: delRisky, delStable, and calldata. delRisky is the amount of tokens to be transferred from the FractionalArtVault, delStable is the amount of stablecoin to be transferred, and calldata is any additional data that may be needed for the transfer. The function then uses the safeTransfer function to securely transfer the tokens from the FractionalArtVault and the stablecoin to the Engine contract. (autogenerated documentation)

This function is used to deposit funds into the Engine contract. It takes in two parameters, delRisky and delStable, which represent the amount of risky and stable tokens to be deposited, respectively. It also takes in a calldata parameter, which is used to provide additional data to the function. The function then transfers the specified amounts of tokens to the Engine contract, using the safeTransfer function to ensure that the tokens are transferred securely. (autogenerated documentation)

This function allows a user to deposit liquidity into a pool. It takes two parameters, delRisky and delStable, which represent the amount of risky and stable assets the user is depositing. The function then uses the safeTransferFrom function to transfer the assets from the user's address to the address of the pool. Finally, the engine.allocate function is used to allocate the assets to the pool. (autogenerated documentation)

This function is an event that is triggered when an ERC721 token is received. It takes four parameters: the address of the operator, the address of the from account, the ID of the token, and a byte array of data. It returns a bytes4 value, which is the selector of the onERC721Received function. This function is used to track the transfer of ERC721 tokens and is typically used in smart contracts that manage ERC721 tokens. (autogenerated documentation)

This function allows the owner of the contract to withdraw liquidity from the contract. It takes two parameters, delRisky and delStable, which represent the amount of risky and stable tokens to be withdrawn. The function then calls the withdraw function of the engine contract, passing in the address of the owner and the amounts of tokens to be withdrawn. (autogenerated documentation)

Fractionalized ERC721 Options

Options for ERC721 assets via fractionalizing into ERC20 tokens & depositing into Primitve

4 downloads

Audit

Creator

Get Cookin'
4

4 downloads

Creator

Fractionalized ERC721 Options

Options for ERC721 assets via fractionalizing into ERC20 tokens & depositing into Primitve

Fractionalized ERC721 Options

Options for ERC721 assets via fractionalizing into ERC20 tokens & depositing into Primitve

4 downloads

Audit

Creator

Get Cookin'4

4 downloads

Creator

Fractionalized ERC721 Options

Options for ERC721 assets via fractionalizing into ERC20 tokens & depositing into Primitve

Get Cookin'
4