File size: 94,800 Bytes
f998fcd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
{
"language": "Solidity",
"sources": {
"contracts/libraries/VaultLifecycleTreasuryBare.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nimport {SafeMath} from \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {Vault} from \"./Vault.sol\";\nimport {ShareMath} from \"./ShareMath.sol\";\nimport {IStrikeSelection} from \"../interfaces/IRibbon.sol\";\nimport {GnosisAuction} from \"./GnosisAuction.sol\";\nimport {DateTime} from \"./DateTime.sol\";\nimport {\n IOtokenFactory,\n IOtoken,\n IController,\n GammaTypes\n} from \"../interfaces/GammaInterface.sol\";\nimport {IERC20Detailed} from \"../interfaces/IERC20Detailed.sol\";\nimport {IGnosisAuction} from \"../interfaces/IGnosisAuction.sol\";\nimport {SupportsNonCompliantERC20} from \"./SupportsNonCompliantERC20.sol\";\n\nlibrary VaultLifecycleTreasuryBare {\n using SafeMath for uint256;\n using SupportsNonCompliantERC20 for IERC20;\n\n struct CloseParams {\n address OTOKEN_FACTORY;\n address USDC;\n address currentOption;\n uint256 delay;\n uint16 lastStrikeOverrideRound;\n uint256 overriddenStrikePrice;\n uint256 period;\n }\n\n /**\n * @notice Initialization parameters for the vault.\n * @param _owner is the owner of the vault with critical permissions\n * @param _feeRecipient is the address to recieve vault performance and management fees\n * @param _managementFee is the management fee pct.\n * @param _performanceFee is the perfomance fee pct.\n * @param _tokenName is the name of the token\n * @param _tokenSymbol is the symbol of the token\n * @param _optionsPremiumPricer is the address of the contract with the\n black-scholes premium calculation logic\n * @param _strikeSelection is the address of the contract with strike selection logic\n * @param _premiumDiscount is the vault's discount applied to the premium\n * @param _auctionDuration is the duration of the gnosis auction\n * @param _period is the period between each option sales\n */\n struct InitParams {\n address _owner;\n address _keeper;\n address _feeRecipient;\n uint256 _managementFee;\n uint256 _performanceFee;\n string _tokenName;\n string _tokenSymbol;\n address _optionsPremiumPricer;\n address _strikeSelection;\n uint32 _premiumDiscount;\n uint256 _auctionDuration;\n uint256 _period;\n uint256 _maxDepositors;\n uint256 _minDeposit;\n }\n\n /**\n * @notice Sets the next option the vault will be shorting, and calculates its premium for the auction\n * @param strikeSelection is the address of the contract with strike selection logic\n * @param optionsPremiumPricer is the address of the contract with the\n black-scholes premium calculation logic\n * @param premiumDiscount is the vault's discount applied to the premium\n * @param closeParams is the struct with details on previous option and strike selection details\n * @param vaultParams is the struct with vault general data\n * @param vaultState is the struct with vault accounting state\n * @return otokenAddress is the address of the new option\n * @return premium is the premium of the new option\n * @return strikePrice is the strike price of the new option\n * @return delta is the delta of the new option\n */\n function commitAndClose(\n address strikeSelection,\n address optionsPremiumPricer,\n uint256 premiumDiscount,\n CloseParams calldata closeParams,\n Vault.VaultParams storage vaultParams,\n Vault.VaultState storage vaultState\n )\n external\n returns (\n address otokenAddress,\n uint256 premium,\n uint256 strikePrice,\n uint256 delta\n )\n {\n uint256 expiry;\n\n // uninitialized state\n if (closeParams.currentOption == address(0)) {\n expiry = getNextExpiry(block.timestamp, closeParams.period);\n } else {\n expiry = getNextExpiry(\n IOtoken(closeParams.currentOption).expiryTimestamp(),\n closeParams.period\n );\n }\n\n bool isPut = vaultParams.isPut;\n address underlying = vaultParams.underlying;\n address asset = vaultParams.asset;\n\n (strikePrice, delta) = closeParams.lastStrikeOverrideRound ==\n vaultState.round\n ? (closeParams.overriddenStrikePrice, 0)\n : IStrikeSelection(strikeSelection).getStrikePrice(expiry, isPut);\n\n require(strikePrice != 0, \"!strikePrice\");\n\n // retrieve address if option already exists, or deploy it\n otokenAddress = getOrDeployOtoken(\n closeParams,\n vaultParams,\n underlying,\n asset,\n strikePrice,\n expiry,\n isPut\n );\n\n // get the black scholes premium of the option\n premium = optionsPremiumPricer == address(1)\n ? 1\n : GnosisAuction.getOTokenPremiumInStables(\n otokenAddress,\n optionsPremiumPricer,\n premiumDiscount\n );\n\n require(premium > 0, \"!premium\");\n\n return (otokenAddress, premium, strikePrice, delta);\n }\n\n /**\n * @notice Verify the otoken has the correct parameters to prevent vulnerability to opyn contract changes\n * @param otokenAddress is the address of the otoken\n * @param vaultParams is the struct with vault general data\n * @param collateralAsset is the address of the collateral asset\n * @param USDC is the address of usdc\n * @param delay is the delay between commitAndClose and rollToNextOption\n */\n function verifyOtoken(\n address otokenAddress,\n Vault.VaultParams storage vaultParams,\n address collateralAsset,\n address USDC,\n uint256 delay\n ) private view {\n require(otokenAddress != address(0), \"!otokenAddress\");\n\n IOtoken otoken = IOtoken(otokenAddress);\n require(otoken.isPut() == vaultParams.isPut, \"Type mismatch\");\n require(\n otoken.underlyingAsset() == vaultParams.underlying,\n \"Wrong underlyingAsset\"\n );\n require(\n otoken.collateralAsset() == collateralAsset,\n \"Wrong collateralAsset\"\n );\n\n // we just assume all options use USDC as the strike\n require(otoken.strikeAsset() == USDC, \"strikeAsset != USDC\");\n\n uint256 readyAt = block.timestamp.add(delay);\n require(otoken.expiryTimestamp() >= readyAt, \"Expiry before delay\");\n }\n\n /**\n * @param currentShareSupply is the supply of the shares invoked with totalSupply()\n * @param asset is the address of the vault's asset\n * @param decimals is the decimals of the asset\n * @param lastQueuedWithdrawAmount is the amount queued for withdrawals from last round\n * @param managementFee is the management fee percent to charge on the AUM\n */\n struct RolloverParams {\n uint256 decimals;\n uint256 totalBalance;\n uint256 currentShareSupply;\n uint256 lastQueuedWithdrawAmount;\n uint256 managementFee;\n }\n\n /**\n * @notice Calculate the shares to mint, new price per share, and\n amount of funds to re-allocate as collateral for the new round\n * @param vaultState is the storage variable vaultState passed from RibbonVault\n * @param params is the rollover parameters passed to compute the next state\n * @return newLockedAmount is the amount of funds to allocate for the new round\n * @return queuedWithdrawAmount is the amount of funds set aside for withdrawal\n * @return newPricePerShare is the price per share of the new round\n * @return mintShares is the amount of shares to mint from deposits\n * @return managementFeeInAsset is the amount of management fee charged by vault\n */\n function rollover(\n Vault.VaultState storage vaultState,\n RolloverParams calldata params\n )\n external\n view\n returns (\n uint256 newLockedAmount,\n uint256 queuedWithdrawAmount,\n uint256 newPricePerShare,\n uint256 mintShares,\n uint256 managementFeeInAsset\n )\n {\n uint256 currentBalance = params.totalBalance;\n uint256 pendingAmount = vaultState.totalPending;\n uint256 queuedWithdrawShares = vaultState.queuedWithdrawShares;\n\n uint256 balanceForVaultFees;\n {\n uint256 pricePerShareBeforeFee =\n ShareMath.pricePerShare(\n params.currentShareSupply,\n currentBalance,\n pendingAmount,\n params.decimals\n );\n\n uint256 queuedWithdrawBeforeFee =\n params.currentShareSupply > 0\n ? ShareMath.sharesToAsset(\n queuedWithdrawShares,\n pricePerShareBeforeFee,\n params.decimals\n )\n : 0;\n\n // Deduct the difference between the newly scheduled withdrawals\n // and the older withdrawals\n // so we can charge them fees before they leave\n uint256 withdrawAmountDiff =\n queuedWithdrawBeforeFee > params.lastQueuedWithdrawAmount\n ? queuedWithdrawBeforeFee.sub(\n params.lastQueuedWithdrawAmount\n )\n : 0;\n\n balanceForVaultFees = currentBalance\n .sub(queuedWithdrawBeforeFee)\n .add(withdrawAmountDiff);\n }\n\n managementFeeInAsset = getManagementFee(\n balanceForVaultFees,\n vaultState.totalPending,\n params.managementFee\n );\n\n // Take into account the fee\n // so we can calculate the newPricePerShare\n currentBalance = currentBalance.sub(managementFeeInAsset);\n\n {\n newPricePerShare = ShareMath.pricePerShare(\n params.currentShareSupply,\n currentBalance,\n pendingAmount,\n params.decimals\n );\n\n // After closing the short, if the options expire in-the-money\n // vault pricePerShare would go down because vault's asset balance decreased.\n // This ensures that the newly-minted shares do not take on the loss.\n mintShares = ShareMath.assetToShares(\n pendingAmount,\n newPricePerShare,\n params.decimals\n );\n\n uint256 newSupply = params.currentShareSupply.add(mintShares);\n\n queuedWithdrawAmount = newSupply > 0\n ? ShareMath.sharesToAsset(\n queuedWithdrawShares,\n newPricePerShare,\n params.decimals\n )\n : 0;\n }\n\n return (\n currentBalance.sub(queuedWithdrawAmount), // new locked balance subtracts the queued withdrawals\n queuedWithdrawAmount,\n newPricePerShare,\n mintShares,\n managementFeeInAsset\n );\n }\n\n /**\n * @notice Creates the actual Opyn short position by depositing collateral and minting otokens\n * @param gammaController is the address of the opyn controller contract\n * @param marginPool is the address of the opyn margin contract which holds the collateral\n * @param oTokenAddress is the address of the otoken to mint\n * @param depositAmount is the amount of collateral to deposit\n * @return the otoken mint amount\n */\n function createShort(\n address gammaController,\n address marginPool,\n address oTokenAddress,\n uint256 depositAmount\n ) external returns (uint256) {\n IController controller = IController(gammaController);\n uint256 newVaultID =\n (controller.getAccountVaultCounter(address(this))).add(1);\n\n // An otoken's collateralAsset is the vault's `asset`\n // So in the context of performing Opyn short operations we call them collateralAsset\n IOtoken oToken = IOtoken(oTokenAddress);\n address collateralAsset = oToken.collateralAsset();\n\n uint256 collateralDecimals =\n uint256(IERC20Detailed(collateralAsset).decimals());\n uint256 mintAmount;\n\n if (oToken.isPut()) {\n // For minting puts, there will be instances where the full depositAmount will not be used for minting.\n // This is because of an issue with precision.\n //\n // For ETH put options, we are calculating the mintAmount (10**8 decimals) using\n // the depositAmount (10**18 decimals), which will result in truncation of decimals when scaling down.\n // As a result, there will be tiny amounts of dust left behind in the Opyn vault when minting put otokens.\n //\n // For simplicity's sake, we do not refund the dust back to the address(this) on minting otokens.\n // We retain the dust in the vault so the calling contract can withdraw the\n // actual locked amount + dust at settlement.\n //\n // To test this behavior, we can console.log\n // MarginCalculatorInterface(0x7A48d10f372b3D7c60f6c9770B91398e4ccfd3C7).getExcessCollateral(vault)\n // to see how much dust (or excess collateral) is left behind.\n mintAmount = depositAmount\n .mul(10**Vault.OTOKEN_DECIMALS)\n .mul(10**18) // we use 10**18 to give extra precision\n .div(oToken.strikePrice().mul(10**(10 + collateralDecimals)));\n } else {\n mintAmount = depositAmount;\n\n if (collateralDecimals > 8) {\n uint256 scaleBy = 10**(collateralDecimals.sub(8)); // oTokens have 8 decimals\n if (mintAmount > scaleBy) {\n mintAmount = depositAmount.div(scaleBy); // scale down from 10**18 to 10**8\n }\n }\n }\n\n // double approve to fix non-compliant ERC20s\n IERC20 collateralToken = IERC20(collateralAsset);\n collateralToken.safeApproveNonCompliant(marginPool, depositAmount);\n\n IController.ActionArgs[] memory actions =\n new IController.ActionArgs[](3);\n\n actions[0] = IController.ActionArgs(\n IController.ActionType.OpenVault,\n address(this), // owner\n address(this), // receiver\n address(0), // asset, otoken\n newVaultID, // vaultId\n 0, // amount\n 0, //index\n \"\" //data\n );\n\n actions[1] = IController.ActionArgs(\n IController.ActionType.DepositCollateral,\n address(this), // owner\n address(this), // address to transfer from\n collateralAsset, // deposited asset\n newVaultID, // vaultId\n depositAmount, // amount\n 0, //index\n \"\" //data\n );\n\n actions[2] = IController.ActionArgs(\n IController.ActionType.MintShortOption,\n address(this), // owner\n address(this), // address to transfer to\n oTokenAddress, // option address\n newVaultID, // vaultId\n mintAmount, // amount\n 0, //index\n \"\" //data\n );\n\n controller.operate(actions);\n\n return mintAmount;\n }\n\n /**\n * @notice Close the existing short otoken position. Currently this implementation is simple.\n * It closes the most recent vault opened by the contract. This assumes that the contract will\n * only have a single vault open at any given time. Since calling `_closeShort` deletes vaults by\n calling SettleVault action, this assumption should hold.\n * @param gammaController is the address of the opyn controller contract\n * @return amount of collateral redeemed from the vault\n */\n function settleShort(address gammaController) external returns (uint256) {\n IController controller = IController(gammaController);\n\n // gets the currently active vault ID\n uint256 vaultID = controller.getAccountVaultCounter(address(this));\n\n GammaTypes.Vault memory vault =\n controller.getVault(address(this), vaultID);\n\n require(vault.shortOtokens.length > 0, \"No short\");\n\n // An otoken's collateralAsset is the vault's `asset`\n // So in the context of performing Opyn short operations we call them collateralAsset\n IERC20 collateralToken = IERC20(vault.collateralAssets[0]);\n\n // The short position has been previously closed, or all the otokens have been burned.\n // So we return early.\n if (address(collateralToken) == address(0)) {\n return 0;\n }\n\n // This is equivalent to doing IERC20(vault.asset).balanceOf(address(this))\n uint256 startCollateralBalance =\n collateralToken.balanceOf(address(this));\n\n // If it is after expiry, we need to settle the short position using the normal way\n // Delete the vault and withdraw all remaining collateral from the vault\n IController.ActionArgs[] memory actions =\n new IController.ActionArgs[](1);\n\n actions[0] = IController.ActionArgs(\n IController.ActionType.SettleVault,\n address(this), // owner\n address(this), // address to transfer to\n address(0), // not used\n vaultID, // vaultId\n 0, // not used\n 0, // not used\n \"\" // not used\n );\n\n controller.operate(actions);\n\n uint256 endCollateralBalance = collateralToken.balanceOf(address(this));\n\n return endCollateralBalance.sub(startCollateralBalance);\n }\n\n /**\n * @notice Exercises the ITM option using existing long otoken position. Currently this implementation is simple.\n * It calls the `Redeem` action to claim the payout.\n * @param gammaController is the address of the opyn controller contract\n * @param oldOption is the address of the old option\n * @param asset is the address of the vault's asset\n * @return amount of asset received by exercising the option\n */\n function settleLong(\n address gammaController,\n address oldOption,\n address asset\n ) external returns (uint256) {\n IController controller = IController(gammaController);\n\n uint256 oldOptionBalance = IERC20(oldOption).balanceOf(address(this));\n\n if (controller.getPayout(oldOption, oldOptionBalance) == 0) {\n return 0;\n }\n\n uint256 startAssetBalance = IERC20(asset).balanceOf(address(this));\n\n // If it is after expiry, we need to redeem the profits\n IController.ActionArgs[] memory actions =\n new IController.ActionArgs[](1);\n\n actions[0] = IController.ActionArgs(\n IController.ActionType.Redeem,\n address(0), // not used\n address(this), // address to send profits to\n oldOption, // address of otoken\n 0, // not used\n oldOptionBalance, // otoken balance\n 0, // not used\n \"\" // not used\n );\n\n controller.operate(actions);\n\n uint256 endAssetBalance = IERC20(asset).balanceOf(address(this));\n\n return endAssetBalance.sub(startAssetBalance);\n }\n\n /**\n * @notice Burn the remaining oTokens left over from auction. Currently this implementation is simple.\n * It burns oTokens from the most recent vault opened by the contract. This assumes that the contract will\n * only have a single vault open at any given time.\n * @param gammaController is the address of the opyn controller contract\n * @param currentOption is the address of the current option\n * @return amount of collateral redeemed by burning otokens\n */\n function burnOtokens(address gammaController, address currentOption)\n external\n returns (uint256)\n {\n uint256 numOTokensToBurn =\n IERC20(currentOption).balanceOf(address(this));\n\n require(numOTokensToBurn > 0, \"No oTokens to burn\");\n\n IController controller = IController(gammaController);\n\n // gets the currently active vault ID\n uint256 vaultID = controller.getAccountVaultCounter(address(this));\n\n GammaTypes.Vault memory vault =\n controller.getVault(address(this), vaultID);\n\n require(vault.shortOtokens.length > 0, \"No short\");\n\n IERC20 collateralToken = IERC20(vault.collateralAssets[0]);\n\n uint256 startCollateralBalance =\n collateralToken.balanceOf(address(this));\n\n // Burning `amount` of oTokens from the ribbon vault,\n // then withdrawing the corresponding collateral amount from the vault\n IController.ActionArgs[] memory actions =\n new IController.ActionArgs[](2);\n\n actions[0] = IController.ActionArgs(\n IController.ActionType.BurnShortOption,\n address(this), // owner\n address(this), // address to transfer from\n address(vault.shortOtokens[0]), // otoken address\n vaultID, // vaultId\n numOTokensToBurn, // amount\n 0, //index\n \"\" //data\n );\n\n actions[1] = IController.ActionArgs(\n IController.ActionType.WithdrawCollateral,\n address(this), // owner\n address(this), // address to transfer to\n address(collateralToken), // withdrawn asset\n vaultID, // vaultId\n vault.collateralAmounts[0].mul(numOTokensToBurn).div(\n vault.shortAmounts[0]\n ), // amount\n 0, //index\n \"\" //data\n );\n\n controller.operate(actions);\n\n uint256 endCollateralBalance = collateralToken.balanceOf(address(this));\n\n return endCollateralBalance.sub(startCollateralBalance);\n }\n\n /**\n * @notice Calculates the management fee for this week's round\n * @param currentBalance is the balance of funds held on the vault after closing short\n * @param pendingAmount is the pending deposit amount\n * @param managementFeePercent is the management fee pct.\n * @return managementFeeInAsset is the management fee\n */\n function getManagementFee(\n uint256 currentBalance,\n uint256 pendingAmount,\n uint256 managementFeePercent\n ) internal pure returns (uint256 managementFeeInAsset) {\n // At the first round, currentBalance=0, pendingAmount>0\n // so we just do not charge anything on the first round\n uint256 lockedBalanceSansPending =\n currentBalance > pendingAmount\n ? currentBalance.sub(pendingAmount)\n : 0;\n\n uint256 _managementFeeInAsset;\n\n // Always charge management fee regardless of whether the vault is\n // making a profit from the previous options sale\n _managementFeeInAsset = managementFeePercent > 0\n ? lockedBalanceSansPending.mul(managementFeePercent).div(\n 100 * Vault.FEE_MULTIPLIER\n )\n : 0;\n\n return _managementFeeInAsset;\n }\n\n /**\n * @notice Either retrieves the option token if it already exists, or deploy it\n * @param closeParams is the struct with details on previous option and strike selection details\n * @param vaultParams is the struct with vault general data\n * @param underlying is the address of the underlying asset of the option\n * @param collateralAsset is the address of the collateral asset of the option\n * @param strikePrice is the strike price of the option\n * @param expiry is the expiry timestamp of the option\n * @param isPut is whether the option is a put\n * @return the address of the option\n */\n function getOrDeployOtoken(\n CloseParams calldata closeParams,\n Vault.VaultParams storage vaultParams,\n address underlying,\n address collateralAsset,\n uint256 strikePrice,\n uint256 expiry,\n bool isPut\n ) internal returns (address) {\n IOtokenFactory factory = IOtokenFactory(closeParams.OTOKEN_FACTORY);\n\n address otokenFromFactory =\n factory.getOtoken(\n underlying,\n closeParams.USDC,\n collateralAsset,\n strikePrice,\n expiry,\n isPut\n );\n\n if (otokenFromFactory != address(0)) {\n return otokenFromFactory;\n }\n\n address otoken =\n factory.createOtoken(\n underlying,\n closeParams.USDC,\n collateralAsset,\n strikePrice,\n expiry,\n isPut\n );\n\n verifyOtoken(\n otoken,\n vaultParams,\n collateralAsset,\n closeParams.USDC,\n closeParams.delay\n );\n\n return otoken;\n }\n\n /**\n * @notice Starts the gnosis auction\n * @param auctionDetails is the struct with all the custom parameters of the auction\n * @return the auction id of the newly created auction\n */\n function startAuction(GnosisAuction.AuctionDetails calldata auctionDetails)\n external\n returns (uint256)\n {\n return GnosisAuction.startAuction(auctionDetails);\n }\n\n /**\n * @notice Settles the gnosis auction\n * @param gnosisEasyAuction is the contract address of Gnosis easy auction protocol\n * @param auctionID is the auction ID of the gnosis easy auction\n */\n function settleAuction(address gnosisEasyAuction, uint256 auctionID)\n internal\n {\n IGnosisAuction(gnosisEasyAuction).settleAuction(auctionID);\n }\n\n /**\n * @notice Places a bid in an auction\n * @param bidDetails is the struct with all the details of the\n bid including the auction's id and how much to bid\n */\n function placeBid(GnosisAuction.BidDetails calldata bidDetails)\n external\n returns (\n uint256 sellAmount,\n uint256 buyAmount,\n uint64 userId\n )\n {\n return GnosisAuction.placeBid(bidDetails);\n }\n\n /**\n * @notice Claims the oTokens belonging to the vault\n * @param auctionSellOrder is the sell order of the bid\n * @param gnosisEasyAuction is the address of the gnosis auction contract\n holding custody to the funds\n * @param counterpartyThetaVault is the address of the counterparty theta\n vault of this delta vault\n */\n function claimAuctionOtokens(\n Vault.AuctionSellOrder calldata auctionSellOrder,\n address gnosisEasyAuction,\n address counterpartyThetaVault\n ) external {\n GnosisAuction.claimAuctionOtokens(\n auctionSellOrder,\n gnosisEasyAuction,\n counterpartyThetaVault\n );\n }\n\n /**\n * @notice Verify the constructor params satisfy requirements\n * @param _initParams is the initialization parameter including owner, keeper, etc.\n * @param _vaultParams is the struct with vault general data\n */\n function verifyInitializerParams(\n InitParams calldata _initParams,\n Vault.VaultParams calldata _vaultParams,\n uint256 _min_auction_duration\n ) external pure {\n require(_initParams._owner != address(0), \"!_owner\");\n require(_initParams._keeper != address(0), \"!_keeper\");\n require(_initParams._feeRecipient != address(0), \"!_feeRecipient\");\n require(\n _initParams._performanceFee < 100 * Vault.FEE_MULTIPLIER,\n \"performanceFee >= 100%\"\n );\n require(\n _initParams._managementFee < 100 * Vault.FEE_MULTIPLIER,\n \"managementFee >= 100%\"\n );\n require(bytes(_initParams._tokenName).length > 0, \"!_tokenName\");\n require(bytes(_initParams._tokenSymbol).length > 0, \"!_tokenSymbol\");\n require(\n (_initParams._period == 7) ||\n (_initParams._period == 14) ||\n (_initParams._period == 30) ||\n (_initParams._period == 90) ||\n (_initParams._period == 180),\n \"!_period\"\n );\n require(\n _initParams._optionsPremiumPricer != address(0),\n \"!_optionsPremiumPricer\"\n );\n require(\n _initParams._strikeSelection != address(0),\n \"!_strikeSelection\"\n );\n require(\n _initParams._premiumDiscount > 0 &&\n _initParams._premiumDiscount <\n 100 * Vault.PREMIUM_DISCOUNT_MULTIPLIER,\n \"!_premiumDiscount\"\n );\n require(\n _initParams._auctionDuration >= _min_auction_duration,\n \"!_auctionDuration\"\n );\n require(_initParams._maxDepositors > 0, \"!_maxDepositors\");\n require(_initParams._minDeposit > 0, \"!_minDeposit\");\n\n require(_vaultParams.asset != address(0), \"!asset\");\n require(_vaultParams.underlying != address(0), \"!underlying\");\n require(_vaultParams.minimumSupply > 0, \"!minimumSupply\");\n require(_vaultParams.cap > 0, \"!cap\");\n require(\n _vaultParams.cap > _vaultParams.minimumSupply,\n \"cap has to be higher than minimumSupply\"\n );\n }\n\n /**\n * @notice Gets the next options expiry timestamp, this function should be called\n when there is sufficient guard to ensure valid period\n * @param timestamp is the expiry timestamp of the current option\n * @param period is no. of days in between option sales. Available periods are: \n * 7(1w), 14(2w), 30(1m), 90(3m), 180(6m)\n */\n function getNextExpiry(uint256 timestamp, uint256 period)\n internal\n pure\n returns (uint256 nextExpiry)\n {\n if (period == 7) {\n nextExpiry = DateTime.getNextFriday(timestamp);\n nextExpiry = nextExpiry <= timestamp\n ? nextExpiry + 1 weeks\n : nextExpiry;\n } else if (period == 14) {\n nextExpiry = DateTime.getNextFriday(timestamp);\n nextExpiry = nextExpiry <= timestamp\n ? nextExpiry + 2 weeks\n : nextExpiry;\n } else if (period == 30) {\n nextExpiry = DateTime.getMonthLastFriday(timestamp);\n nextExpiry = nextExpiry <= timestamp\n ? DateTime.getMonthLastFriday(nextExpiry + 1 weeks)\n : nextExpiry;\n } else if (period == 90) {\n nextExpiry = DateTime.getQuarterLastFriday(timestamp);\n nextExpiry = nextExpiry <= timestamp\n ? DateTime.getQuarterLastFriday(nextExpiry + 1 weeks)\n : nextExpiry;\n } else if (period == 180) {\n nextExpiry = DateTime.getBiannualLastFriday(timestamp);\n nextExpiry = nextExpiry <= timestamp\n ? DateTime.getBiannualLastFriday(nextExpiry + 1 weeks)\n : nextExpiry;\n }\n\n nextExpiry = nextExpiry - (nextExpiry % (24 hours)) + (8 hours);\n }\n}\n"
},
"@openzeppelin/contracts/utils/math/SafeMath.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n }\n}\n"
},
"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
},
"contracts/libraries/Vault.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nlibrary Vault {\n /************************************************\n * IMMUTABLES & CONSTANTS\n ***********************************************/\n\n // Fees are 6-decimal places. For example: 20 * 10**6 = 20%\n uint256 internal constant FEE_MULTIPLIER = 10**6;\n\n // Premium discount has 1-decimal place. For example: 80 * 10**1 = 80%. Which represents a 20% discount.\n uint256 internal constant PREMIUM_DISCOUNT_MULTIPLIER = 10;\n\n // Otokens have 8 decimal places.\n uint256 internal constant OTOKEN_DECIMALS = 8;\n\n // Percentage of funds allocated to options is 2 decimal places. 10 * 10**2 = 10%\n uint256 internal constant OPTION_ALLOCATION_MULTIPLIER = 10**2;\n\n // Placeholder uint value to prevent cold writes\n uint256 internal constant PLACEHOLDER_UINT = 1;\n\n struct VaultParams {\n // Option type the vault is selling\n bool isPut;\n // Token decimals for vault shares\n uint8 decimals;\n // Asset used in Theta / Delta Vault\n address asset;\n // Underlying asset of the options sold by vault\n address underlying;\n // Minimum supply of the vault shares issued, for ETH it's 10**10\n uint56 minimumSupply;\n // Vault cap\n uint104 cap;\n }\n\n struct OptionState {\n // Option that the vault is shorting / longing in the next cycle\n address nextOption;\n // Option that the vault is currently shorting / longing\n address currentOption;\n // The timestamp when the `nextOption` can be used by the vault\n uint32 nextOptionReadyAt;\n }\n\n struct VaultState {\n // 32 byte slot 1\n // Current round number. `round` represents the number of `period`s elapsed.\n uint16 round;\n // Amount that is currently locked for selling options\n uint104 lockedAmount;\n // Amount that was locked for selling options in the previous round\n // used for calculating performance fee deduction\n uint104 lastLockedAmount;\n // 32 byte slot 2\n // Stores the total tally of how much of `asset` there is\n // to be used to mint rTHETA tokens\n uint128 totalPending;\n // Total amount of queued withdrawal shares from previous rounds (doesn't include the current round)\n uint128 queuedWithdrawShares;\n }\n\n struct DepositReceipt {\n // Maximum of 65535 rounds. Assuming 1 round is 7 days, maximum is 1256 years.\n uint16 round;\n // Deposit amount, max 20,282,409,603,651 or 20 trillion ETH deposit\n uint104 amount;\n // Unredeemed shares balance\n uint128 unredeemedShares;\n }\n\n struct Withdrawal {\n // Maximum of 65535 rounds. Assuming 1 round is 7 days, maximum is 1256 years.\n uint16 round;\n // Number of shares withdrawn\n uint128 shares;\n }\n\n struct AuctionSellOrder {\n // Amount of `asset` token offered in auction\n uint96 sellAmount;\n // Amount of oToken requested in auction\n uint96 buyAmount;\n // User Id of delta vault in latest gnosis auction\n uint64 userId;\n }\n}\n"
},
"contracts/libraries/ShareMath.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nimport {SafeMath} from \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport {Vault} from \"./Vault.sol\";\n\nlibrary ShareMath {\n using SafeMath for uint256;\n\n uint256 internal constant PLACEHOLDER_UINT = 1;\n\n function assetToShares(\n uint256 assetAmount,\n uint256 assetPerShare,\n uint256 decimals\n ) internal pure returns (uint256) {\n // If this throws, it means that vault's roundPricePerShare[currentRound] has not been set yet\n // which should never happen.\n // Has to be larger than 1 because `1` is used in `initRoundPricePerShares` to prevent cold writes.\n require(assetPerShare > PLACEHOLDER_UINT, \"Invalid assetPerShare\");\n\n return assetAmount.mul(10**decimals).div(assetPerShare);\n }\n\n function sharesToAsset(\n uint256 shares,\n uint256 assetPerShare,\n uint256 decimals\n ) internal pure returns (uint256) {\n // If this throws, it means that vault's roundPricePerShare[currentRound] has not been set yet\n // which should never happen.\n // Has to be larger than 1 because `1` is used in `initRoundPricePerShares` to prevent cold writes.\n require(assetPerShare > PLACEHOLDER_UINT, \"Invalid assetPerShare\");\n\n return shares.mul(assetPerShare).div(10**decimals);\n }\n\n /**\n * @notice Returns the shares unredeemed by the user given their DepositReceipt\n * @param depositReceipt is the user's deposit receipt\n * @param currentRound is the `round` stored on the vault\n * @param assetPerShare is the price in asset per share\n * @param decimals is the number of decimals the asset/shares use\n * @return unredeemedShares is the user's virtual balance of shares that are owed\n */\n function getSharesFromReceipt(\n Vault.DepositReceipt memory depositReceipt,\n uint256 currentRound,\n uint256 assetPerShare,\n uint256 decimals\n ) internal pure returns (uint256 unredeemedShares) {\n if (depositReceipt.round > 0 && depositReceipt.round < currentRound) {\n uint256 sharesFromRound =\n assetToShares(depositReceipt.amount, assetPerShare, decimals);\n\n return\n uint256(depositReceipt.unredeemedShares).add(sharesFromRound);\n }\n return depositReceipt.unredeemedShares;\n }\n\n function pricePerShare(\n uint256 totalSupply,\n uint256 totalBalance,\n uint256 pendingAmount,\n uint256 decimals\n ) internal pure returns (uint256) {\n uint256 singleShare = 10**decimals;\n return\n totalSupply > 0\n ? singleShare.mul(totalBalance.sub(pendingAmount)).div(\n totalSupply\n )\n : singleShare;\n }\n\n /************************************************\n * HELPERS\n ***********************************************/\n\n function assertUint104(uint256 num) internal pure {\n require(num <= type(uint104).max, \"Overflow uint104\");\n }\n\n function assertUint128(uint256 num) internal pure {\n require(num <= type(uint128).max, \"Overflow uint128\");\n }\n}\n"
},
"contracts/interfaces/IRibbon.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\nimport {Vault} from \"../libraries/Vault.sol\";\n\ninterface IRibbonVault {\n function deposit(uint256 amount) external;\n\n function depositETH() external payable;\n\n function cap() external view returns (uint256);\n\n function depositFor(uint256 amount, address creditor) external;\n\n function vaultParams() external view returns (Vault.VaultParams memory);\n}\n\ninterface IStrikeSelection {\n function getStrikePrice(uint256 expiryTimestamp, bool isPut)\n external\n view\n returns (uint256, uint256);\n\n function delta() external view returns (uint256);\n}\n\ninterface IOptionsPremiumPricer {\n function getPremium(\n uint256 strikePrice,\n uint256 timeToExpiry,\n bool isPut\n ) external view returns (uint256);\n\n function getPremiumInStables(\n uint256 strikePrice,\n uint256 timeToExpiry,\n bool isPut\n ) external view returns (uint256);\n\n function getOptionDelta(\n uint256 spotPrice,\n uint256 strikePrice,\n uint256 volatility,\n uint256 expiryTimestamp\n ) external view returns (uint256 delta);\n\n function getUnderlyingPrice() external view returns (uint256);\n\n function priceOracle() external view returns (address);\n\n function volatilityOracle() external view returns (address);\n\n function optionId() external view returns (bytes32);\n}\n"
},
"contracts/libraries/GnosisAuction.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nimport {SafeMath} from \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {DSMath} from \"../vendor/DSMath.sol\";\nimport {IGnosisAuction} from \"../interfaces/IGnosisAuction.sol\";\nimport {IOtoken} from \"../interfaces/GammaInterface.sol\";\nimport {IOptionsPremiumPricer} from \"../interfaces/IRibbon.sol\";\nimport {Vault} from \"./Vault.sol\";\nimport {IRibbonThetaVault} from \"../interfaces/IRibbonThetaVault.sol\";\n\nlibrary GnosisAuction {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n event InitiateGnosisAuction(\n address indexed auctioningToken,\n address indexed biddingToken,\n uint256 auctionCounter,\n address indexed manager\n );\n\n event PlaceAuctionBid(\n uint256 auctionId,\n address indexed auctioningToken,\n uint256 sellAmount,\n uint256 buyAmount,\n address indexed bidder\n );\n\n struct AuctionDetails {\n address oTokenAddress;\n address gnosisEasyAuction;\n address asset;\n uint256 assetDecimals;\n uint256 oTokenPremium;\n uint256 duration;\n }\n\n struct BidDetails {\n address oTokenAddress;\n address gnosisEasyAuction;\n address asset;\n uint256 assetDecimals;\n uint256 auctionId;\n uint256 lockedBalance;\n uint256 optionAllocation;\n uint256 optionPremium;\n address bidder;\n }\n\n function startAuction(AuctionDetails calldata auctionDetails)\n internal\n returns (uint256 auctionID)\n {\n uint256 oTokenSellAmount =\n getOTokenSellAmount(auctionDetails.oTokenAddress);\n require(oTokenSellAmount > 0, \"No otokens to sell\");\n\n IERC20(auctionDetails.oTokenAddress).safeApprove(\n auctionDetails.gnosisEasyAuction,\n IERC20(auctionDetails.oTokenAddress).balanceOf(address(this))\n );\n\n // minBidAmount is total oTokens to sell * premium per oToken\n // shift decimals to correspond to decimals of USDC for puts\n // and underlying for calls\n uint256 minBidAmount =\n DSMath.wmul(\n oTokenSellAmount.mul(10**10),\n auctionDetails.oTokenPremium\n );\n\n minBidAmount = auctionDetails.assetDecimals > 18\n ? minBidAmount.mul(10**(auctionDetails.assetDecimals.sub(18)))\n : minBidAmount.div(\n 10**(uint256(18).sub(auctionDetails.assetDecimals))\n );\n\n require(\n minBidAmount <= type(uint96).max,\n \"optionPremium * oTokenSellAmount > type(uint96) max value!\"\n );\n\n uint256 auctionEnd = block.timestamp.add(auctionDetails.duration);\n\n auctionID = IGnosisAuction(auctionDetails.gnosisEasyAuction)\n .initiateAuction(\n // address of oToken we minted and are selling\n auctionDetails.oTokenAddress,\n // address of asset we want in exchange for oTokens. Should match vault `asset`\n auctionDetails.asset,\n // orders can be cancelled at any time during the auction\n auctionEnd,\n // order will last for `duration`\n auctionEnd,\n // we are selling all of the otokens minus a fee taken by gnosis\n uint96(oTokenSellAmount),\n // the minimum we are willing to sell all the oTokens for. A discount is applied on black-scholes price\n uint96(minBidAmount),\n // the minimum bidding amount must be 1 * 10 ** -assetDecimals\n 1,\n // the min funding threshold\n 0,\n // no atomic closure\n false,\n // access manager contract\n address(0),\n // bytes for storing info like a whitelist for who can bid\n bytes(\"\")\n );\n\n emit InitiateGnosisAuction(\n auctionDetails.oTokenAddress,\n auctionDetails.asset,\n auctionID,\n msg.sender\n );\n }\n\n function placeBid(BidDetails calldata bidDetails)\n internal\n returns (\n uint256 sellAmount,\n uint256 buyAmount,\n uint64 userId\n )\n {\n // calculate how much to allocate\n sellAmount = bidDetails\n .lockedBalance\n .mul(bidDetails.optionAllocation)\n .div(100 * Vault.OPTION_ALLOCATION_MULTIPLIER);\n\n // divide the `asset` sellAmount by the target premium per oToken to\n // get the number of oTokens to buy (8 decimals)\n buyAmount = sellAmount\n .mul(10**(bidDetails.assetDecimals.add(Vault.OTOKEN_DECIMALS)))\n .div(bidDetails.optionPremium)\n .div(10**bidDetails.assetDecimals);\n\n require(\n sellAmount <= type(uint96).max,\n \"sellAmount > type(uint96) max value!\"\n );\n require(\n buyAmount <= type(uint96).max,\n \"buyAmount > type(uint96) max value!\"\n );\n\n // approve that amount\n IERC20(bidDetails.asset).safeApprove(\n bidDetails.gnosisEasyAuction,\n sellAmount\n );\n\n uint96[] memory _minBuyAmounts = new uint96[](1);\n uint96[] memory _sellAmounts = new uint96[](1);\n bytes32[] memory _prevSellOrders = new bytes32[](1);\n _minBuyAmounts[0] = uint96(buyAmount);\n _sellAmounts[0] = uint96(sellAmount);\n _prevSellOrders[\n 0\n ] = 0x0000000000000000000000000000000000000000000000000000000000000001;\n\n // place sell order with that amount\n userId = IGnosisAuction(bidDetails.gnosisEasyAuction).placeSellOrders(\n bidDetails.auctionId,\n _minBuyAmounts,\n _sellAmounts,\n _prevSellOrders,\n \"0x\"\n );\n\n emit PlaceAuctionBid(\n bidDetails.auctionId,\n bidDetails.oTokenAddress,\n sellAmount,\n buyAmount,\n bidDetails.bidder\n );\n\n return (sellAmount, buyAmount, userId);\n }\n\n function claimAuctionOtokens(\n Vault.AuctionSellOrder calldata auctionSellOrder,\n address gnosisEasyAuction,\n address counterpartyThetaVault\n ) internal {\n bytes32 order =\n encodeOrder(\n auctionSellOrder.userId,\n auctionSellOrder.buyAmount,\n auctionSellOrder.sellAmount\n );\n bytes32[] memory orders = new bytes32[](1);\n orders[0] = order;\n IGnosisAuction(gnosisEasyAuction).claimFromParticipantOrder(\n IRibbonThetaVault(counterpartyThetaVault).optionAuctionID(),\n orders\n );\n }\n\n function getOTokenSellAmount(address oTokenAddress)\n internal\n view\n returns (uint256)\n {\n // We take our current oToken balance. That will be our sell amount\n // but otokens will be transferred to gnosis.\n uint256 oTokenSellAmount =\n IERC20(oTokenAddress).balanceOf(address(this));\n\n require(\n oTokenSellAmount <= type(uint96).max,\n \"oTokenSellAmount > type(uint96) max value!\"\n );\n\n return oTokenSellAmount;\n }\n\n function getOTokenPremiumInStables(\n address oTokenAddress,\n address optionsPremiumPricer,\n uint256 premiumDiscount\n ) internal view returns (uint256) {\n IOtoken newOToken = IOtoken(oTokenAddress);\n IOptionsPremiumPricer premiumPricer =\n IOptionsPremiumPricer(optionsPremiumPricer);\n\n // Apply black-scholes formula (from rvol library) to option given its features\n // and get price for 100 contracts denominated USDC for both call and put options\n uint256 optionPremium =\n premiumPricer.getPremiumInStables(\n newOToken.strikePrice(),\n newOToken.expiryTimestamp(),\n newOToken.isPut()\n );\n\n // Apply a discount to incentivize arbitraguers\n optionPremium = optionPremium.mul(premiumDiscount).div(\n 100 * Vault.PREMIUM_DISCOUNT_MULTIPLIER\n );\n\n require(\n optionPremium <= type(uint96).max,\n \"optionPremium > type(uint96) max value!\"\n );\n\n return optionPremium;\n }\n\n function encodeOrder(\n uint64 userId,\n uint96 buyAmount,\n uint96 sellAmount\n ) internal pure returns (bytes32) {\n return\n bytes32(\n (uint256(userId) << 192) +\n (uint256(buyAmount) << 96) +\n uint256(sellAmount)\n );\n }\n}\n"
},
"contracts/libraries/DateTime.sol": {
"content": "// SPDX-License-Identifier: MIT\n// Source: https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary\n// ----------------------------------------------------------------------------\n// BokkyPooBah's DateTime Library v1.01\n// ----------------------------------------------------------------------------\n\npragma solidity =0.8.4;\n\nlibrary DateTime {\n uint256 constant SECONDS_PER_DAY = 24 * 60 * 60;\n uint256 constant SECONDS_PER_HOUR = 60 * 60;\n uint256 constant SECONDS_PER_MINUTE = 60;\n int256 constant OFFSET19700101 = 2440588;\n\n uint256 constant DOW_MON = 1;\n uint256 constant DOW_TUE = 2;\n uint256 constant DOW_WED = 3;\n uint256 constant DOW_THU = 4;\n uint256 constant DOW_FRI = 5;\n uint256 constant DOW_SAT = 6;\n uint256 constant DOW_SUN = 7;\n\n // ------------------------------------------------------------------------\n // Calculate the number of days from 1970/01/01 to year/month/day using\n // the date conversion algorithm from\n // http://aa.usno.navy.mil/faq/docs/JD_Formula.php\n // and subtracting the offset 2440588 so that 1970/01/01 is day 0\n //\n // days = day\n // - 32075\n // + 1461 * (year + 4800 + (month - 14) / 12) / 4\n // + 367 * (month - 2 - (month - 14) / 12 * 12) / 12\n // - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4\n // - offset\n // ------------------------------------------------------------------------\n function _daysFromDate(\n uint256 year,\n uint256 month,\n uint256 day\n ) internal pure returns (uint256 _days) {\n require(year >= 1970);\n int256 _year = int256(year);\n int256 _month = int256(month);\n int256 _day = int256(day);\n\n int256 __days =\n _day -\n 32075 +\n (1461 * (_year + 4800 + (_month - 14) / 12)) /\n 4 +\n (367 * (_month - 2 - ((_month - 14) / 12) * 12)) /\n 12 -\n (3 * ((_year + 4900 + (_month - 14) / 12) / 100)) /\n 4 -\n OFFSET19700101;\n\n _days = uint256(__days);\n }\n\n // ------------------------------------------------------------------------\n // Calculate year/month/day from the number of days since 1970/01/01 using\n // the date conversion algorithm from\n // http://aa.usno.navy.mil/faq/docs/JD_Formula.php\n // and adding the offset 2440588 so that 1970/01/01 is day 0\n //\n // int L = days + 68569 + offset\n // int N = 4 * L / 146097\n // L = L - (146097 * N + 3) / 4\n // year = 4000 * (L + 1) / 1461001\n // L = L - 1461 * year / 4 + 31\n // month = 80 * L / 2447\n // dd = L - 2447 * month / 80\n // L = month / 11\n // month = month + 2 - 12 * L\n // year = 100 * (N - 49) + year + L\n // ------------------------------------------------------------------------\n function _daysToDate(uint256 _days)\n internal\n pure\n returns (\n uint256 year,\n uint256 month,\n uint256 day\n )\n {\n int256 __days = int256(_days);\n\n int256 L = __days + 68569 + OFFSET19700101;\n int256 N = (4 * L) / 146097;\n L = L - (146097 * N + 3) / 4;\n int256 _year = (4000 * (L + 1)) / 1461001;\n L = L - (1461 * _year) / 4 + 31;\n int256 _month = (80 * L) / 2447;\n int256 _day = L - (2447 * _month) / 80;\n L = _month / 11;\n _month = _month + 2 - 12 * L;\n _year = 100 * (N - 49) + _year + L;\n\n year = uint256(_year);\n month = uint256(_month);\n day = uint256(_day);\n }\n\n function isLeapYear(uint256 timestamp)\n internal\n pure\n returns (bool leapYear)\n {\n (uint256 year, , ) = _daysToDate(timestamp / SECONDS_PER_DAY);\n leapYear = _isLeapYear(year);\n }\n\n function _isLeapYear(uint256 year) internal pure returns (bool leapYear) {\n leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);\n }\n\n function getDaysInMonth(uint256 timestamp)\n internal\n pure\n returns (uint256 daysInMonth)\n {\n (uint256 year, uint256 month, ) =\n _daysToDate(timestamp / SECONDS_PER_DAY);\n daysInMonth = _getDaysInMonth(year, month);\n }\n\n function _getDaysInMonth(uint256 year, uint256 month)\n internal\n pure\n returns (uint256 daysInMonth)\n {\n if (\n month == 1 ||\n month == 3 ||\n month == 5 ||\n month == 7 ||\n month == 8 ||\n month == 10 ||\n month == 12\n ) {\n daysInMonth = 31;\n } else if (month != 2) {\n daysInMonth = 30;\n } else {\n daysInMonth = _isLeapYear(year) ? 29 : 28;\n }\n }\n\n // 1 = Monday, 7 = Sunday\n function getDayOfWeek(uint256 timestamp)\n internal\n pure\n returns (uint256 dayOfWeek)\n {\n uint256 _days = timestamp / SECONDS_PER_DAY;\n dayOfWeek = ((_days + 3) % 7) + 1;\n }\n\n function getYear(uint256 timestamp) internal pure returns (uint256 year) {\n (year, , ) = _daysToDate(timestamp / SECONDS_PER_DAY);\n }\n\n function getMonth(uint256 timestamp) internal pure returns (uint256 month) {\n (, month, ) = _daysToDate(timestamp / SECONDS_PER_DAY);\n }\n\n function getDay(uint256 timestamp) internal pure returns (uint256 day) {\n (, , day) = _daysToDate(timestamp / SECONDS_PER_DAY);\n }\n\n function timestampFromDate(\n uint256 year,\n uint256 month,\n uint256 day\n ) internal pure returns (uint256 timestamp) {\n timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;\n }\n\n /**\n * @notice Gets the Friday of the same week\n * @param timestamp is the given date and time\n * @return the Friday of the same week in unix time\n */\n function getThisWeekFriday(uint256 timestamp)\n internal\n pure\n returns (uint256)\n {\n return timestamp + 5 days - getDayOfWeek(timestamp) * 1 days;\n }\n\n /**\n * @notice Gets the next friday after the given date and time\n * @param timestamp is the given date and time\n * @return the next friday after the given date and time\n */\n function getNextFriday(uint256 timestamp) internal pure returns (uint256) {\n uint256 friday = getThisWeekFriday(timestamp);\n return friday >= timestamp ? friday : friday + 1 weeks;\n }\n\n /**\n * @notice Gets the last day of the month\n * @param timestamp is the given date and time\n * @return the last day of the same month in unix time\n */\n function getLastDayOfMonth(uint256 timestamp)\n internal\n pure\n returns (uint256)\n {\n return\n timestampFromDate(getYear(timestamp), getMonth(timestamp) + 1, 1) -\n 1 days;\n }\n\n /**\n * @notice Gets the last Friday of the month\n * @param timestamp is the given date and time\n * @return the last Friday of the same month in unix time\n */\n function getMonthLastFriday(uint256 timestamp)\n internal\n pure\n returns (uint256)\n {\n uint256 lastDay = getLastDayOfMonth(timestamp);\n uint256 friday = getThisWeekFriday(lastDay);\n\n return friday > lastDay ? friday - 1 weeks : friday;\n }\n\n /**\n * @notice Gets the last Friday of the quarter\n * @param timestamp is the given date and time\n * @return the last Friday of the quarter in unix time\n */\n function getQuarterLastFriday(uint256 timestamp)\n internal\n pure\n returns (uint256)\n {\n uint256 month = getMonth(timestamp);\n uint256 quarterMonth =\n (month <= 3) ? 3 : (month <= 6) ? 6 : (month <= 9) ? 9 : 12;\n\n uint256 quarterDate =\n timestampFromDate(getYear(timestamp), quarterMonth, 1);\n\n return getMonthLastFriday(quarterDate);\n }\n\n /**\n * @notice Gets the last Friday of the half-year\n * @param timestamp is the given date and time\n * @return the last friday of the half-year\n */\n function getBiannualLastFriday(uint256 timestamp)\n internal\n pure\n returns (uint256)\n {\n uint256 month = getMonth(timestamp);\n uint256 biannualMonth = (month <= 6) ? 6 : 12;\n\n uint256 biannualDate =\n timestampFromDate(getYear(timestamp), biannualMonth, 1);\n\n return getMonthLastFriday(biannualDate);\n }\n}\n"
},
"contracts/interfaces/GammaInterface.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nlibrary GammaTypes {\n // vault is a struct of 6 arrays that describe a position a user has, a user can have multiple vaults.\n struct Vault {\n // addresses of oTokens a user has shorted (i.e. written) against this vault\n address[] shortOtokens;\n // addresses of oTokens a user has bought and deposited in this vault\n // user can be long oTokens without opening a vault (e.g. by buying on a DEX)\n // generally, long oTokens will be 'deposited' in vaults to act as collateral\n // in order to write oTokens against (i.e. in spreads)\n address[] longOtokens;\n // addresses of other ERC-20s a user has deposited as collateral in this vault\n address[] collateralAssets;\n // quantity of oTokens minted/written for each oToken address in shortOtokens\n uint256[] shortAmounts;\n // quantity of oTokens owned and held in the vault for each oToken address in longOtokens\n uint256[] longAmounts;\n // quantity of ERC-20 deposited as collateral in the vault for each ERC-20 address in collateralAssets\n uint256[] collateralAmounts;\n }\n}\n\ninterface IOtoken {\n function underlyingAsset() external view returns (address);\n\n function strikeAsset() external view returns (address);\n\n function collateralAsset() external view returns (address);\n\n function strikePrice() external view returns (uint256);\n\n function expiryTimestamp() external view returns (uint256);\n\n function isPut() external view returns (bool);\n}\n\ninterface IOtokenFactory {\n function getOtoken(\n address _underlyingAsset,\n address _strikeAsset,\n address _collateralAsset,\n uint256 _strikePrice,\n uint256 _expiry,\n bool _isPut\n ) external view returns (address);\n\n function createOtoken(\n address _underlyingAsset,\n address _strikeAsset,\n address _collateralAsset,\n uint256 _strikePrice,\n uint256 _expiry,\n bool _isPut\n ) external returns (address);\n\n function getTargetOtokenAddress(\n address _underlyingAsset,\n address _strikeAsset,\n address _collateralAsset,\n uint256 _strikePrice,\n uint256 _expiry,\n bool _isPut\n ) external view returns (address);\n\n event OtokenCreated(\n address tokenAddress,\n address creator,\n address indexed underlying,\n address indexed strike,\n address indexed collateral,\n uint256 strikePrice,\n uint256 expiry,\n bool isPut\n );\n}\n\ninterface IController {\n // possible actions that can be performed\n enum ActionType {\n OpenVault,\n MintShortOption,\n BurnShortOption,\n DepositLongOption,\n WithdrawLongOption,\n DepositCollateral,\n WithdrawCollateral,\n SettleVault,\n Redeem,\n Call,\n Liquidate\n }\n\n struct ActionArgs {\n // type of action that is being performed on the system\n ActionType actionType;\n // address of the account owner\n address owner;\n // address which we move assets from or to (depending on the action type)\n address secondAddress;\n // asset that is to be transfered\n address asset;\n // index of the vault that is to be modified (if any)\n uint256 vaultId;\n // amount of asset that is to be transfered\n uint256 amount;\n // each vault can hold multiple short / long / collateral assets\n // but we are restricting the scope to only 1 of each in this version\n // in future versions this would be the index of the short / long / collateral asset that needs to be modified\n uint256 index;\n // any other data that needs to be passed in for arbitrary function calls\n bytes data;\n }\n\n struct RedeemArgs {\n // address to which we pay out the oToken proceeds\n address receiver;\n // oToken that is to be redeemed\n address otoken;\n // amount of oTokens that is to be redeemed\n uint256 amount;\n }\n\n function getPayout(address _otoken, uint256 _amount)\n external\n view\n returns (uint256);\n\n function operate(ActionArgs[] calldata _actions) external;\n\n function getAccountVaultCounter(address owner)\n external\n view\n returns (uint256);\n\n function oracle() external view returns (address);\n\n function getVault(address _owner, uint256 _vaultId)\n external\n view\n returns (GammaTypes.Vault memory);\n\n function getProceed(address _owner, uint256 _vaultId)\n external\n view\n returns (uint256);\n\n function isSettlementAllowed(\n address _underlying,\n address _strike,\n address _collateral,\n uint256 _expiry\n ) external view returns (bool);\n}\n\ninterface IOracle {\n function setAssetPricer(address _asset, address _pricer) external;\n\n function updateAssetPricer(address _asset, address _pricer) external;\n\n function getPrice(address _asset) external view returns (uint256);\n}\n"
},
"contracts/interfaces/IERC20Detailed.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\ninterface IERC20Detailed is IERC20 {\n function decimals() external view returns (uint8);\n\n function symbol() external view returns (string calldata);\n\n function name() external view returns (string calldata);\n}\n"
},
"contracts/interfaces/IGnosisAuction.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nlibrary AuctionType {\n struct AuctionData {\n IERC20 auctioningToken;\n IERC20 biddingToken;\n uint256 orderCancellationEndDate;\n uint256 auctionEndDate;\n bytes32 initialAuctionOrder;\n uint256 minimumBiddingAmountPerOrder;\n uint256 interimSumBidAmount;\n bytes32 interimOrder;\n bytes32 clearingPriceOrder;\n uint96 volumeClearingPriceOrder;\n bool minFundingThresholdNotReached;\n bool isAtomicClosureAllowed;\n uint256 feeNumerator;\n uint256 minFundingThreshold;\n }\n}\n\ninterface IGnosisAuction {\n function initiateAuction(\n address _auctioningToken,\n address _biddingToken,\n uint256 orderCancellationEndDate,\n uint256 auctionEndDate,\n uint96 _auctionedSellAmount,\n uint96 _minBuyAmount,\n uint256 minimumBiddingAmountPerOrder,\n uint256 minFundingThreshold,\n bool isAtomicClosureAllowed,\n address accessManagerContract,\n bytes memory accessManagerContractData\n ) external returns (uint256);\n\n function auctionCounter() external view returns (uint256);\n\n function auctionData(uint256 auctionId)\n external\n view\n returns (AuctionType.AuctionData memory);\n\n function auctionAccessManager(uint256 auctionId)\n external\n view\n returns (address);\n\n function auctionAccessData(uint256 auctionId)\n external\n view\n returns (bytes memory);\n\n function FEE_DENOMINATOR() external view returns (uint256);\n\n function feeNumerator() external view returns (uint256);\n\n function settleAuction(uint256 auctionId) external returns (bytes32);\n\n function placeSellOrders(\n uint256 auctionId,\n uint96[] memory _minBuyAmounts,\n uint96[] memory _sellAmounts,\n bytes32[] memory _prevSellOrders,\n bytes calldata allowListCallData\n ) external returns (uint64);\n\n function claimFromParticipantOrder(\n uint256 auctionId,\n bytes32[] memory orders\n ) external returns (uint256, uint256);\n}\n"
},
"contracts/libraries/SupportsNonCompliantERC20.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\n/**\n * This library supports ERC20s that have quirks in their behavior.\n * One such ERC20 is USDT, which requires allowance to be 0 before calling approve.\n * We plan to update this library with ERC20s that display such idiosyncratic behavior.\n */\nlibrary SupportsNonCompliantERC20 {\n address private constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;\n\n function safeApproveNonCompliant(\n IERC20 token,\n address spender,\n uint256 amount\n ) internal {\n if (address(token) == USDT) {\n SafeERC20.safeApprove(token, spender, 0);\n }\n SafeERC20.safeApprove(token, spender, amount);\n }\n}\n"
},
"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n function safeTransfer(\n IERC20 token,\n address to,\n uint256 value\n ) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(\n IERC20 token,\n address from,\n address to,\n uint256 value\n ) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n require(\n (value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) {\n // Return data is optional\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n"
},
"contracts/vendor/DSMath.sol": {
"content": "// SPDX-License-Identifier: MIT\n\n/// math.sol -- mixin for inline numerical wizardry\n\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program. If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity >0.4.13;\n\nlibrary DSMath {\n function add(uint256 x, uint256 y) internal pure returns (uint256 z) {\n require((z = x + y) >= x, \"ds-math-add-overflow\");\n }\n\n function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {\n require((z = x - y) <= x, \"ds-math-sub-underflow\");\n }\n\n function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {\n require(y == 0 || (z = x * y) / y == x, \"ds-math-mul-overflow\");\n }\n\n function min(uint256 x, uint256 y) internal pure returns (uint256 z) {\n return x <= y ? x : y;\n }\n\n function max(uint256 x, uint256 y) internal pure returns (uint256 z) {\n return x >= y ? x : y;\n }\n\n function imin(int256 x, int256 y) internal pure returns (int256 z) {\n return x <= y ? x : y;\n }\n\n function imax(int256 x, int256 y) internal pure returns (int256 z) {\n return x >= y ? x : y;\n }\n\n uint256 constant WAD = 10**18;\n uint256 constant RAY = 10**27;\n\n //rounds to zero if x*y < WAD / 2\n function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {\n z = add(mul(x, y), WAD / 2) / WAD;\n }\n\n //rounds to zero if x*y < WAD / 2\n function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {\n z = add(mul(x, y), RAY / 2) / RAY;\n }\n\n //rounds to zero if x*y < WAD / 2\n function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {\n z = add(mul(x, WAD), y / 2) / y;\n }\n\n //rounds to zero if x*y < RAY / 2\n function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {\n z = add(mul(x, RAY), y / 2) / y;\n }\n\n // This famous algorithm is called \"exponentiation by squaring\"\n // and calculates x^n with x as fixed-point and n as regular unsigned.\n //\n // It's O(log n), instead of O(n) for naive repeated multiplication.\n //\n // These facts are why it works:\n //\n // If n is even, then x^n = (x^2)^(n/2).\n // If n is odd, then x^n = x * x^(n-1),\n // and applying the equation for even x gives\n // x^n = x * (x^2)^((n-1) / 2).\n //\n // Also, EVM division is flooring and\n // floor[(n-1) / 2] = floor[n / 2].\n //\n function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {\n z = n % 2 != 0 ? x : RAY;\n\n for (n /= 2; n != 0; n /= 2) {\n x = rmul(x, x);\n\n if (n % 2 != 0) {\n z = rmul(z, x);\n }\n }\n }\n}\n"
},
"contracts/interfaces/IRibbonThetaVault.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity =0.8.4;\n\nimport {Vault} from \"../libraries/Vault.sol\";\n\ninterface IRibbonThetaVault {\n function currentOption() external view returns (address);\n\n function nextOption() external view returns (address);\n\n function vaultParams() external view returns (Vault.VaultParams memory);\n\n function vaultState() external view returns (Vault.VaultState memory);\n\n function optionState() external view returns (Vault.OptionState memory);\n\n function optionAuctionID() external view returns (uint256);\n\n function pricePerShare() external view returns (uint256);\n\n function roundPricePerShare(uint256) external view returns (uint256);\n\n function depositFor(uint256 amount, address creditor) external;\n\n function initiateWithdraw(uint256 numShares) external;\n\n function completeWithdraw() external;\n\n function maxRedeem() external;\n\n function depositYieldTokenFor(uint256 amount, address creditor) external;\n\n function symbol() external view returns (string calldata);\n}\n"
},
"@openzeppelin/contracts/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n assembly {\n size := extcodesize(account)\n }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n"
}
},
"settings": {
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"metadata": {
"useLiteralContent": true
},
"libraries": {}
}
} |